Redmine

    c.parse_comment

  def test_not_associate_any_mentioned_tickets

    Setting.commit_ref_keywords = 'key'

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :comments => 'New commit (#2). #1')

    c.parse_comment

    assert_equal [], c.issue_ids

  end

  def test_fixes_multiple_tickets

    Setting.commit_fix_status_id = IssueStatus.find(:first, :conditions => ["is_closed = ?", true]).id

    Setting.commit_fix_keywords = 'fixes , closes'

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :comments => 'Fixes #1,#2')

    c.parse_comment

    assert_equal [1, 2], c.issue_ids.sort

  end

    c.parse_comment

  def test_log_time_without_issues_should_do_nothing

    count = TimeEntry.count

    Setting.advanced_commit_parsing = 1

    Setting.commit_ref_keywords = '*'

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :comments => 'time 3,5')

    c.parse_comment

    assert_equal count, TimeEntry.count

  end

  def test_log_time_should_work

    Setting.advanced_commit_parsing = 1

    Setting.commit_ref_keywords = '*'

    comment = <<-EOL

#1

time 3,5

EOL

    time = Time.now

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => time,

                      :comments => comment)

    c.parse_comment

    time_entry = TimeEntry.last

    assert_equal 3.5, time_entry.hours

  end

  def test_log_time_should_not_create_duplicate_logs

    count = TimeEntry.count

    Setting.advanced_commit_parsing = 1

    Setting.commit_ref_keywords = '*'

    committed_on = Time.now

    comment = <<-EOL

#1

time 3,5

EOL

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => committed_on,

                      :comments => comment)

    c.parse_comment

    c.parse_comment

    assert_equal count+1, TimeEntry.count

  end

  def test_log_time_splits_the_time_equally

    Setting.commit_fix_keywords = 'fixes , closes'

    Setting.advanced_commit_parsing = 1

    comment = <<-EOL

fixes #1,#2

time 3

the comment

EOL

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :comments => comment)

    c.parse_comment

    time_entry = TimeEntry.find(:first, :order => 'id DESC')

    assert_equal 1.5, time_entry.hours

    assert_equal 'the comment', time_entry.comments

  end

  def test_extract_time

    c = Changeset.new

    time_formats =  [ "2", "21.1", "2,1","7:12", "10h", "10 h", "45m", "45 m", "3h15", "3h 15", "3 h 15", "3 h 15m", "3 h 15 m"]

    time_formats.each do |format|

      assert_equal format, c.send(:extract_time!, "time #{format}")

    end

  end

  def test_set_done_ratio

    Setting.commit_ref_keywords = '*'

    Setting.advanced_commit_parsing = 1

    comment = <<-EOL

#1

done 50%

#2

done 40

EOL

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :comments => comment)

    c.parse_comment

    assert_equal [1, 2], c.issue_ids.sort

    assert_equal 50, Issue.find(1).done_ratio

    assert_equal 40, Issue.find(2).done_ratio

  end

  def test_set_committer_identified_by_email

    Setting.commit_fix_keywords = 'fixes'

    user = User.find(:first)

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :committer => "arnie<#{user.mail}>",

                      :comments => 'Fixes #1')

    c.parse_comment

    fixed = Issue.find(1)

    assert fixed.closed?

    assert_equal user, fixed.journals.find(:first, :order => 'id DESC').user

  end

  def test_set_committer_identified_by_login

    Setting.commit_fix_keywords = 'fixes'

    user = User.find(:first)

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :committer => user.login,

                      :comments => 'Fixes #1')

    c.parse_comment

    fixed = Issue.find(1)

    assert fixed.closed?

    assert_equal user, fixed.journals.find(:first, :order => 'id DESC').user

  end

  def test_set_annonymous_if_committer_unknown

    Setting.commit_fix_keywords = 'fixes'

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :committer => 'arnie',

                      :comments => 'Fixes #1')

    c.parse_comment

    fixed = Issue.find(1)

    assert fixed.closed?

    assert_equal User.anonymous, fixed.journals.find(:first, :order => 'id DESC').user

  end

  def test_mail_deliveries

    ActionMailer::Base.deliveries.clear

    Setting.commit_fix_keywords = 'fixes'

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :comments => 'Fixes #1')

    c.parse_comment

    assert_equal 1, ActionMailer::Base.deliveries.size

  end

  def test_ignore_cross_refrenced_issue_ids

    Setting.commit_fix_keywords = 'fixes'

    c = Changeset.new(:repository => Project.find(1).repository,

                      :committed_on => Time.now,

                      :comments => 'Fixes #1234')

    c.parse_comment

    assert_equal [], c.issue_ids.sort

  end

  def test_for_changeset_comments_strip

    comment = <<-COMMENT

    This is a loooooooooooooooooooooooooooong comment                                                   

    COMMENT

    changeset = Changeset.new :comments => comment

    assert_equal( 'This is a loooooooooooooooooooooooooooong comment', changeset.comments )

  end

  after_create :parse_comment

  # This starts the comment parsing. Executed by an after_save filter

  def parse_comment

    return if comments.blank?

    keywords = (ref_keywords + fix_keywords)

    return if keywords.blank?

    process_issues_marked_by(keywords)

  # Returns the previous changeset

  def previous

    @previous ||= Changeset.find(:first, :conditions => ['id < ? AND repository_id = ?', self.id, self.repository_id], :order => 'id DESC')

  end

  # Returns the next changeset

  def next

    @next ||= Changeset.find(:first, :conditions => ['id > ? AND repository_id = ?', self.id, self.repository_id], :order => 'id ASC')

  end

 protected

  # This parses the whole comment. Therefore the comment gets split into parts.

  def process_issues_marked_by(ticket_keywords)

    comments.scan( splitting_regexp(ticket_keywords) ).each do |match|

      rest = match.last

      process_part(action, target_issues, rest)

      referenced_issues += target_issues

    end

    self.issues = referenced_issues.uniq

  end

  # returns a regexp that splits the long comment into parts

  #

  # Each part starts with a valid ticket reference and 

  # either ends with one or ends at the end of the comment

  def splitting_regexp(ticket_keywords)

    ref_any = ticket_keywords.delete('*')

    joined_kw = ticket_keywords.join("|")

    first = "(#{joined_kw})#{ref_any ? '*' : '+' }"

    second = joined_kw + (ref_any ? '|#' : '')

    /#{first}[\s:]*(([\s,;&]*#?\d+)+)(.*?)(?=#{second}|\Z)/im 

  end

  # Process_part analyses the part and executes ticket changes, time logs etc.

  def process_part(action,target_issues,rest)

    if Setting.advanced_commit_parsing?

      time = extract_time!(rest)

      ratio = extract_ratio!(rest)

    end

    target_issues.each do |issue|

      journal = init_journal(issue)

      if fix_status && action && fix_keywords.include?(action.downcase)

        # 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

        break if issue.status.is_closed?

        issue.status = fix_status

        issue.done_ratio = done_ratio if done_ratio

      else

        if ratio and !issue.status.is_closed?

          issue.done_ratio = ratio

      if time && issue.time_entries.find(:first, :conditions => ['spent_on = ? AND comments = ? AND user_id = ?',committed_on.to_date,rest[0..254],committer_user.id]).nil?

        time_entry = TimeEntry.new( :hours => time,

                                    :spent_on => committed_on.to_date,

                                    :activity_id => activity_id,

                                    :comments => rest[0..254],

                                    :user => committer_user)

        time_entry.hours /= target_issues.length

        issue.time_entries << time_entry

      end

      if issue.changed?

        issue.save

        Mailer.deliver_issue_edit(journal) if Setting.notified_events.include?('issue_updated')

      end

  # init the journal for our issue

  def init_journal(issue)

    csettext = "r#{self.revision}"

    if self.scmid && (! (csettext =~ /^r[0-9]+$/))

      csettext = "commit:\"#{self.scmid}\""

    end

    issue.init_journal(committer_user, l(:text_status_changed_by_changeset, csettext))

  end

  # extracts the time

  def extract_time!(string)

    extract!(/(?:#{time_keywords.join("|")})[\s:]+(\d+[.,:hm ]*\d*[m ]*)/,string)

  end

  # extracts the ratio

  def extract_ratio!(string)

    extract!(/(?:#{ratio_keywords.join("|")})[\s:]+(\d+)%?/,string)

  end

  # generic extract function. Notice the !. The original string is silently manipulated

  def extract!(regexp,string)

    if match = string.match(/(.*?)#{regexp}(.*)/mi)

      replacement = if match[1] && !match[1].strip.empty?

                      match[1].strip + ' ' + match[3].strip

                    else

                      match[3].strip

                    end

      string.replace(replacement)

      match[2]

    end

  end

  # keywords used to reference issues

  def ref_keywords

    @ref_keywords ||= Setting.commit_ref_keywords.downcase.split(",").collect(&:strip)

  end

  # keywords used to fix issues

  def fix_keywords

    @fix_keywords ||= Setting.commit_fix_keywords.downcase.split(",").collect(&:strip)

  end

  # keywords used to set the ratio of the issues

  def ratio_keywords

    @ratio_keywords ||= Setting.commit_ratio_keywords.downcase.split(',').collect(&:strip)

  end

  # keywords used to log time of an issue

  def time_keywords

    @time_keywords ||= Setting.commit_time_keywords.downcase.split(',').collect(&:strip)

  end

  # status if an issue is fixed

  def fix_status

    @fix_status ||= IssueStatus.find_by_id(Setting.commit_fix_status_id)

  end

  # the ratio if an issue is fixed

  def done_ratio

    @done_ratio ||= Setting.commit_fix_done_ratio.blank? ? nil : Setting.commit_fix_done_ratio.to_i

  end

  # gets the default activity id or the id of the first

  def activity_id

    @activity_id ||= (Enumeration.default('ACTI') || Enumeration::get_values('ACTI').first).id

  end

  # or the anonymous user

    @user ||= if committer && committer.strip =~ /^([^<]+)(<(.*)>)?$/

    end || User.anonymous

<fieldset class="box tabular settings"><legend><%= l(:text_issues_advanced_commit_message_keywords) %></legend>

<p><label><%= l(:setting_advanced_commit_keywords) %></label>

<%= check_box_tag 'settings[advanced_commit_parsing]', 1, Setting.advanced_commit_parsing?, :onclick=>"Element.toggle('advanced_keywords'); return true;" %><%= hidden_field_tag 'settings[advanced_commit_parsing]', 0 %></p>

<div id="advanced_keywords" <%= Setting.advanced_commit_parsing? ? '' : 'style="display:none"' %>>

<p><label><%= l(:setting_commit_time_keywords) %></label>

<%= text_field_tag 'settings[commit_time_keywords]', Setting.commit_time_keywords, :size => 30 %>

<br /><em><%= l(:text_comma_separated) %></em></p>

<p><label><%= l(:setting_commit_ratio_keywords) %></label>

<%= text_field_tag 'settings[commit_ratio_keywords]', Setting.commit_ratio_keywords, :size => 30 %>

<br /><em><%= l(:text_comma_separated) %></em></p>

</div>

</fieldset>

setting_advanced_commit_keywords: Enable advanced keywords

setting_commit_time_keywords: Time logging keywords

setting_commit_ratio_keywords: Done ratio keywords

text_issues_advanced_commit_message_keywords: Logging time and setting issue ratios via commit messages

setting_advanced_commit_keywords: Erweiterte Schlüsselwörter aktivieren

setting_commit_time_keywords: Schlüsselwörter (Zeiterfassung)

setting_commit_ratio_keywords: Schlüsselwörter (Erledigt)

text_issues_advanced_commit_message_keywords: Ticket-Zeiterfassung und -Erledigt in Commit-Log-Meldungen

advanced_commit_parsing:

  default: 0

commit_time_keywords:

  default: 'time,log'

commit_ratio_keywords:

  default: 'done,ratio'