SoundSoftware Code Site

K 25

svn:wc:ra_dav:version-url

END

subversion_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

bazaar_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

abstract_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

git_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

mercurial_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

filesystem_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

cvs_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

darcs_adapter.rb

K 25

svn:wc:ra_dav:version-url

END

10

dir

http://redmine.rubyforge.org/svn

tmaruyama

tmaruyama

bazaar_adapter.rb

file

tmaruyama

has-props

mercurial

dir

tmaruyama

has-props

git_adapter.rb

file

tmaruyama

has-props

mercurial_adapter.rb

file

tmaruyama

has-props

filesystem_adapter.rb

file

tmaruyama

has-props

cvs_adapter.rb

file

tmaruyama

has-props

darcs_adapter.rb

file

tmaruyama

has-props

#

# 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.

        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)

            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

          return nil

        end

          return nil

        end

          return nil

        end

        def default_branch

          return nil

        end

        def properties(path, 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)

          return nil

        end

        def cat(path, identifier=nil)

          return nil

        end

        def with_leading_slash(path)

          path ||= ''

          (path[0,1]!="/") ? "/#{path}" : path

          info = self.info

          info ? info.root_url : nil

        end

        def target(path)

          path ||= ''

          base = path.match(/^\//) ? root_url : url

          q = (Redmine::Platform.mswin? ? '"' : "'")

          cmd.to_s.gsub(/(\-\-(password|username))\s+(#{q}[^#{q}]+#{q}|[^#{q}]\S+)/, '\\1 xxxx')

        end

        def strip_credential(cmd)

          self.class.strip_credential(cmd)

        end

      class Entries < Array

        def sort_by_name

            if x.kind == y.kind

              x.name.to_s <=> y.name.to_s

            else

            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.lastrev = attributes[:lastrev]

        end

      end

      class Entry

        attr_accessor :name, :path, :kind, :size, :lastrev

        def initialize(attributes={})

          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|

              0

            end

          }.last

      end

      class Revision

        def initialize(attributes={})

          self.identifier = attributes[:identifier]

        end

        # Returns the readable identifier.

        def format_identifier

        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

#

# 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.

        # Returns an Entries collection

        # or nil if the given path doesn't exist in the repository

          path ||= ''

          entries = Entries.new

          cmd = "#{self.class.sq_bin} ls -v --show-ids"

          cmd << " #{target(path)}"

          shellout(cmd) do |io|

            prefix = "#{url}/#{path}".gsub('\\', '/')

                parsing = nil

              else

                next unless revision

                if line =~ /^revno: (\d+)($|\s\[merge\]$)/

                  revision.identifier = $1.to_i

                elsif line =~ /^committer: (.+)$/

        def diff(path, identifier_from, identifier_to=nil)

          path ||= ''

          if identifier_to

          else

            identifier_to = identifier_from.to_i - 1

          end

            identifier = nil

            io.each_line do |line|

              next unless line =~ %r{^(\d+) ([^|]+)\| (.*)$}

            end

          end

          return nil if $? && $?.exitstatus != 0

# 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.

        # CVS executable name

        CVS_BIN = Redmine::Configuration['scm_cvs_command'] || "cvs"

        class << self

          def client_command

            @@bin    ||= CVS_BIN

        end

        # Guidelines for the input:

        #  root_url -> the good old, sometimes damned, CVSROOT

        #  password -> unnecessary too

        def initialize(url, root_url=nil, login=nil, password=nil,

                       path_encoding=nil)

          @password = (password || "") if @login

        end

        end

        def info

        # Returns an Entries collection

        # or nil if the given path doesn't exist in the repository

        # this method is used by the repository-browser (aka LIST)

          logger.debug "<cvs> entries '#{path}' with identifier '#{identifier}'"

          entries = Entries.new

              logger.debug(">>InspectLine #{fields.inspect}")

              if fields[0]!="D"

                  #:path => fields[-4].include?(path)?fields[-4]:(path + "/"+ fields[-4]),

                  :kind => 'file',

                  :size => nil,

                  })

              else

                  :lastrev => nil

              end

          end

          entries.sort_by_name

        end

        STARTLOG="----------------------------"

        # in the repository. both identifier have to be dates or nil.

        # these method returns nothing but yield every result in block

        def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={}, &block)

            io.each_line() do |line|

              end

                  entry_path = normalize_cvs_path($1)

                  entry_name = normalize_path(File.basename($1))

                  logger.debug("Path #{entry_path} <=> Name #{entry_name}")

                elsif /^head: (.+)$/ =~ line

                  entry_headRev = $1 #unless entry.nil?

                elsif /^symbolic names:/ =~ line

                elsif /^#{STARTLOG}/ =~ line

                next

                else

                  next

                if /^#{STARTLOG}/ =~ line

                  commit_log = ""

                elsif /^#{ENDLOG}/ =~ line

                end

                next

                if /^#{ENDLOG}/ =~ line || /^#{STARTLOG}/ =~ line

                  if revision

                      if revHelper.is_in_branch_with_symbol(branch_point)

                      end

                    end

                    logger.debug("********** YIELD Revision #{revision}::#{revBranch}")

                    yield Revision.new({

                      :paths => [{

                        :revision => revision,

                  end

                  if /^#{ENDLOG}/ =~ line

                  end

                  next

                end

                if /^branches: (.+)$/ =~ line

                elsif /^revision (\d+(?:\.\d+)+).*$/ =~ line

                elsif /^date:\s+(\d+.\d+.\d+\s+\d+:\d+:\d+)/ =~ line

                  #                linechanges =/lines: \+(\d+) -(\d+)/.match(line)

                  #                unless linechanges.nil?

                  #                  version.line_plus  = linechanges[1]

              end

            end

          end

        end

        def diff(path, identifier_from, identifier_to=nil)

          diff = []

            io.each_line do |line|

              diff << line

            end

          end

          diff

        end

        def cat(path, identifier=nil)

          identifier = (identifier) ? identifier : "HEAD"

          logger.debug "<cvs> cat path:'#{path}',identifier #{identifier}"

          cat = nil

            io.binmode

            cat = io.read

          end

          cat

        end

        def annotate(path, identifier=nil)

          logger.debug "<cvs> annotate path:'#{path}',identifier #{identifier}"

          blame = Annotate.new

            io.each_line do |line|

              next unless line =~ %r{^([\d\.]+)\s+\(([^\)]+)\s+[^\)]+\):\s(.*)$}

            end

          end

          blame

        end

        private

        # convert a date/time into the CVS-format

        def time_to_cvstime(time)

          return nil if time.nil?

          unless time.kind_of? Time

            time = Time.parse(time)

          end

        end

        def time_to_cvstime_rlog(time)

          t1 = time.clone.localtime

          return t1.strftime("%Y-%m-%d %H:%M:%S")

        end

        def normalize_cvs_path(path)

          normalize_path(path.gsub(/Attic\//,''))

        end

        def normalize_path(path)

          path.sub(/^(\/)*(.*)/,'\2').sub(/(.*)(,v)+/,'\1')

      class CvsRevisionHelper

        attr_accessor :complete_rev, :revision, :base, :branchid

        def initialize(complete_rev)

          @complete_rev = complete_rev

          parseRevision()

        end

        def branchPoint

          return @base

        end

        def branchVersion

          if isBranchRevision

            return @base+"."+@branchid

          end

          return @base

        end

        def isBranchRevision

          !@branchid.nil?

        end

        def prevRev

          end

        end

        def is_in_branch_with_symbol(branch_symbol)

        end

        private

        def buildRevision(rev)

            if @branchid.nil?

            else

              @base

            end

          else

          end

        end

        # Interpretiert die cvs revisionsnummern wie z.b. 1.14 oder 1.3.0.15

        def parseRevision()

          if baseSize > 2

        end

      end

    end

#

# 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.

        # Returns an Entries collection

        # or nil if the given path doesn't exist in the repository

          path_prefix = (path.blank? ? '' : "#{path}/")

          if path.blank?

            path = ( self.class.client_version_above?([2, 2, 0]) ? @url : '.' )

#

# FileSystem adapter

# File written by Paul Rivier, at Demotera.

# 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.

        def initialize(url, root_url=nil, login=nil, password=nil,

                       path_encoding=nil)

          @url = with_trailling_slash(url)

        end

        def format_path_ends(path, leading=true, trailling=true)

            without_leading_slash(path)

        end

        def info

          return nil

        end

          entries = Entries.new

          trgt_utf8 = target(path)

          trgt = scm_iconv(@path_encoding, 'UTF-8', trgt_utf8)

          Dir.new(trgt).each do |e1|

            e_utf8 = scm_iconv('UTF-8', @path_encoding, e1)

            t1_utf8 = target(relative_path_utf8)

            t1 = scm_iconv(@path_encoding, 'UTF-8', t1_utf8)

            relative_path = scm_iconv(@path_encoding, 'UTF-8', relative_path_utf8)

                          :path => utf_8_path,

                          :kind => (File.directory?(t1) ? 'dir' : 'file'),

                          :size => (File.directory?(t1) ? nil : [File.size(t1)].pack('l').unpack('L').first),

                              Revision.new({:time => (File.mtime(t1)) })

                        })

            end

#

# 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.

    module Adapters

      class GitAdapter < AbstractAdapter

        # Git executable name

        GIT_BIN = Redmine::Configuration['scm_git_command'] || "git"

        def initialize(url, root_url=nil, login=nil, password=nil, path_encoding=nil)

          super

        end

        def info

        def branches

          return @branches if @branches

          @branches = []

            io.each_line do |line|

              @branches << line.match('\s*\*?\s*(.*)$')[1]

            end

          end

          @branches.sort!

        end

        def tags

          return @tags if @tags

            @tags = io.readlines.sort!.map{|t| t.strip}

          end

        end

          path ||= ''

          entries = Entries.new

            io.each_line do |line|

              e = line.chomp.to_s

              if e =~ /^\d+\s+(\w+)\s+([0-9a-f]{40})\s+([0-9-]+)\t(.+)$/

                type = $1

                size = $3

                name = $4

                 :kind => (type == "tree") ? 'dir' : 'file',

                 :size => (type == "tree") ? nil : size,

                }) unless entries.detect{|entry| entry.name == name}

              end

            end

          end

          entries.sort_by_name

        end

        def lastrev(path, rev)

          return nil if path.nil?

          cmd_args = %w|log --no-color --encoding=UTF-8 --date=iso --pretty=fuller --no-merges -n 1|

          cmd_args << "--" << path unless path.empty?

          lines = []

          scm_cmd(*cmd_args) { |io| lines = io.readlines }

              Revision.new({

                :identifier => id,

                })

          rescue NoMethodError => e

              logger.error("The revision '#{path}' has a wrong format")

        end

        def revisions(path, identifier_from, identifier_to, options={})

          cmd_args = %w|log --no-color --encoding=UTF-8 --raw --date=iso --pretty=fuller|

          cmd_args << "--reverse" if options[:reverse]

          cmd_args << "--all" if options[:all]

          from_to << "#{identifier_to}" if identifier_to

          cmd_args << from_to if !from_to.empty?

          cmd_args << "--since=#{options[:since].strftime("%Y-%m-%d %H:%M:%S")}" if options[:since]

          scm_cmd *cmd_args do |io|

            files=[]

            changeset = {}

            parsing_descr = 0  #0: not parsing desc or files, 1: parsing desc, 2: parsing files

            io.each_line do |line|

              if line =~ /^commit ([0-9a-f]{40})$/

                  parsing_descr = 0

                  revision = Revision.new({

                    :identifier => changeset[:commit],

                  })

                  if block_given?

                    yield revision

                  else

                  end

                  changeset = {}

                  files = []

                end

                changeset[:commit] = $1

              elsif (parsing_descr == 0) && line =~ /^(\w+):\s*(.*)$/

                parsing_descr = 1

                changeset[:description] = ""