jro_apps/redmine Commit - r11978:b6cb7aa8e3b9

Ability to define commit keywords per tracker (#7590)....

Jean-Philippe Lang -

r11978:b6cb7aa8e3b9

parent child

Context file:

r11978:b6cb7aa8e3b9

Collapse all files

app/controllers/settings_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 SettingsController < ApplicationController
               layout 'admin'
               menu_item :plugins, :only => :plugin
               helper :queries
               before_filter :require_admin
               def index
                 edit
                 render :action => 'edit'
               end
               def edit
                 @notifiables = Redmine::Notifiable.all
                 if request.post? && params[:settings] && params[:settings].is_a?(Hash)
                   settings = (params[:settings] || {}).dup.symbolize_keys
                   settings.each do |name, value|
                     Setting.set_from_params name, value
                   end
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to settings_path(:tab => params[:tab])
                 else
                   @options = {}
                   user_format = User::USER_FORMATS.collect{|key, value| [key, value[:setting_order]]}.sort{|a, b| a[1] <=> b[1]}
                   @options[:user_format] = user_format.collect{|f| [User.current.name(f[0]), f[0].to_s]}
                   @deliveries = ActionMailer::Base.perform_deliveries
                   @guessed_host_and_path = request.host_with_port.dup
                   @guessed_host_and_path << ('/'+ Redmine::Utils.relative_url_root.gsub(%r{^\/}, '')) unless Redmine::Utils.relative_url_root.blank?
                   @commit_update_keywords = Setting.commit_update_keywords.dup
-                  @commit_update_keywords[''] = {} if @commit_update_keywords.blank?
+                  @commit_update_keywords << {} if @commit_update_keywords.blank?
                   Redmine::Themes.rescan
                 end
               end
               def plugin
                 @plugin = Redmine::Plugin.find(params[:id])
                 unless @plugin.configurable?
                   render_404
                   return
                 end
                 if request.post?
                   Setting.send "plugin_#{@plugin.id}=", params[:settings]
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to plugin_settings_path(@plugin)
                 else
                   @partial = @plugin.settings[:partial]
                   @settings = Setting.send "plugin_#{@plugin.id}"
                 end
               rescue Redmine::PluginNotFound
                 render_404
               end
             end

app/models/changeset.rb +7 -5

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 Changeset < ActiveRecord::Base
               belongs_to :repository
               belongs_to :user
               has_many :filechanges, :class_name => 'Change', :dependent => :delete_all
               has_and_belongs_to_many :issues
               has_and_belongs_to_many :parents,
                                       :class_name => "Changeset",
                                       :join_table => "#{table_name_prefix}changeset_parents#{table_name_suffix}",
                                       :association_foreign_key => 'parent_id', :foreign_key => 'changeset_id'
               has_and_belongs_to_many :children,
                                       :class_name => "Changeset",
                                       :join_table => "#{table_name_prefix}changeset_parents#{table_name_suffix}",
                                       :association_foreign_key => 'changeset_id', :foreign_key => 'parent_id'
               acts_as_event :title => Proc.new {|o| o.title},
                             :description => :long_comments,
                             :datetime => :committed_on,
                             :url => Proc.new {|o| {:controller => 'repositories', :action => 'revision', :id => o.repository.project, :repository_id => o.repository.identifier_param, :rev => o.identifier}}
               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
               scope :visible, lambda {|*args|
                 includes(:repository => :project).where(Project.allowed_to_condition(args.shift || User.current, :view_changesets, *args))
               }
               after_create :scan_for_issues
               before_create :before_create_cs
               def revision=(r)
                 write_attribute :revision, (r.nil? ? nil : r.to_s)
               end
               # Returns the identifier of this changeset; depending on repository backends
               def identifier
                 if repository.class.respond_to? :changeset_identifier
                   repository.class.changeset_identifier self
                 else
                   revision.to_s
                 end
               end
               def committed_on=(date)
                 self.commit_date = date
                 super
               end
               # Returns the readable identifier
               def format_identifier
                 if repository.class.respond_to? :format_changeset_identifier
                   repository.class.format_changeset_identifier self
                 else
                   identifier
                 end
               end
               def project
                 repository.project
               end
               def author
                 user || committer.to_s.split('<').first
               end
               def before_create_cs
                 self.committer = self.class.to_utf8(self.committer, repository.repo_log_encoding)
                 self.comments  = self.class.normalize_comments(
                                    self.comments, repository.repo_log_encoding)
                 self.user = repository.find_committer_user(self.committer)
               end
               def scan_for_issues
                 scan_comment_for_issue_ids
               end
               TIMELOG_RE = /
                 (
                 ((\d+)(h|hours?))((\d+)(m|min)?)?
                 |
                 ((\d+)(h|hours?|m|min))
                 |
                 (\d+):(\d+)
                 |
                 (\d+([\.,]\d+)?)h?
                 )
                 /x
               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)
                 ref_keywords_any = ref_keywords.delete('*')
                 # keywords used to fix issues
-                fix_keywords = Setting.commit_update_by_keyword.keys
+                fix_keywords = Setting.commit_update_keywords_array.map {|r| r['keywords']}.flatten.compact
                 kw_regexp = (ref_keywords + fix_keywords).collect{|kw| Regexp.escape(kw)}.join("|")
                 referenced_issues = []
                 comments.scan(/([\s\(\[,-]|^)((#{kw_regexp})[\s:]+)?(#\d+(\s+@#{TIMELOG_RE})?([\s,;&]+#\d+(\s+@#{TIMELOG_RE})?)*)(?=[[:punct:]]|\s|<|$)/i) do |match|
                   action, refs = match[2].to_s.downcase, match[3]
                   next unless action.present? || ref_keywords_any
                   refs.scan(/#(\d+)(\s+@#{TIMELOG_RE})?/).each do |m|
                     issue, hours = find_referenced_issue_by_id(m[0].to_i), m[2]
                     if issue
                       referenced_issues << issue
                       # Don't update issues or log time when importing old commits
                       unless repository.created_on && committed_on && committed_on < repository.created_on
                         fix_issue(issue, action) if fix_keywords.include?(action)
                         log_time(issue, hours) if hours && Setting.commit_logtime_enabled?
                       end
                     end
                   end
                 end
                 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
               def text_tag(ref_project=nil)
                 tag = if scmid?
                   "commit:#{scmid}"
                 else
                   "r#{revision}"
                 end
                 if repository && repository.identifier.present?
                   tag = "#{repository.identifier}|#{tag}"
                 end
                 if ref_project && project && ref_project != project
                   tag = "#{project.identifier}:#{tag}"
                 end
                 tag
               end
               # Returns the title used for the changeset in the activity/search results
               def title
                 repo = (repository && repository.identifier.present?) ? " (#{repository.identifier})" : ''
                 comm = short_comments.blank? ? '' : (': ' + short_comments)
                 "#{l(:label_revision)} #{format_identifier}#{repo}#{comm}"
               end
               # Returns the previous changeset
               def previous
                 @previous ||= Changeset.where(["id < ? AND repository_id = ?", id, repository_id]).order('id DESC').first
               end
               # Returns the next changeset
               def next
                 @next ||= Changeset.where(["id > ? AND repository_id = ?", id, repository_id]).order('id ASC').first
               end
               # Creates a new Change from it's common parameters
               def create_change(change)
                 Change.create(:changeset     => self,
                               :action        => change[:action],
                               :path          => change[:path],
                               :from_path     => change[:from_path],
                               :from_revision => change[:from_revision])
               end
               # Finds an issue that can be referenced by the commit message
               def find_referenced_issue_by_id(id)
                 return nil if id.blank?
                 issue = Issue.find_by_id(id.to_i, :include => :project)
                 if Setting.commit_cross_project_ref?
                   # all issues can be referenced/fixed
                 elsif issue
                   # issue that belong to the repository project, a subproject or a parent project only
                   unless issue.project &&
                             (project == issue.project || project.is_ancestor_of?(issue.project) ||
                              project.is_descendant_of?(issue.project))
                     issue = nil
                   end
                 end
                 issue
               end
               private
               # Updates the +issue+ according to +action+
               def fix_issue(issue, action)
-                updates = Setting.commit_update_by_keyword[action]
-                return unless updates.is_a?(Hash)
                 # 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
                 return if issue.status && issue.status.is_closed?
                 journal = issue.init_journal(user || User.anonymous, ll(Setting.default_language, :text_status_changed_by_changeset, text_tag(issue.project)))
-                issue.assign_attributes updates.slice(*Issue.attribute_names)
+                rule = Setting.commit_update_keywords_array.detect do |rule|
+                  rule['keywords'].include?(action) && (rule['if_tracker_id'].blank? || rule['if_tracker_id'] == issue.tracker_id.to_s)
+                end
+                if rule
+                  issue.assign_attributes rule.slice(*Issue.attribute_names)
+                end
                 Redmine::Hook.call_hook(:model_changeset_scan_commit_for_issue_ids_pre_issue_update,
                                         { :changeset => self, :issue => issue, :action => action })
                 unless issue.save
                   logger.warn("Issue ##{issue.id} could not be saved by changeset #{id}: #{issue.errors.full_messages}") if logger
                 end
                 issue
               end
               def log_time(issue, hours)
                 time_entry = TimeEntry.new(
                   :user => user,
                   :hours => hours,
                   :issue => issue,
                   :spent_on => commit_date,
                   :comments => l(:text_time_logged_by_changeset, :value => text_tag(issue.project),
                                  :locale => Setting.default_language)
                   )
                 time_entry.activity = log_time_activity unless log_time_activity.nil?
                 unless time_entry.save
                   logger.warn("TimeEntry could not be created by changeset #{id}: #{time_entry.errors.full_messages}") if logger
                 end
                 time_entry
               end
               def log_time_activity
                 if Setting.commit_logtime_activity_id.to_i > 0
                   TimeEntryActivity.find_by_id(Setting.commit_logtime_activity_id.to_i)
                 end
               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
               public
               # Strips and reencodes a commit log before insertion into the database
               def self.normalize_comments(str, encoding)
                 Changeset.to_utf8(str.to_s.strip, encoding)
               end
               def self.to_utf8(str, encoding)
                 Redmine::CodesetUtil.to_utf8(str, encoding)
               end
             end

app/models/setting.rb +21 -21

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 Setting < ActiveRecord::Base
               DATE_FORMATS = [
                     '%Y-%m-%d',
                     '%d/%m/%Y',
                     '%d.%m.%Y',
                     '%d-%m-%Y',
                     '%m/%d/%Y',
                     '%d %b %Y',
                     '%d %B %Y',
                     '%b %d, %Y',
                     '%B %d, %Y'
                 ]
               TIME_FORMATS = [
                 '%H:%M',
                 '%I:%M %p'
                 ]
               ENCODINGS = %w(US-ASCII
                               windows-1250
                               windows-1251
                               windows-1252
                               windows-1253
                               windows-1254
                               windows-1255
                               windows-1256
                               windows-1257
                               windows-1258
                               windows-31j
                               ISO-2022-JP
                               ISO-2022-KR
                               ISO-8859-1
                               ISO-8859-2
                               ISO-8859-3
                               ISO-8859-4
                               ISO-8859-5
                               ISO-8859-6
                               ISO-8859-7
                               ISO-8859-8
                               ISO-8859-9
                               ISO-8859-13
                               ISO-8859-15
                               KOI8-R
                               UTF-8
                               UTF-16
                               UTF-16BE
                               UTF-16LE
                               EUC-JP
                               Shift_JIS
                               CP932
                               GB18030
                               GBK
                               ISCII91
                               EUC-KR
                               Big5
                               Big5-HKSCS
                               TIS-620)
               cattr_accessor :available_settings
               @@available_settings = YAML::load(File.open("#{Rails.root}/config/settings.yml"))
               Redmine::Plugin.all.each do |plugin|
                 next unless plugin.settings
                 @@available_settings["plugin_#{plugin.id}"] = {'default' => plugin.settings[:default], 'serialized' => true}
               end
               validates_uniqueness_of :name
               validates_inclusion_of :name, :in => @@available_settings.keys
               validates_numericality_of :value, :only_integer => true, :if => Proc.new { |setting| @@available_settings[setting.name]['format'] == 'int' }
               # Hash used to cache setting values
               @cached_settings = {}
               @cached_cleared_on = Time.now
               def value
                 v = read_attribute(:value)
                 # Unserialize serialized settings
                 v = YAML::load(v) if @@available_settings[name]['serialized'] && v.is_a?(String)
                 v = v.to_sym if @@available_settings[name]['format'] == 'symbol' && !v.blank?
                 v
               end
               def value=(v)
                 v = v.to_yaml if v && @@available_settings[name] && @@available_settings[name]['serialized']
                 write_attribute(:value, v.to_s)
               end
               # Returns the value of the setting named name
               def self.[](name)
                 v = @cached_settings[name]
                 v ? v : (@cached_settings[name] = find_or_default(name).value)
               end
               def self.[]=(name, v)
                 setting = find_or_default(name)
                 setting.value = (v ? v : "")
                 @cached_settings[name] = nil
                 setting.save
                 setting.value
               end
               # Defines getter and setter for each setting
               # Then setting values can be read using: Setting.some_setting_name
               # or set using Setting.some_setting_name = "some value"
               @@available_settings.each do |name, params|
                 src = <<-END_SRC
                 def self.#{name}
                   self[:#{name}]
                 end
                 def self.#{name}?
                   self[:#{name}].to_i > 0
                 end
                 def self.#{name}=(value)
                   self[:#{name}] = value
                 end
             END_SRC
                 class_eval src, __FILE__, __LINE__
               end
               # Sets a setting value from params
               def self.set_from_params(name, params)
                 params = params.dup
                 params.delete_if {|v| v.blank? } if params.is_a?(Array)
                 m = "#{name}_from_params"
                 if respond_to? m
                   self[name.to_sym] = send m, params
                 else
                   self[name.to_sym] = params
                 end
               end
               # Returns a hash suitable for commit_update_keywords setting
               #
               # Example:
               # params = {:keywords => ['fixes', 'closes'], :status_id => ["3", "5"], :done_ratio => ["", "100"]}
               # Setting.commit_update_keywords_from_params(params)
-              # # => {'fixes' => {'status_id' => "3"}, 'closes' => {'status_id' => "5", 'done_ratio' => "100"}}
+              # # => [{'keywords => 'fixes', 'status_id' => "3"}, {'keywords => 'closes', 'status_id' => "5", 'done_ratio' => "100"}]
               def self.commit_update_keywords_from_params(params)
-                s = {}
+                s = []
                 if params.is_a?(Hash) && params.key?(:keywords) && params.values.all? {|v| v.is_a? Array}
                   attributes = params.except(:keywords).keys
                   params[:keywords].each_with_index do |keywords, i|
                     next if keywords.blank?
-                    s[keywords] = attributes.inject({}) {|h, a|
+                    s << attributes.inject({}) {|h, a|
                       value = params[a][i].to_s
                       h[a.to_s] = value if value.present?
                       h
+                    }.merge('keywords' => keywords)
                   end
                 end
                 s
               end
               # Helper that returns an array based on per_page_options setting
               def self.per_page_options_array
                 per_page_options.split(%r{[\s,]}).collect(&:to_i).select {|n| n > 0}.sort
               end
               # Helper that returns a Hash with single update keywords as keys
-              def self.commit_update_by_keyword
+              def self.commit_update_keywords_array
-                h = {}
+                a = []
-                if commit_update_keywords.is_a?(Hash)
+                if commit_update_keywords.is_a?(Array)
-                  commit_update_keywords.each do |keywords, attribute_updates|
+                  commit_update_keywords.each do |rule|
-                    next unless attribute_updates.is_a?(Hash)
+                    next unless rule.is_a?(Hash)
-                    attribute_updates = attribute_updates.dup
+                    rule = rule.dup
-                    attribute_updates.delete_if {|k, v| v.blank?}
+                    rule.delete_if {|k, v| v.blank?}
-                    keywords.to_s.split(",").map(&:strip).reject(&:blank?).each do |keyword|
+                    keywords = rule['keywords'].to_s.downcase.split(",").map(&:strip).reject(&:blank?)
-                      h[keyword.downcase] = attribute_updates
+                    next if keywords.empty?
+                    a << rule.merge('keywords' => keywords)
                   end
                 end
-                end
               end
               def self.commit_fix_keywords
                 ActiveSupport::Deprecation.warn "Setting.commit_fix_keywords is deprecated and will be removed in Redmine 3"
-                if commit_update_keywords.is_a?(Hash)
+                if commit_update_keywords.is_a?(Array)
-                  commit_update_keywords.keys.first
+                  commit_update_keywords.first && commit_update_keywords.first['keywords']
                 end
               end
               def self.commit_fix_status_id
                 ActiveSupport::Deprecation.warn "Setting.commit_fix_status_id is deprecated and will be removed in Redmine 3"
-                if commit_update_keywords.is_a?(Hash)
+                if commit_update_keywords.is_a?(Array)
-                  commit_update_keywords[commit_fix_keywords]['status_id']
+                  commit_update_keywords.first && commit_update_keywords.first['status_id']
                 end
               end
               def self.commit_fix_done_ratio
                 ActiveSupport::Deprecation.warn "Setting.commit_fix_done_ratio is deprecated and will be removed in Redmine 3"
-                if commit_update_keywords.is_a?(Hash)
+                if commit_update_keywords.is_a?(Array)
-                  commit_update_keywords[commit_fix_keywords]['done_ratio']
+                  commit_update_keywords.first && commit_update_keywords.first['done_ratio']
                 end
               end
               def self.openid?
                 Object.const_defined?(:OpenID) && self[:openid].to_i > 0
               end
               # Checks if settings have changed since the values were read
               # and clears the cache hash if it's the case
               # Called once per request
               def self.check_cache
                 settings_updated_on = Setting.maximum(:updated_on)
                 if settings_updated_on && @cached_cleared_on <= settings_updated_on
                   clear_cache
                 end
               end
               # Clears the settings cache
               def self.clear_cache
                 @cached_settings.clear
                 @cached_cleared_on = Time.now
                 logger.info "Settings cache cleared." if logger
               end
             private
               # Returns the Setting instance for the setting named name
               # (record found in database or new record with default value)
               def self.find_or_default(name)
                 name = name.to_s
                 raise "There's no setting named #{name}" unless @@available_settings.has_key?(name)
                 setting = find_by_name(name)
                 unless setting
                   setting = new(:name => name)
                   setting.value = @@available_settings[name]['default']
                 end
                 setting
               end
             end

app/views/settings/_repositories.html.erb +7 -4

             <%= form_tag({:action => 'edit', :tab => 'repositories'}) do %>
             <fieldset class="box settings enabled_scm">
             <legend><%= l(:setting_enabled_scm) %></legend>
             <%= hidden_field_tag 'settings[enabled_scm][]', '' %>
             <table>
               <tr>
                 <th></th>
                 <th><%= l(:text_scm_command)         %></th>
                 <th><%= l(:text_scm_command_version) %></th>
               </tr>
               <% Redmine::Scm::Base.all.collect do |choice| %>
                 <% scm_class = "Repository::#{choice}".constantize %>
                 <% text, value = (choice.is_a?(Array) ? choice : [choice, choice]) %>
                 <% setting = :enabled_scm %>
                 <% enabled = Setting.send(setting).include?(value) %>
                 <tr>
                   <td class="scm_name">
                     <label>
                       <%= check_box_tag("settings[#{setting}][]", value, enabled, :id => nil) %>
                       <%= text.to_s %>
                     </label>
                   </td>
                   <td>
                     <% if enabled %>
                       <%=
                         image_tag(
                           (scm_class.scm_available ? 'true.png' : 'exclamation.png'),
                           :style => "vertical-align:bottom;"
                         )
                        %>
                       <%= scm_class.scm_command %>
                     <% end %>
                   </td>
                   <td>
                     <%= scm_class.scm_version_string if enabled %>
                   </td>
                 </tr>
               <% end %>
             </table>
             <p><em class="info"><%= l(:text_scm_config) %></em></p>
             </fieldset>
             <div class="box tabular settings">
             <p><%= setting_check_box :autofetch_changesets %></p>
             <p><%= setting_check_box :sys_api_enabled,
                                      :onclick =>
                                          "if (this.checked) { $('#settings_sys_api_key').removeAttr('disabled'); } else { $('#settings_sys_api_key').attr('disabled', true); }" %></p>
             <p><%= setting_text_field :sys_api_key,
                                       :size     => 30,
                                       :id       => 'settings_sys_api_key',
                                       :disabled => !Setting.sys_api_enabled?,
                                       :label    => :setting_mail_handler_api_key %>
               <%= link_to_function l(:label_generate_key),
                                    "if (!$('#settings_sys_api_key').attr('disabled')) { $('#settings_sys_api_key').val(randomKey(20)) }" %>
             </p>
             <p><%= setting_text_field :repository_log_display_limit, :size => 6 %></p>
             </div>
             <fieldset class="box tabular settings">
             <legend><%= l(:text_issues_ref_in_commit_messages) %></legend>
             <p><%= setting_text_field :commit_ref_keywords, :size => 30 %>
             <em class="info"><%= l(:text_comma_separated) %></em></p>
             <p><%= setting_check_box :commit_cross_project_ref %></p>
             <p><%= setting_check_box :commit_logtime_enabled,
                                      :onclick =>
                                         "if (this.checked) { $('#settings_commit_logtime_activity_id').removeAttr('disabled'); } else { $('#settings_commit_logtime_activity_id').attr('disabled', true); }"%></p>
             <p><%= setting_select :commit_logtime_activity_id,
                                   [[l(:label_default), 0]] +
                                       TimeEntryActivity.shared.active.collect{|activity| [activity.name, activity.id.to_s]},
                                   :disabled => !Setting.commit_logtime_enabled?%></p>
             </fieldset>
             <table class="list" id="commit-keywords">
               <thead>
                 <tr>
+                  <th><%= l(:label_tracker) %></th>
                   <th><%= l(:setting_commit_fix_keywords) %></th>
                   <th><%= l(:label_applied_status) %></th>
                   <th><%= l(:field_done_ratio) %></th>
                   <th class="buttons"></th>
                 </tr>
               </thead>
               <tbody>
-                <% @commit_update_keywords.each do |keywords, updates| %>
+                <% @commit_update_keywords.each do |rule| %>
                 <tr class="commit-keywords">
-                  <td><%= text_field_tag "settings[commit_update_keywords][keywords][]", keywords, :size => 30 %></td>
+                  <td><%= select_tag "settings[commit_update_keywords][if_tracker_id][]", options_for_select([[l(:label_all), ""]] + Tracker.sorted.all.map {|t| [t.name, t.id.to_s]}, rule['if_tracker_id']) %></td>
-                  <td><%= select_tag "settings[commit_update_keywords][status_id][]", options_for_select([["", 0]] + IssueStatus.sorted.all.collect{|status| [status.name, status.id.to_s]}, updates['status_id']) %></td>
+                  <td><%= text_field_tag "settings[commit_update_keywords][keywords][]", rule['keywords'], :size => 30 %></td>
-                  <td><%= select_tag "settings[commit_update_keywords][done_ratio][]", options_for_select([["", ""]] + (0..10).to_a.collect {|r| ["#{r*10} %", "#{r*10}"] }, updates['done_ratio']) %></td>
+                  <td><%= select_tag "settings[commit_update_keywords][status_id][]", options_for_select([["", 0]] + IssueStatus.sorted.all.collect{|status| [status.name, status.id.to_s]}, rule['status_id']) %></td>
+                  <td><%= select_tag "settings[commit_update_keywords][done_ratio][]", options_for_select([["", ""]] + (0..10).to_a.collect {|r| ["#{r*10} %", "#{r*10}"] }, rule['done_ratio']) %></td>
                   <td class="buttons"><%= link_to image_tag('delete.png'), '#', :class => 'delete-commit-keywords' %></td>
                 </tr>
                 <% end %>
                 <tr>
+                  <td></td>
                   <td><em class="info"><%= l(:text_comma_separated) %></em></td>
                   <td></td>
                   <td></td>
                   <td class="buttons"><%= link_to image_tag('add.png'), '#', :class => 'add-commit-keywords' %></td>
                 </tr>
               </tbody>
             </table>
             <p><%= submit_tag l(:button_save) %></p>
             <% end %>
             <%= javascript_tag do %>
             $('#commit-keywords').on('click', 'a.delete-commit-keywords', function(e){
               e.preventDefault();
               if ($('#commit-keywords tbody tr.commit-keywords').length > 1) {
                 $(this).parents('#commit-keywords tr').remove();
               } else {
                 $('#commit-keywords tbody tr.commit-keywords').find('input, select').val('');
               }
             });
             $('#commit-keywords').on('click', 'a.add-commit-keywords', function(e){
               e.preventDefault();
               var row = $('#commit-keywords tr.commit-keywords:last');
               row.clone().insertAfter(row).find('input, select').val('');
             });
             <% end %>

config/settings.yml +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  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.
             # DO NOT MODIFY THIS FILE !!!
             # Settings can be defined through the application in Admin -> Settings
             app_title:
               default: Redmine
             app_subtitle:
               default: Project management
             welcome_text:
               default:
             login_required:
               default: 0
             self_registration:
               default: '2'
             lost_password:
               default: 1
             unsubscribe:
               default: 1
             password_min_length:
               format: int
               default: 8
             # Maximum lifetime of user sessions in minutes
             session_lifetime:
               format: int
               default: 0
             # User session timeout in minutes
             session_timeout:
               format: int
               default: 0
             attachment_max_size:
               format: int
               default: 5120
             issues_export_limit:
               format: int
               default: 500
             activity_days_default:
               format: int
               default: 30
             per_page_options:
               default: '25,50,100'
             mail_from:
               default: redmine@example.net
             bcc_recipients:
               default: 1
             plain_text_mail:
               default: 0
             text_formatting:
               default: textile
             cache_formatted_text:
               default: 0
             wiki_compression:
               default: ""
             default_language:
               default: en
             host_name:
               default: localhost:3000
             protocol:
               default: http
             feeds_limit:
               format: int
               default: 15
             gantt_items_limit:
               format: int
               default: 500
             # Maximum size of files that can be displayed
             # inline through the file viewer (in KB)
             file_max_size_displayed:
               format: int
               default: 512
             diff_max_lines_displayed:
               format: int
               default: 1500
             enabled_scm:
               serialized: true
               default:
               - Subversion
               - Darcs
               - Mercurial
               - Cvs
               - Bazaar
               - Git
             autofetch_changesets:
               default: 1
             sys_api_enabled:
               default: 0
             sys_api_key:
               default: ''
             commit_cross_project_ref:
               default: 0
             commit_ref_keywords:
               default: 'refs,references,IssueID'
             commit_update_keywords:
               serialized: true
-              default: {}
+              default: []
             commit_logtime_enabled:
               default: 0
             commit_logtime_activity_id:
               format: int
               default: 0
             # autologin duration in days
             # 0 means autologin is disabled
             autologin:
               format: int
               default: 0
             # date format
             date_format:
               default: ''
             time_format:
               default: ''
             user_format:
               default: :firstname_lastname
               format: symbol
             cross_project_issue_relations:
               default: 0
             # Enables subtasks to be in other projects
             cross_project_subtasks:
               default: 'tree'
             issue_group_assignment:
               default: 0
             default_issue_start_date_to_creation_date:
               default: 1
             notified_events:
               serialized: true
               default:
               - issue_added
               - issue_updated
             mail_handler_body_delimiters:
               default: ''
             mail_handler_excluded_filenames:
               default: ''
             mail_handler_api_enabled:
               default: 0
             mail_handler_api_key:
               default:
             issue_list_default_columns:
               serialized: true
               default:
               - tracker
               - status
               - priority
               - subject
               - assigned_to
               - updated_on
             display_subprojects_issues:
               default: 1
             issue_done_ratio:
               default: 'issue_field'
             default_projects_public:
               default: 1
             default_projects_modules:
               serialized: true
               default:
               - issue_tracking
               - time_tracking
               - news
               - documents
               - files
               - wiki
               - repository
               - boards
               - calendar
               - gantt
             default_projects_tracker_ids:
               serialized: true
               default:
             # Role given to a non-admin user who creates a project
             new_project_user_role_id:
               format: int
               default: ''
             sequential_project_identifiers:
               default: 0
             # encodings used to convert repository files content to UTF-8
             # multiple values accepted, comma separated
             repositories_encodings:
               default: ''
             # encoding used to convert commit logs to UTF-8
             commit_logs_encoding:
               default: 'UTF-8'
             repository_log_display_limit:
               format: int
               default: 100
             ui_theme:
               default: ''
             emails_footer:
               default: |-
                 You have received this notification because you have either subscribed to it, or are involved in it.
                 To change your notification preferences, please click here: http://hostname/my/account
             gravatar_enabled:
               default: 0
             openid:
               default: 0
             gravatar_default:
               default: ''
             start_of_week:
               default: ''
             rest_api_enabled:
               default: 0
             jsonp_enabled:
               default: 0
             default_notification_option:
               default: 'only_my_events'
             emails_header:
               default: ''
             thumbnails_enabled:
               default: 0
             thumbnails_size:
               format: int
               default: 100
             non_working_week_days:
               serialized: true
               default:
               - '6'
               - '7'

test/functional/settings_controller_test.rb +19 -15

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 File.expand_path('../../test_helper', __FILE__)
             class SettingsControllerTest < ActionController::TestCase
               fixtures :users
               def setup
                 User.current = nil
                 @request.session[:user_id] = 1 # admin
               end
               def test_index
                 get :index
                 assert_response :success
                 assert_template 'edit'
               end
               def test_get_edit
                 get :edit
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'input', :attributes => {:name => 'settings[enabled_scm][]', :value => ''}
               end
               def test_get_edit_should_preselect_default_issue_list_columns
                 with_settings :issue_list_default_columns => %w(tracker subject status updated_on) do
                   get :edit
                   assert_response :success
                 end
                 assert_select 'select[id=selected_columns][name=?]', 'settings[issue_list_default_columns][]' do
                   assert_select 'option', 4
                   assert_select 'option[value=tracker]', :text => 'Tracker'
                   assert_select 'option[value=subject]', :text => 'Subject'
                   assert_select 'option[value=status]', :text => 'Status'
                   assert_select 'option[value=updated_on]', :text => 'Updated'
                 end
                 assert_select 'select[id=available_columns]' do
                   assert_select 'option[value=tracker]', 0
                   assert_select 'option[value=priority]', :text => 'Priority'
                 end
               end
               def test_get_edit_without_trackers_should_succeed
                 Tracker.delete_all
                 get :edit
                 assert_response :success
               end
               def test_post_edit_notifications
                 post :edit, :settings => {:mail_from => 'functional@test.foo',
                                           :bcc_recipients  => '0',
                                           :notified_events => %w(issue_added issue_updated news_added),
                                           :emails_footer => 'Test footer'
                                           }
                 assert_redirected_to '/settings'
                 assert_equal 'functional@test.foo', Setting.mail_from
                 assert !Setting.bcc_recipients?
                 assert_equal %w(issue_added issue_updated news_added), Setting.notified_events
                 assert_equal 'Test footer', Setting.emails_footer
                 Setting.clear_cache
               end
               def test_edit_commit_update_keywords
-                with_settings :commit_update_keywords => {
+                with_settings :commit_update_keywords => [
-                  "fixes, resolves" => {"status_id" => "3"},
+                  {"keywords" => "fixes, resolves", "status_id" => "3"},
-                  "closes" => {"status_id" => "5", "done_ratio" => "100"}
+                  {"keywords" => "closes", "status_id" => "5", "done_ratio" => "100", "if_tracker_id" => "2"}
-                } do
+                ] do
                   get :edit
                 end
                 assert_response :success
                 assert_select 'tr.commit-keywords', 2
-                assert_select 'tr.commit-keywords' do
+                assert_select 'tr.commit-keywords:nth-child(1)' do
                   assert_select 'input[name=?][value=?]', 'settings[commit_update_keywords][keywords][]', 'fixes, resolves'
                   assert_select 'select[name=?]', 'settings[commit_update_keywords][status_id][]' do
                     assert_select 'option[value=3][selected=selected]'
                   end
                 end
-                assert_select 'tr.commit-keywords' do
+                assert_select 'tr.commit-keywords:nth-child(2)' do
                   assert_select 'input[name=?][value=?]', 'settings[commit_update_keywords][keywords][]', 'closes'
                   assert_select 'select[name=?]', 'settings[commit_update_keywords][status_id][]' do
-                    assert_select 'option[value=5][selected=selected]'
+                    assert_select 'option[value=5][selected=selected]', :text => 'Closed'
                   end
                   assert_select 'select[name=?]', 'settings[commit_update_keywords][done_ratio][]' do
-                    assert_select 'option[value=100][selected=selected]'
+                    assert_select 'option[value=100][selected=selected]', :text => '100 %'
+                  end
+                  assert_select 'select[name=?]', 'settings[commit_update_keywords][if_tracker_id][]' do
+                    assert_select 'option[value=2][selected=selected]', :text => 'Feature request'
                   end
                 end
               end
               def test_edit_without_commit_update_keywords_should_show_blank_line
-                with_settings :commit_update_keywords => {} do
+                with_settings :commit_update_keywords => [] do
                   get :edit
                 end
                 assert_response :success
                 assert_select 'tr.commit-keywords', 1 do
-                  assert_select 'input[name=?][value=?]', 'settings[commit_update_keywords][keywords][]', ''
+                  assert_select 'input[name=?]:not([value])', 'settings[commit_update_keywords][keywords][]'
                 end
               end
               def test_post_edit_commit_update_keywords
                 post :edit, :settings => {
                   :commit_update_keywords => {
                     :keywords => ["resolves", "closes"],
                     :status_id => ["3", "5"],
-                    :done_ratio => ["", "100"]
+                    :done_ratio => ["", "100"],
+                    :if_tracker_id => ["", "2"]
                   }
                 }
                 assert_redirected_to '/settings'
-                assert_equal({
+                assert_equal([
-                  "resolves" => {"status_id" => "3"},
+                  {"keywords" => "resolves", "status_id" => "3"},
-                  "closes" => {"status_id" => "5", "done_ratio" => "100"}
+                  {"keywords" => "closes", "status_id" => "5", "done_ratio" => "100", "if_tracker_id" => "2"}
-                }, Setting.commit_update_keywords)
+                ], Setting.commit_update_keywords)
               end
               def test_get_plugin_settings
                 Setting.stubs(:plugin_foo).returns({'sample_setting' => 'Plugin setting value'})
                 ActionController::Base.append_view_path(File.join(Rails.root, "test/fixtures/plugins"))
                 Redmine::Plugin.register :foo do
                   settings :partial => "foo_plugin/foo_plugin_settings"
                 end
                 get :plugin, :id => 'foo'
                 assert_response :success
                 assert_template 'plugin'
                 assert_tag 'form', :attributes => {:action => '/settings/plugin/foo'},
                   :descendant => {:tag => 'input', :attributes => {:name => 'settings[sample_setting]', :value => 'Plugin setting value'}}
                 Redmine::Plugin.clear
               end
               def test_get_invalid_plugin_settings
                 get :plugin, :id => 'none'
                 assert_response 404
               end
               def test_get_non_configurable_plugin_settings
                 Redmine::Plugin.register(:foo) {}
                 get :plugin, :id => 'foo'
                 assert_response 404
                 Redmine::Plugin.clear
               end
               def test_post_plugin_settings
                 Setting.expects(:plugin_foo=).with({'sample_setting' => 'Value'}).returns(true)
                 Redmine::Plugin.register(:foo) do
                   settings :partial => 'not blank' # so that configurable? is true
                 end
                 post :plugin, :id => 'foo', :settings => {'sample_setting' => 'Value'}
                 assert_redirected_to '/settings/plugin/foo'
               end
               def test_post_non_configurable_plugin_settings
                 Redmine::Plugin.register(:foo) {}
                 post :plugin, :id => 'foo', :settings => {'sample_setting' => 'Value'}
                 assert_response 404
                 Redmine::Plugin.clear
               end
             end

test/object_helpers.rb +12 0

             module ObjectHelpers
               def User.generate!(attributes={})
                 @generated_user_login ||= 'user0'
                 @generated_user_login.succ!
                 user = User.new(attributes)
                 user.login = @generated_user_login.dup if user.login.blank?
                 user.mail = "#{@generated_user_login}@example.com" if user.mail.blank?
                 user.firstname = "Bob" if user.firstname.blank?
                 user.lastname = "Doe" if user.lastname.blank?
                 yield user if block_given?
                 user.save!
                 user
               end
               def User.add_to_project(user, project, roles=nil)
                 roles = Role.find(1) if roles.nil?
                 roles = [roles] unless roles.is_a?(Array)
                 Member.create!(:principal => user, :project => project, :roles => roles)
               end
               def Group.generate!(attributes={})
                 @generated_group_name ||= 'Group 0'
                 @generated_group_name.succ!
                 group = Group.new(attributes)
                 group.name = @generated_group_name.dup if group.name.blank?
                 yield group if block_given?
                 group.save!
                 group
               end
               def Project.generate!(attributes={})
                 @generated_project_identifier ||= 'project-0000'
                 @generated_project_identifier.succ!
                 project = Project.new(attributes)
                 project.name = @generated_project_identifier.dup if project.name.blank?
                 project.identifier = @generated_project_identifier.dup if project.identifier.blank?
                 yield project if block_given?
                 project.save!
                 project
               end
               def Project.generate_with_parent!(parent, attributes={})
                 project = Project.generate!(attributes)
                 project.set_parent!(parent)
                 project
               end
               def Tracker.generate!(attributes={})
                 @generated_tracker_name ||= 'Tracker 0'
                 @generated_tracker_name.succ!
                 tracker = Tracker.new(attributes)
                 tracker.name = @generated_tracker_name.dup if tracker.name.blank?
                 yield tracker if block_given?
                 tracker.save!
                 tracker
               end
               def Role.generate!(attributes={})
                 @generated_role_name ||= 'Role 0'
                 @generated_role_name.succ!
                 role = Role.new(attributes)
                 role.name = @generated_role_name.dup if role.name.blank?
                 yield role if block_given?
                 role.save!
                 role
               end
               # Generates an unsaved Issue
               def Issue.generate(attributes={})
                 issue = Issue.new(attributes)
                 issue.project ||= Project.find(1)
                 issue.tracker ||= issue.project.trackers.first
                 issue.subject = 'Generated' if issue.subject.blank?
                 issue.author ||= User.find(2)
                 yield issue if block_given?
                 issue
               end
               # Generates a saved Issue
               def Issue.generate!(attributes={}, &block)
                 issue = Issue.generate(attributes, &block)
                 issue.save!
                 issue
               end
               # Generates an issue with 2 children and a grandchild
               def Issue.generate_with_descendants!(attributes={})
                 issue = Issue.generate!(attributes)
                 child = Issue.generate!(:project => issue.project, :subject => 'Child1', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child2', :parent_issue_id => issue.id)
                 Issue.generate!(:project => issue.project, :subject => 'Child11', :parent_issue_id => child.id)
                 issue.reload
               end
               def Journal.generate!(attributes={})
                 journal = Journal.new(attributes)
                 journal.user ||= User.first
                 journal.journalized ||= Issue.first
                 yield journal if block_given?
                 journal.save!
                 journal
               end
               def Version.generate!(attributes={})
                 @generated_version_name ||= 'Version 0'
                 @generated_version_name.succ!
                 version = Version.new(attributes)
                 version.name = @generated_version_name.dup if version.name.blank?
                 yield version if block_given?
                 version.save!
                 version
               end
               def TimeEntry.generate!(attributes={})
                 entry = TimeEntry.new(attributes)
                 entry.user ||= User.find(2)
                 entry.issue ||= Issue.find(1) unless entry.project
                 entry.project ||= entry.issue.project
                 entry.activity ||= TimeEntryActivity.first
                 entry.spent_on ||= Date.today
                 entry.hours ||= 1.0
                 entry.save!
                 entry
               end
               def AuthSource.generate!(attributes={})
                 @generated_auth_source_name ||= 'Auth 0'
                 @generated_auth_source_name.succ!
                 source = AuthSource.new(attributes)
                 source.name = @generated_auth_source_name.dup if source.name.blank?
                 yield source if block_given?
                 source.save!
                 source
               end
               def Board.generate!(attributes={})
                 @generated_board_name ||= 'Forum 0'
                 @generated_board_name.succ!
                 board = Board.new(attributes)
                 board.name = @generated_board_name.dup if board.name.blank?
                 board.description = @generated_board_name.dup if board.description.blank?
                 yield board if block_given?
                 board.save!
                 board
               end
               def Attachment.generate!(attributes={})
                 @generated_filename ||= 'testfile0'
                 @generated_filename.succ!
                 attributes = attributes.dup
                 attachment = Attachment.new(attributes)
                 attachment.container ||= Issue.find(1)
                 attachment.author ||= User.find(2)
                 attachment.filename = @generated_filename.dup if attachment.filename.blank?
                 attachment.save!
                 attachment
               end
               def CustomField.generate!(attributes={})
                 @generated_custom_field_name ||= 'Custom field 0'
                 @generated_custom_field_name.succ!
                 field = new(attributes)
                 field.name = @generated_custom_field_name.dup if field.name.blank?
                 field.field_format = 'string' if field.field_format.blank?
                 yield field if block_given?
                 field.save!
                 field
               end
+              def Changeset.generate!(attributes={})
+                @generated_changeset_rev ||= '123456'
+                @generated_changeset_rev.succ!
+                changeset = new(attributes)
+                changeset.repository ||= Project.find(1).repository
+                changeset.revision ||= @generated_changeset_rev
+                changeset.committed_on ||= Time.now
+                yield changeset if block_given?
+                changeset.save!
+                changeset
+              end
             end

test/unit/changeset_test.rb +37 -16

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2013  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 File.expand_path('../../test_helper', __FILE__)
             class ChangesetTest < ActiveSupport::TestCase
               fixtures :projects, :repositories,
                        :issues, :issue_statuses, :issue_categories,
                        :changesets, :changes,
                        :enumerations,
                        :custom_fields, :custom_values,
                        :users, :members, :member_roles, :trackers,
                        :enabled_modules, :roles
               def test_ref_keywords_any
                 ActionMailer::Base.deliveries.clear
                 Setting.commit_ref_keywords = '*'
-                Setting.commit_update_keywords = {'fixes , closes' => {'status_id' => '5', 'done_ratio' => '90'}}
+                Setting.commit_update_keywords = [{'keywords' => 'fixes , closes', 'status_id' => '5', 'done_ratio' => '90'}]
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => 'New commit (#2). Fixes #1',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [1, 2], c.issue_ids.sort
                 fixed = Issue.find(1)
                 assert fixed.closed?
                 assert_equal 90, fixed.done_ratio
                 assert_equal 1, ActionMailer::Base.deliveries.size
               end
               def test_ref_keywords
                 Setting.commit_ref_keywords = 'refs'
                 Setting.commit_update_keywords = ''
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => 'Ignores #2. Refs #1',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [1], c.issue_ids.sort
               end
               def test_ref_keywords_any_only
                 Setting.commit_ref_keywords = '*'
                 Setting.commit_update_keywords = ''
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => 'Ignores #2. Refs #1',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [1, 2], c.issue_ids.sort
               end
               def test_ref_keywords_any_with_timelog
                 Setting.commit_ref_keywords = '*'
                 Setting.commit_logtime_enabled = '1'
                 {
                   '2' => 2.0,
                   '2h' => 2.0,
                   '2hours' => 2.0,
                   '15m' => 0.25,
                   '15min' => 0.25,
                   '3h15' => 3.25,
                   '3h15m' => 3.25,
                   '3h15min' => 3.25,
                   '3:15' => 3.25,
                   '3.25' => 3.25,
                   '3.25h' => 3.25,
                   '3,25' => 3.25,
                   '3,25h' => 3.25,
                 }.each do |syntax, expected_hours|
                   c = Changeset.new(:repository   => Project.find(1).repository,
                                     :committed_on => 24.hours.ago,
                                     :comments     => "Worked on this issue #1 @#{syntax}",
                                     :revision     => '520',
                                     :user         => User.find(2))
                   assert_difference 'TimeEntry.count' do
                     c.scan_comment_for_issue_ids
                   end
                   assert_equal [1], c.issue_ids.sort
                   time = TimeEntry.first(:order => 'id desc')
                   assert_equal 1, time.issue_id
                   assert_equal 1, time.project_id
                   assert_equal 2, time.user_id
                   assert_equal expected_hours, time.hours,
                       "@#{syntax} should be logged as #{expected_hours} hours but was #{time.hours}"
                   assert_equal Date.yesterday, time.spent_on
                   assert time.activity.is_default?
                   assert time.comments.include?('r520'),
                         "r520 was expected in time_entry comments: #{time.comments}"
                 end
               end
               def test_ref_keywords_closing_with_timelog
                 Setting.commit_ref_keywords = '*'
-                Setting.commit_update_keywords = {
+                Setting.commit_update_keywords = [{'keywords' => 'fixes , closes', 'status_id' => IssueStatus.where(:is_closed => true).first.id.to_s}]
-                  'fixes , closes' => {
-                    'status_id' => IssueStatus.where(:is_closed => true).first.id.to_s
                 Setting.commit_logtime_enabled = '1'
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => 'This is a comment. Fixes #1 @4.5, #2 @1',
                                   :user         => User.find(2))
                 assert_difference 'TimeEntry.count', 2 do
                   c.scan_comment_for_issue_ids
                 end
                 assert_equal [1, 2], c.issue_ids.sort
                 assert Issue.find(1).closed?
                 assert Issue.find(2).closed?
                 times = TimeEntry.all(:order => 'id desc', :limit => 2)
                 assert_equal [1, 2], times.collect(&:issue_id).sort
               end
               def test_ref_keywords_any_line_start
                 Setting.commit_ref_keywords = '*'
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => '#1 is the reason of this commit',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [1], c.issue_ids.sort
               end
               def test_ref_keywords_allow_brackets_around_a_issue_number
                 Setting.commit_ref_keywords = '*'
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => '[#1] Worked on this issue',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [1], c.issue_ids.sort
               end
               def test_ref_keywords_allow_brackets_around_multiple_issue_numbers
                 Setting.commit_ref_keywords = '*'
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => '[#1 #2, #3] Worked on these',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [1,2,3], c.issue_ids.sort
               end
               def test_update_keywords_with_multiple_rules
-                Setting.commit_update_keywords = {
+                with_settings :commit_update_keywords => [
-                  'fixes, closes' => {'status_id' => '5'},
+                  {'keywords' => 'fixes, closes', 'status_id' => '5'},
-                  'resolves' => {'status_id' => '3'}
+                  {'keywords' => 'resolves', 'status_id' => '3'}
+                ] do
                   issue1 = Issue.generate!
                   issue2 = Issue.generate!
+                  Changeset.generate!(:comments => "Closes ##{issue1.id}\nResolves ##{issue2.id}")
+                  assert_equal 5, issue1.reload.status_id
+                  assert_equal 3, issue2.reload.status_id
+                end
+              end
-                c = Changeset.new(:repository   => Project.find(1).repository,
+              def test_update_keywords_with_multiple_rules_should_match_tracker
-                                  :committed_on => Time.now,
+                with_settings :commit_update_keywords => [
-                                  :comments     => "Closes ##{issue1.id}\nResolves ##{issue2.id}",
+                  {'keywords' => 'fixes', 'status_id' => '5', 'if_tracker_id' => '2'},
-                                  :revision     => '12345')
+                  {'keywords' => 'fixes', 'status_id' => '3', 'if_tracker_id' => ''}
-                assert c.save
+                ] do
+                  issue1 = Issue.generate!(:tracker_id => 2)
+                  issue2 = Issue.generate!
+                  Changeset.generate!(:comments => "Fixes ##{issue1.id}, ##{issue2.id}")
                   assert_equal 5, issue1.reload.status_id
                   assert_equal 3, issue2.reload.status_id
                 end
+              end
+              def test_update_keywords_with_multiple_rules_and_no_match
+                with_settings :commit_update_keywords => [
+                  {'keywords' => 'fixes', 'status_id' => '5', 'if_tracker_id' => '2'},
+                  {'keywords' => 'fixes', 'status_id' => '3', 'if_tracker_id' => '3'}
+                ] do
+                  issue1 = Issue.generate!(:tracker_id => 2)
+                  issue2 = Issue.generate!
+                  Changeset.generate!(:comments => "Fixes ##{issue1.id}, ##{issue2.id}")
+                  assert_equal 5, issue1.reload.status_id
+                  assert_equal 1, issue2.reload.status_id # no updates
+                end
+              end
               def test_commit_referencing_a_subproject_issue
                 c = Changeset.new(:repository   => Project.find(1).repository,
                                   :committed_on => Time.now,
                                   :comments     => 'refs #5, a subproject issue',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [5], c.issue_ids.sort
                 assert c.issues.first.project != c.project
               end
               def test_commit_closing_a_subproject_issue
-                with_settings :commit_update_keywords => {'closes' => {'status_id' => '5'}},
+                with_settings :commit_update_keywords => [{'keywords' => 'closes', 'status_id' => '5'}],
                               :default_language => 'en' do
                   issue = Issue.find(5)
                   assert !issue.closed?
                   assert_difference 'Journal.count' do
                     c = Changeset.new(:repository   => Project.find(1).repository,
                                       :committed_on => Time.now,
                                       :comments     => 'closes #5, a subproject issue',
                                       :revision     => '12345')
                     assert c.save
                   end
                   assert issue.reload.closed?
                   journal = Journal.first(:order => 'id DESC')
                   assert_equal issue, journal.issue
                   assert_include "Applied in changeset ecookbook:r12345.", journal.notes
                 end
               end
               def test_commit_referencing_a_parent_project_issue
                 # repository of child project
                 r = Repository::Subversion.create!(
                       :project => Project.find(3),
                       :url     => 'svn://localhost/test')
                 c = Changeset.new(:repository   => r,
                                   :committed_on => Time.now,
                                   :comments     => 'refs #2, an issue of a parent project',
                                   :revision     => '12345')
                 assert c.save
                 assert_equal [2], c.issue_ids.sort
                 assert c.issues.first.project != c.project
               end
               def test_commit_referencing_a_project_with_commit_cross_project_ref_disabled
                 r = Repository::Subversion.create!(
                       :project => Project.find(3),
                       :url     => 'svn://localhost/test')
                 with_settings :commit_cross_project_ref => '0' do
                   c = Changeset.new(:repository   => r,
                                     :committed_on => Time.now,
                                     :comments     => 'refs #4, an issue of a different project',
                                     :revision     => '12345')
                   assert c.save
                   assert_equal [], c.issue_ids
                 end
               end
               def test_commit_referencing_a_project_with_commit_cross_project_ref_enabled
                 r = Repository::Subversion.create!(
                       :project => Project.find(3),
                       :url     => 'svn://localhost/test')
                 with_settings :commit_cross_project_ref => '1' do
                   c = Changeset.new(:repository   => r,
                                     :committed_on => Time.now,
                                     :comments     => 'refs #4, an issue of a different project',
                                     :revision     => '12345')
                   assert c.save
                   assert_equal [4], c.issue_ids
                 end
               end
               def test_old_commits_should_not_update_issues_nor_log_time
                 Setting.commit_ref_keywords = '*'
                 Setting.commit_update_keywords = {'fixes , closes' => {'status_id' => '5', 'done_ratio' => '90'}}
                 Setting.commit_logtime_enabled = '1'
                 repository = Project.find(1).repository
                 repository.created_on = Time.now
                 repository.save!
                 c = Changeset.new(:repository   => repository,
                                   :committed_on => 1.month.ago,
                                   :comments     => 'New commit (#2). Fixes #1 @1h',
                                   :revision     => '12345')
                 assert_no_difference 'TimeEntry.count' do
                   assert c.save
                 end
                 assert_equal [1, 2], c.issue_ids.sort
                 issue = Issue.find(1)
                 assert_equal 1, issue.status_id
                 assert_equal 0, issue.done_ratio
               end
               def test_text_tag_revision
                 c = Changeset.new(:revision => '520')
                 assert_equal 'r520', c.text_tag
               end
               def test_text_tag_revision_with_same_project
                 c = Changeset.new(:revision => '520', :repository => Project.find(1).repository)
                 assert_equal 'r520', c.text_tag(Project.find(1))
               end
               def test_text_tag_revision_with_different_project
                 c = Changeset.new(:revision => '520', :repository => Project.find(1).repository)
                 assert_equal 'ecookbook:r520', c.text_tag(Project.find(2))
               end
               def test_text_tag_revision_with_repository_identifier
                 r = Repository::Subversion.create!(
                       :project_id => 1,
                       :url     => 'svn://localhost/test',
                       :identifier => 'documents')
                 c = Changeset.new(:revision => '520', :repository => r)
                 assert_equal 'documents|r520', c.text_tag
                 assert_equal 'ecookbook:documents|r520', c.text_tag(Project.find(2))
               end
               def test_text_tag_hash
                 c = Changeset.new(
                       :scmid    => '7234cb2750b63f47bff735edc50a1c0a433c2518',
                       :revision => '7234cb2750b63f47bff735edc50a1c0a433c2518')
                 assert_equal 'commit:7234cb2750b63f47bff735edc50a1c0a433c2518', c.text_tag
               end
               def test_text_tag_hash_with_same_project
                 c = Changeset.new(:revision => '7234cb27', :scmid => '7234cb27', :repository => Project.find(1).repository)
                 assert_equal 'commit:7234cb27', c.text_tag(Project.find(1))
               end
               def test_text_tag_hash_with_different_project
                 c = Changeset.new(:revision => '7234cb27', :scmid => '7234cb27', :repository => Project.find(1).repository)
                 assert_equal 'ecookbook:commit:7234cb27', c.text_tag(Project.find(2))
               end
               def test_text_tag_hash_all_number
                 c = Changeset.new(:scmid => '0123456789', :revision => '0123456789')
                 assert_equal 'commit:0123456789', c.text_tag
               end
               def test_previous
                 changeset = Changeset.find_by_revision('3')
                 assert_equal Changeset.find_by_revision('2'), changeset.previous
               end
               def test_previous_nil
                 changeset = Changeset.find_by_revision('1')
                 assert_nil changeset.previous
               end
               def test_next
                 changeset = Changeset.find_by_revision('2')
                 assert_equal Changeset.find_by_revision('3'), changeset.next
               end
               def test_next_nil
                 changeset = Changeset.find_by_revision('10')
                 assert_nil changeset.next
               end
               def test_comments_should_be_converted_to_utf8
                 proj = Project.find(3)
                 # str = File.read("#{RAILS_ROOT}/test/fixtures/encoding/iso-8859-1.txt")
                 str = "Texte encod\xe9 en ISO-8859-1."
                 str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)
                 r = Repository::Bazaar.create!(
                         :project      => proj,
                         :url          => '/tmp/test/bazaar',
                         :log_encoding => 'ISO-8859-1' )
                 assert r
                 c = Changeset.new(:repository   => r,
                                   :committed_on => Time.now,
                                   :revision     => '123',
                                   :scmid        => '12345',
                                   :comments     => str)
                 assert( c.save )
                 str_utf8 = "Texte encod\xc3\xa9 en ISO-8859-1."
                 str_utf8.force_encoding("UTF-8") if str_utf8.respond_to?(:force_encoding)
                 assert_equal str_utf8, c.comments
               end
               def test_invalid_utf8_sequences_in_comments_should_be_replaced_latin1
                 proj = Project.find(3)
                 # str = File.read("#{RAILS_ROOT}/test/fixtures/encoding/iso-8859-1.txt")
                 str1 = "Texte encod\xe9 en ISO-8859-1."
                 str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test"
                 str1.force_encoding("UTF-8") if str1.respond_to?(:force_encoding)
                 str2.force_encoding("ASCII-8BIT") if str2.respond_to?(:force_encoding)
                 r = Repository::Bazaar.create!(
                         :project      => proj,
                         :url          => '/tmp/test/bazaar',
                         :log_encoding => 'UTF-8' )
                 assert r
                 c = Changeset.new(:repository   => r,
                                   :committed_on => Time.now,
                                   :revision     => '123',
                                   :scmid        => '12345',
                                   :comments     => str1,
                                   :committer    => str2)
                 assert( c.save )
                 assert_equal "Texte encod? en ISO-8859-1.", c.comments
                 assert_equal "?a?b?c?d?e test", c.committer
               end
               def test_invalid_utf8_sequences_in_comments_should_be_replaced_ja_jis
                 proj = Project.find(3)
                 str = "test\xb5\xfetest\xb5\xfe"
                 if str.respond_to?(:force_encoding)
                   str.force_encoding('ASCII-8BIT')
                 end
                 r = Repository::Bazaar.create!(
                         :project      => proj,
                         :url          => '/tmp/test/bazaar',
                         :log_encoding => 'ISO-2022-JP' )
                 assert r
                 c = Changeset.new(:repository   => r,
                                   :committed_on => Time.now,
                                   :revision     => '123',
                                   :scmid        => '12345',
                                   :comments     => str)
                 assert( c.save )
                 assert_equal "test??test??", c.comments
               end
               def test_comments_should_be_converted_all_latin1_to_utf8
                 s1 = "\xC2\x80"
                 s2 = "\xc3\x82\xc2\x80"
                 s4 = s2.dup
                 if s1.respond_to?(:force_encoding)
                   s3 = s1.dup
                   s1.force_encoding('ASCII-8BIT')
                   s2.force_encoding('ASCII-8BIT')
                   s3.force_encoding('ISO-8859-1')
                   s4.force_encoding('UTF-8')
                   assert_equal s3.encode('UTF-8'), s4
                 end
                 proj = Project.find(3)
                 r = Repository::Bazaar.create!(
                         :project      => proj,
                         :url          => '/tmp/test/bazaar',
                         :log_encoding => 'ISO-8859-1' )
                 assert r
                 c = Changeset.new(:repository   => r,
                                   :committed_on => Time.now,
                                   :revision     => '123',
                                   :scmid        => '12345',
                                   :comments     => s1)
                 assert( c.save )
                 assert_equal s4, c.comments
               end
               def test_invalid_utf8_sequences_in_paths_should_be_replaced
                 proj = Project.find(3)
                 str1 = "Texte encod\xe9 en ISO-8859-1"
                 str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test"
                 str1.force_encoding("UTF-8")      if str1.respond_to?(:force_encoding)
                 str2.force_encoding("ASCII-8BIT") if str2.respond_to?(:force_encoding)
                 r = Repository::Bazaar.create!(
                         :project => proj,
                         :url => '/tmp/test/bazaar',
                         :log_encoding => 'UTF-8' )
                 assert r
                 cs = Changeset.new(
                            :repository   => r,
                            :committed_on => Time.now,
                            :revision     => '123',
                            :scmid        => '12345',
                            :comments     => "test")
                 assert(cs.save)
                 ch = Change.new(
                               :changeset     => cs,
                               :action        => "A",
                               :path          => str1,
                               :from_path     => str2,
                               :from_revision => "345")
                 assert(ch.save)
                 assert_equal "Texte encod? en ISO-8859-1", ch.path
                 assert_equal "?a?b?c?d?e test", ch.from_path
               end
               def test_comments_nil
                 proj = Project.find(3)
                 r = Repository::Bazaar.create!(
                         :project      => proj,
                         :url          => '/tmp/test/bazaar',
                         :log_encoding => 'ISO-8859-1' )
                 assert r
                 c = Changeset.new(:repository   => r,
                                   :committed_on => Time.now,
                                   :revision     => '123',
                                   :scmid        => '12345',
                                   :comments     => nil,
                                   :committer    => nil)
                 assert( c.save )
                 assert_equal "", c.comments
                 assert_equal nil, c.committer
                 if c.comments.respond_to?(:force_encoding)
                   assert_equal "UTF-8", c.comments.encoding.to_s
                 end
               end
               def test_comments_empty
                 proj = Project.find(3)
                 r = Repository::Bazaar.create!(
                         :project      => proj,
                         :url          => '/tmp/test/bazaar',
                         :log_encoding => 'ISO-8859-1' )
                 assert r
                 c = Changeset.new(:repository   => r,
                                   :committed_on => Time.now,
                                   :revision     => '123',
                                   :scmid        => '12345',
                                   :comments     => "",
                                   :committer    => "")
                 assert( c.save )
                 assert_equal "", c.comments
                 assert_equal "", c.committer
                 if c.comments.respond_to?(:force_encoding)
                   assert_equal "UTF-8", c.comments.encoding.to_s
                   assert_equal "UTF-8", c.committer.encoding.to_s
                 end
               end
               def test_identifier
                 c = Changeset.find_by_revision('1')
                 assert_equal c.revision, c.identifier
               end
             end

test/unit/repository_test.rb +3 -3

             # Redmine - project management software
             # Copyright (C) 2006-2013  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 File.expand_path('../../test_helper', __FILE__)
             class RepositoryTest < ActiveSupport::TestCase
               fixtures :projects,
                        :trackers,
                        :projects_trackers,
                        :enabled_modules,
                        :repositories,
                        :issues,
                        :issue_statuses,
                        :issue_categories,
                        :changesets,
                        :changes,
                        :users,
                        :members,
                        :member_roles,
                        :roles,
                        :enumerations
               include Redmine::I18n
               def setup
                 @repository = Project.find(1).repository
               end
               def test_blank_log_encoding_error_message
                 set_language_if_valid 'en'
                 repo = Repository::Bazaar.new(
                                     :project      => Project.find(3),
                                     :url          => "/test",
                                     :log_encoding => ''
                                   )
                 assert !repo.save
                 assert_include "Commit messages encoding can't be blank",
                                repo.errors.full_messages
               end
               def test_blank_log_encoding_error_message_fr
                 set_language_if_valid 'fr'
                 str = "Encodage des messages de commit doit \xc3\xaatre renseign\xc3\xa9(e)"
                 str.force_encoding('UTF-8') if str.respond_to?(:force_encoding)
                 repo = Repository::Bazaar.new(
                                     :project      => Project.find(3),
                                     :url          => "/test"
                                   )
                 assert !repo.save
                 assert_include str, repo.errors.full_messages
               end
               def test_create
                 repository = Repository::Subversion.new(:project => Project.find(3))
                 assert !repository.save
                 repository.url = "svn://localhost"
                 assert repository.save
                 repository.reload
                 project = Project.find(3)
                 assert_equal repository, project.repository
               end
               def test_first_repository_should_be_set_as_default
                 repository1 = Repository::Subversion.new(
                                   :project => Project.find(3),
                                   :identifier => 'svn1',
                                   :url => 'file:///svn1'
                                 )
                 assert repository1.save
                 assert repository1.is_default?
                 repository2 = Repository::Subversion.new(
                                   :project => Project.find(3),
                                   :identifier => 'svn2',
                                   :url => 'file:///svn2'
                                 )
                 assert repository2.save
                 assert !repository2.is_default?
                 assert_equal repository1, Project.find(3).repository
                 assert_equal [repository1, repository2], Project.find(3).repositories.sort
               end
               def test_identifier_should_accept_letters_digits_dashes_and_underscores
                 r = Repository::Subversion.new(
                   :project_id => 3,
                   :identifier => 'svn-123_45',
                   :url => 'file:///svn'
                 )
                 assert r.save
               end
               def test_identifier_should_not_be_frozen_for_a_new_repository
                 assert_equal false, Repository.new.identifier_frozen?
               end
               def test_identifier_should_not_be_frozen_for_a_saved_repository_with_blank_identifier
                 Repository.update_all(["identifier = ''"], "id = 10")
                 assert_equal false, Repository.find(10).identifier_frozen?
               end
               def test_identifier_should_be_frozen_for_a_saved_repository_with_valid_identifier
                 Repository.update_all(["identifier = 'abc123'"], "id = 10")
                 assert_equal true, Repository.find(10).identifier_frozen?
               end
               def test_identifier_should_not_accept_change_if_frozen
                 r = Repository.new(:identifier => 'foo')
                 r.stubs(:identifier_frozen?).returns(true)
                 r.identifier = 'bar'
                 assert_equal 'foo', r.identifier
               end
               def test_identifier_should_accept_change_if_not_frozen
                 r = Repository.new(:identifier => 'foo')
                 r.stubs(:identifier_frozen?).returns(false)
                 r.identifier = 'bar'
                 assert_equal 'bar', r.identifier
               end
               def test_destroy
                 repository = Repository.find(10)
                 changesets = repository.changesets.count
                 changes = repository.filechanges.count
                 assert_difference 'Changeset.count', -changesets do
                   assert_difference 'Change.count', -changes do
                     Repository.find(10).destroy
                   end
                 end
               end
               def test_destroy_should_delete_parents_associations
                 changeset = Changeset.find(102)
                 changeset.parents = Changeset.find_all_by_id([100, 101])
                 assert_difference 'Changeset.connection.select_all("select * from changeset_parents").size', -2 do
                   Repository.find(10).destroy
                 end
               end
               def test_destroy_should_delete_issues_associations
                 changeset = Changeset.find(102)
                 changeset.issues = Issue.find_all_by_id([1, 2])
                 assert_difference 'Changeset.connection.select_all("select * from changesets_issues").size', -2 do
                   Repository.find(10).destroy
                 end
               end
               def test_should_not_create_with_disabled_scm
                 # disable Subversion
                 with_settings :enabled_scm => ['Darcs', 'Git'] do
                   repository = Repository::Subversion.new(
                                   :project => Project.find(3), :url => "svn://localhost")
                   assert !repository.save
                   assert_include I18n.translate('activerecord.errors.messages.invalid'),
                                  repository.errors[:type]
                 end
               end
               def test_scan_changesets_for_issue_ids
                 Setting.default_language = 'en'
                 Setting.commit_ref_keywords = 'refs , references, IssueID'
-                Setting.commit_update_keywords = {
+                Setting.commit_update_keywords = [
-                  'fixes , closes' => {'status_id' => IssueStatus.where(:is_closed => true).first.id, 'done_ratio' => '90'}
+                  {'keywords' => 'fixes , closes', 'status_id' => IssueStatus.where(:is_closed => true).first.id, 'done_ratio' => '90'}
+                ]
                 Setting.default_language = 'en'
                 ActionMailer::Base.deliveries.clear
                 # make sure issue 1 is not already closed
                 fixed_issue = Issue.find(1)
                 assert !fixed_issue.status.is_closed?
                 old_status = fixed_issue.status
                 with_settings :notified_events => %w(issue_added issue_updated) do
                   Repository.scan_changesets_for_issue_ids
                 end
                 assert_equal [101, 102], Issue.find(3).changeset_ids
                 # fixed issues
                 fixed_issue.reload
                 assert fixed_issue.status.is_closed?
                 assert_equal 90, fixed_issue.done_ratio
                 assert_equal [101], fixed_issue.changeset_ids
                 # issue change
                 journal = fixed_issue.journals.reorder('created_on desc').first
                 assert_equal User.find_by_login('dlopper'), journal.user
                 assert_equal 'Applied in changeset r2.', journal.notes
                 # 2 email notifications
                 assert_equal 2, ActionMailer::Base.deliveries.size
                 mail = ActionMailer::Base.deliveries.first
                 assert_not_nil mail
                 assert mail.subject.starts_with?(
                     "[#{fixed_issue.project.name} - #{fixed_issue.tracker.name} ##{fixed_issue.id}]")
                 assert_mail_body_match(
                     "Status changed from #{old_status} to #{fixed_issue.status}", mail)
                 # ignoring commits referencing an issue of another project
                 assert_equal [], Issue.find(4).changesets
               end
               def test_for_changeset_comments_strip
                 repository = Repository::Mercurial.create(
                                 :project => Project.find( 4 ),
                                 :url => '/foo/bar/baz' )
                 comment = <<-COMMENT
                 This is a loooooooooooooooooooooooooooong comment
                 COMMENT
                 changeset = Changeset.new(
                   :comments => comment, :commit_date => Time.now,
                   :revision => 0, :scmid => 'f39b7922fb3c',
                   :committer => 'foo <foo@example.com>',
                   :committed_on => Time.now, :repository => repository )
                 assert( changeset.save )
                 assert_not_equal( comment, changeset.comments )
                 assert_equal( 'This is a loooooooooooooooooooooooooooong comment',
                               changeset.comments )
               end
               def test_for_urls_strip_cvs
                 repository = Repository::Cvs.create(
                     :project => Project.find(4),
                     :url => ' :pserver:login:password@host:/path/to/the/repository',
                     :root_url => 'foo  ',
                     :log_encoding => 'UTF-8')
                 assert repository.save
                 repository.reload
                 assert_equal ':pserver:login:password@host:/path/to/the/repository',
                               repository.url
                 assert_equal 'foo', repository.root_url
               end
               def test_for_urls_strip_subversion
                 repository = Repository::Subversion.create(
                     :project => Project.find(4),
                     :url => ' file:///dummy   ')
                 assert repository.save
                 repository.reload
                 assert_equal 'file:///dummy', repository.url
               end
               def test_for_urls_strip_git
                 repository = Repository::Git.create(
                     :project => Project.find(4),
                     :url => ' c:\dummy   ')
                 assert repository.save
                 repository.reload
                 assert_equal 'c:\dummy', repository.url
               end
               def test_manual_user_mapping
                 assert_no_difference "Changeset.where('user_id <> 2').count" do
                   c = Changeset.create!(
                           :repository => @repository,
                           :committer => 'foo',
                           :committed_on => Time.now,
                           :revision => 100,
                           :comments => 'Committed by foo.'
                         )
                   assert_nil c.user
                   @repository.committer_ids = {'foo' => '2'}
                   assert_equal User.find(2), c.reload.user
                   # committer is now mapped
                   c = Changeset.create!(
                           :repository => @repository,
                           :committer => 'foo',
                           :committed_on => Time.now,
                           :revision => 101,
                           :comments => 'Another commit by foo.'
                         )
                   assert_equal User.find(2), c.user
                 end
               end
               def test_auto_user_mapping_by_username
                 c = Changeset.create!(
                       :repository   => @repository,
                       :committer    => 'jsmith',
                       :committed_on => Time.now,
                       :revision     => 100,
                       :comments     => 'Committed by john.'
                     )
                 assert_equal User.find(2), c.user
               end
               def test_auto_user_mapping_by_email
                 c = Changeset.create!(
                       :repository   => @repository,
                       :committer    => 'john <jsmith@somenet.foo>',
                       :committed_on => Time.now,
                       :revision     => 100,
                       :comments     => 'Committed by john.'
                     )
                 assert_equal User.find(2), c.user
               end
               def test_filesystem_avaialbe
                 klass = Repository::Filesystem
                 assert klass.scm_adapter_class
                 assert_equal true, klass.scm_available
               end
               def test_merge_extra_info
                 repo = Repository::Subversion.new(:project => Project.find(3))
                 assert !repo.save
                 repo.url = "svn://localhost"
                 assert repo.save
                 repo.reload
                 project = Project.find(3)
                 assert_equal repo, project.repository
                 assert_nil repo.extra_info
                 h1 = {"test_1" => {"test_11" => "test_value_11"}}
                 repo.merge_extra_info(h1)
                 assert_equal h1, repo.extra_info
                 h2 = {"test_2" => {
                                "test_21" => "test_value_21",
                                "test_22" => "test_value_22",
                               }}
                 repo.merge_extra_info(h2)
                 assert_equal (h = {"test_11" => "test_value_11"}),
                              repo.extra_info["test_1"]
                 assert_equal "test_value_21",
                              repo.extra_info["test_2"]["test_21"]
                 h3 = {"test_2" => {
                                "test_23" => "test_value_23",
                                "test_24" => "test_value_24",
                               }}
                 repo.merge_extra_info(h3)
                 assert_equal (h = {"test_11" => "test_value_11"}),
                              repo.extra_info["test_1"]
                 assert_nil repo.extra_info["test_2"]["test_21"]
                 assert_equal "test_value_23",
                              repo.extra_info["test_2"]["test_23"]
               end
               def test_sort_should_not_raise_an_error_with_nil_identifiers
                 r1 = Repository.new
                 r2 = Repository.new
                 assert_nothing_raised do
                   [r1, r2].sort
                 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