jro_apps/redmine Commit - r2187:a7a4c9f84878

Fixed: deleted files should not be shown when browsing a Darcs repository (#2385)....

Jean-Philippe Lang -

r2187:a7a4c9f84878

parent child

Context file:

r2187:a7a4c9f84878

Collapse all files

lib/redmine/scm/adapters/darcs_adapter.rb +10 -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?
                        # cat supported in darcs 2.0.0 and higher
                        self.class.client_version_above?([2, 0, 0])
                      end
                      # 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
+                       entries.compact.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
+                     # Returns an Entry from the given XML element
+                     # or nil if the entry was deleted
                      def entry_from_xml(element, path_prefix)
+                       modified_element = element.elements['modified']
+                       if modified_element.elements['modified_how'].text.match(/removed/)
+                         return nil
+                       end
                        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']
+                                    :scmid => modified_element.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 +6 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_deleted_files_should_not_be_listed
+                   entries = @repository.entries('sources')
+                   assert entries.detect {|e| e.name == 'watchers_controller.rb'}
+                   assert_nil entries.detect {|e| e.name == 'welcome_controller.rb'}
+                 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