jro_apps/redmine Commit - r8166:5eed64b8488a

human_attribute_name accepts optional argument....

Jean-Philippe Lang -

r8166:5eed64b8488a

parent child

Context file:

r8166:5eed64b8488a

Collapse all files

app/models/group.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 Group < Principal
               has_and_belongs_to_many :users, :after_add => :user_added,
                                               :after_remove => :user_removed
               acts_as_customizable
               validates_presence_of :lastname
               validates_uniqueness_of :lastname, :case_sensitive => false
               validates_length_of :lastname, :maximum => 30
               before_destroy :remove_references_before_destroy
               def to_s
                 lastname.to_s
               end
               alias :name :to_s
               def user_added(user)
                 members.each do |member|
                   next if member.project.nil?
                   user_member = Member.find_by_project_id_and_user_id(member.project_id, user.id) || Member.new(:project_id => member.project_id, :user_id => user.id)
                   member.member_roles.each do |member_role|
                     user_member.member_roles << MemberRole.new(:role => member_role.role, :inherited_from => member_role.id)
                   end
                   user_member.save!
                 end
               end
               def user_removed(user)
                 members.each do |member|
                   MemberRole.find(:all, :include => :member,
                                         :conditions => ["#{Member.table_name}.user_id = ? AND #{MemberRole.table_name}.inherited_from IN (?)", user.id, member.member_role_ids]).each(&:destroy)
                 end
               end
-              def self.human_attribute_name(attribute_key_name)
+              def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name
                 if attr_name == 'lastname'
                   attr_name = "name"
                 end
-                super(attr_name)
+                super(attr_name, *args)
               end
               private
               # Removes references that are not handled by associations
               def remove_references_before_destroy
                 return if self.id.nil?
                 Issue.update_all 'assigned_to_id = NULL', ['assigned_to_id = ?', id]
               end
             end

app/models/repository.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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 :changes, :through => :changesets
               serialize :extra_info
               # 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
               # 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)
+              def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name
                 if attr_name == "log_encoding"
                   attr_name = "commit_logs_encoding"
                 end
-                super(attr_name)
+                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
                 @scm ||= self.scm_adapter.new(url, root_url,
                                               login, password, path_encoding)
                 update_attribute(:root_url, @scm.root_url) if root_url.blank?
                 @scm
               end
               def scm_name
                 self.class.scm_name
               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)
               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?
                 changesets.find(:first, :conditions => (name.match(/^\d*$/) ?
                       ["revision = ?", name.to_s] : ["revision LIKE ?", name + '%']))
               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
                   changes.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).find(:all, :include => :repository).each do |project|
                   if project.repository
                     begin
                       project.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
               private
               def clear_changesets
                 cs, ch, ci = Changeset.table_name, Change.table_name, "#{table_name_prefix}changesets_issues#{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 #{cs} WHERE #{cs}.repository_id = #{id}")
               end
             end

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

             # Redmine - project management software
             # Copyright (C) 2006-2011  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)
+              def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
-                super(attr_name)
+                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
               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 +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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)
+              def self.human_attribute_name(attribute_key_name, *args)
                 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)
+                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=changes.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
                 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.changes.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.changes.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 changes.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
                   changesets.find(
                           :all,
                           :order => 'committed_on ASC, id ASC',
                           :conditions => "revision LIKE 'tmp%'"
                        ).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 +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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)
+              def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
-                super(attr_name)
+                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
                 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.changes.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 +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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)
+              def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name
                 if attr_name == "url"
                   attr_name = "root_directory"
                 end
-                super(attr_name)
+                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 +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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)
+              def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
-                super(attr_name)
+                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,
                             identifier,
                             options = {:report_last_commit => extra_report_last_commit})
               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 parse revisions per branch.
               # Branch "last_scmid" is for this requirement.
               #
               # 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
                 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 |br1|
                   br = br1.to_s
                   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)
                     transaction do
                       if db_rev.nil?
                         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
                       end
                       h["branches"][br]["last_scmid"] = rev.scmid
                       merge_extra_info(h)
                       self.save
                     end
                   end
                 end
               end
               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
                 changeset
               end
               private :save_revision
               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/models/repository/mercurial.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2011  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/mercurial_adapter'
             class Repository::Mercurial < Repository
               # sort changesets by revision number
               has_many :changesets,
                        :order       => "#{Changeset.table_name}.id DESC",
                        :foreign_key => 'repository_id'
               attr_protected        :root_url
               validates_presence_of :url
               # number of changesets to fetch at once
               FETCH_AT_ONCE = 100
-              def self.human_attribute_name(attribute_key_name)
+              def self.human_attribute_name(attribute_key_name, *args)
                 attr_name = attribute_key_name
                 if attr_name == "url"
                   attr_name = "path_to_repository"
                 end
-                super(attr_name)
+                super(attr_name, *args)
               end
               def self.scm_adapter_class
                 Redmine::Scm::Adapters::MercurialAdapter
               end
               def self.scm_name
                 'Mercurial'
               end
               def supports_directory_revisions?
                 true
               end
               def supports_revision_graph?
                 true
               end
               def repo_log_encoding
                 'UTF-8'
               end
               # Returns the readable identifier for the given mercurial changeset
               def self.format_changeset_identifier(changeset)
                 "#{changeset.revision}:#{changeset.scmid}"
               end
               # Returns the identifier for the given Mercurial changeset
               def self.changeset_identifier(changeset)
                 changeset.scmid
               end
               def diff_format_revisions(cs, cs_to, sep=':')
                 super(cs, cs_to, ' ')
               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.nil? || name.empty?
                 if /[^\d]/ =~ name or name.to_s.size > 8
                   e = changesets.find(:first, :conditions => ['scmid = ?', name.to_s])
                 else
                   e = changesets.find(:first, :conditions => ['revision = ?', name.to_s])
                 end
                 return e if e
                 changesets.find(:first, :conditions => ['scmid LIKE ?', "#{name}%"])  # last ditch
               end
               # Returns the latest changesets for +path+; sorted by revision number
               #
               # 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?
               def latest_changesets(path, rev, limit=10)
                 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
                 end
                 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(%r{[%_\\]}) { |s| "\\#{s}" }}/%" << '\\'
                 end
                 [cond.join(' AND '), *args] unless cond.empty?
               end
               private :latest_changesets_cond
               def fetch_changesets
                 return if scm.info.nil?
                 scm_rev = scm.info.lastrev.revision.to_i
                 db_rev  = latest_changeset ? latest_changeset.revision.to_i : -1
                 return unless db_rev < scm_rev  # already up-to-date
                 logger.debug "Fetching changesets for repository #{url}" if logger
                 (db_rev + 1).step(scm_rev, FETCH_AT_ONCE) do |i|
                   transaction do
                     scm.each_revision('', i, [i + FETCH_AT_ONCE - 1, scm_rev].min) do |re|
                       cs = Changeset.create(:repository   => self,
                                             :revision     => re.revision,
                                             :scmid        => re.scmid,
                                             :committer    => re.author,
                                             :committed_on => re.time,
                                             :comments     => re.message)
                       re.paths.each { |e| cs.create_change(e) }
                       parents = {}
                       parents[cs] = re.parents unless re.parents.nil?
                       parents.each do |ch, chparents|
                         ch.parents = chparents.collect{|rp| find_changeset_by_name(rp)}.compact
                       end
                     end
                   end
                 end
               end
             end

config/initializers/10-patches.rb +1 -1

             # Patches active_support/core_ext/load_error.rb to support 1.9.3 LoadError message
             if RUBY_VERSION >= '1.9.3'
               MissingSourceFile::REGEXPS << [/^cannot load such file -- (.+)$/i, 1]
             end
             require 'active_record'
             module ActiveRecord
               class Base
                 include Redmine::I18n
                 # Translate attribute names for validation errors display
-                def self.human_attribute_name(attr)
+                def self.human_attribute_name(attr, *args)
                   l("field_#{attr.to_s.gsub(/_id$/, '')}", :default => attr)
                 end
               end
             end
             module ActiveRecord
               class Errors
                 def full_messages(options = {})
                   full_messages = []
                   @errors.each_key do |attr|
                     @errors[attr].each do |message|
                       next unless message
                       if attr == "base"
                         full_messages << message
                       elsif attr == "custom_values"
                         # Replace the generic "custom values is invalid"
                         # with the errors on custom values
                         @base.custom_values.each do |value|
                           value.errors.each do |attr, msg|
                             full_messages << value.custom_field.name + ' ' + msg
                           end
                         end
                       else
                         attr_name = @base.class.human_attribute_name(attr)
                         full_messages << attr_name + ' ' + message.to_s
                       end
                     end
                   end
                   full_messages
                 end
               end
             end
             module ActionView
               module Helpers
                 module DateHelper
                   # distance_of_time_in_words breaks when difference is greater than 30 years
                   def distance_of_date_in_words(from_date, to_date = 0, options = {})
                     from_date = from_date.to_date if from_date.respond_to?(:to_date)
                     to_date = to_date.to_date if to_date.respond_to?(:to_date)
                     distance_in_days = (to_date - from_date).abs
                     I18n.with_options :locale => options[:locale], :scope => :'datetime.distance_in_words' do |locale|
                       case distance_in_days
                         when 0..60     then locale.t :x_days,             :count => distance_in_days.round
                         when 61..720   then locale.t :about_x_months,     :count => (distance_in_days / 30).round
                         else                locale.t :over_x_years,       :count => (distance_in_days / 365).floor
                       end
                     end
                   end
                 end
               end
             end
             ActionView::Base.field_error_proc = Proc.new{ |html_tag, instance| "#{html_tag}" }
             module AsynchronousMailer
               # Adds :async_smtp and :async_sendmail delivery methods
               # to perform email deliveries asynchronously
               %w(smtp sendmail).each do |type|
                 define_method("perform_delivery_async_#{type}") do |mail|
                   Thread.start do
                     send "perform_delivery_#{type}", mail
                   end
                 end
               end
               # Adds a delivery method that writes emails in tmp/emails for testing purpose
               def perform_delivery_tmp_file(mail)
                 dest_dir = File.join(Rails.root, 'tmp', 'emails')
                 Dir.mkdir(dest_dir) unless File.directory?(dest_dir)
                 File.open(File.join(dest_dir, mail.message_id.gsub(/[<>]/, '') + '.eml'), 'wb') {|f| f.write(mail.encoded) }
               end
             end
             ActionMailer::Base.send :include, AsynchronousMailer
             module TMail
               # TMail::Unquoter.convert_to_with_fallback_on_iso_8859_1 introduced in TMail 1.2.7
               # triggers a test failure in test_add_issue_with_japanese_keywords(MailHandlerTest)
               class Unquoter
                 class << self
                   alias_method :convert_to, :convert_to_without_fallback_on_iso_8859_1
                 end
               end
               # Patch for TMail 1.2.7. See http://www.redmine.org/issues/8751
               class Encoder
                 def puts_meta(str)
                   add_text str
                 end
               end
             end
             module ActionController
               module MimeResponds
                 class Responder
                   def api(&block)
                     any(:xml, :json, &block)
                   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