jro_apps/redmine Commit - r1758:d93f96765b6f

Adds support for file viewing with Darcs 2.0+ (patch #1799 by Ralph Lange slightly edited)....

Jean-Philippe Lang -

r1758:d93f96765b6f

parent child

Context file:

r1758:d93f96765b6f

Collapse all files

app/models/repository/darcs.rb +10 0

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/darcs_adapter'
             class Repository::Darcs < Repository
               validates_presence_of :url
               def scm_adapter
                 Redmine::Scm::Adapters::DarcsAdapter
               end
               def self.scm_name
                 'Darcs'
               end
+              def entry(path=nil, identifier=nil)
+                patch = identifier.nil? ? nil : changesets.find_by_revision(identifier)
+                scm.entry(path, patch.nil? ? nil : patch.scmid)
+              end
               def entries(path=nil, identifier=nil)
                 patch = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 entries = scm.entries(path, patch.nil? ? nil : patch.scmid)
                 if entries
                   entries.each do |entry|
                     # Search the DB for the entry's last change
                     changeset = changesets.find_by_scmid(entry.lastrev.scmid) if entry.lastrev && !entry.lastrev.scmid.blank?
                     if changeset
                       entry.lastrev.identifier = changeset.revision
                       entry.lastrev.name = changeset.revision
                       entry.lastrev.time = changeset.committed_on
                       entry.lastrev.author = changeset.committer
                     end
                   end
                 end
                 entries
               end
+              def cat(path, identifier=nil)
+                patch = identifier.nil? ? nil : changesets.find_by_revision(identifier)
+                scm.cat(path, patch.nil? ? nil : patch.scmid)
+              end
               def diff(path, rev, rev_to)
                 patch_from = changesets.find_by_revision(rev)
                 return nil if patch_from.nil?
                 patch_to = changesets.find_by_revision(rev_to) if rev_to
                 if path.blank?
                   path = patch_from.changes.collect{|change| change.path}.join(' ')
                 end
                 patch_from ? scm.diff(path, patch_from.scmid, patch_to ? patch_to.scmid : nil) : nil
               end
               def fetch_changesets
                 scm_info = scm.info
                 if scm_info
                   db_last_id = latest_changeset ? latest_changeset.scmid : nil
                   next_rev = latest_changeset ? latest_changeset.revision.to_i + 1 : 1
                   # latest revision in the repository
                   scm_revision = scm_info.lastrev.scmid
                   unless changesets.find_by_scmid(scm_revision)
                     revisions = scm.revisions('', db_last_id, nil, :with_path => true)
                     transaction do
                       revisions.reverse_each do |revision|
                         changeset = Changeset.create(:repository => self,
                                                      :revision => next_rev,
                                                      :scmid => revision.scmid,
                                                      :committer => revision.author,
                                                      :committed_on => revision.time,
                                                      :comments => revision.message)
                         revision.paths.each do |change|
                           Change.create(:changeset => changeset,
                                         :action => change[:action],
                                         :path => change[:path],
                                         :from_path => change[:from_path],
                                         :from_revision => change[:from_revision])
                         end
                         next_rev += 1
                       end if revisions
                     end
                   end
                 end
               end
             end

doc/RUNNING_TESTS +2 -2

             Creating test repositories
             ===================
             mkdir tmp/test
             Subversion
             ----------
             svnadmin create tmp/test/subversion_repository
             gunzip < test/fixtures/repositories/subversion_repository.dump.gz | svnadmin load tmp/test/subversion_repository
             CVS
             ---
             gunzip < test/fixtures/repositories/cvs_repository.tar.gz | tar -xv -C tmp/test
             Bazaar
             ------
             gunzip < test/fixtures/repositories/bazaar_repository.tar.gz | tar -xv -C tmp/test
             Mercurial
             ---------
             gunzip < test/fixtures/repositories/mercurial_repository.tar.gz | tar -xv -C tmp/test
             Git
             ---
             gunzip < test/fixtures/repositories/git_repository.tar.gz | tar -xv -C tmp/test
-            Darcs
+            Darcs (2.0+ required)
-            -----
+            ---------------------
             gunzip < test/fixtures/repositories/darcs_repository.tar.gz | tar -xv -C tmp/test
             FileSystem
             ----------
             gunzip < test/fixtures/repositories/filesystem_repository.tar.gz | tar -xv -C tmp/test
             Running Tests
             =============
             Run
               rake --tasks | grep test
             to see available tests.
             RAILS_ENV=test rake test will run tests.

lib/redmine/scm/adapters/darcs_adapter.rb +36 -3

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/abstract_adapter'
             require 'rexml/document'
             module Redmine
               module Scm
                 module Adapters
                   class DarcsAdapter < AbstractAdapter
                     # Darcs executable name
                     DARCS_BIN = "darcs"
+                    class << self
+                      def client_version
+                        @@client_version ||= (darcs_binary_version || [])
+                      end
+                      def darcs_binary_version
+                        cmd = "#{DARCS_BIN} --version"
+                        version = nil
+                        shellout(cmd) do |io|
+                          # Read darcs version in first returned line
+                          if m = io.gets.match(%r{((\d+\.)+\d+)})
+                            version = m[0].scan(%r{\d+}).collect(&:to_i)
+                          end
+                        end
+                        return nil if $? && $?.exitstatus != 0
+                        version
+                      end
+                    end
                     def initialize(url, root_url=nil, login=nil, password=nil)
                       @url = url
                       @root_url = url
                     end
                     def supports_cat?
-                      false
+                      # cat supported in darcs 2.0.0 and higher
+                      self.class.client_version_above?([2, 0, 0])
                     end
-                    # Get info about the svn repository
+                    # Get info about the darcs repository
                     def info
                       rev = revisions(nil,nil,nil,{:limit => 1})
                       rev ? Info.new({:root_url => @url, :lastrev => rev.last}) : nil
                     end
                     # Returns an Entries collection
                     # or nil if the given path doesn't exist in the repository
                     def entries(path=nil, identifier=nil)
                       path_prefix = (path.blank? ? '' : "#{path}/")
                       path = '.' if path.blank?
                       entries = Entries.new
                       cmd = "#{DARCS_BIN} annotate --repodir #{@url} --xml-output"
                       cmd << " --match \"hash #{identifier}\"" if identifier
                       cmd << " #{path}"
                       shellout(cmd) do |io|
                         begin
                           doc = REXML::Document.new(io)
                           if doc.root.name == 'directory'
                             doc.elements.each('directory/*') do |element|
                               next unless ['file', 'directory'].include? element.name
                               entries << entry_from_xml(element, path_prefix)
                             end
                           elsif doc.root.name == 'file'
                             entries << entry_from_xml(doc.root, path_prefix)
                           end
                         rescue
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       entries.sort_by_name
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       path = '.' if path.blank?
                       revisions = Revisions.new
                       cmd = "#{DARCS_BIN} changes --repodir #{@url} --xml-output"
                       cmd << " --from-match \"hash #{identifier_from}\"" if identifier_from
                       cmd << " --last #{options[:limit].to_i}" if options[:limit]
                       shellout(cmd) do |io|
                         begin
                           doc = REXML::Document.new(io)
                           doc.elements.each("changelog/patch") do |patch|
                             message = patch.elements['name'].text
                             message << "\n" + patch.elements['comment'].text.gsub(/\*\*\*END OF DESCRIPTION\*\*\*.*\z/m, '') if patch.elements['comment']
                             revisions << Revision.new({:identifier => nil,
                                           :author => patch.attributes['author'],
                                           :scmid => patch.attributes['hash'],
                                           :time => Time.parse(patch.attributes['local_date']),
                                           :message => message,
                                           :paths => (options[:with_path] ? get_paths_for_patch(patch.attributes['hash']) : nil)
                                         })
                           end
                         rescue
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       revisions
                     end
                     def diff(path, identifier_from, identifier_to=nil)
                       path = '*' if path.blank?
                       cmd = "#{DARCS_BIN} diff --repodir #{@url}"
                       if identifier_to.nil?
                         cmd << " --match \"hash #{identifier_from}\""
                       else
                         cmd << " --to-match \"hash #{identifier_from}\""
                         cmd << " --from-match \"hash #{identifier_to}\""
                       end
                       cmd << " -u #{path}"
                       diff = []
                       shellout(cmd) do |io|
                         io.each_line do |line|
                           diff << line
                         end
                       end
                       return nil if $? && $?.exitstatus != 0
                       diff
                     end
+                    def cat(path, identifier=nil)
+                      cmd = "#{DARCS_BIN} show content --repodir #{@url}"
+                      cmd << " --match \"hash #{identifier}\"" if identifier
+                      cmd << " #{shell_quote path}"
+                      cat = nil
+                      shellout(cmd) do |io|
+                        io.binmode
+                        cat = io.read
+                      end
+                      return nil if $? && $?.exitstatus != 0
+                      cat
+                    end
                     private
                     def entry_from_xml(element, path_prefix)
                       Entry.new({:name => element.attributes['name'],
                                  :path => path_prefix + element.attributes['name'],
                                  :kind => element.name == 'file' ? 'file' : 'dir',
                                  :size => nil,
                                  :lastrev => Revision.new({
                                    :identifier => nil,
                                    :scmid => element.elements['modified'].elements['patch'].attributes['hash']
                                    })
                                  })
                     end
                     # Retrieve changed paths for a single patch
                     def get_paths_for_patch(hash)
                       cmd = "#{DARCS_BIN} annotate --repodir #{@url} --summary --xml-output"
                       cmd << " --match \"hash #{hash}\" "
                       paths = []
                       shellout(cmd) do |io|
                         begin
                           # Darcs xml output has multiple root elements in this case (tested with darcs 1.0.7)
                           # A root element is added so that REXML doesn't raise an error
                           doc = REXML::Document.new("<fake_root>" + io.read + "</fake_root>")
                           doc.elements.each('fake_root/summary/*') do |modif|
                             paths << {:action => modif.name[0,1].upcase,
                                       :path => "/" + modif.text.chomp.gsub(/^\s*/, '')
                                      }
                           end
                         rescue
                         end
                       end
                       paths
                     rescue CommandFailed
                       paths
                     end
                   end
                 end
               end
             end

test/unit/repository_darcs_test.rb +7 0

             # redMine - project management software
             # Copyright (C) 2006-2008  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.dirname(__FILE__) + '/../test_helper'
             class RepositoryDarcsTest < Test::Unit::TestCase
               fixtures :projects
               # No '..' in the repository path
               REPOSITORY_PATH = RAILS_ROOT.gsub(%r{config\/\.\.}, '') + '/tmp/test/darcs_repository'
               def setup
                 @project = Project.find(1)
                 assert @repository = Repository::Darcs.create(:project => @project, :url => REPOSITORY_PATH)
               end
               if File.directory?(REPOSITORY_PATH)
                 def test_fetch_changesets_from_scratch
                   @repository.fetch_changesets
                   @repository.reload
                   assert_equal 6, @repository.changesets.count
                   assert_equal 13, @repository.changes.count
                   assert_equal "Initial commit.", @repository.changesets.find_by_revision('1').comments
                 end
                 def test_fetch_changesets_incremental
                   @repository.fetch_changesets
                   # Remove changesets with revision > 3
                   @repository.changesets.find(:all).each {|c| c.destroy if c.revision.to_i > 3}
                   @repository.reload
                   assert_equal 3, @repository.changesets.count
                   @repository.fetch_changesets
                   assert_equal 6, @repository.changesets.count
                 end
+                def test_cat
+                  @repository.fetch_changesets
+                  cat = @repository.cat("sources/welcome_controller.rb", 2)
+                  assert_not_nil cat
+                  assert cat.include?('class WelcomeController < ApplicationController')
+                end
               else
                 puts "Darcs test repository NOT FOUND. Skipping unit tests !!!"
                 def test_fake; assert true end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages