jro_apps/redmine Commit - r9622:7c105ec9e93b

Adds a method to load changesets for repository entries....

Jean-Philippe Lang -

r9622:7c105ec9e93b

parent child

Context file:

r9622:7c105ec9e93b

Collapse all files

app/models/repository.rb +13 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class ScmFetchError < Exception; end
             class Repository < ActiveRecord::Base
               include Redmine::Ciphering
               belongs_to :project
               has_many :changesets, :order => "#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC"
               has_many :filechanges, :class_name => 'Change', :through => :changesets
               serialize :extra_info
               before_save :check_default
               # Raw SQL to delete changesets and changes in the database
               # has_many :changesets, :dependent => :destroy is too slow for big repositories
               before_destroy :clear_changesets
               validates_length_of :password, :maximum => 255, :allow_nil => true
               validates_length_of :identifier, :maximum => 255, :allow_blank => true
               validates_presence_of :identifier, :unless => Proc.new { |r| r.is_default? || r.set_as_default? }
               validates_uniqueness_of :identifier, :scope => :project_id, :allow_blank => true
               validates_exclusion_of :identifier, :in => %w(show entry raw changes annotate diff show stats graph)
               # donwcase letters, digits, dashes but not digits only
               validates_format_of :identifier, :with => /^(?!\d+$)[a-z0-9\-]*$/, :allow_blank => true
               # Checks if the SCM is enabled when creating a repository
               validate :repo_create_validation, :on => :create
               def repo_create_validation
                 unless Setting.enabled_scm.include?(self.class.name.demodulize)
                   errors.add(:type, :invalid)
                 end
               end
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == "log_encoding"
                   attr_name = "commit_logs_encoding"
                 end
                 super(attr_name, *args)
               end
               # Removes leading and trailing whitespace
               def url=(arg)
                 write_attribute(:url, arg ? arg.to_s.strip : nil)
               end
               # Removes leading and trailing whitespace
               def root_url=(arg)
                 write_attribute(:root_url, arg ? arg.to_s.strip : nil)
               end
               def password
                 read_ciphered_attribute(:password)
               end
               def password=(arg)
                 write_ciphered_attribute(:password, arg)
               end
               def scm_adapter
                 self.class.scm_adapter_class
               end
               def scm
                 unless @scm
                   @scm = self.scm_adapter.new(url, root_url,
                                               login, password, path_encoding)
                   if root_url.blank? && @scm.root_url.present?
                     update_attribute(:root_url, @scm.root_url)
                   end
                 end
                 @scm
               end
               def scm_name
                 self.class.scm_name
               end
               def name
                 if identifier.present?
                   identifier
                 elsif is_default?
                   l(:field_repository_is_default)
                 else
                   scm_name
                 end
               end
               def identifier_param
                 if is_default?
                   nil
                 elsif identifier.present?
                   identifier
                 else
                   id.to_s
                 end
               end
               def <=>(repository)
                 if is_default?
                   -1
                 elsif repository.is_default?
                 else
                   identifier.to_s <=> repository.identifier.to_s
                 end
               end
               def self.find_by_identifier_param(param)
                 if param.to_s =~ /^\d+$/
                   find_by_id(param)
                 else
                   find_by_identifier(param)
                 end
               end
               def merge_extra_info(arg)
                 h = extra_info || {}
                 return h if arg.nil?
                 h.merge!(arg)
                 write_attribute(:extra_info, h)
               end
               def report_last_commit
                 true
               end
               def supports_cat?
                 scm.supports_cat?
               end
               def supports_annotate?
                 scm.supports_annotate?
               end
               def supports_all_revisions?
                 true
               end
               def supports_directory_revisions?
                 false
               end
               def supports_revision_graph?
                 false
               end
               def entry(path=nil, identifier=nil)
                 scm.entry(path, identifier)
               end
               def entries(path=nil, identifier=nil)
-                scm.entries(path, identifier)
+                entries = scm.entries(path, identifier)
+                load_entries_changesets(entries)
+                entries
               end
               def branches
                 scm.branches
               end
               def tags
                 scm.tags
               end
               def default_branch
                 nil
               end
               def properties(path, identifier=nil)
                 scm.properties(path, identifier)
               end
               def cat(path, identifier=nil)
                 scm.cat(path, identifier)
               end
               def diff(path, rev, rev_to)
                 scm.diff(path, rev, rev_to)
               end
               def diff_format_revisions(cs, cs_to, sep=':')
                 text = ""
                 text << cs_to.format_identifier + sep if cs_to
                 text << cs.format_identifier if cs
                 text
               end
               # Returns a path relative to the url of the repository
               def relative_path(path)
                 path
               end
               # Finds and returns a revision with a number or the beginning of a hash
               def find_changeset_by_name(name)
                 return nil if name.blank?
                 s = name.to_s
                 changesets.find(:first, :conditions => (s.match(/^\d*$/) ?
                       ["revision = ?", s] : ["revision LIKE ?", s + '%']))
               end
               def latest_changeset
                 @latest_changeset ||= changesets.find(:first)
               end
               # Returns the latest changesets for +path+
               # Default behaviour is to search in cached changesets
               def latest_changesets(path, rev, limit=10)
                 if path.blank?
                   changesets.find(
                      :all,
                      :include => :user,
                      :order => "#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC",
                      :limit => limit)
                 else
                   filechanges.find(
                      :all,
                      :include => {:changeset => :user},
                      :conditions => ["path = ?", path.with_leading_slash],
                      :order => "#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC",
                      :limit => limit
                    ).collect(&:changeset)
                 end
               end
               def scan_changesets_for_issue_ids
                 self.changesets.each(&:scan_comment_for_issue_ids)
               end
               # Returns an array of committers usernames and associated user_id
               def committers
                 @committers ||= Changeset.connection.select_rows(
                      "SELECT DISTINCT committer, user_id FROM #{Changeset.table_name} WHERE repository_id = #{id}")
               end
               # Maps committers username to a user ids
               def committer_ids=(h)
                 if h.is_a?(Hash)
                   committers.each do |committer, user_id|
                     new_user_id = h[committer]
                     if new_user_id && (new_user_id.to_i != user_id.to_i)
                       new_user_id = (new_user_id.to_i > 0 ? new_user_id.to_i : nil)
                       Changeset.update_all(
                            "user_id = #{ new_user_id.nil? ? 'NULL' : new_user_id }",
                            ["repository_id = ? AND committer = ?", id, committer])
                     end
                   end
                   @committers            = nil
                   @found_committer_users = nil
                   true
                 else
                   false
                 end
               end
               # Returns the Redmine User corresponding to the given +committer+
               # It will return nil if the committer is not yet mapped and if no User
               # with the same username or email was found
               def find_committer_user(committer)
                 unless committer.blank?
                   @found_committer_users ||= {}
                   return @found_committer_users[committer] if @found_committer_users.has_key?(committer)
                   user = nil
                   c = changesets.find(:first, :conditions => {:committer => committer}, :include => :user)
                   if c && c.user
                     user = c.user
                   elsif committer.strip =~ /^([^<]+)(<(.*)>)?$/
                     username, email = $1.strip, $3
                     u = User.find_by_login(username)
                     u ||= User.find_by_mail(email) unless email.blank?
                     user = u
                   end
                   @found_committer_users[committer] = user
                   user
                 end
               end
               def repo_log_encoding
                 encoding = log_encoding.to_s.strip
                 encoding.blank? ? 'UTF-8' : encoding
               end
               # Fetches new changesets for all repositories of active projects
               # Can be called periodically by an external script
               # eg. ruby script/runner "Repository.fetch_changesets"
               def self.fetch_changesets
                 Project.active.has_module(:repository).all.each do |project|
                   project.repositories.each do |repository|
                     begin
                       repository.fetch_changesets
                     rescue Redmine::Scm::Adapters::CommandFailed => e
                       logger.error "scm: error during fetching changesets: #{e.message}"
                     end
                   end
                 end
               end
               # scan changeset comments to find related and fixed issues for all repositories
               def self.scan_changesets_for_issue_ids
                 find(:all).each(&:scan_changesets_for_issue_ids)
               end
               def self.scm_name
                 'Abstract'
               end
               def self.available_scm
                 subclasses.collect {|klass| [klass.scm_name, klass.name]}
               end
               def self.factory(klass_name, *args)
                 klass = "Repository::#{klass_name}".constantize
                 klass.new(*args)
               rescue
                 nil
               end
               def self.scm_adapter_class
                 nil
               end
               def self.scm_command
                 ret = ""
                 begin
                   ret = self.scm_adapter_class.client_command if self.scm_adapter_class
                 rescue Exception => e
                   logger.error "scm: error during get command: #{e.message}"
                 end
                 ret
               end
               def self.scm_version_string
                 ret = ""
                 begin
                   ret = self.scm_adapter_class.client_version_string if self.scm_adapter_class
                 rescue Exception => e
                   logger.error "scm: error during get version string: #{e.message}"
                 end
                 ret
               end
               def self.scm_available
                 ret = false
                 begin
                   ret = self.scm_adapter_class.client_available if self.scm_adapter_class
                 rescue Exception => e
                   logger.error "scm: error during get scm available: #{e.message}"
                 end
                 ret
               end
               def set_as_default?
                 new_record? && project && !Repository.first(:conditions => {:project_id => project.id})
               end
               protected
               def check_default
                 if !is_default? && set_as_default?
                   self.is_default = true
                 end
                 if is_default? && is_default_changed?
                   Repository.update_all(["is_default = ?", false], ["project_id = ?", project_id])
                 end
               end
+              def load_entries_changesets(entries)
+                if entries
+                  entries.each do |entry|
+                    if entry.lastrev && entry.lastrev.identifier
+                      entry.changeset = find_changeset_by_name(entry.lastrev.identifier)
+                    end
+                  end
+                end
+              end
               private
               # Deletes repository data
               def clear_changesets
                 cs = Changeset.table_name
                 ch = Change.table_name
                 ci = "#{table_name_prefix}changesets_issues#{table_name_suffix}"
                 cp = "#{table_name_prefix}changeset_parents#{table_name_suffix}"
                 connection.delete("DELETE FROM #{ch} WHERE #{ch}.changeset_id IN (SELECT #{cs}.id FROM #{cs} WHERE #{cs}.repository_id = #{id})")
                 connection.delete("DELETE FROM #{ci} WHERE #{ci}.changeset_id IN (SELECT #{cs}.id FROM #{cs} WHERE #{cs}.repository_id = #{id})")
                 connection.delete("DELETE FROM #{cp} WHERE #{cp}.changeset_id IN (SELECT #{cs}.id FROM #{cs} WHERE #{cs}.repository_id = #{id})")
                 connection.delete("DELETE FROM #{cs} WHERE #{cs}.repository_id = #{id}")
               end
             end

app/models/repository/bazaar.rb +2 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/bazaar_adapter'
             class Repository::Bazaar < Repository
               attr_protected :root_url
               validates_presence_of :url, :log_encoding
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
                 super(attr_name, *args)
               end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::BazaarAdapter
               end
               def self.scm_name
                 'Bazaar'
               end
               def entries(path=nil, identifier=nil)
                 entries = scm.entries(path, identifier)
                 if entries
                   entries.each do |e|
                     next if e.lastrev.revision.blank?
                     # Set the filesize unless browsing a specific revision
                     if identifier.nil? && e.is_file?
                       full_path = File.join(root_url, e.path)
                       e.size = File.stat(full_path).size if File.file?(full_path)
                     end
                     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")
                     if c
                       e.lastrev.identifier = c.changeset.revision
                       e.lastrev.name       = c.changeset.revision
                       e.lastrev.author     = c.changeset.committer
                     end
                   end
                 end
+                load_entries_changesets(entries)
+                entries
               end
               def fetch_changesets
                 scm_info = scm.info
                 if scm_info
                   # latest revision found in database
                   db_revision = latest_changeset ? latest_changeset.revision.to_i : 0
                   # latest revision in the repository
                   scm_revision = scm_info.lastrev.identifier.to_i
                   if db_revision < scm_revision
                     logger.debug "Fetching changesets for repository #{url}" if logger && logger.debug?
                     identifier_from = db_revision + 1
                     while (identifier_from <= scm_revision)
                       # loads changesets by batches of 200
                       identifier_to = [identifier_from + 199, scm_revision].min
                       revisions = scm.revisions('', identifier_to, identifier_from, :with_paths => true)
                       transaction do
                         revisions.reverse_each do |revision|
                           changeset = Changeset.create(:repository   => self,
                                                        :revision     => revision.identifier,
                                                        :committer    => revision.author,
                                                        :committed_on => revision.time,
                                                        :scmid        => revision.scmid,
                                                        :comments     => revision.message)
                           revision.paths.each do |change|
                             Change.create(:changeset => changeset,
                                           :action    => change[:action],
                                           :path      => change[:path],
                                           :revision  => change[:revision])
                           end
                         end
                       end unless revisions.nil?
                       identifier_from = identifier_to + 1
                     end
                   end
                 end
               end
             end

app/models/repository/cvs.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/cvs_adapter'
             require 'digest/sha1'
             class Repository::Cvs < Repository
               validates_presence_of :url, :root_url, :log_encoding
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == "root_url"
                   attr_name = "cvsroot"
                 elsif attr_name == "url"
                   attr_name = "cvs_module"
                 end
                 super(attr_name, *args)
               end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::CvsAdapter
               end
               def self.scm_name
                 'CVS'
               end
               def entry(path=nil, identifier=nil)
                 rev = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 scm.entry(path, rev.nil? ? nil : rev.committed_on)
               end
               def entries(path=nil, identifier=nil)
                 rev = nil
                 if ! identifier.nil?
                   rev = changesets.find_by_revision(identifier)
                   return nil if rev.nil?
                 end
                 entries = scm.entries(path, rev.nil? ? nil : rev.committed_on)
                 if entries
                   entries.each() do |entry|
                     if ( ! entry.lastrev.nil? ) && ( ! entry.lastrev.revision.nil? )
                       change = filechanges.find_by_revision_and_path(
                                  entry.lastrev.revision,
                                  scm.with_leading_slash(entry.path) )
                       if change
                         entry.lastrev.identifier = change.changeset.revision
                         entry.lastrev.revision   = change.changeset.revision
                         entry.lastrev.author     = change.changeset.committer
                         # entry.lastrev.branch     = change.branch
                       end
                     end
                   end
                 end
+                load_entries_changesets(entries)
                 entries
               end
               def cat(path, identifier=nil)
                 rev = nil
                 if ! identifier.nil?
                   rev = changesets.find_by_revision(identifier)
                   return nil if rev.nil?
                 end
                 scm.cat(path, rev.nil? ? nil : rev.committed_on)
               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
               def diff(path, rev, rev_to)
                 # convert rev to revision. CVS can't handle changesets here
                 diff=[]
                 changeset_from = changesets.find_by_revision(rev)
                 if rev_to.to_i > 0
                   changeset_to = changesets.find_by_revision(rev_to)
                 end
                 changeset_from.filechanges.each() do |change_from|
                   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
                   if revision_from
                     if changeset_to
                       changeset_to.filechanges.each() do |change_to|
                         revision_to = change_to.revision if change_to.path == change_from.path
                       end
                     end
                     unless revision_to
                       revision_to = scm.get_previous_revision(revision_from)
                     end
                     file_diff = scm.diff(change_from.path, revision_from, revision_to)
                     diff = diff + file_diff unless file_diff.nil?
                   end
                 end
                 return diff
               end
               def fetch_changesets
                 # some nifty bits to introduce a commit-id with cvs
                 # natively cvs doesn't provide any kind of changesets,
                 # there is only a revision per file.
                 # we now take a guess using the author, the commitlog and the commit-date.
                 # last one is the next step to take. the commit-date is not equal for all
                 # commits in one changeset. cvs update the commit-date when the *,v file was touched. so
                 # we use a small delta here, to merge all changes belonging to _one_ changeset
                 time_delta  = 10.seconds
                 fetch_since = latest_changeset ? latest_changeset.committed_on : nil
                 transaction do
                   tmp_rev_num = 1
                   scm.revisions('', fetch_since, nil, :log_encoding => repo_log_encoding) do |revision|
                     # only add the change to the database, if it doen't exists. the cvs log
                     # is not exclusive at all.
                     tmp_time = revision.time.clone
                     unless filechanges.find_by_path_and_revision(
             	                         scm.with_leading_slash(revision.paths[0][:path]),
             	                         revision.paths[0][:revision]
             	                           )
                       cmt = Changeset.normalize_comments(revision.message, repo_log_encoding)
                       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....
                       unless cs
                         # we use a temporaray revision number here (just for inserting)
                         # later on, we calculate a continous positive number
                         tmp_time2 = tmp_time.clone.gmtime
                         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,
                                               :committed_on => tmp_time,
                                               :comments     => revision.message)
                         tmp_rev_num += 1
                       end
                       # 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
                       end
                       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]
                           )
                     end
                   end
                   # Renumber new changesets in chronological order
                   Changeset.all(
                           :order => 'committed_on ASC, id ASC',
                           :conditions => ["repository_id = ? AND revision LIKE 'tmp%'", id]
                        ).each do |changeset|
                     changeset.update_attribute :revision, next_revision_number
                   end
                 end # transaction
                 @current_revision_number = nil
               end
               private
               # Returns the next revision number to assign to a CVS changeset
               def next_revision_number
                 # Need to retrieve existing revision numbers to sort them as integers
                 sql = "SELECT revision FROM #{Changeset.table_name} "
                 sql << "WHERE repository_id = #{id} AND revision NOT LIKE 'tmp%'"
                 @current_revision_number ||= (connection.select_values(sql).collect(&:to_i).max || 0)
                 @current_revision_number += 1
               end
             end

app/models/repository/darcs.rb +1 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/darcs_adapter'
             class Repository::Darcs < Repository
               validates_presence_of :url, :log_encoding
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
                 super(attr_name, *args)
               end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::DarcsAdapter
               end
               def self.scm_name
                 'Darcs'
               end
               def supports_directory_revisions?
                 true
               end
               def entry(path=nil, identifier=nil)
                 patch = identifier.nil? ? nil : changesets.find_by_revision(identifier)
                 scm.entry(path, patch.nil? ? nil : patch.scmid)
               end
               def entries(path=nil, identifier=nil)
                 patch = nil
                 if ! identifier.nil?
                   patch = changesets.find_by_revision(identifier)
                   return nil if patch.nil?
                 end
                 entries = scm.entries(path, patch.nil? ? nil : patch.scmid)
                 if entries
                   entries.each do |entry|
                     # Search the DB for the entry's last change
                     if entry.lastrev && !entry.lastrev.scmid.blank?
                       changeset = changesets.find_by_scmid(entry.lastrev.scmid)
                     end
                     if changeset
                       entry.lastrev.identifier = changeset.revision
                       entry.lastrev.name       = changeset.revision
                       entry.lastrev.time       = changeset.committed_on
                       entry.lastrev.author     = changeset.committer
                     end
                   end
                 end
+                load_entries_changesets(entries)
                 entries
               end
               def cat(path, identifier=nil)
                 patch = identifier.nil? ? nil : changesets.find_by_revision(identifier.to_s)
                 scm.cat(path, patch.nil? ? nil : patch.scmid)
               end
               def diff(path, rev, rev_to)
                 patch_from = changesets.find_by_revision(rev)
                 return nil if patch_from.nil?
                 patch_to = changesets.find_by_revision(rev_to) if rev_to
                 if path.blank?
                   path = patch_from.filechanges.collect{|change| change.path}.join(' ')
                 end
                 patch_from ? scm.diff(path, patch_from.scmid, patch_to ? patch_to.scmid : nil) : nil
               end
               def fetch_changesets
                 scm_info = scm.info
                 if scm_info
                   db_last_id = latest_changeset ? latest_changeset.scmid : nil
                   next_rev   = latest_changeset ? latest_changeset.revision.to_i + 1 : 1
                   # latest revision in the repository
                   scm_revision = scm_info.lastrev.scmid
                   unless changesets.find_by_scmid(scm_revision)
                     revisions = scm.revisions('', db_last_id, nil, :with_path => true)
                     transaction do
                       revisions.reverse_each do |revision|
                         changeset = Changeset.create(:repository   => self,
                                                      :revision     => next_rev,
                                                      :scmid        => revision.scmid,
                                                      :committer    => revision.author,
                                                      :committed_on => revision.time,
                                                      :comments     => revision.message)
                         revision.paths.each do |change|
                           changeset.create_change(change)
                         end
                         next_rev += 1
                       end if revisions
                     end
                   end
                 end
               end
             end

app/models/repository/filesystem.rb 0 -4

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # FileSystem adapter
             # File written by Paul Rivier, at Demotera.
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/filesystem_adapter'
             class Repository::Filesystem < Repository
               attr_protected :root_url
               validates_presence_of :url
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == "url"
                   attr_name = "root_directory"
                 end
                 super(attr_name, *args)
               end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::FilesystemAdapter
               end
               def self.scm_name
                 'Filesystem'
               end
               def supports_all_revisions?
                 false
               end
-              def entries(path=nil, identifier=nil)
-                scm.entries(path, identifier)
-              end
               def fetch_changesets
                 nil
               end
             end

app/models/repository/git.rb +3 -3

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             # Copyright (C) 2007  Patrick Aljord patcito@ŋmail.com
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'redmine/scm/adapters/git_adapter'
             class Repository::Git < Repository
               attr_protected :root_url
               validates_presence_of :url
               def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name.to_s
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
                 super(attr_name, *args)
               end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::GitAdapter
               end
               def self.scm_name
                 'Git'
               end
               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 supports_revision_graph?
                 true
               end
               def repo_log_encoding
                 'UTF-8'
               end
               # Returns the identifier for the given git changeset
               def self.changeset_identifier(changeset)
                 changeset.scmid
               end
               # Returns the readable identifier for the given git changeset
               def self.format_changeset_identifier(changeset)
                 changeset.revision[0, 8]
               end
               def branches
                 scm.branches
               end
               def tags
                 scm.tags
               end
               def default_branch
                 scm.default_branch
               rescue Exception => e
                 logger.error "git: error during get default branch: #{e.message}"
                 nil
               end
               def find_changeset_by_name(name)
                 return nil if name.nil? || name.empty?
                 e = changesets.find(:first, :conditions => ['revision = ?', name.to_s])
                 return e if e
                 changesets.find(:first, :conditions => ['scmid LIKE ?', "#{name}%"])
               end
               def entries(path=nil, identifier=nil)
-                scm.entries(path,
+                entries = scm.entries(path, identifier, :report_last_commit => extra_report_last_commit)
-                            identifier,
+                load_entries_changesets(entries)
-                            options = {:report_last_commit => extra_report_last_commit})
+                entries
               end
               # 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.
               #
               # However, Git does not have a sequential commit numbering.
               #
               # In order to fetch only new adding revisions,
               # Redmine needs to save "heads".
               #
               # 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.
               #
               # The repository can still be fully reloaded by calling #clear_changesets
               # before fetching changesets (eg. for offline resync)
               def fetch_changesets
                 scm_brs = branches
                 return if scm_brs.nil? || scm_brs.empty?
                 h1 = extra_info || {}
                 h  = h1.dup
                 repo_heads = scm_brs.map{ |br| br.scmid }
                 h["heads"] ||= []
                 prev_db_heads = h["heads"].dup
                 if prev_db_heads.empty?
                   prev_db_heads += heads_from_branches_hash
                 end
                 return if prev_db_heads.sort == repo_heads.sort
                 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
                 save_revisions(prev_db_heads, repo_heads)
               end
               def save_revisions(prev_db_heads, repo_heads)
                 h = {}
                 opts = {}
                 opts[:reverse]  = true
                 opts[:excludes] = prev_db_heads
                 opts[:includes] = repo_heads
                 revisions = scm.revisions('', nil, nil, opts)
                 return if revisions.blank?
                 # Make the search for existing revisions in the database in a more sufficient manner
                 #
                 # Git branch is the reference to the specific revision.
                 # Git can *delete* remote branch and *re-push* branch.
                 #
                 #  $ git push remote :branch
                 #  $ git push remote branch
                 #
                 # After deleting branch, revisions remain in repository until "git gc".
                 # On git 1.7.2.3, default pruning date is 2 weeks.
                 # So, "git log --not deleted_branch_head_revision" return code is 0.
                 #
                 # After re-pushing branch, "git log" returns revisions which are saved in database.
                 # So, Redmine needs to scan revisions and database every time.
                 #
                 # 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 algorithm 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.
                     save_revision(rev)
                   end
                 end
                 h["heads"] = repo_heads.dup
                 merge_extra_info(h)
                 self.save
               end
               private :save_revisions
               def save_revision(rev)
                 parents = (rev.parents || []).collect{|rp| find_changeset_by_name(rp)}.compact
                 changeset = Changeset.create(
                           :repository   => self,
                           :revision     => rev.identifier,
                           :scmid        => rev.scmid,
                           :committer    => rev.author,
                           :committed_on => rev.time,
                           :comments     => rev.message,
                           :parents      => parents
                           )
                 unless changeset.new_record?
                   rev.paths.each { |change| changeset.create_change(change) }
                 end
                 changeset
               end
               private :save_revision
               def heads_from_branches_hash
                 h1 = extra_info || {}
                 h  = h1.dup
                 h["branches"] ||= {}
                 h['branches'].map{|br, hs| hs['last_scmid']}
               end
               def latest_changesets(path,rev,limit=10)
                 revisions = scm.revisions(path, nil, rev, :limit => limit, :all => false)
                 return [] if revisions.nil? || revisions.empty?
                 changesets.find(
                   :all,
                   :conditions => [
                     "scmid IN (?)",
                     revisions.map!{|c| c.scmid}
                   ],
                   :order => 'committed_on DESC'
                 )
               end
             end

app/views/repositories/_dir_list_content.html.erb +3 -4

             <% @entries.each do |entry| %>
             <% tr_id = Digest::MD5.hexdigest(entry.path)
                depth = params[:depth].to_i %>
             <%  ent_path = Redmine::CodesetUtil.replace_invalid_utf8(entry.path)   %>
             <%  ent_name = Redmine::CodesetUtil.replace_invalid_utf8(entry.name)   %>
             <tr id="<%= tr_id %>" class="<%= h params[:parent_id] %> entry <%= entry.kind %>">
             <td style="padding-left: <%=18 * depth%>px;" class="<%=
                        @repository.report_last_commit ? "filename" : "filename_no_report" %>";>
             <% if entry.is_dir? %>
             <span class="expander" onclick="<%= remote_function(
                               :url => {
                                    :action => 'show',
                                    :id     => @project,
             											 :repository_id => @repository.identifier_param,
                                    :path   => to_path_param(ent_path),
                                    :rev    => @rev,
                                    :depth  => (depth + 1),
                                    :parent_id => tr_id
                                      },
                               :method => :get,
                               :update => { :success => tr_id },
                               :position => :after,
                               :success => "scmEntryLoaded('#{tr_id}')",
                               :condition => "scmEntryClick('#{tr_id}')"
                             ) %>">&nbsp</span>
             <% end %>
             <%=  link_to h(ent_name),
                       {:action => (entry.is_dir? ? 'show' : 'changes'), :id => @project, :repository_id => @repository.identifier_param, :path => to_path_param(ent_path), :rev => @rev},
                       :class => (entry.is_dir? ? 'icon icon-folder' : "icon icon-file #{Redmine::MimeType.css_class_of(ent_name)}")%>
             </td>
             <td class="size"><%= (entry.size ? number_to_human_size(entry.size) : "?") unless entry.is_dir? %></td>
-            <% changeset = @repository.find_changeset_by_name(entry.lastrev.identifier) if entry.lastrev && entry.lastrev.identifier %>
             <% if @repository.report_last_commit %>
-            <td class="revision"><%= link_to_revision(changeset, @repository) if changeset %></td>
+            <td class="revision"><%= link_to_revision(entry.changeset, @repository) if entry.changeset %></td>
             <td class="age"><%= distance_of_time_in_words(entry.lastrev.time, Time.now) if entry.lastrev && entry.lastrev.time %></td>
-            <td class="author"><%= changeset.nil? ? h(Redmine::CodesetUtil.replace_invalid_utf8(entry.lastrev.author.to_s.split('<').first)) : h(changeset.author) if entry.lastrev %></td>
+            <td class="author"><%= entry.changeset.nil? ? h(Redmine::CodesetUtil.replace_invalid_utf8(entry.lastrev.author.to_s.split('<').first)) : h(entry.changeset.author) if entry.lastrev %></td>
-            <td class="comments"><%=h truncate(changeset.comments, :length => 50) unless changeset.nil? %></td>
+            <td class="comments"><%=h truncate(entry.changeset.comments, :length => 50) if entry.changeset %></td>
             <% end %>
             </tr>
             <% end %>

lib/redmine/scm/adapters/abstract_adapter.rb +2 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'cgi'
             module Redmine
               module Scm
                 module Adapters
                   class CommandFailed < StandardError #:nodoc:
                   end
                   class AbstractAdapter #:nodoc:
                     # raised if scm command exited with error, e.g. unknown revision.
                     class ScmCommandAborted < CommandFailed; end
                     class << self
                       def client_command
                         ""
                       end
                       def shell_quote_command
                         if Redmine::Platform.mswin? && RUBY_PLATFORM == 'java'
                           client_command
                         else
                           shell_quote(client_command)
                         end
                       end
                       # Returns the version of the scm client
                       # Eg: [1, 5, 0] or [] if unknown
                       def client_version
                         []
                       end
                       # Returns the version string of the scm client
                       # Eg: '1.5.0' or 'Unknown version' if unknown
                       def client_version_string
                         v = client_version || 'Unknown version'
                         v.is_a?(Array) ? v.join('.') : v.to_s
                       end
                       # Returns true if the current client version is above
                       # or equals the given one
                       # If option is :unknown is set to true, it will return
                       # true if the client version is unknown
                       def client_version_above?(v, options={})
                         ((client_version <=> v) >= 0) || (client_version.empty? && options[:unknown])
                       end
                       def client_available
                         true
                       end
                       def shell_quote(str)
                         if Redmine::Platform.mswin?
                           '"' + str.gsub(/"/, '\\"') + '"'
                         else
                           "'" + str.gsub(/'/, "'\"'\"'") + "'"
                         end
                       end
                     end
                     def initialize(url, root_url=nil, login=nil, password=nil,
                                    path_encoding=nil)
                       @url = url
                       @login = login if login && !login.empty?
                       @password = (password || "") if @login
                       @root_url = root_url.blank? ? retrieve_root_url : root_url
                     end
                     def adapter_name
                       'Abstract'
                     end
                     def supports_cat?
                       true
                     end
                     def supports_annotate?
                       respond_to?('annotate')
                     end
                     def root_url
                       @root_url
                     end
                     def url
                       @url
                     end
                     def path_encoding
                       nil
                     end
                     # get info about the svn repository
                     def info
                       return nil
                     end
                     # Returns the entry identified by path and revision identifier
                     # or nil if entry doesn't exist in the repository
                     def entry(path=nil, identifier=nil)
                       parts = path.to_s.split(%r{[\/\\]}).select {|n| !n.blank?}
                       search_path = parts[0..-2].join('/')
                       search_name = parts[-1]
                       if search_path.blank? && search_name.blank?
                         # Root entry
                         Entry.new(:path => '', :kind => 'dir')
                       else
                         # Search for the entry in the parent directory
                         es = entries(search_path, identifier)
                         es ? es.detect {|e| e.name == search_name} : nil
                       end
                     end
                     # Returns an Entries collection
                     # or nil if the given path doesn't exist in the repository
                     def entries(path=nil, identifier=nil, options={})
                       return nil
                     end
                     def branches
                       return nil
                     end
                     def tags
                       return nil
                     end
                     def default_branch
                       return nil
                     end
                     def properties(path, identifier=nil)
                       return nil
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       return nil
                     end
                     def diff(path, identifier_from, identifier_to=nil)
                       return nil
                     end
                     def cat(path, identifier=nil)
                       return nil
                     end
                     def with_leading_slash(path)
                       path ||= ''
                       (path[0,1]!="/") ? "/#{path}" : path
                     end
                     def with_trailling_slash(path)
                       path ||= ''
                       (path[-1,1] == "/") ? path : "#{path}/"
                     end
                     def without_leading_slash(path)
                       path ||= ''
                       path.gsub(%r{^/+}, '')
                     end
                     def without_trailling_slash(path)
                       path ||= ''
                       (path[-1,1] == "/") ? path[0..-2] : path
                      end
                     def shell_quote(str)
                       self.class.shell_quote(str)
                     end
                   private
                     def retrieve_root_url
                       info = self.info
                       info ? info.root_url : nil
                     end
                     def target(path, sq=true)
                       path ||= ''
                       base = path.match(/^\//) ? root_url : url
                       str = "#{base}/#{path}".gsub(/[?<>\*]/, '')
                       if sq
                         str = shell_quote(str)
                       end
                       str
                     end
                     def logger
                       self.class.logger
                     end
                     def shellout(cmd, options = {}, &block)
                       self.class.shellout(cmd, options, &block)
                     end
                     def self.logger
                       Rails.logger
                     end
                     def self.shellout(cmd, options = {}, &block)
                       if logger && logger.debug?
                         logger.debug "Shelling out: #{strip_credential(cmd)}"
                       end
                       if Rails.env == 'development'
                         # Capture stderr when running in dev environment
                         cmd = "#{cmd} 2>>#{shell_quote(Rails.root.join('log/scm.stderr.log').to_s)}"
                       end
                       begin
                         mode = "r+"
                         IO.popen(cmd, mode) do |io|
                           io.set_encoding("ASCII-8BIT") if io.respond_to?(:set_encoding)
                           io.close_write unless options[:write_stdin]
                           block.call(io) if block_given?
                         end
                       ## If scm command does not exist,
                       ## Linux JRuby 1.6.2 (ruby-1.8.7-p330) raises java.io.IOException
                       ## in production environment.
                       # rescue Errno::ENOENT => e
                       rescue Exception => e
                         msg = strip_credential(e.message)
                         # The command failed, log it and re-raise
                         logmsg = "SCM command failed, "
                         logmsg += "make sure that your SCM command (e.g. svn) is "
                         logmsg += "in PATH (#{ENV['PATH']})\n"
                         logmsg += "You can configure your scm commands in config/configuration.yml.\n"
                         logmsg += "#{strip_credential(cmd)}\n"
                         logmsg += "with: #{msg}"
                         logger.error(logmsg)
                         raise CommandFailed.new(msg)
                       end
                     end
                     # Hides username/password in a given command
                     def self.strip_credential(cmd)
                       q = (Redmine::Platform.mswin? ? '"' : "'")
                       cmd.to_s.gsub(/(\-\-(password|username))\s+(#{q}[^#{q}]+#{q}|[^#{q}]\S+)/, '\\1 xxxx')
                     end
                     def strip_credential(cmd)
                       self.class.strip_credential(cmd)
                     end
                     def scm_iconv(to, from, str)
                       return nil if str.nil?
                       return str if to == from
                       begin
                         Iconv.conv(to, from, str)
                       rescue Iconv::Failure => err
                         logger.error("failed to convert from #{from} to #{to}. #{err}")
                         nil
                       end
                     end
                     def parse_xml(xml)
                       if RUBY_PLATFORM == 'java'
                         xml = xml.sub(%r{<\?xml[^>]*\?>}, '')
                       end
                       ActiveSupport::XmlMini.parse(xml)
                     end
                   end
                   class Entries < Array
                     def sort_by_name
                       dup.sort! {|x,y|
                         if x.kind == y.kind
                           x.name.to_s <=> y.name.to_s
                         else
                           x.kind <=> y.kind
                         end
                       }
                     end
                     def revisions
                       revisions ||= Revisions.new(collect{|entry| entry.lastrev}.compact)
                     end
                   end
                   class Info
                     attr_accessor :root_url, :lastrev
                     def initialize(attributes={})
                       self.root_url = attributes[:root_url] if attributes[:root_url]
                       self.lastrev = attributes[:lastrev]
                     end
                   end
                   class Entry
-                    attr_accessor :name, :path, :kind, :size, :lastrev
+                    attr_accessor :name, :path, :kind, :size, :lastrev, :changeset
                     def initialize(attributes={})
                       self.name = attributes[:name] if attributes[:name]
                       self.path = attributes[:path] if attributes[:path]
                       self.kind = attributes[:kind] if attributes[:kind]
                       self.size = attributes[:size].to_i if attributes[:size]
                       self.lastrev = attributes[:lastrev]
                     end
                     def is_file?
                       'file' == self.kind
                     end
                     def is_dir?
                       'dir' == self.kind
                     end
                     def is_text?
                       Redmine::MimeType.is_type?('text', name)
                     end
                   end
                   class Revisions < Array
                     def latest
                       sort {|x,y|
                         unless x.time.nil? or y.time.nil?
                           x.time <=> y.time
                         else
                         end
                       }.last
                     end
                   end
                   class Revision
                     attr_accessor :scmid, :name, :author, :time, :message,
                                   :paths, :revision, :branch, :identifier,
                                   :parents
                     def initialize(attributes={})
                       self.identifier = attributes[:identifier]
                       self.scmid      = attributes[:scmid]
                       self.name       = attributes[:name] || self.identifier
                       self.author     = attributes[:author]
                       self.time       = attributes[:time]
                       self.message    = attributes[:message] || ""
                       self.paths      = attributes[:paths]
                       self.revision   = attributes[:revision]
                       self.branch     = attributes[:branch]
                       self.parents    = attributes[:parents]
                     end
                     # Returns the readable identifier.
                     def format_identifier
                       self.identifier.to_s
                     end
                   end
                   class Annotate
                     attr_reader :lines, :revisions
                     def initialize
                       @lines = []
                       @revisions = []
                     end
                     def add_line(line, revision)
                       @lines << line
                       @revisions << revision
                     end
                     def content
                       content = lines.join("\n")
                     end
                     def empty?
                       lines.empty?
                     end
                   end
                   class Branch < String
                     attr_accessor :revision, :scmid
                   end
                 end
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages