Redmine

  # Creates a new Change from it's common parameters

  def create_change(change)

    Change.create(:changeset => self,

                  :action => change[:action],

                  :path => change[:path],

                  :from_path => change[:from_path],

                  :from_revision => change[:from_revision])

  end

              changeset.create_change(change)

                changeset.create_change(change)

                changeset.create_change(change)

   end.compact

      path = ''

        path += '/' + dir

        p[path] ||= {}

        p = p[path]

      text = File.basename(h(file))

      if s = tree[file][:s]

        style << ' folder'

        path_param = to_path_param(@repository.relative_path(file))

        text = link_to(text, :controller => 'repositories',

                             :action => 'show',

                             :id => @project,

                             :path => path_param,

                             :rev => @changeset.revision)

        output << "<li class='#{style}'>#{text}</li>"

        output << render_changes_tree(s)

      elsif c = tree[file][:c]

        style << " change-#{c.action}"

                             :rev => @changeset.revision) unless c.action == 'D'

        output << "<li class='#{style}'>#{text}</li>"

    revisions = scm.revisions('', nil, nil, :all => true, :since => since, :reverse => true)

      :order => 'id DESC'

  has_and_belongs_to_many :changesets, :order => "#{Changeset.table_name}.id ASC"

  has_many :changesets, :order => "#{Changeset.table_name}.id DESC"

                         :order => "#{Changeset.table_name}.id DESC",

  # Returns the identifier of this changeset.

  # e.g. revision number for centralized system; hash id for DVCS

  def identifier

    scmid || revision

  end

        attr_accessor :scmid, :name, :author, :time, :message, :paths, :revision, :branch

        attr_writer :identifier

        # Returns the identifier of this revision.

        # e.g. revision number for centralized system; hash id for DVCS

        def identifier

          @identifier || scmid || revision

        end

    # TODO: is this query efficient enough? can we write as single query?

    e = changesets.find(:first, :conditions => ['revision = ? OR scmid = ?', name.to_s, name.to_s])

    return e if e

    changesets.find(:first, :conditions => ['scmid LIKE ?', "#{name}%"])

    rev = revision.respond_to?(:identifier) ? revision.identifier : revision

    link_to(text, {:controller => 'repositories', :action => 'revision', :id => project, :rev => rev},

            :title => l(:label_revision_id, format_revision(revision)))

  # truncate rev to 8 chars if it's quite long

  def truncate_long_revision_name(rev)

    rev.to_s.size <= 12 ? rev.to_s : rev.to_s[0, 8]

  end

  private :truncate_long_revision_name

  def format_revision(revision)

    if [:identifier, :revision, :scmid].all? { |e| revision.respond_to? e }

      if revision.scmid and revision.revision != revision.scmid and /[^\d]/ !~ revision.revision

        "#{revision.revision}:#{revision.scmid}"  # number:hashid

      else

        truncate_long_revision_name(revision.identifier)

      end

    else

      truncate_long_revision_name(revision)

    end

              link = link_to h("#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :rev => changeset.identifier},

  # Returns the wiki identifier, "rN" or "commit:ABCDEF"

  def wiki_identifier

    if scmid  # hash-like

      "commit:#{scmid}"

    else  # numeric

      "r#{revision}"

    end

  end

  private :wiki_identifier

          journal = issue.init_journal(user || User.anonymous, ll(Setting.default_language, :text_status_changed_by_changeset, wiki_identifier))

  module_function :format_revision  # callable as RepositoriesHelper.format_revision

  acts_as_event :title => Proc.new {|o| "#{l(:label_revision)} #{RepositoriesHelper.format_revision(o)}" + (o.short_comments.blank? ? '' : (': ' + o.short_comments))},

                :url => Proc.new {|o| {:controller => 'repositories', :action => 'revision', :id => o.repository.project, :rev => o.identifier}}

                             :rev => @changeset.identifier)

                             :rev => @changeset.identifier) unless c.action == 'D'

                                       :rev => @changeset.identifier) + ') ' if c.action == 'M'

<td class="revision"><%= link_to_revision(changeset, @project) if changeset %></td>

<td class="id"><%= link_to_revision(changeset, project) %></td>

<td class="checkbox"><%= radio_button_tag('rev', changeset.identifier, (line_num==1), :id => "cb-#{line_num}", :onclick => "$('cbto-#{line_num+1}').checked=true;") if show_diff && (line_num < revisions.size) %></td>

<td class="checkbox"><%= radio_button_tag('rev_to', changeset.identifier, (line_num==2), :id => "cbto-#{line_num}", :onclick => "if ($('cb-#{line_num}').checked==true) {$('cb-#{line_num-1}').checked=true;}") if show_diff && (line_num > 1) %></td>

      <%= (revision.identifier ? link_to_revision(revision, @project) : format_revision(revision)) if revision %></td>

    <%= link_to_revision(@changeset.previous, @project, :text => l(:label_previous)) %>

    <%= link_to_revision(@changeset.next, @project, :text => l(:label_next)) %>

<h2><%= l(:label_revision) %> <%= format_revision(@changeset) %></h2>

<p><%= link_to(l(:label_view_diff), :action => 'diff', :id => @project, :path => "", :rev => @changeset.identifier) if @changeset.changes.any? %></p>

    <%= text_field_tag 'rev', @rev, :size => 8 %>

        begin

          project.repository.fetch_changesets

        rescue Redmine::Scm::Adapters::CommandFailed => e

          logger.error "Repository: error during fetching changesets: #{e.message}"

        end

# redminehelper: draft extension for Mercurial

# it's a draft to show a possible way to explore repository by the Redmine overhaul patch

# see: http://www.redmine.org/issues/4455

#

# Copyright 2010 Alessio Franceschelli (alefranz.net)

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

'''command to list revision of each file

'''

from mercurial import cmdutil, commands

from mercurial.i18n import _

def overhaul(ui, repo, rev=None, **opts):

    mf = repo[rev].manifest()

    for f in repo[rev]:

        try:

            fctx = repo.filectx(f, fileid=mf[f])

            ctx = fctx.changectx()

            ui.write('%s\t%d\t%s\n' %

                     (ctx,fctx.size(),f))

        except LookupError:

            pass

cmdtable = {

    'overhaul': (overhaul,commands.templateopts, _('hg overhaul [rev]'))

}

# redminehelper: Redmine helper extension for Mercurial

# Copyright 2010 Yuya Nishihara <yuya@tcha.org>

import re, time

from mercurial import cmdutil, commands, node, error

SPECIAL_TAGS = ('tip',)

def rhsummary(ui, repo, **opts):

    """output the summary of the repository"""

    # see mercurial/commands.py:tip

    ui.write(':tip: rev node\n')

    tipctx = repo[len(repo) - 1]

    ui.write('%d %s\n' % (tipctx.rev(), tipctx))

    # see mercurial/commands.py:root

    ui.write(':root: path\n')

    ui.write(repo.root + '\n')

    # see mercurial/commands.py:tags

    ui.write(':tags: rev node name\n')

    for t, n in reversed(repo.tagslist()):

        if t in SPECIAL_TAGS:

            continue

        try:

            r = repo.changelog.rev(n)

        except error.LookupError:

            r = -1

        ui.write('%d %s %s\n' % (r, node.short(n), t))

    # see mercurial/commands.py:branches

    def iterbranches():

        for t, n in repo.branchtags().iteritems():

            yield t, n, repo.changelog.rev(n)

    ui.write(':branches: rev node name\n')

    for t, n, r in sorted(iterbranches(), key=lambda e: e[2], reverse=True):

        if repo.lookup(r) in repo.branchheads(t, closed=False):

            ui.write('%d %s %s\n' % (r, node.short(n), t))  # only open branch

def rhentries(ui, repo, path='', **opts):

    """output the entries of the specified directory"""

    rev = opts.get('rev')

    pathprefix = (path.rstrip('/') + '/').lstrip('/')

    # TODO: clean up

    dirs, files = {}, {}

        if not f.startswith(pathprefix):

            continue

        name = re.sub(r'/.*', '', f[len(pathprefix):])

        if '/' in f[len(pathprefix):]:

            dirs[name] = (name,)

        else:

            try:

                fctx = repo.filectx(f, fileid=mf[f])

                ctx = fctx.changectx()

                tm, tzoffset = ctx.date()

                localtime = int(tm) + tzoffset - time.timezone

                files[name] = (ctx.rev(), node.short(ctx.node()), localtime,

                               fctx.size(), name)

            except LookupError:  # TODO: when this occurs?

                pass

    ui.write(':dirs: name\n')

    for n, v in sorted(dirs.iteritems(), key=lambda e: e[0]):

        ui.write(' '.join(v) + '\n')

    ui.write(':files: rev node time size name\n')

    for n, v in sorted(files.iteritems(), key=lambda e: e[0]):

        ui.write(' '.join(str(e) for e in v) + '\n')

    'rhsummary': (rhsummary, [], 'hg rhsummary'),

    'rhentries': (rhentries,

                  [('r', 'rev', '', 'show the specified revision')],

                  'hg rhentries [path]'),

        HG_HELPER_EXT = "#{RAILS_ROOT}/extra/mercurial/redminehelper.py"

        # raised if hg command exited with error, e.g. unknown revision.

        class HgCommandAborted < CommandFailed; end

          hg 'cat', '-r', hgrev(identifier), without_leading_slash(path) do |io|

            io.read

        rescue HgCommandAborted

          nil  # means not found

        # Runs 'hg' command with the given args

        def hg(*args, &block)

          full_args = [HG_BIN, '--cwd', url]

          full_args << '--config' << "extensions.redminehelper=#{HG_HELPER_EXT}"

          full_args += args

          ret = shellout(full_args.map { |e| shell_quote e.to_s }.join(' '), &block)

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

            raise HgCommandAborted, "hg exited with non-zero status: #{$?.exitstatus}"

          end

          ret

        end

        private :hg

        # Returns correct revision identifier

        def hgrev(identifier)

          identifier.blank? ? 'tip' : identifier.to_s

        end

        private :hgrev

          hg_args = ['diff', '--nodates']

            hg_args << '-r' << hgrev(identifier_to) << '-r' << hgrev(identifier_from)

            hg_args << '-c' << hgrev(identifier_from)

          hg_args << without_leading_slash(path) unless path.blank?

          hg *hg_args do |io|

            io.collect

        rescue HgCommandAborted

          nil  # means not found

          hg 'annotate', '-ncu', '-r', hgrev(identifier), without_leading_slash(path) do |io|

            io.each do |line|

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

              r = Revision.new(:author => $1.strip, :revision => $2, :scmid => $3)

              blame.add_line($4.rstrip, r)

        rescue HgCommandAborted

          nil  # means not found or cannot be annotated

footer='</log>'

footer='</log>'

require 'rexml/document'

        # TODO: is this api necessary?

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

          revisions = Revisions.new

          each_revision { |e| revisions << e }

          revisions

        end

        # Iterates the revisions by using a template file that

        def each_revision(path=nil, identifier_from=nil, identifier_to=nil, options={})

          hg_args = ['log', '--debug', '-C', '--style', self.class.template_path]

          hg_args << '-r' << "#{hgrev(identifier_from)}:#{hgrev(identifier_to)}"

          hg_args << '--limit' << options[:limit] if options[:limit]

          hg_args << without_leading_slash(path) unless path.blank?

          doc = hg(*hg_args) { |io| REXML::Document.new(io.read) }

          # TODO: ??? HG doesn't close the XML Document...

          doc.each_element('log/logentry') do |le|

            cpalist = le.get_elements('paths/path-copied').map do |e|

              [e.text, e.attributes['copyfrom-path']]

            end

            cpmap = Hash[*cpalist.flatten]

            paths = le.get_elements('paths/path').map do |e|

              {:action => e.attributes['action'], :path => with_leading_slash(e.text),

                :from_path => (cpmap.member?(e.text) ? with_leading_slash(cpmap[e.text]) : nil),

                :from_revision => (cpmap.member?(e.text) ? le.attributes['revision'] : nil)}

            end.sort { |a, b| a[:path] <=> b[:path] }

            yield Revision.new(:identifier => le.attributes['revision'],

                               :revision => le.attributes['revision'],

                               :scmid => le.attributes['node'],

                               :author => (le.elements['author'].text rescue ''),

                               :time => Time.parse(le.elements['date'].text).localtime,

                               :message => le.elements['msg'].text,

                               :paths => paths)

          self

          tip = summary['tip'].first

          Info.new(:root_url => summary['root'].first['path'],

                   :lastrev => Revision.new(:identifier => tip['rev'].to_i,

                                            :revision => tip['rev'],

                                            :scmid => tip['node']))

        def summary

          @summary ||= fetchg 'rhsummary'

        end

        private :summary

        # Runs 'hg' helper, then parses output to return

        def fetchg(*args)

          # command output example:

          #   :tip: rev node

          #   100 abcdef012345

          #   :tags: rev node name

          #   100 abcdef012345 tip

          #   ...

          data = Hash.new { |h, k| h[k] = [] }

          hg(*args) do |io|

            key, attrs = nil, nil

            io.each do |line|

              next if line.chomp.empty?

              if /^:(\w+): ([\w ]+)/ =~ line

                key = $1

                attrs = $2.split(/ /)

              elsif key

                alist = attrs.zip(line.chomp.split(/ /, attrs.size))

                data[key] << Hash[*alist.flatten]

              end

            end

          end

          data

        end

        private :fetchg

  FETCH_AT_ONCE = 100  # number of changesets to fetch at once

    scm_rev = scm.info.lastrev.revision.to_i

    db_rev = latest_changeset ? latest_changeset.revision.to_i : -1

    return unless db_rev < scm_rev  # already up-to-date

    logger.debug "Fetching changesets for repository #{url}" if logger

    (db_rev + 1).step(scm_rev, FETCH_AT_ONCE) do |i|

      transaction do

        scm.each_revision('', i, [i + FETCH_AT_ONCE - 1, scm_rev].min) do |re|

          cs = Changeset.create(:repository => self,

                                :revision => re.revision,

                                :scmid => re.scmid,

                                :committer => re.author,

                                :committed_on => re.time,

                                :comments => re.message)

          re.paths.each { |e| cs.create_change(e) }

    self

  # Returns the latest changesets for +path+

  def latest_changesets(path, rev, limit=10)

    changesets.find(:all, :include => :user,

                    :conditions => latest_changesets_cond(path, rev),

                    :limit => limit)

  end

  def latest_changesets_cond(path, rev)

    cond, args = [], []

    if last = rev ? find_changeset_by_name(rev) : nil

      cond << "#{Changeset.table_name}.id <= ?"

      args << last.id

    end

    unless path.blank?

      # TODO: there must be a better way to build sub-query

      cond << "EXISTS (SELECT * FROM #{Change.table_name}

                 WHERE #{Change.table_name}.changeset_id = #{Changeset.table_name}.id

                 AND (#{Change.table_name}.path = ? OR #{Change.table_name}.path LIKE ?))"

      args << path.with_leading_slash << "#{path.with_leading_slash}/%"

    end

    [cond.join(' AND '), *args] unless cond.empty?

  end

  private :latest_changesets_cond

    if last = rev ? find_changeset_by_name(scm.tagmap[rev] || rev) : nil

        def tags

          summary['tags'].map { |e| e['name'] }

        end

        # Returns map of {'tag' => 'nodeid', ...}

        def tagmap

          alist = summary['tags'].map { |e| e.values_at('name', 'node') }

          Hash[*alist.flatten]

        end

    scm.entries(path, identifier)

          fetched_entries = fetchg('rhentries', '-r', hgrev(identifier),

                                   without_leading_slash(path.to_s))

          fetched_entries['dirs'].each do |e|

            entries << Entry.new(:name => e['name'],

                                 :path => "#{with_trailling_slash(path)}#{e['name']}",

                                 :kind => 'dir')

          fetched_entries['files'].each do |e|

            entries << Entry.new(:name => e['name'],

                                 :path => "#{with_trailling_slash(path)}#{e['name']}",

                                 :kind => 'file',

                                 :size => e['size'].to_i,

                                 :lastrev => Revision.new(:identifier => e['rev'].to_i,

                                                          :time => Time.at(e['time'].to_i)))

          end

          entries

        rescue HgCommandAborted

          nil  # means not found

  def branches

    bras = scm.branches

    bras.sort unless bras == %w|default|

  end

                    :conditions => latest_changesets_cond(path, rev, limit),

  def latest_changesets_cond(path, rev, limit)

    if scm.branchmap.member? rev

      # dirty hack to filter by branch. branch name should be in database.

      cond << "#{Changeset.table_name}.scmid IN (?)"

      args << scm.nodes_in_branch(rev, path, rev, 0, :limit => limit)

    elsif last = rev ? find_changeset_by_name(scm.tagmap[rev] || rev) : nil

        def branches

          summary['branches'].map { |e| e['name'] }

        end

        # Returns map of {'branch' => 'nodeid', ...}

        def branchmap