redmine-mercurial.patch

Mercurial overhaul - Peter Fern, 2009-12-21 01:27

Download (22.3 KB)

View differences:

app/models/repository/mercurial.rb
28 28
  def self.scm_name
29 29
    'Mercurial'
30 30
  end
31
  
32
  def entries(path=nil, identifier=nil)
33
    entries=scm.entries(path, identifier)
34
    if entries
35
      entries.each do |entry|
36
        next unless entry.is_file?
37
        # Set the filesize unless browsing a specific revision
38
        if identifier.nil?
39
          full_path = File.join(root_url, entry.path)
40
          entry.size = File.stat(full_path).size if File.file?(full_path)
41
        end
42
        # Search the DB for the entry's last change
43
        change = changes.find(:first, :conditions => ["path = ?", scm.with_leading_slash(entry.path)], :order => "#{Changeset.table_name}.committed_on DESC")
44
        if change
45
          entry.lastrev.identifier = change.changeset.revision
46
          entry.lastrev.name = change.changeset.revision
47
          entry.lastrev.author = change.changeset.committer
48
          entry.lastrev.revision = change.revision
49
        end
50
      end
51
    end
52
    entries
31

  
32
  def branches
33
    scm.branches
34
  end
35

  
36
  def tags
37
    scm.tags
53 38
  end
54 39

  
40
  # Sequential changesets are brittle in Mercurial, so we take
41
  # a leaf out of Git's book, but run two passes to take 
42
  # advantage of the 'lite' log speed to build our sync list
55 43
  def fetch_changesets
56 44
    scm_info = scm.info
57
    if scm_info
58
      # latest revision found in database
59
      db_revision = latest_changeset ? latest_changeset.revision.to_i : -1
60
      # latest revision in the repository
61
      latest_revision = scm_info.lastrev
62
      return if latest_revision.nil?
63
      scm_revision = latest_revision.identifier.to_i
64
      if db_revision < scm_revision
65
        logger.debug "Fetching changesets for repository #{url}" if logger && logger.debug?
66
        identifier_from = db_revision + 1
67
        while (identifier_from <= scm_revision)
68
          # loads changesets by batches of 100
69
          identifier_to = [identifier_from + 99, scm_revision].min
70
          revisions = scm.revisions('', identifier_from, identifier_to, :with_paths => true)
71
          transaction do
72
            revisions.each do |revision|
73
              changeset = Changeset.create(:repository => self,
74
                                           :revision => revision.identifier,
75
                                           :scmid => revision.scmid,
76
                                           :committer => revision.author, 
77
                                           :committed_on => revision.time,
78
                                           :comments => revision.message)
79
              
80
              revision.paths.each do |change|
81
                Change.create(:changeset => changeset,
82
                              :action => change[:action],
83
                              :path => change[:path],
84
                              :from_path => change[:from_path],
85
                              :from_revision => change[:from_revision])
86
              end
87
            end
88
          end unless revisions.nil?
89
          identifier_from = identifier_to + 1
90
        end
91
      end
92
    end
45
    return unless scm_info or scm_info.lastrev.nil?
46
    
47
    db_revision = latest_changeset ? latest_changeset.scmid.to_s : 0
48
    scm_revision = scm_info.lastrev.scmid.to_s
49
    # Save ourselves an expensive operation if we're already up to date
50
    scm_revcount = scm.num_revisions
51
    db_revcount = changesets.count
52
    return if scm.num_revisions == changesets.count and db_revision == scm_revision
53
   
54
    lite_revisions = scm.revisions(nil, nil, scm_revision, :lite => true)
55
    return if lite_revisions.nil? or lite_revisions.empty?
56

  
57
    # Find revisions that redmine knows about already
58
    existing_revisions = changesets.find(:all).map!{|c| c.scmid}
59

  
60
    # Clean out revisions that are no longer in Mercurial
61
    Changeset.delete_all(["scmid NOT IN (?) AND repository_id = (?)", lite_revisions.map{|r| r.scmid}, self.id])
62

  
63
    # Subtract revisions that redmine already knows about
64
    lite_revisions.reject!{|r| existing_revisions.include?(r.scmid)}
65
    return if lite_revisions.nil? or lite_revisions.empty?
66
   
67
    # Retrieve full revisions for the remainder
68
    revisions = []
69
    lite_revisions.each {|r| revisions += scm.revisions(nil, r.scmid, r.scmid)}
70
    return if revisions.nil? or revisions.empty?
71

  
72
    # Save the results to the database
73
    revisions.each{|r| r.save(self)} unless revisions.nil?
74
  end
75
  
76
  def latest_changesets(path, rev, limit=10)
77
    revisions = scm.revisions(path, rev, 0, :limit => limit, :lite => true)
78
    return [] if revisions.nil? or revisions.empty?
79

  
80
    changesets.find(
81
      :all, 
82
      :conditions => [
83
        "scmid IN (?)", 
84
        revisions.map!{|c| c.scmid}
85
      ],
86
      :order => 'committed_on DESC'
87
    )
93 88
  end
94 89
end
lib/redmine/scm/adapters/mercurial/hg-template-0.9.5-lite.tmpl
1
changeset = 'This template must be used with --debug option\n'
2
changeset_quiet =  'This template must be used with --debug option\n'
3
changeset_verbose = 'This template must be used with --debug option\n'
4
changeset_debug = '<logentry revision="{rev}" shortnode="{node|short}" node="{node}">\n<author>{author|escape}</author>\n<date>{date|isodate}</date>\n<msg>{desc|escape}</msg>\n{tags}</logentry>\n\n'
5

  
6
tag = '<tag>{tag|escape}</tag>\n'
7
header='<?xml version="1.0" encoding="UTF-8" ?>\n<log>\n\n'
8
# footer="</log>"
lib/redmine/scm/adapters/mercurial/hg-template-0.9.5.tmpl
1 1
changeset = 'This template must be used with --debug option\n'
2 2
changeset_quiet =  'This template must be used with --debug option\n'
3 3
changeset_verbose = 'This template must be used with --debug option\n'
4
changeset_debug = '<logentry revision="{rev}" node="{node|short}">\n<author>{author|escape}</author>\n<date>{date|isodate}</date>\n<paths>\n{files}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc|escape}</msg>\n{tags}</logentry>\n\n'
4
changeset_debug = '<logentry revision="{rev}" shortnode="{node|short}" node="{node}">\n<author>{author|escape}</author>\n<date>{date|isodate}</date>\n<paths>\n{files}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc|escape}</msg>\n{tags}</logentry>\n\n'
5 5

  
6 6
file = '<path action="M">{file|escape}</path>\n'
7 7
file_add = '<path action="A">{file_add|escape}</path>\n'
lib/redmine/scm/adapters/mercurial/hg-template-1.0-lite.tmpl
1
changeset = 'This template must be used with --debug option\n'
2
changeset_quiet =  'This template must be used with --debug option\n'
3
changeset_verbose = 'This template must be used with --debug option\n'
4
changeset_debug = '<logentry revision="{rev}" shortnode="{node|short}" node="{node}">\n<author>{author|escape}</author>\n<date>{date|isodate}</date>\n<paths />\n<msg>{desc|escape}</msg>\n{tags}</logentry>\n\n'
5

  
6
tag = '<tag>{tag|escape}</tag>\n'
7
header='<?xml version="1.0" encoding="UTF-8" ?>\n<log>\n\n'
8
# footer="</log>"
lib/redmine/scm/adapters/mercurial/hg-template-1.0.tmpl
1 1
changeset = 'This template must be used with --debug option\n'
2 2
changeset_quiet =  'This template must be used with --debug option\n'
3 3
changeset_verbose = 'This template must be used with --debug option\n'
4
changeset_debug = '<logentry revision="{rev}" node="{node|short}">\n<author>{author|escape}</author>\n<date>{date|isodate}</date>\n<paths>\n{file_mods}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc|escape}</msg>\n{tags}</logentry>\n\n'
4
changeset_debug = '<logentry revision="{rev}" shortnode="{node|short}" node="{node}">\n<author>{author|escape}</author>\n<date>{date|isodate}</date>\n<paths>\n{file_mods}{file_adds}{file_dels}{file_copies}</paths>\n<msg>{desc|escape}</msg>\n{tags}</logentry>\n\n'
5 5

  
6 6
file_mod = '<path action="M">{file_mod|escape}</path>\n'
7 7
file_add = '<path action="A">{file_add|escape}</path>\n'
lib/redmine/scm/adapters/mercurial_adapter.rb
21 21
  module Scm
22 22
    module Adapters    
23 23
      class MercurialAdapter < AbstractAdapter
24
        
24

  
25 25
        # Mercurial executable name
26 26
        HG_BIN = "hg"
27 27
        TEMPLATES_DIR = File.dirname(__FILE__) + "/mercurial"
28 28
        TEMPLATE_NAME = "hg-template"
29 29
        TEMPLATE_EXTENSION = "tmpl"
30
        
30

  
31 31
        class << self
32 32
          def client_version
33 33
            @@client_version ||= (hgversion || [])
34 34
          end
35
          
35

  
36 36
          def hgversion  
37 37
            # The hg version is expressed either as a
38 38
            # release number (eg 0.9.5 or 1.0) or as a revision
......
42 42
              theversion.split(".").collect(&:to_i)
43 43
            end
44 44
          end
45
          
45

  
46 46
          def hgversion_from_command_line
47 47
            %x{#{HG_BIN} --version}.match(/\(version (.*)\)/)[1]
48 48
          end
49
          
49

  
50 50
          def template_path
51 51
            @@template_path ||= template_path_for(client_version)
52 52
          end
53
          
54
          def template_path_for(version)
53

  
54
          def lite_template_path
55
            @@lite_template_path ||= template_path_for(client_version,'lite')
56
          end
57

  
58
          def template_path_for(version,style=nil)
55 59
            if ((version <=> [0,9,5]) > 0) || version.empty?
56 60
              ver = "1.0"
57 61
            else
58 62
              ver = "0.9.5"
59 63
            end
60
            "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{ver}.#{TEMPLATE_EXTENSION}"
64
            if style
65
              tmpl = "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{ver}-#{style}.#{TEMPLATE_EXTENSION}"
66
            else
67
            	tmpl = "#{TEMPLATES_DIR}/#{TEMPLATE_NAME}-#{ver}.#{TEMPLATE_EXTENSION}"
68
            end
69
            tmpl
70
          end
71
        end
72

  
73
        def default_branch
74
          @default_branch ||= 'tip'
75
        end
76

  
77
        def branches
78
          @branches ||= get_branches
79
        end
80

  
81
        def get_branches
82
          branches = []
83
          cmd = "#{HG_BIN} -R #{target('')} branches"
84
          shellout(cmd) do |io|
85
            io.each_line do |line|
86
              branches << line.chomp.match('^([^\s]+).*$')[1]
87
            end
88
          end
89
          branches.sort!
90
        end
91

  
92
        def tags
93
          @tags ||= get_tags
94
        end
95

  
96
        def get_tags
97
          tags = []
98
          cmd = "#{HG_BIN} -R #{target('')} tags"
99
          shellout(cmd) do |io|
100
            io.each_line do |line|
101
              tags << line.chomp.match('^([\w]+).*$')[1]
102
            end
61 103
          end
104
          tags.sort!
105
        end
106

  
107
        def tip
108
          @tip ||= get_tip
62 109
        end
63 110
        
111
        def get_tip
112
          tip = nil
113
          cmd = "#{HG_BIN} -R #{target('')} tip"
114
          shellout(cmd) do |io|
115
            tip = io.gets.chomp.match('^changeset:\s+\d+:(\w+)$')[1]
116
          end
117
          return nil if $? && $?.exitstatus != 0
118
          tip
119
        end
120

  
64 121
        def info
65 122
          cmd = "#{HG_BIN} -R #{target('')} root"
66 123
          root_url = nil
......
69 126
          end
70 127
          return nil if $? && $?.exitstatus != 0
71 128
          info = Info.new({:root_url => root_url.chomp,
72
                            :lastrev => revisions(nil,nil,nil,{:limit => 1}).last
129
                            :lastrev => lastrev(nil,tip)
73 130
                          })
74 131
          info
75 132
        rescue CommandFailed
76 133
          return nil
77 134
        end
78 135
        
79
        def entries(path=nil, identifier=nil)
136
        def lastrev(path=nil, identifier=nil)
137
          lastrev = revisions(path,identifier,0,:limit => 1, :lite => true)
138
          return nil if lastrev.nil? or lastrev.empty?
139
          lastrev.last
140
        end
141

  
142
        def num_revisions
143
          cmd = "#{HG_BIN} -R #{target('')} log -r :tip --template='\n' | wc -l"
144
          shellout(cmd) {|io| io.gets.chomp.to_i}
145
        end
146
        
147
        # Returns the entry identified by path and revision identifier
148
        # or nil if entry doesn't exist in the repository
149
        def entry(path=nil, identifier=nil)
150
          parts = path.to_s.split(%r{[\/\\]}).select {|n| !n.blank?}
151
          search_path = parts[0..-2].join('/')
152
          search_name = parts[-1]
153
          if search_path.blank? && search_name.blank?
154
            # Root entry
155
            Entry.new(:path => '', :kind => 'dir')
156
          else
157
            # Search for the entry in the parent directory
158
            es = entries(search_path, identifier, :search => search_name)
159
            es ? es.detect {|e| e.name == search_name} : nil
160
          end
161
        end
162

  
163
        def entries(path=nil, identifier=nil, options={})  
80 164
          path ||= ''
165
          identifier ||= 'tip'
81 166
          entries = Entries.new
82 167
          cmd = "#{HG_BIN} -R #{target('')} --cwd #{target('')} locate"
83
          cmd << " -r " + (identifier ? identifier.to_s : "tip")
168
          cmd << " -r #{shell_quote(identifier.to_s)}"
169
          cmd << " -I" if options[:search] unless path.empty?
84 170
          cmd << " " + shell_quote("path:#{path}") unless path.empty?
171
          cmd << " " + shell_quote(options[:search]) if options[:search]
85 172
          shellout(cmd) do |io|
86 173
            io.each_line do |line|
87 174
              # HG uses antislashs as separator on Windows
......
89 176
              if path.empty? or e = line.gsub!(%r{^#{with_trailling_slash(path)}},'')
90 177
                e ||= line
91 178
                e = e.chomp.split(%r{[\/\\]})
179
                k = (e.size > 1 ? 'dir' : 'file')
180
                p = (path.nil? or path.empty? ? e.first : "#{with_trailling_slash(path)}#{e.first}")
181
                # Always set the file size if we have the 'size' extension for 
182
                # Mercurial, otherwise set from the filesystem if we're browsing 
183
                # the default 'branch' (tip)
184
                s = nil
185
                if (k == 'file')
186
                  s = size(p,identifier)
187
                  if s.nil? and (identifier.to_s == default_branch or identifier.to_s == 'tip')
188
                    full_path = info.root_url + '/' + p
189
                    s = File.stat(full_path).size if File.file?(full_path)
190
                  end
191
                end
92 192
                entries << Entry.new({:name => e.first,
93
                                       :path => (path.nil? or path.empty? ? e.first : "#{with_trailling_slash(path)}#{e.first}"),
94
                                       :kind => (e.size > 1 ? 'dir' : 'file'),
95
                                       :lastrev => Revision.new
193
                                       :path => p,
194
                                       :kind => k,
195
                                       :size => s,
196
                                       :lastrev => lastrev(p,identifier)
96 197
                                     }) unless e.empty? || entries.detect{|entry| entry.name == e.first}
97 198
              end
98 199
            end
......
100 201
          return nil if $? && $?.exitstatus != 0
101 202
          entries.sort_by_name
102 203
        end
103
        
204

  
104 205
        # Fetch the revisions by using a template file that 
105 206
        # makes Mercurial produce a xml output.
106 207
        def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})  
107 208
          revisions = Revisions.new
108
          cmd = "#{HG_BIN} --debug --encoding utf8 -R #{target('')} log -C --style #{shell_quote self.class.template_path}"
209
          cmd = "#{HG_BIN} --debug --encoding utf8 -R #{target('')} --cwd #{target('')} log"
210
          if options[:lite]
211
            cmd << " --style #{shell_quote self.class.lite_template_path}" 
212
          else
213
          	cmd << " -C --style #{shell_quote self.class.template_path}"
214
          end
109 215
          if identifier_from && identifier_to
110
            cmd << " -r #{identifier_from.to_i}:#{identifier_to.to_i}"
216
            cmd << " -r #{shell_quote(identifier_from.to_s)}:#{shell_quote(identifier_to.to_s)}"
111 217
          elsif identifier_from
112
            cmd << " -r #{identifier_from.to_i}:"
218
            cmd << " -r #{shell_quote(identifier_from.to_s)}:"
219
          elsif identifier_to
220
            cmd << " -r :#{shell_quote(identifier_to.to_s)}"
113 221
          end
114 222
          cmd << " --limit #{options[:limit].to_i}" if options[:limit]
115 223
          cmd << " #{path}" if path
116 224
          shellout(cmd) do |io|
117 225
            begin
118 226
              # HG doesn't close the XML Document...
119
              doc = REXML::Document.new(io.read << "</log>")
227
              output = io.read
228
              return nil if output.empty?
229
              doc = REXML::Document.new(output << "</log>")
120 230
              doc.elements.each("log/logentry") do |logentry|
121 231
                paths = []
122 232
                copies = logentry.get_elements('paths/path-copied')
......
124 234
                  # Detect if the added file is a copy
125 235
                  if path.attributes['action'] == 'A' and c = copies.find{ |e| e.text == path.text }
126 236
                    from_path = c.attributes['copyfrom-path']
127
                    from_rev = logentry.attributes['revision']
237
                    from_rev = logentry.attributes['shortnode']
128 238
                  end
129 239
                  paths << {:action => path.attributes['action'],
130 240
                    :path => "/#{path.text}",
......
132 242
                    :from_revision => from_rev ? from_rev : nil
133 243
                  }
134 244
                end
135
                paths.sort! { |x,y| x[:path] <=> y[:path] }
136
                
137
                revisions << Revision.new({:identifier => logentry.attributes['revision'],
245
                paths.sort! { |x,y| x[:path] <=> y[:path] } unless paths.empty?
246

  
247
                revisions << Revision.new({:identifier => logentry.attributes['shortnode'],
138 248
                                            :scmid => logentry.attributes['node'],
139 249
                                            :author => (logentry.elements['author'] ? logentry.elements['author'].text : ""),
140 250
                                            :time => Time.parse(logentry.elements['date'].text).localtime,
......
149 259
          return nil if $? && $?.exitstatus != 0
150 260
          revisions
151 261
        end
152
        
262

  
153 263
        def diff(path, identifier_from, identifier_to=nil)
154 264
          path ||= ''
155 265
          if identifier_to
156
            identifier_to = identifier_to.to_i 
266
            cmd = "#{HG_BIN} -R #{target('')} diff -r #{shell_quote(identifier_to.to_s)} -r #{shell_quote(identifier_from.to_s)} --nodates"
157 267
          else
158
            identifier_to = identifier_from.to_i - 1
268
            cmd = "#{HG_BIN} -R #{target('')} diff -c #{identifier_from} --nodates"
159 269
          end
160
          cmd = "#{HG_BIN} -R #{target('')} diff -r #{identifier_to} -r #{identifier_from} --nodates"
161 270
          cmd << " -I #{target(path)}" unless path.empty?
162 271
          diff = []
163 272
          shellout(cmd) do |io|
......
168 277
          return nil if $? && $?.exitstatus != 0
169 278
          diff
170 279
        end
171
        
280

  
172 281
        def cat(path, identifier=nil)
173 282
          cmd = "#{HG_BIN} -R #{target('')} cat"
174
          cmd << " -r " + (identifier ? identifier.to_s : "tip")
175
          cmd << " #{target(path)}"
283
          cmd << " -r " + shell_quote((identifier ? identifier.to_s : "tip"))
284
          cmd << " #{target(path)}" unless path.empty?
176 285
          cat = nil
177 286
          shellout(cmd) do |io|
178 287
            io.binmode
......
181 290
          return nil if $? && $?.exitstatus != 0
182 291
          cat
183 292
        end
184
        
293

  
294
        def size(path, identifier=nil)
295
          cmd = "#{HG_BIN} --cwd #{target('')} size"
296
          cmd << " -r " + shell_quote((identifier ? identifier.to_s : "tip"))
297
          cmd << " #{path}" unless path.empty?
298
          size = nil
299
          shellout(cmd) do |io|
300
            size = io.read
301
          end
302
          return nil if $? && $?.exitstatus != 0
303
          size.to_i
304
        end
305

  
185 306
        def annotate(path, identifier=nil)
186 307
          path ||= ''
187 308
          cmd = "#{HG_BIN} -R #{target('')}"
188
          cmd << " annotate -n -u"
189
          cmd << " -r " + (identifier ? identifier.to_s : "tip")
190
          cmd << " -r #{identifier.to_i}" if identifier
191
          cmd << " #{target(path)}"
309
          cmd << " annotate -c -u"
310
          cmd << " -r #{shell_quote(identifier.to_s)}" if identifier
311
          cmd << " #{target(path)}" unless path.empty?
192 312
          blame = Annotate.new
193 313
          shellout(cmd) do |io|
194 314
            io.each_line do |line|
195
              next unless line =~ %r{^([^:]+)\s(\d+):(.*)$}
196
              blame.add_line($3.rstrip, Revision.new(:identifier => $2.to_i, :author => $1.strip))
315
              next unless line =~ %r{^([^:]+)\s(\w+):(.*)$}
316
              blame.add_line($3.rstrip, Revision.new(:identifier => $2.to_s, :author => $1.strip))
197 317
            end
198 318
          end
199 319
          return nil if $? && $?.exitstatus != 0