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)

# 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: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)

    # TODO: closed branch?

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

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

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

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_ENV = {'HGPLAIN' => '', 'HGENCODING' => 'utf-8',

          'LANG' => nil, 'LANGUAGE' => nil, 'LC_MESSAGES' => nil}

          def shellout(cmd, &block)

            orig = Hash[HG_ENV.keys.zip(ENV.values_at(*HG_ENV.keys))]

            ENV.update(HG_ENV)

            begin

              ret = super

            ensure

              ENV.update(orig)

              ret

            end

          end

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

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

            io.read

        # 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 CommandFailed, "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

          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]+):(.*)$}

              blame.add_line($4.rstrip,

                             Revision.new(:identifier => $2.to_i, :author => $1.strip,

                                          :revision => $2, :scmid => $3))

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 => root_url,

                   :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),

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

                    :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

  SHORT_NODEID_LEN = 12

  # Finds and returns a revision with a number or the beginning of a hash

  def find_changeset_by_name(name)

    if /[^\d]/ =~ name or name.length >= SHORT_NODEID_LEN

      if e = changesets.find(:first, :conditions => ["scmid = ?", name])

        e

      else

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

      end

    else

      super

    end

  end

    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

    # TODO: filter by branch if rev is branch name

                    :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

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

          Hash[*alist.flatten]

        end

        # NOTE: DO NOT IMPLEMENT default_branch !!

        # It's used as the default revision by RepositoriesController.

        # Returns list of nodes in the specified branch

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

          hg_args = ['log', '--template', '{node|short}\n', '-b', branch]

          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?

          hg(*hg_args) { |io| io.readlines.map { |e| e.chomp } }

        end

            shellout("#{HG_BIN} --version") do |io|

              io.read.match(/\(version (.*)\)/)[1]

            end

  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",

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

  # Returns identifier of the revision.

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

  def revision_id

    # TODO: should be 'revision' by default, and overriden by sub-class or mixin

    scmid || revision

  end

  # Returns human-readable string representing the revision

  def revision_repr

    # TODO: should be 'revision' by default, and overriden by sub-class or mixin

    if scmid and revision != scmid

      "#{revision}:#{scmid}"  # Mercurial style

    else

      revision[0, 8]  # TODO: [0, 8] maybe for git

    end

  end

        # FIXME: Changeset class has same methods to revision_id and revision_repr.

        # They should be mix-in module or something.

        # FIXME: It seems 'revision_id' should be 'identifier', but Revision.save uses

        # 'identifier' for :revision. I need to check usage of Revision class to

        # improve class design.

        # Returns identifier of the revision.

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

        def revision_id  # TODO: confusing name; there's already 'identifier'

          # TODO: should be 'revision' by default, and overriden by sub-class or mixin

          scmid || revision || identifier

        end

        # Returns human-readable string representing the revision

        def revision_repr

          # TODO: should be 'revision' by default, and overriden by sub-class or mixin

          if scmid and revision != scmid

            "#{revision}:#{scmid}"  # Mercurial style

          elsif revision

            revision[0, 8]  # TODO: [0, 8] maybe for git

          else

            "#{identifier}"[0, 8]

          end

        end

  def link_to_revision(changeset, project, options={})

    text = options.delete(:text) || format_revision(changeset)

    revision = changeset.respond_to?(:revision_id) ? changeset.revision_id : changeset

    link_to(text, {:controller => 'repositories', :action => 'revision', :id => project, :rev => revision}, :title => l(:label_revision_id, format_revision(changeset)))

  def format_revision(changeset)

    if changeset.respond_to? :revision_repr

      changeset.revision_repr

    else

      return changeset.to_s[0,8]

    end

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

<td class="id"><%= link_to_revision(changeset, project) %></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>

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