jro_apps/redmine Commit - r3391:d80fb751fd01

Merged r3469, r3472 and r3473 from trunk....

Jean-Philippe Lang -

r3391:d80fb751fd01

parent child

Context file:

r3391:d80fb751fd01

Collapse all files

app/models/changeset.rb +7 -6

             # Redmine - project management software
             # Copyright (C) 2006-2010  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 'iconv'
             class Changeset < ActiveRecord::Base
               belongs_to :repository
               belongs_to :user
               has_many :changes, :dependent => :delete_all
               has_and_belongs_to_many :issues
               acts_as_event :title => Proc.new {|o| "#{l(:label_revision)} #{o.revision}" + (o.short_comments.blank? ? '' : (': ' + o.short_comments))},
                             :description => :long_comments,
                             :datetime => :committed_on,
                             :url => Proc.new {|o| {:controller => 'repositories', :action => 'revision', :id => o.repository.project, :rev => o.revision}}
               acts_as_searchable :columns => 'comments',
                                  :include => {:repository => :project},
                                  :project_key => "#{Repository.table_name}.project_id",
                                  :date_column => 'committed_on'
               acts_as_activity_provider :timestamp => "#{table_name}.committed_on",
                                         :author_key => :user_id,
                                         :find_options => {:include => [:user, {:repository => :project}]}
               validates_presence_of :repository_id, :revision, :committed_on, :commit_date
               validates_uniqueness_of :revision, :scope => :repository_id
               validates_uniqueness_of :scmid, :scope => :repository_id, :allow_nil => true
               named_scope :visible, lambda {|*args| { :include => {:repository => :project},
                                                       :conditions => Project.allowed_to_condition(args.first || User.current, :view_changesets) } }
               def revision=(r)
                 write_attribute :revision, (r.nil? ? nil : r.to_s)
               end
               def comments=(comment)
                 write_attribute(:comments, Changeset.normalize_comments(comment))
               end
               def committed_on=(date)
                 self.commit_date = date
                 super
               end
               def committer=(arg)
                 write_attribute(:committer, self.class.to_utf8(arg.to_s))
               end
               def project
                 repository.project
               end
               def author
                 user || committer.to_s.split('<').first
               end
               def before_create
                 self.user = repository.find_committer_user(committer)
               end
               def after_create
                 scan_comment_for_issue_ids
               end
               require 'pp'
               def scan_comment_for_issue_ids
                 return if comments.blank?
                 # keywords used to reference issues
                 ref_keywords = Setting.commit_ref_keywords.downcase.split(",").collect(&:strip)
                 # keywords used to fix issues
                 fix_keywords = Setting.commit_fix_keywords.downcase.split(",").collect(&:strip)
-                # status and optional done ratio applied
-                fix_status = IssueStatus.find_by_id(Setting.commit_fix_status_id)
-                done_ratio = Setting.commit_fix_done_ratio.blank? ? nil : Setting.commit_fix_done_ratio.to_i
                 kw_regexp = (ref_keywords + fix_keywords).collect{|kw| Regexp.escape(kw)}.join("|")
                 return if kw_regexp.blank?
                 referenced_issues = []
                 if ref_keywords.delete('*')
                   # find any issue ID in the comments
                   target_issue_ids = []
                   comments.scan(%r{([\s\(\[,-]|^)#(\d+)(?=[[:punct:]]|\s|<|$)}).each { |m| target_issue_ids << m[1] }
                   referenced_issues += find_referenced_issues_by_id(target_issue_ids)
                 end
                 comments.scan(Regexp.new("(#{kw_regexp})[\s:]+(([\s,;&]*#?\\d+)+)", Regexp::IGNORECASE)).each do |match|
                   action = match[0]
                   target_issue_ids = match[1].scan(/\d+/)
                   target_issues = find_referenced_issues_by_id(target_issue_ids)
-                  if fix_status && fix_keywords.include?(action.downcase)
+                  if fix_keywords.include?(action.downcase) && fix_status = IssueStatus.find_by_id(Setting.commit_fix_status_id)
                     # update status of issues
                     logger.debug "Issues fixed by changeset #{self.revision}: #{issue_ids.join(', ')}." if logger && logger.debug?
                     target_issues.each do |issue|
                       # the issue may have been updated by the closure of another one (eg. duplicate)
                       issue.reload
                       # don't change the status is the issue is closed
                       next if issue.status.is_closed?
                       csettext = "r#{self.revision}"
                       if self.scmid && (! (csettext =~ /^r[0-9]+$/))
                         csettext = "commit:\"#{self.scmid}\""
                       end
                       journal = issue.init_journal(user || User.anonymous, ll(Setting.default_language, :text_status_changed_by_changeset, csettext))
                       issue.status = fix_status
-                      issue.done_ratio = done_ratio if done_ratio
+                      unless Setting.commit_fix_done_ratio.blank?
+                        issue.done_ratio = Setting.commit_fix_done_ratio.to_i
+                      end
                       Redmine::Hook.call_hook(:model_changeset_scan_commit_for_issue_ids_pre_issue_update,
                                               { :changeset => self, :issue => issue })
                       issue.save
                     end
                   end
                   referenced_issues += target_issues
                 end
-                self.issues = referenced_issues.uniq
+                referenced_issues.uniq!
+                self.issues = referenced_issues unless referenced_issues.empty?
               end
               def short_comments
                 @short_comments || split_comments.first
               end
               def long_comments
                 @long_comments || split_comments.last
               end
               # Returns the previous changeset
               def previous
                 @previous ||= Changeset.find(:first, :conditions => ['id < ? AND repository_id = ?', self.id, self.repository_id], :order => 'id DESC')
               end
               # Returns the next changeset
               def next
                 @next ||= Changeset.find(:first, :conditions => ['id > ? AND repository_id = ?', self.id, self.repository_id], :order => 'id ASC')
               end
               # Strips and reencodes a commit log before insertion into the database
               def self.normalize_comments(str)
                 to_utf8(str.to_s.strip)
               end
               private
               # Finds issues that can be referenced by the commit message
               # i.e. issues that belong to the repository project, a subproject or a parent project
               def find_referenced_issues_by_id(ids)
+                return [] if ids.compact.empty?
                 Issue.find_all_by_id(ids, :include => :project).select {|issue|
                   project == issue.project || project.is_ancestor_of?(issue.project) || project.is_descendant_of?(issue.project)
                 }
               end
               def split_comments
                 comments =~ /\A(.+?)\r?\n(.*)$/m
                 @short_comments = $1 || comments
                 @long_comments = $2.to_s.strip
                 return @short_comments, @long_comments
               end
               def self.to_utf8(str)
                 return str if /\A[\r\n\t\x20-\x7e]*\Z/n.match(str) # for us-ascii
                 encoding = Setting.commit_logs_encoding.to_s.strip
                 unless encoding.blank? || encoding == 'UTF-8'
                   begin
                     str = Iconv.conv('UTF-8', encoding, str)
                   rescue Iconv::Failure
                     # do nothing here
                   end
                 end
                 # removes invalid UTF8 sequences
                 Iconv.conv('UTF-8//IGNORE', 'UTF-8', str + '  ')[0..-3]
               end
             end

app/models/repository.rb +10 -3

             # redMine - project management software
             # Copyright (C) 2006-2007  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 Repository < ActiveRecord::Base
               belongs_to :project
               has_many :changesets, :order => "#{Changeset.table_name}.committed_on DESC, #{Changeset.table_name}.id DESC"
               has_many :changes, :through => :changesets
               # 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
               # Checks if the SCM is enabled when creating a repository
               validate_on_create { |r| r.errors.add(:type, :invalid) unless Setting.enabled_scm.include?(r.class.name.demodulize) }
               # 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 scm
                 @scm ||= self.scm_adapter.new url, root_url, login, password
                 update_attribute(:root_url, @scm.root_url) if root_url.blank?
                 @scm
               end
               def scm_name
                 self.class.scm_name
               end
               def supports_cat?
                 scm.supports_cat?
               end
               def supports_annotate?
                 scm.supports_annotate?
               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
                 scm.default_branch
               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
               # 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)
                 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)
-                if 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
-                    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
               # 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
                     project.repository.fetch_changesets
                   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
               private
               def before_save
                 # Strips url and root_url
                 url.strip!
                 root_url.strip!
                 true
               end
               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

lib/redmine/scm/adapters/abstract_adapter.rb +11 -9

             # redMine - project management software
             # Copyright (C) 2006-2007  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:
                     class << self
                       # 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
                     end
                     def initialize(url, root_url=nil, login=nil, password=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
                     # 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)
                       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)
                       if Redmine::Platform.mswin?
                         '"' + str.gsub(/"/, '\\"') + '"'
                       else
                         "'" + str.gsub(/'/, "'\"'\"'") + "'"
                       end
                     end
                   private
                     def retrieve_root_url
                       info = self.info
                       info ? info.root_url : nil
                     end
                     def target(path)
                       path ||= ''
                       base = path.match(/^\//) ? root_url : url
                       shell_quote("#{base}/#{path}".gsub(/[?<>\*]/, ''))
                     end
                     def logger
                       self.class.logger
                     end
                     def shellout(cmd, &block)
                       self.class.shellout(cmd, &block)
                     end
                     def self.logger
                       RAILS_DEFAULT_LOGGER
                     end
                     def self.shellout(cmd, &block)
                       logger.debug "Shelling out: #{strip_credential(cmd)}" if logger && logger.debug?
                       if Rails.env == 'development'
                         # Capture stderr when running in dev environment
                         cmd = "#{cmd} 2>>#{RAILS_ROOT}/log/scm.stderr.log"
                       end
                       begin
                         IO.popen(cmd, "r+") do |io|
                           io.close_write
                           block.call(io) if block_given?
                         end
                       rescue Errno::ENOENT => e
                         msg = strip_credential(e.message)
                         # The command failed, log it and re-raise
                         logger.error("SCM command failed, make sure that your SCM binary (eg. svn) is in PATH (#{ENV['PATH']}): #{strip_credential(cmd)}\n  with: #{msg}")
                         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
                   end
                   class Entries < Array
                     def sort_by_name
                       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
                     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 :identifier, :scmid, :name, :author, :time, :message, :paths, :revision, :branch
                     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]
                     end
                     def save(repo)
-                      if repo.changesets.find_by_scmid(scmid.to_s).nil?
+                      Changeset.transaction do
-                        changeset = Changeset.create!(
+                        changeset = Changeset.new(
                           :repository => repo,
                           :revision => identifier,
                           :scmid => scmid,
                           :committer => author,
                           :committed_on => time,
                           :comments => message)
-                        paths.each do |file|
+                        if changeset.save
-                          Change.create!(
+                          paths.each do |file|
-                            :changeset => changeset,
+                            Change.create(
-                            :action => file[:action],
+                              :changeset => changeset,
-                            :path => file[:path])
+                              :action => file[:action],
-                        end
+                              :path => file[:path])
+                          end
+                        end
                       end
                     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
                 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