jro_apps/redmine Commit - r1494:e69b4647f201

Adds Filesystem adapter (patch #1393 by Paul R)....

Jean-Philippe Lang -

r1494:e69b4647f201

parent child

Context file:

r1494:e69b4647f201

Collapse all files

app/models/repository/filesystem.rb created 644 +43 0

@@ -0,0 +1,43
	1	# redMine - project management software
	2	# Copyright (C) 2006-2007 Jean-Philippe Lang
	3	#
	4	# FileSystem adapter
	5	# File written by Paul Rivier, at Demotera.
	6	#
	7	# This program is free software; you can redistribute it and/or
	8	# modify it under the terms of the GNU General Public License
	9	# as published by the Free Software Foundation; either version 2
	10	# of the License, or (at your option) any later version.
	11	#
	12	# This program is distributed in the hope that it will be useful,
	13	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	# GNU General Public License for more details.
	16	#
	17	# You should have received a copy of the GNU General Public License
	18	# along with this program; if not, write to the Free Software
	19	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	20
	21	require 'redmine/scm/adapters/filesystem_adapter'
	22
	23	class Repository::Filesystem < Repository
	24	attr_protected :root_url
	25	validates_presence_of :url
	26
	27	def scm_adapter
	28	Redmine::Scm::Adapters::FilesystemAdapter
	29	end
	30
	31	def self.scm_name
	32	'Filesystem'
	33	end
	34
	35	def entries(path=nil, identifier=nil)
	36	scm.entries(path, identifier)
	37	end
	38
	39	def fetch_changesets
	40	nil
	41	end
	42
	43	end

lib/redmine/scm/adapters/filesystem_adapter.rb created 644 +94 0

@@ -0,0 +1,94
	1	# redMine - project management software
	2	# Copyright (C) 2006-2007 Jean-Philippe Lang
	3	#
	4	# FileSystem adapter
	5	# File written by Paul Rivier, at Demotera.
	6	#
	7	# This program is free software; you can redistribute it and/or
	8	# modify it under the terms of the GNU General Public License
	9	# as published by the Free Software Foundation; either version 2
	10	# of the License, or (at your option) any later version.
	11	#
	12	# This program is distributed in the hope that it will be useful,
	13	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	# GNU General Public License for more details.
	16	#
	17	# You should have received a copy of the GNU General Public License
	18	# along with this program; if not, write to the Free Software
	19	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	20
	21	require 'redmine/scm/adapters/abstract_adapter'
	22	require 'find'
	23
	24	module Redmine
	25	module Scm
	26	module Adapters
	27	class FilesystemAdapter < AbstractAdapter
	28
	29
	30	def initialize(url, root_url=nil, login=nil, password=nil)
	31	@url = with_trailling_slash(url)
	32	end
	33
	34	def format_path_ends(path, leading=true, trailling=true)
	35	path = leading ? with_leading_slash(path) :
	36	without_leading_slash(path)
	37	trailling ? with_trailling_slash(path) :
	38	without_trailling_slash(path)
	39	end
	40
	41	def info
	42	info = Info.new({:root_url => target(),
	43	:lastrev => nil
	44	})
	45	info
	46	rescue CommandFailed
	47	return nil
	48	end
	49
	50	def entries(path="", identifier=nil)
	51	entries = Entries.new
	52	Dir.new(target(path)).each do \|e\|
	53	relative_path = format_path_ends((format_path_ends(path,
	54	false,
	55	true) + e),
	56	false,false)
	57	target = target(relative_path)
	58	entries <<
	59	Entry.new({ :name => File.basename(e),
	60	# below : list unreadable files, but dont link them.
	61	:path => File.readable?(target) ? relative_path : "",
	62	:kind => (File.directory?(target) ? 'dir' : 'file'),
	63	:size => if (File.directory?(target))
	64	nil else File.size(target) end,
	65	:lastrev =>
	66	Revision.new({:time => (File.mtime(target)).localtime,
	67	})
	68	}) if File.exist?(target) and # paranoid test
	69	%w{file directory}.include?(File.ftype(target)) and # avoid special types
	70	not File.basename(e).match(/^\.+$/) # avoid . and ..
	71	end
	72	entries.sort_by_name
	73	end
	74
	75	def cat(path, identifier=nil)
	76	File.new(target(path)).read
	77	end
	78
	79	private
	80
	81	# AbstractAdapter::target is implicitly made to quote paths.
	82	# Here we do not shell-out, so we do not want quotes.
	83	def target(path=nil)
	84	#Prevent the use of ..
	85	if path and !path.match(/(^\|\/)\.\.(\/\|$)/)
	86	return "#{self.url}#{without_leading_slash(path)}"
	87	end
	88	return self.url
	89	end
	90
	91	end
	92	end
	93	end
	94	end

test/fixtures/repositories/filesystem_repository.tar.gz created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

test/unit/filesystem_adapter_test.rb created 644 +42 0

@@ -0,0 +1,42
	1
	2	require File.dirname(__FILE__) + '/../test_helper'
	3
	4
	5	class FilesystemAdapterTest < Test::Unit::TestCase
	6
	7	REPOSITORY_PATH = RAILS_ROOT.gsub(%r{config\/\.\.}, '') + '/tmp/test/filesystem_repository'
	8
	9	if File.directory?(REPOSITORY_PATH)
	10	def setup
	11	@adapter = Redmine::Scm::Adapters::FilesystemAdapter.new(REPOSITORY_PATH)
	12	end
	13
	14	def test_entries
	15	assert_equal 2, @adapter.entries.size
	16	assert_equal ["dir", "test"], @adapter.entries.collect(&:name)
	17	assert_equal ["dir", "test"], @adapter.entries(nil).collect(&:name)
	18	assert_equal ["dir", "test"], @adapter.entries("/").collect(&:name)
	19	["dir", "/dir", "/dir/", "dir/"].each do \|path\|
	20	assert_equal ["subdir", "dirfile"], @adapter.entries(path).collect(&:name)
	21	end
	22	# If y try to use "..", the path is ignored
	23	["/../","dir/../", "..", "../", "/..", "dir/.."].each do \|path\|
	24	assert_equal ["dir", "test"], @adapter.entries(path).collect(&:name), ".. must be ignored in path argument"
	25	end
	26	end
	27
	28	def test_cat
	29	assert_equal "TEST CAT\n", @adapter.cat("test")
	30	assert_equal "TEST CAT\n", @adapter.cat("/test")
	31	# Revision number is ignored
	32	assert_equal "TEST CAT\n", @adapter.cat("/test", 1)
	33	end
	34
	35	else
	36	puts "Filesystem test repository NOT FOUND. Skipping unit tests !!! See doc/RUNNING_TESTS."
	37	def test_fake; assert true end
	38	end
	39
	40	end
	41
	42

test/unit/repository_filesystem_test.rb created 644 +54 0

@@ -0,0 +1,54
	1	# redMine - project management software
	2	# Copyright (C) 2006-2007 Jean-Philippe Lang
	3	#
	4	# This program is free software; you can redistribute it and/or
	5	# modify it under the terms of the GNU General Public License
	6	# as published by the Free Software Foundation; either version 2
	7	# of the License, or (at your option) any later version.
	8	#
	9	# This program is distributed in the hope that it will be useful,
	10	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	# GNU General Public License for more details.
	13	#
	14	# You should have received a copy of the GNU General Public License
	15	# along with this program; if not, write to the Free Software
	16	# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	17
	18	require File.dirname(__FILE__) + '/../test_helper'
	19
	20	class RepositoryFilesystemTest < Test::Unit::TestCase
	21	fixtures :projects
	22
	23	# No '..' in the repository path
	24	REPOSITORY_PATH = RAILS_ROOT.gsub(%r{config\/\.\.}, '') + '/tmp/test/filesystem_repository'
	25
	26	def setup
	27	@project = Project.find(1)
	28	Setting.enabled_scm << 'Filesystem' unless Setting.enabled_scm.include?('Filesystem')
	29	assert @repository = Repository::Filesystem.create(:project => @project, :url => REPOSITORY_PATH)
	30	end
	31
	32	if File.directory?(REPOSITORY_PATH)
	33	def test_fetch_changesets
	34	@repository.fetch_changesets
	35	@repository.reload
	36
	37	assert_equal 0, @repository.changesets.count
	38	assert_equal 0, @repository.changes.count
	39	end
	40
	41	def test_entries
	42	assert_equal 2, @repository.entries("", 2).size
	43	assert_equal 2, @repository.entries("dir", 3).size
	44	end
	45
	46	def test_cat
	47	assert_equal "TEST CAT\n", @repository.scm.cat("test")
	48	end
	49
	50	else
	51	puts "Filesystem test repository NOT FOUND. Skipping unit tests !!! See doc/RUNNING_TESTS."
	52	def test_fake; assert true end
	53	end
	54	end

app/helpers/repositories_helper.rb +4 0

             # redMine - project management software
             # Copyright (C) 2006  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 'coderay'
             require 'coderay/helpers/file_type'
             require 'iconv'
             module RepositoriesHelper
               def syntax_highlight(name, content)
                 type = CodeRay::FileType[name]
                 type ? CodeRay.scan(content, type).html : h(content)
               end
               def format_revision(txt)
                 txt.to_s[0,8]
               end
               def to_utf8(str)
                 return str if /\A[\r\n\t\x20-\x7e]*\Z/n.match(str) # for us-ascii
                 @encodings ||= Setting.repositories_encodings.split(',').collect(&:strip)
                 @encodings.each do |encoding|
                   begin
                     return Iconv.conv('UTF-8', encoding, str)
                   rescue Iconv::Failure
                     # do nothing here and try the next encoding
                   end
                 end
                 str
               end
               def repository_field_tags(form, repository)
                 method = repository.class.name.demodulize.underscore + "_field_tags"
                 send(method, form, repository) if repository.is_a?(Repository) && respond_to?(method)
               end
               def scm_select_tag(repository)
                 scm_options = [["--- #{l(:actionview_instancetag_blank_option)} ---", '']]
                 REDMINE_SUPPORTED_SCM.each do |scm|
                   scm_options << ["Repository::#{scm}".constantize.scm_name, scm] if Setting.enabled_scm.include?(scm) || (repository && repository.class.name.demodulize == scm)
                 end
                 select_tag('repository_scm',
                            options_for_select(scm_options, repository.class.name.demodulize),
                            :disabled => (repository && !repository.new_record?),
                            :onchange => remote_function(:url => { :controller => 'repositories', :action => 'edit', :id => @project }, :method => :get, :with => "Form.serialize(this.form)")
                            )
               end
               def with_leading_slash(path)
                 path.to_s.starts_with?('/') ? path : "/#{path}"
               end
               def without_leading_slash(path)
                 path.gsub(%r{^/+}, '')
               end
               def subversion_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)) +
                                    '<br />(http://, https://, svn://, file:///)') +
                   content_tag('p', form.text_field(:login, :size => 30)) +
                   content_tag('p', form.password_field(:password, :size => 30, :name => 'ignore',
                                                        :value => ((repository.new_record? || repository.password.blank?) ? '' : ('x'*15)),
                                                        :onfocus => "this.value=''; this.name='repository[password]';",
                                                        :onchange => "this.name='repository[password]';"))
               end
               def darcs_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :label => 'Root directory', :size => 60, :required => true, :disabled => (repository && !repository.new_record?)))
               end
               def mercurial_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :label => 'Root directory', :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)))
               end
               def git_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :label => 'Path to .git directory', :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)))
               end
               def cvs_field_tags(form, repository)
                   content_tag('p', form.text_field(:root_url, :label => 'CVSROOT', :size => 60, :required => true, :disabled => !repository.new_record?)) +
                   content_tag('p', form.text_field(:url, :label => 'Module', :size => 30, :required => true, :disabled => !repository.new_record?))
               end
               def bazaar_field_tags(form, repository)
                   content_tag('p', form.text_field(:url, :label => 'Root directory', :size => 60, :required => true, :disabled => (repository && !repository.new_record?)))
               end
+              def filesystem_field_tags(form, repository)
+                content_tag('p', form.text_field(:url, :label => 'Root directory', :size => 60, :required => true, :disabled => (repository && !repository.root_url.blank?)))
+              end
             end

doc/RUNNING_TESTS +4 0

             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
+            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.rb +1 -1

             require 'redmine/access_control'
             require 'redmine/menu_manager'
             require 'redmine/mime_type'
             require 'redmine/core_ext'
             require 'redmine/themes'
             require 'redmine/plugin'
             begin
               require_library_or_gem 'RMagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
-            REDMINE_SUPPORTED_SCM = %w( Subversion Darcs Mercurial Cvs Bazaar Git )
+            REDMINE_SUPPORTED_SCM = %w( Subversion Darcs Mercurial Cvs Bazaar Git Filesystem )
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show, :activity]}, :public => true
               map.permission :search_project, {:search => :index}, :public => true
               map.permission :edit_project, {:projects => [:settings, :edit]}, :require => :member
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :manage_members, {:projects => :settings, :members => [:new, :edit, :destroy]}, :require => :member
               map.permission :manage_versions, {:projects => [:settings, :add_version], :versions => [:edit, :destroy]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => [:settings, :add_issue_category], :issue_categories => [:edit, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:projects => [:changelog, :roadmap],
                                               :issues => [:index, :changes, :show, :context_menu],
                                               :versions => [:show, :status_by],
                                               :queries => :index,
                                               :reports => :issue_report}, :public => true
                 map.permission :add_issues, {:issues => :new}
                 map.permission :edit_issues, {:issues => [:edit, :reply, :bulk_edit, :destroy_attachment]}
                 map.permission :manage_issue_relations, {:issue_relations => [:new, :destroy]}
                 map.permission :add_issue_notes, {:issues => [:edit, :reply]}
                 map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
                 map.permission :move_issues, {:issues => :move}, :require => :loggedin
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :edit, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :edit, :destroy]}, :require => :loggedin
                 # Gantt & calendar
                 map.permission :view_gantt, :projects => :gantt
                 map.permission :view_calendar, :projects => :calendar
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => :edit}, :require => :loggedin
                 map.permission :view_time_entries, :timelog => [:details, :report]
                 map.permission :edit_time_entries, {:timelog => [:edit, :destroy]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :destroy]}, :require => :loggedin
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :edit, :destroy, :destroy_comment]}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true
                 map.permission :comment_news, {:news => :add_comment}
               end
               map.project_module :documents do |map|
                 map.permission :manage_documents, {:documents => [:new, :edit, :destroy, :add_attachment, :destroy_attachment]}, :require => :loggedin
                 map.permission :view_documents, :documents => [:index, :show, :download]
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:projects => :add_file, :versions => :destroy_file}, :require => :loggedin
                 map.permission :view_files, :projects => :list_files, :versions => :download
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => :destroy}, :require => :member
                 map.permission :view_wiki_pages, :wiki => [:index, :history, :diff, :annotate, :special]
                 map.permission :edit_wiki_pages, :wiki => [:edit, :preview, :add_attachment, :destroy_attachment]
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:edit, :destroy]}, :require => :member
                 map.permission :browse_repository, :repositories => [:show, :browse, :entry, :annotate, :changes, :diff, :stats, :graph]
                 map.permission :view_changesets, :repositories => [:show, :revisions, :revision]
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :edit, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true
                 map.permission :add_messages, {:messages => [:new, :reply]}
                 map.permission :edit_messages, {:messages => :edit}, :require => :member
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path, :html => { :class => 'home' }
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :html => { :class => 'mypage' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural, :html => { :class => 'projects' }
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :html => { :class => 'admin' }, :if => Proc.new { User.current.admin? }
               menu.push :help, Redmine::Info.help_url, :html => { :class => 'help' }
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :html => { :class => 'login' }, :if => Proc.new { !User.current.logged? }
               menu.push :register, { :controller => 'account', :action => 'register' }, :html => { :class => 'register' }, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :html => { :class => 'myaccount' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => { :class => 'logout' }, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'projects', :action => 'activity' }
               menu.push :roadmap, { :controller => 'projects', :action => 'roadmap' },
                           :if => Proc.new { |p| p.versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new' }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) }
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'index', :page => nil },
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'projects', :action => 'list_files' }, :caption => :label_attachment_plural
               menu.push :repository, { :controller => 'repositories', :action => 'show' },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }
             end

lib/redmine/scm/adapters/abstract_adapter.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 'cgi'
             module Redmine
               module Scm
                 module Adapters
                   class CommandFailed < StandardError #:nodoc:
                   end
                   class AbstractAdapter #:nodoc:
                     def initialize(url, root_url=nil, login=nil, password=nil)
                       @url = url
                       @login = login if login && !login.empty?
                       @password = (password || "") if @login
                       @root_url = root_url.blank? ? retrieve_root_url : root_url
                     end
                     def adapter_name
                       'Abstract'
                     end
                     def supports_cat?
                       true
                     end
                     def supports_annotate?
                       respond_to?('annotate')
                     end
                     def root_url
                       @root_url
                     end
                     def url
                       @url
                     end
                     # get info about the svn repository
                     def info
                       return nil
                     end
                     # Returns the entry identified by path and revision identifier
                     # or nil if entry doesn't exist in the repository
                     def entry(path=nil, identifier=nil)
                       parts = path.to_s.split(%r{[\/\\]}).select {|n| !n.blank?}
                       search_path = parts[0..-2].join('/')
                       search_name = parts[-1]
                       if search_path.blank? && search_name.blank?
                         # Root entry
                         Entry.new(:path => '', :kind => 'dir')
                       else
                         # Search for the entry in the parent directory
                         es = entries(search_path, identifier)
                         es ? es.detect {|e| e.name == search_name} : nil
                       end
                     end
                     # Returns an Entries collection
                     # or nil if the given path doesn't exist in the repository
                     def entries(path=nil, identifier=nil)
                       return nil
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       return nil
                     end
                     def diff(path, identifier_from, identifier_to=nil, type="inline")
                       return nil
                     end
                     def cat(path, identifier=nil)
                       return nil
                     end
                     def with_leading_slash(path)
                       path ||= ''
                       (path[0,1]!="/") ? "/#{path}" : path
                     end
                     def with_trailling_slash(path)
                       path ||= ''
                       (path[-1,1] == "/") ? path : "#{path}/"
                     end
+                    def without_leading_slash(path)
+                      path ||= ''
+                      path.gsub(%r{^/+}, '')
+                    end
+                    def without_trailling_slash(path)
+                      path ||= ''
+                      (path[-1,1] == "/") ? path[0..-2] : path
+                     end
                     def shell_quote(str)
                       if RUBY_PLATFORM =~ /mswin/
                         '"' + str.gsub(/"/, '\\"') + '"'
                       else
                         "'" + str.gsub(/'/, "'\"'\"'") + "'"
                       end
                     end
                   private
                     def retrieve_root_url
                       info = self.info
                       info ? info.root_url : nil
                     end
                     def target(path)
                       path ||= ''
                       base = path.match(/^\//) ? root_url : url
                       shell_quote("#{base}/#{path}".gsub(/[?<>\*]/, ''))
                     end
                     def logger
                       RAILS_DEFAULT_LOGGER
                     end
                     def shellout(cmd, &block)
                       logger.debug "Shelling out: #{cmd}" if logger && logger.debug?
                       begin
                         IO.popen(cmd, "r+") do |io|
                           io.close_write
                           block.call(io) if block_given?
                         end
                       rescue Errno::ENOENT => e
                         msg = strip_credential(e.message)
                         # The command failed, log it and re-raise
                         logger.error("SCM command failed: #{strip_credential(cmd)}\n  with: #{msg}")
                         raise CommandFailed.new(msg)
                       end
                     end
                     # Hides username/password in a given command
                     def self.hide_credential(cmd)
                       q = (RUBY_PLATFORM =~ /mswin/ ? '"' : "'")
                       cmd.to_s.gsub(/(\-\-(password|username))\s+(#{q}[^#{q}]+#{q}|[^#{q}]\S+)/, '\\1 xxxx')
                     end
                     def strip_credential(cmd)
                       self.class.hide_credential(cmd)
                     end
                   end
                   class Entries < Array
                     def sort_by_name
                       sort {|x,y|
                         if x.kind == y.kind
                           x.name <=> y.name
                         else
                           x.kind <=> y.kind
                         end
                       }
                     end
                     def revisions
                       revisions ||= Revisions.new(collect{|entry| entry.lastrev}.compact)
                     end
                   end
                   class Info
                     attr_accessor :root_url, :lastrev
                     def initialize(attributes={})
                       self.root_url = attributes[:root_url] if attributes[:root_url]
                       self.lastrev = attributes[:lastrev]
                     end
                   end
                   class Entry
                     attr_accessor :name, :path, :kind, :size, :lastrev
                     def initialize(attributes={})
                       self.name = attributes[:name] if attributes[:name]
                       self.path = attributes[:path] if attributes[:path]
                       self.kind = attributes[:kind] if attributes[:kind]
                       self.size = attributes[:size].to_i if attributes[:size]
                       self.lastrev = attributes[:lastrev]
                     end
                     def is_file?
                       'file' == self.kind
                     end
                     def is_dir?
                       'dir' == self.kind
                     end
                     def is_text?
                       Redmine::MimeType.is_type?('text', name)
                     end
                   end
                   class Revisions < Array
                     def latest
                       sort {|x,y|
                         unless x.time.nil? or y.time.nil?
                           x.time <=> y.time
                         else
                         end
                       }.last
                     end
                   end
                   class Revision
                     attr_accessor :identifier, :scmid, :name, :author, :time, :message, :paths, :revision, :branch
                     def initialize(attributes={})
                       self.identifier = attributes[:identifier]
                       self.scmid = attributes[:scmid]
                       self.name = attributes[:name] || self.identifier
                       self.author = attributes[:author]
                       self.time = attributes[:time]
                       self.message = attributes[:message] || ""
                       self.paths = attributes[:paths]
                       self.revision = attributes[:revision]
                       self.branch = attributes[:branch]
                     end
                   end
                   # A line of Diff
                   class Diff
                     attr_accessor :nb_line_left
                     attr_accessor :line_left
                     attr_accessor :nb_line_right
                     attr_accessor :line_right
                     attr_accessor :type_diff_right
                     attr_accessor :type_diff_left
                     def initialize ()
                       self.nb_line_left = ''
                       self.nb_line_right = ''
                       self.line_left = ''
                       self.line_right = ''
                       self.type_diff_right = ''
                       self.type_diff_left = ''
                     end
                     def inspect
                       puts '### Start Line Diff ###'
                       puts self.nb_line_left
                       puts self.line_left
                       puts self.nb_line_right
                       puts self.line_right
                     end
                   end
                   class DiffTableList < Array
                     def initialize (diff, type="inline")
                         diff_table = DiffTable.new type
                         diff.each do |line|
                             if line =~ /^(---|\+\+\+) (.*)$/
                                 self << diff_table if diff_table.length > 1
                                 diff_table = DiffTable.new type
                             end
                             a = diff_table.add_line line
                         end
                         self << diff_table unless diff_table.empty?
                         self
                     end
                   end
                   # Class for create a Diff
                   class DiffTable < Hash
                     attr_reader :file_name, :line_num_l, :line_num_r
                     # Initialize with a Diff file and the type of Diff View
                     # The type view must be inline or sbs (side_by_side)
                     def initialize(type="inline")
                       @parsing = false
                       @nb_line = 1
                       @start = false
                       @before = 'same'
                       @second = true
                       @type = type
                     end
                     # Function for add a line of this Diff
                     def add_line(line)
                       unless @parsing
                         if line =~ /^(---|\+\+\+) (.*)$/
                           @file_name = $2
                           return false
                         elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                           @line_num_l = $5.to_i
                           @line_num_r = $2.to_i
                           @parsing = true
                         end
                       else
                         if line =~ /^[^\+\-\s@\\]/
                           @parsing = false
                           return false
                         elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/
                           @line_num_l = $5.to_i
                           @line_num_r = $2.to_i
                         else
                           @nb_line += 1 if parse_line(line, @type)
                         end
                       end
                       return true
                     end
                     def inspect
                       puts '### DIFF TABLE ###'
                       puts "file : #{file_name}"
                       self.each do |d|
                         d.inspect
                       end
                     end
                   private
                     # Test if is a Side By Side type
                     def sbs?(type, func)
                       if @start and type == "sbs"
                         if @before == func and @second
                           tmp_nb_line = @nb_line
                           self[tmp_nb_line] = Diff.new
                         else
                             @second = false
                             tmp_nb_line = @start
                             @start += 1
                             @nb_line -= 1
                         end
                       else
                         tmp_nb_line = @nb_line
                         @start = @nb_line
                         self[tmp_nb_line] = Diff.new
                         @second = true
                       end
                       unless self[tmp_nb_line]
                         @nb_line += 1
                         self[tmp_nb_line] = Diff.new
                       else
                         self[tmp_nb_line]
                       end
                     end
                     # Escape the HTML for the diff
                     def escapeHTML(line)
                         CGI.escapeHTML(line)
                     end
                     def parse_line(line, type="inline")
                       if line[0, 1] == "+"
                         diff = sbs? type, 'add'
                         @before = 'add'
                         diff.line_left = escapeHTML line[1..-1]
                         diff.nb_line_left = @line_num_l
                         diff.type_diff_left = 'diff_in'
                         @line_num_l += 1
                         true
                       elsif line[0, 1] == "-"
                         diff = sbs? type, 'remove'
                         @before = 'remove'
                         diff.line_right = escapeHTML line[1..-1]
                         diff.nb_line_right = @line_num_r
                         diff.type_diff_right = 'diff_out'
                         @line_num_r += 1
                         true
                       elsif line[0, 1] =~ /\s/
                         @before = 'same'
                         @start = false
                         diff = Diff.new
                         diff.line_right = escapeHTML line[1..-1]
                         diff.nb_line_right = @line_num_r
                         diff.line_left = escapeHTML line[1..-1]
                         diff.nb_line_left = @line_num_l
                         self[@nb_line] = diff
                         @line_num_l += 1
                         @line_num_r += 1
                         true
                       elsif line[0, 1] = "\\"
                         true
                       else
                         false
                       end
                     end
                   end
                   class Annotate
                     attr_reader :lines, :revisions
                     def initialize
                       @lines = []
                       @revisions = []
                     end
                     def add_line(line, revision)
                       @lines << line
                       @revisions << revision
                     end
                     def content
                       content = lines.join("\n")
                     end
                     def empty?
                       lines.empty?
                     end
                   end
                 end
               end
             end

test/unit/repository_test.rb +2 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 File.dirname(__FILE__) + '/../test_helper'
             class RepositoryTest < Test::Unit::TestCase
               fixtures :projects,
                        :trackers,
                        :projects_trackers,
                        :repositories,
                        :issues,
                        :issue_statuses,
                        :changesets,
                        :changes,
                        :users,
                        :enumerations
               def setup
                 @repository = Project.find(1).repository
               end
               def test_create
                 repository = Repository::Subversion.new(:project => Project.find(3))
                 assert !repository.save
                 repository.url = "svn://localhost"
                 assert repository.save
                 repository.reload
                 project = Project.find(3)
                 assert_equal repository, project.repository
               end
               def test_should_not_create_with_disabled_scm
                 # disable Subversion
                 Setting.enabled_scm = ['Darcs', 'Git']
                 repository = Repository::Subversion.new(:project => Project.find(3), :url => "svn://localhost")
                 assert !repository.save
                 assert_equal :activerecord_error_invalid, repository.errors.on(:type)
+                # re-enable Subversion for following tests
+                Setting.delete_all
               end
               def test_scan_changesets_for_issue_ids
                 # choosing a status to apply to fix issues
                 Setting.commit_fix_status_id = IssueStatus.find(:first, :conditions => ["is_closed = ?", true]).id
                 Setting.commit_fix_done_ratio = "90"
                 Setting.commit_ref_keywords = 'refs , references, IssueID'
                 Setting.commit_fix_keywords = 'fixes , closes'
                 Setting.default_language = 'en'
                 ActionMailer::Base.deliveries.clear
                 # make sure issue 1 is not already closed
                 fixed_issue = Issue.find(1)
                 assert !fixed_issue.status.is_closed?
                 old_status = fixed_issue.status
                 Repository.scan_changesets_for_issue_ids
                 assert_equal [101, 102], Issue.find(3).changeset_ids
                 # fixed issues
                 fixed_issue.reload
                 assert fixed_issue.status.is_closed?
                 assert_equal 90, fixed_issue.done_ratio
                 assert_equal [101], fixed_issue.changeset_ids
                 # issue change
                 journal = fixed_issue.journals.find(:first, :order => 'created_on desc')
                 assert_equal User.find_by_login('dlopper'), journal.user
                 assert_equal 'Applied in changeset r2.', journal.notes
                 # 2 email notifications
                 assert_equal 2, ActionMailer::Base.deliveries.size
                 mail = ActionMailer::Base.deliveries.first
                 assert_kind_of TMail::Mail, mail
                 assert mail.subject.starts_with?("[#{fixed_issue.project.name} - #{fixed_issue.tracker.name} ##{fixed_issue.id}]")
                 assert mail.body.include?("Status changed from #{old_status} to #{fixed_issue.status}")
                 # ignoring commits referencing an issue of another project
                 assert_equal [], Issue.find(4).changesets
               end
               def test_for_changeset_comments_strip
                 repository = Repository::Mercurial.create( :project => Project.find( 4 ), :url => '/foo/bar/baz' )
                 comment = <<-COMMENT
                 This is a loooooooooooooooooooooooooooong comment
                 COMMENT
                 changeset = Changeset.new(
                   :comments => comment, :commit_date => Time.now, :revision => 0, :scmid => 'f39b7922fb3c',
                   :committer => 'foo <foo@example.com>', :committed_on => Time.now, :repository => repository )
                 assert( changeset.save )
                 assert_not_equal( comment, changeset.comments )
                 assert_equal( 'This is a loooooooooooooooooooooooooooong comment', changeset.comments )
               end
               def test_for_urls_strip
                 repository = Repository::Cvs.create(:project => Project.find(4), :url => ' :pserver:login:password@host:/path/to/the/repository',
                                                                                  :root_url => 'foo  ')
                 assert repository.save
                 repository.reload
                 assert_equal ':pserver:login:password@host:/path/to/the/repository', repository.url
                 assert_equal 'foo', repository.root_url
               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