Redmine

  # With SCMs that have a sequential commit numbering,

  # such as Subversion and Mercurial,

  # Redmine is able to be clever and only fetch changesets

  # going forward from the most recent one it knows about.

  # In order to fetch only new adding revisions,

  # Redmine needs to parse revisions per branch.

  # Branch "last_scmid" is for this requirement.

  # 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

    save_revisions(h, scm_brs)

  def save_revisions(h, scm_brs)

    # Remember what revisions we already processed (in any branches)

    all_revisions = []

    scm_brs.each do |br1|

      br = br1.to_s

      last_revision = nil

      from_scmid = nil

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

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

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

      next if revisions.blank?

      # Remember the last commit id here, before we start removing revisions from the array.

      # We'll do that for optimization, but it also means, that we may lose even all revisions.

      last_revision  = revisions.last

      # remove revisions that we have already processed (possibly in other branches)

      revisions.reject!{|r| all_revisions.include?(r.scmid)}

      # add revisions that we are to parse now to 'all processed revisions'

      # (this equals to a union, because we executed diff above)

      all_revisions += revisions.map{|r| r.scmid}

      # Make the search for existing revisions in the database in a more sufficient manner

      # This is replacing the one-after-one queries.

      # Find all revisions, that are in the database, and then remove them from the revision array.

      # Then later we won't need any conditions for db existence.

      # Query for several revisions at once, and remove them from the revisions array, if they are there.

      # Do this in chunks, to avoid eventual memory problems (in case of tens of thousands of commits).

      # If there are no revisions (because the original code's algoritm filtered them),

      # then this part will be stepped over.

      # We make queries, just if there is any revision.

      limit = 100

      offset = 0

      revisions_copy = revisions.clone # revisions will change

      while offset < revisions_copy.size

        recent_changesets_slice = changesets.find(

                                     :all,

                                     :conditions => [

                                        'scmid IN (?)',

                                        revisions_copy.slice(offset, limit).map{|x| x.scmid}

                                      ]

                                    )

        # Subtract revisions that redmine already knows about

        recent_revisions = recent_changesets_slice.map{|c| c.scmid}

        revisions.reject!{|r| recent_revisions.include?(r.scmid)}

        offset += limit

      end

      revisions.each do |rev|

        transaction do

          # There is no search in the db for this revision, because above we ensured,

          # that it's not in the db.

          db_saved_rev = save_revision(rev)

          parents = {}

          parents[db_saved_rev] = rev.parents unless rev.parents.nil?

          parents.each do |ch, chparents|

            ch.parents = chparents.collect{|rp| find_changeset_by_name(rp)}.compact

          end

          # saving the last scmid was moved from here, because we won't come in here,

          # if the revision was already added for another branch

        end

      end

      # save the data about the last revision for this branch

      unless last_revision.nil?

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

        merge_extra_info(h)

        self.save

      end

              :comments     => rev.message

  def heads_from_branches_hash

    h1 = extra_info || {}

    h  = h1.dup

    h["branches"] ||= {}

    h['branches'].map{|br, hs| hs['last_scmid']}

      assert_nil @repository.extra_info

      assert_equal 0, @repository.changesets.count

      assert_equal [], @repository.heads_from_branches_hash

      h["branches"] = {}

      h["branches"]["test1"] = {}

      h["branches"]["test1"]["last_scmid"] = "1234abcd"

      h["branches"]["test2"] = {}

      h["branches"]["test2"]["last_scmid"] = "abcd1234"

      @repository.merge_extra_info(h)

      @repository.save

      @project.reload

      assert_equal ["1234abcd", "abcd1234"], @repository.heads_from_branches_hash.sort

      %w|95488a44bc25f7d1f97d775a31359539ff333a63 95488a44b|.each do |r1|

      %w|67e7792ce20ccae2e4bb73eed09bb397819c8834 67e7792ce20cca|.each do |r1|