SoundSoftware Code Site

6000

http://redmine.rubyforge.org/svn/branches/1.2-stable/app/models/repository

2011-05-19T22:58:38.288878Z

5858

2011-06-06T13:18:33.000000Z

2950b88e98eed34048c7f007a8f7fb21

2011-05-12T07:15:39.740135Z

5751

3397

2011-06-06T13:18:33.000000Z

d4568bac22baf6121a7ea8883b59c58c

2011-05-18T07:11:41.584755Z

5834

3916

2011-06-06T13:18:33.000000Z

b12b4b9bf012b30d430ddabf73eb4962

2011-05-19T22:58:38.288878Z

5858

5213

2011-06-06T13:18:33.000000Z

c02be7ffad5bb78d0cc096a7f88c45fc

2011-05-12T07:52:14.217350Z

5756

5217

2011-06-06T13:18:33.000000Z

a2170e3cb1161b0ea016414b724438f0

2011-05-12T07:41:08.517774Z

5754

1491

2011-06-06T13:18:33.000000Z

a5f74e302ec1d5d5d4a0677b6537c399

2011-05-12T07:16:20.564757Z

5753

7651

2011-06-06T13:18:33.000000Z

5fa94193e544a8c9d94a2cb501a273de

2011-05-12T07:41:29.099665Z

5755

3881

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

    attr_name = attribute_key_name

    if attr_name == "url"

      attr_name = "path_to_repository"

    end

    super(attr_name)

        c = Change.find(

               :first,

               :include    => :changeset,

               :conditions => [

                   "#{Change.table_name}.revision = ? and #{Changeset.table_name}.repository_id = ?",

                   e.lastrev.revision,

                   id

                   ],

               :order => "#{Changeset.table_name}.revision DESC")

          e.lastrev.name       = c.changeset.revision

          e.lastrev.author     = c.changeset.committer

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

                                           :revision     => revision.identifier,

                                           :committer    => revision.author,

                                           :scmid        => revision.scmid,

                                           :comments     => revision.message)

                              :action    => change[:action],

                              :path      => change[:path],

                              :revision  => change[:revision])

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

    attr_name = attribute_key_name

    if attr_name == "root_url"

      attr_name = "cvsroot"

    elsif attr_name == "url"

      attr_name = "cvs_module"

    end

    super(attr_name)

    rev = nil

    if ! identifier.nil?

      rev = changesets.find_by_revision(identifier)

      return nil if rev.nil?

    end

        if ( ! entry.lastrev.nil? ) && ( ! entry.lastrev.revision.nil? )

          change=changes.find_by_revision_and_path(

                     entry.lastrev.revision,

                     scm.with_leading_slash(entry.path) )

            entry.lastrev.identifier = change.changeset.revision

            entry.lastrev.revision   = change.changeset.revision

            entry.lastrev.author     = change.changeset.committer

            # entry.lastrev.branch     = change.branch

    rev = nil

    if ! identifier.nil?

      rev = changesets.find_by_revision(identifier)

      return nil if rev.nil?

    end

  def annotate(path, identifier=nil)

    rev = nil

    if ! identifier.nil?

      rev = changesets.find_by_revision(identifier)

      return nil if rev.nil?

    end

    scm.annotate(path, rev.nil? ? nil : rev.committed_on)

  end

    # convert rev to revision. CVS can't handle changesets here

    changeset_from = changesets.find_by_revision(rev)

    if rev_to.to_i > 0

      changeset_to = changesets.find_by_revision(rev_to)

      revision_from = nil

      revision_to   = nil

      if path.nil? || (change_from.path.starts_with? scm.with_leading_slash(path))

        revision_from = change_from.revision

      end

            revision_to = change_to.revision if change_to.path == change_from.path

          revision_to = scm.get_previous_revision(revision_from)

    # natively cvs doesn't provide any kind of changesets,

    # there is only a revision per file.

    # last one is the next step to take. the commit-date is not equal for all

    time_delta  = 10.seconds

      scm.revisions('', fetch_since, nil, :log_encoding => repo_log_encoding) do |revision|

        # is not exclusive at all.

	                         scm.with_leading_slash(revision.paths[0][:path]),

	                         revision.paths[0][:revision]

	                           )

          author_utf8 = Changeset.to_utf8(revision.author, repo_log_encoding)

          cs  = changesets.find(

            :first,

            :conditions => {

                :committed_on => tmp_time - time_delta .. tmp_time + time_delta,

                :committer    => author_utf8,

                :comments     => cmt

                }

             )

          # create a new changeset....

            branch    = revision.paths[0][:branch]

            scmid     = branch + "-" + tmp_time2.strftime("%Y%m%d-%H%M%S")

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

                                  :revision     => "tmp#{tmp_rev_num}",

                                  :scmid        => scmid,

                                  :committer    => revision.author,

                                  :comments     => revision.message)

          # convert CVS-File-States to internal Action-abbrevations

          # default action is (M)odified

          action = "M"

          if revision.paths[0][:action] == "Exp" && revision.paths[0][:revision] == "1.1"

            action = "A" # add-action always at first revision (= 1.1)

          elsif revision.paths[0][:action] == "dead"

            action = "D" # dead-state is similar to Delete

          Change.create(

             :changeset => cs,

             :action    => action,

             :path      => scm.with_leading_slash(revision.paths[0][:path]),

             :revision  => revision.paths[0][:revision],

             :branch    => revision.paths[0][:branch]

              )

              :all,

              :order => 'committed_on ASC, id ASC',

              :conditions => "revision LIKE 'tmp%'"

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

    attr_name = attribute_key_name

    if attr_name == "url"

      attr_name = "path_to_repository"

    end

    super(attr_name)

  def supports_directory_revisions?

    true

  end

    patch = nil

    if ! identifier.nil?

      patch = changesets.find_by_revision(identifier)

      return nil if patch.nil?

    end

        if entry.lastrev && !entry.lastrev.scmid.blank?

          changeset = changesets.find_by_scmid(entry.lastrev.scmid)

        end

          entry.lastrev.name       = changeset.revision

          entry.lastrev.time       = changeset.committed_on

          entry.lastrev.author     = changeset.committer

      next_rev   = latest_changeset ? latest_changeset.revision.to_i + 1 : 1

      scm_revision = scm_info.lastrev.scmid

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

                                         :revision     => next_rev,

                                         :scmid        => revision.scmid,

                                         :committer    => revision.author,

                                         :comments     => revision.message)

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

    attr_name = attribute_key_name

    if attr_name == "url"

      attr_name = "root_directory"

    end

    super(attr_name)

  def supports_all_revisions?

    false

  end

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

#

    attr_name = attribute_key_name

    if attr_name == "url"

      attr_name = "path_to_repository"

    end

    super(attr_name)

  def report_last_commit

    extra_report_last_commit

  end

  def extra_report_last_commit

    return false if extra_info.nil?

    v = extra_info["extra_report_last_commit"]

    return false if v.nil?

    v.to_s != '0'

  end

  def supports_directory_revisions?

    true

  end

  def entries(path=nil, identifier=nil)

    scm.entries(path,

                identifier,

                options = {:report_last_commit => extra_report_last_commit})

  end

  # In Git and Mercurial, revisions are not in date order.

  # Redmine Mercurial fixed issues.

  #    * Redmine Takes Too Long On Large Mercurial Repository

  #      http://www.redmine.org/issues/3449

  #    * Sorting for changesets might go wrong on Mercurial repos

  #      http://www.redmine.org/issues/3567

  #

  # Database revision column is text, so Redmine can not sort by revision.

  # Mercurial has revision number, and revision number guarantees revision order.

  # Redmine Mercurial model stored revisions ordered by database id to database.

  # So, Redmine Mercurial model can use correct ordering revisions.

  #

  # Redmine Mercurial adapter uses "hg log -r 0:tip --limit 10"

  # to get limited revisions from old to new.

  # But, Git 1.7.3.4 does not support --reverse with -n or --skip.

  #

    scm_brs = branches

    return if scm_brs.nil? || scm_brs.empty?

    h1 = extra_info || {}

    h  = h1.dup

    h["branches"]       ||= {}

    h["db_consistent"]  ||= {}

    if changesets.count == 0

      h["db_consistent"]["ordering"] = 1

      merge_extra_info(h)

      self.save

    elsif ! h["db_consistent"].has_key?("ordering")

      h["db_consistent"]["ordering"] = 0

      merge_extra_info(h)

      self.save

    end

    scm_brs.each do |br|

      from_scmid = nil

      from_scmid = h["branches"][br]["last_scmid"] if h["branches"][br]

      h["branches"][br] ||= {}

      scm.revisions('', from_scmid, br, {:reverse => true}) do |rev|

        db_rev = find_changeset_by_name(rev.revision)

          if db_rev.nil?

            save_revision(rev)

          h["branches"][br]["last_scmid"] = rev.scmid

          merge_extra_info(h)

          self.save

  def save_revision(rev)

    changeset = Changeset.new(

              :repository   => self,

              :revision     => rev.identifier,

              :scmid        => rev.scmid,

              :committer    => rev.author,

              :committed_on => rev.time,

              :comments     => rev.message

              )

    if changeset.save

      rev.paths.each do |file|

        Change.create(

                  :changeset => changeset,

                  :action    => file[:action],

                  :path      => file[:path])

      end

    end

  end

  private :save_revision

      :all,

        "scmid IN (?)",

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

    attr_name = attribute_key_name

    if attr_name == "url"

      attr_name = "path_to_repository"

    end

    super(attr_name)

  def supports_directory_revisions?

    true

  end

  #

  # Because :order => 'id DESC' is defined at 'has_many',

  # there is no need to set 'order'.

  # But, MySQL test fails.

  # Sqlite3 and PostgreSQL pass.

  # Is this MySQL bug?

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

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

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

  end

  def latest_changesets_cond(path, rev, limit)

    cond, args = [], []

    if scm.branchmap.member? rev

      # Mercurial named branch is *stable* in each revision.

      # So, named branch can be stored in database.

      # Mercurial provides *bookmark* which is equivalent with git branch.

      # But, bookmark is not implemented.

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

      # Revisions in root directory and sub directory are not equal.

      # So, in order to get correct limit, we need to get all revisions.

      # But, it is very heavy.

      # Mercurial does not treat direcotry.

      # So, "hg log DIR" is very heavy.

      branch_limit = path.blank? ? limit : ( limit * 5 )

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

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

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

      args << last.id

    unless path.blank?

      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 ? ESCAPE ?))"

      args << path.with_leading_slash

      args << "#{path.with_leading_slash.gsub(/[%_\\]/) { |s| "\\#{s}" }}/%" << '\\'

    end

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

  private :latest_changesets_cond

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

  def supports_directory_revisions?

    true

  end

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

                                           :revision     => revision.identifier,

                                           :committer    => revision.author,

                                           :comments     => revision.message)

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

    attr_name = attribute_key_name

    if attr_name == "url"

      attr_name = "path_to_repository"

    end

    super(attr_name)

        c = Change.find(

               :first,

               :include    => :changeset,

               :conditions => [

                   "#{Change.table_name}.revision = ? and #{Changeset.table_name}.repository_id = ?",

                   e.lastrev.revision,

                   id

                   ],

               :order => "#{Changeset.table_name}.revision DESC")

          e.lastrev.name       = c.changeset.revision

          e.lastrev.author     = c.changeset.committer

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

                                           :revision     => revision.identifier,

                                           :committer    => revision.author,

                                           :scmid        => revision.scmid,

                                           :comments     => revision.message)

                              :action    => change[:action],

                              :path      => change[:path],

                              :revision  => change[:revision])

# Redmine - project management software

# Copyright (C) 2006-2011  Jean-Philippe Lang

#

#

    attr_name = attribute_key_name

    if attr_name == "root_url"

      attr_name = "cvsroot"

    elsif attr_name == "url"

      attr_name = "cvs_module"

    end

    super(attr_name)

    rev = nil

    if ! identifier.nil?

      rev = changesets.find_by_revision(identifier)

      return nil if rev.nil?

    end

        if ( ! entry.lastrev.nil? ) && ( ! entry.lastrev.revision.nil? )

          change=changes.find_by_revision_and_path(

                     entry.lastrev.revision,

                     scm.with_leading_slash(entry.path) )

            entry.lastrev.identifier = change.changeset.revision

            entry.lastrev.revision   = change.changeset.revision

            entry.lastrev.author     = change.changeset.committer

            # entry.lastrev.branch     = change.branch

    rev = nil

    if ! identifier.nil?

      rev = changesets.find_by_revision(identifier)

      return nil if rev.nil?

    end

  def annotate(path, identifier=nil)

    rev = nil

    if ! identifier.nil?

      rev = changesets.find_by_revision(identifier)

      return nil if rev.nil?

    end

    scm.annotate(path, rev.nil? ? nil : rev.committed_on)

  end

    # convert rev to revision. CVS can't handle changesets here

    changeset_from = changesets.find_by_revision(rev)

    if rev_to.to_i > 0

      changeset_to = changesets.find_by_revision(rev_to)

      revision_from = nil

      revision_to   = nil

      if path.nil? || (change_from.path.starts_with? scm.with_leading_slash(path))

        revision_from = change_from.revision

      end

            revision_to = change_to.revision if change_to.path == change_from.path

          revision_to = scm.get_previous_revision(revision_from)

    # natively cvs doesn't provide any kind of changesets,

    # there is only a revision per file.

    # last one is the next step to take. the commit-date is not equal for all

    time_delta  = 10.seconds

      scm.revisions('', fetch_since, nil, :log_encoding => repo_log_encoding) do |revision|

        # is not exclusive at all.

	                         scm.with_leading_slash(revision.paths[0][:path]),

	                         revision.paths[0][:revision]

	                           )

          author_utf8 = Changeset.to_utf8(revision.author, repo_log_encoding)

          cs  = changesets.find(

            :first,

            :conditions => {

                :committed_on => tmp_time - time_delta .. tmp_time + time_delta,

                :committer    => author_utf8,

                :comments     => cmt

                }

             )

          # create a new changeset....

            branch    = revision.paths[0][:branch]

            scmid     = branch + "-" + tmp_time2.strftime("%Y%m%d-%H%M%S")

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

                                  :revision     => "tmp#{tmp_rev_num}",

                                  :scmid        => scmid,

                                  :committer    => revision.author,

                                  :comments     => revision.message)

          # convert CVS-File-States to internal Action-abbrevations

          # default action is (M)odified

          action = "M"

          if revision.paths[0][:action] == "Exp" && revision.paths[0][:revision] == "1.1"

            action = "A" # add-action always at first revision (= 1.1)

          elsif revision.paths[0][:action] == "dead"

            action = "D" # dead-state is similar to Delete

          Change.create(

             :changeset => cs,

             :action    => action,

             :path      => scm.with_leading_slash(revision.paths[0][:path]),

             :revision  => revision.paths[0][:revision],

             :branch    => revision.paths[0][:branch]

              )