jro_apps/redmine Commit - r15503:46044b48a3d7

Adds accessors for report_last_commit....

Jean-Philippe Lang -

r15503:46044b48a3d7

parent child

Context file:

r15503:46044b48a3d7

Collapse all files

app/controllers/repositories_controller.rb +1 -23

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 'SVG/Graph/Bar'
              require 'SVG/Graph/BarHorizontal'
              require 'digest/sha1'
              require 'redmine/scm/adapters'
              class ChangesetNotFound < Exception; end
              class InvalidRevisionParam < Exception; end
              class RepositoriesController < ApplicationController
                menu_item :repository
                menu_item :settings, :only => [:new, :create, :edit, :update, :destroy, :committers]
                default_search_scope :changesets
                before_action :find_project_by_project_id, :only => [:new, :create]
                before_action :find_repository, :only => [:edit, :update, :destroy, :committers]
                before_action :find_project_repository, :except => [:new, :create, :edit, :update, :destroy, :committers]
                before_action :find_changeset, :only => [:revision, :add_related_issue, :remove_related_issue]
                before_action :authorize
                accept_rss_auth :revisions
                rescue_from Redmine::Scm::Adapters::CommandFailed, :with => :show_error_command_failed
                def new
                  scm = params[:repository_scm] || (Redmine::Scm::Base.all & Setting.enabled_scm).first
                  @repository = Repository.factory(scm)
                  @repository.is_default = @project.repository.nil?
                  @repository.project = @project
                end
                def create
-                 attrs = pickup_extra_info
                  @repository = Repository.factory(params[:repository_scm])
                  @repository.safe_attributes = params[:repository]
-                 if attrs[:attrs_extra].keys.any?
-                   @repository.merge_extra_info(attrs[:attrs_extra])
-                 end
                  @repository.project = @project
                  if request.post? && @repository.save
                    redirect_to settings_project_path(@project, :tab => 'repositories')
                  else
                    render :action => 'new'
                  end
                end
                def edit
                end
                def update
-                 attrs = pickup_extra_info
-                 @repository.safe_attributes = attrs[:attrs]
-                 if attrs[:attrs_extra].keys.any?
-                   @repository.merge_extra_info(attrs[:attrs_extra])
-                 end
+                 @repository.safe_attributes = params[:repository]
                  @repository.project = @project
                  if @repository.save
                    redirect_to settings_project_path(@project, :tab => 'repositories')
                  else
                    render :action => 'edit'
                  end
                end
-               def pickup_extra_info
-                 p       = {}
-                 p_extra = {}
-                 params[:repository].each do |k, v|
-                   if k =~ /^extra_/
-                     p_extra[k] = v
-                   else
-                     p[k] = v
-                   end
-                 end
-                 {:attrs => p, :attrs_extra => p_extra}
-               end
-               private :pickup_extra_info
                def committers
                  @committers = @repository.committers
                  @users = @project.users.to_a
                  additional_user_ids = @committers.collect(&:last).collect(&:to_i) - @users.collect(&:id)
                  @users += User.where(:id => additional_user_ids).to_a unless additional_user_ids.empty?
                  @users.compact!
                  @users.sort!
                  if request.post? && params[:committers].is_a?(Hash)
                    # Build a hash with repository usernames as keys and corresponding user ids as values
                    @repository.committer_ids = params[:committers].values.inject({}) {|h, c| h[c.first] = c.last; h}
                    flash[:notice] = l(:notice_successful_update)
                    redirect_to settings_project_path(@project, :tab => 'repositories')
                  end
                end
                def destroy
                  @repository.destroy if request.delete?
                  redirect_to settings_project_path(@project, :tab => 'repositories')
                end
                def show
                  @repository.fetch_changesets if @project.active? && Setting.autofetch_changesets? && @path.empty?
                  @entries = @repository.entries(@path, @rev)
                  @changeset = @repository.find_changeset_by_name(@rev)
                  if request.xhr?
                    @entries ? render(:partial => 'dir_list_content') : head(200)
                  else
                    (show_error_not_found; return) unless @entries
                    @changesets = @repository.latest_changesets(@path, @rev)
                    @properties = @repository.properties(@path, @rev)
                    @repositories = @project.repositories
                    render :action => 'show'
                  end
                end
                alias_method :browse, :show
                def changes
                  @entry = @repository.entry(@path, @rev)
                  (show_error_not_found; return) unless @entry
                  @changesets = @repository.latest_changesets(@path, @rev, Setting.repository_log_display_limit.to_i)
                  @properties = @repository.properties(@path, @rev)
                  @changeset = @repository.find_changeset_by_name(@rev)
                end
                def revisions
                  @changeset_count = @repository.changesets.count
                  @changeset_pages = Paginator.new @changeset_count,
                                                   per_page_option,
                                                   params['page']
                  @changesets = @repository.changesets.
                    limit(@changeset_pages.per_page).
                    offset(@changeset_pages.offset).
                    includes(:user, :repository, :parents).
                    to_a
                  respond_to do |format|
                    format.html { render :layout => false if request.xhr? }
                    format.atom { render_feed(@changesets, :title => "#{@project.name}: #{l(:label_revision_plural)}") }
                  end
                end
                def raw
                  entry_and_raw(true)
                end
                def entry
                  entry_and_raw(false)
                end
                def entry_and_raw(is_raw)
                  @entry = @repository.entry(@path, @rev)
                  (show_error_not_found; return) unless @entry
                  # If the entry is a dir, show the browser
                  (show; return) if @entry.is_dir?
                  if is_raw
                    # Force the download
                    send_opt = { :filename => filename_for_content_disposition(@path.split('/').last) }
                    send_type = Redmine::MimeType.of(@path)
                    send_opt[:type] = send_type.to_s if send_type
                    send_opt[:disposition] = disposition(@path)
                    send_data @repository.cat(@path, @rev), send_opt
                  else
                    if !@entry.size || @entry.size <= Setting.file_max_size_displayed.to_i.kilobyte
                      content = @repository.cat(@path, @rev)
                      (show_error_not_found; return) unless content
                      if content.size <= Setting.file_max_size_displayed.to_i.kilobyte &&
                         is_entry_text_data?(content, @path)
                        # TODO: UTF-16
                        # Prevent empty lines when displaying a file with Windows style eol
                        # Is this needed? AttachmentsController simply reads file.
                        @content = content.gsub("\r\n", "\n")
                      end
                    end
                    @changeset = @repository.find_changeset_by_name(@rev)
                  end
                end
                private :entry_and_raw
                def is_entry_text_data?(ent, path)
                  # UTF-16 contains "\x00".
                  # It is very strict that file contains less than 30% of ascii symbols
                  # in non Western Europe.
                  return true if Redmine::MimeType.is_type?('text', path)
                  # Ruby 1.8.6 has a bug of integer divisions.
                  # http://apidock.com/ruby/v1_8_6_287/String/is_binary_data%3F
                  return false if ent.is_binary_data?
                  true
                end
                private :is_entry_text_data?
                def annotate
                  @entry = @repository.entry(@path, @rev)
                  (show_error_not_found; return) unless @entry
                  @annotate = @repository.scm.annotate(@path, @rev)
                  if @annotate.nil? || @annotate.empty?
                    @annotate = nil
                    @error_message = l(:error_scm_annotate)
                  else
                    ann_buf_size = 0
                    @annotate.lines.each do |buf|
                      ann_buf_size += buf.size
                    end
                    if ann_buf_size > Setting.file_max_size_displayed.to_i.kilobyte
                      @annotate = nil
                      @error_message = l(:error_scm_annotate_big_text_file)
                    end
                  end
                  @changeset = @repository.find_changeset_by_name(@rev)
                end
                def revision
                  respond_to do |format|
                    format.html
                    format.js {render :layout => false}
                  end
                end
                # Adds a related issue to a changeset
                # POST /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues
                def add_related_issue
                  issue_id = params[:issue_id].to_s.sub(/^#/,'')
                  @issue = @changeset.find_referenced_issue_by_id(issue_id)
                  if @issue && (!@issue.visible? || @changeset.issues.include?(@issue))
                    @issue = nil
                  end
                  if @issue
                    @changeset.issues << @issue
                  end
                end
                # Removes a related issue from a changeset
                # DELETE /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues/:issue_id
                def remove_related_issue
                  @issue = Issue.visible.find_by_id(params[:issue_id])
                  if @issue
                    @changeset.issues.delete(@issue)
                  end
                end
                def diff
                  if params[:format] == 'diff'
                    @diff = @repository.diff(@path, @rev, @rev_to)
                    (show_error_not_found; return) unless @diff
                    filename = "changeset_r#{@rev}"
                    filename << "_r#{@rev_to}" if @rev_to
                    send_data @diff.join, :filename => "#{filename}.diff",
                                          :type => 'text/x-patch',
                                          :disposition => 'attachment'
                  else
                    @diff_type = params[:type] || User.current.pref[:diff_type] || 'inline'
                    @diff_type = 'inline' unless %w(inline sbs).include?(@diff_type)
                    # Save diff type as user preference
                    if User.current.logged? && @diff_type != User.current.pref[:diff_type]
                      User.current.pref[:diff_type] = @diff_type
                      User.current.preference.save
                    end
                    @cache_key = "repositories/diff/#{@repository.id}/" +
                                    Digest::MD5.hexdigest("#{@path}-#{@rev}-#{@rev_to}-#{@diff_type}-#{current_language}")
                    unless read_fragment(@cache_key)
                      @diff = @repository.diff(@path, @rev, @rev_to)
                      show_error_not_found unless @diff
                    end
                    @changeset = @repository.find_changeset_by_name(@rev)
                    @changeset_to = @rev_to ? @repository.find_changeset_by_name(@rev_to) : nil
                    @diff_format_revisions = @repository.diff_format_revisions(@changeset, @changeset_to)
                  end
                end
                def stats
                end
                def graph
                  data = nil
                  case params[:graph]
                  when "commits_per_month"
                    data = graph_commits_per_month(@repository)
                  when "commits_per_author"
                    data = graph_commits_per_author(@repository)
                  end
                  if data
                    headers["Content-Type"] = "image/svg+xml"
                    send_data(data, :type => "image/svg+xml", :disposition => "inline")
                  else
                    render_404
                  end
                end
                private
                def find_repository
                  @repository = Repository.find(params[:id])
                  @project = @repository.project
                rescue ActiveRecord::RecordNotFound
                  render_404
                end
                REV_PARAM_RE = %r{\A[a-f0-9]*\Z}i
                def find_project_repository
                  @project = Project.find(params[:id])
                  if params[:repository_id].present?
                    @repository = @project.repositories.find_by_identifier_param(params[:repository_id])
                  else
                    @repository = @project.repository
                  end
                  (render_404; return false) unless @repository
                  @path = params[:path].is_a?(Array) ? params[:path].join('/') : params[:path].to_s
                  @rev = params[:rev].blank? ? @repository.default_branch : params[:rev].to_s.strip
                  @rev_to = params[:rev_to]
                  unless @rev.to_s.match(REV_PARAM_RE) && @rev_to.to_s.match(REV_PARAM_RE)
                    if @repository.branches.blank?
                      raise InvalidRevisionParam
                    end
                  end
                rescue ActiveRecord::RecordNotFound
                  render_404
                rescue InvalidRevisionParam
                  show_error_not_found
                end
                def find_changeset
                  if @rev.present?
                    @changeset = @repository.find_changeset_by_name(@rev)
                  end
                  show_error_not_found unless @changeset
                end
                def show_error_not_found
                  render_error :message => l(:error_scm_not_found), :status => 404
                end
                # Handler for Redmine::Scm::Adapters::CommandFailed exception
                def show_error_command_failed(exception)
                  render_error l(:error_scm_command_failed, exception.message)
                end
                def graph_commits_per_month(repository)
                  @date_to = User.current.today
                  @date_from = @date_to << 11
                  @date_from = Date.civil(@date_from.year, @date_from.month, 1)
                  commits_by_day = Changeset.
                    where("repository_id = ? AND commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
                    group(:commit_date).
                    count
                  commits_by_month = [0] * 12
                  commits_by_day.each {|c| commits_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                  changes_by_day = Change.
                    joins(:changeset).
                    where("#{Changeset.table_name}.repository_id = ? AND #{Changeset.table_name}.commit_date BETWEEN ? AND ?", repository.id, @date_from, @date_to).
                    group(:commit_date).
                    count
                  changes_by_month = [0] * 12
                  changes_by_day.each {|c| changes_by_month[(@date_to.month - c.first.to_date.month) % 12] += c.last }
                  fields = []
                  today = User.current.today
 .times {|m| fields << month_name(((today.month - 1 - m) % 12) + 1)}
                  graph = SVG::Graph::Bar.new(
                    :height => 300,
                    :width => 800,
                    :fields => fields.reverse,
                    :stack => :side,
                    :scale_integers => true,
                    :step_x_labels => 2,
                    :show_data_values => false,
                    :graph_title => l(:label_commits_per_month),
                    :show_graph_title => true
                  )
                  graph.add_data(
                    :data => commits_by_month[0..11].reverse,
                    :title => l(:label_revision_plural)
                  )
                  graph.add_data(
                    :data => changes_by_month[0..11].reverse,
                    :title => l(:label_change_plural)
                  )
                  graph.burn
                end
                def graph_commits_per_author(repository)
                  #data
                  stats = repository.stats_by_author
                  fields, commits_data, changes_data = [], [], []
                  stats.each do |name, hsh|
                    fields << name
                    commits_data << hsh[:commits_count]
                    changes_data << hsh[:changes_count]
                  end
                  #expand to 10 values if needed
                  fields = fields + [""]*(10 - fields.length) if fields.length<10
                  commits_data = commits_data + [0]*(10 - commits_data.length) if commits_data.length<10
                  changes_data = changes_data + [0]*(10 - changes_data.length) if changes_data.length<10
                  # Remove email address in usernames
                  fields = fields.collect {|c| c.gsub(%r{<.+@.+>}, '') }
                  #prepare graph
                  graph = SVG::Graph::BarHorizontal.new(
                    :height => 30 * commits_data.length,
                    :width => 800,
                    :fields => fields,
                    :stack => :side,
                    :scale_integers => true,
                    :show_data_values => false,
                    :rotate_y_labels => false,
                    :graph_title => l(:label_commits_per_author),
                    :show_graph_title => true
                  )
                  graph.add_data(
                    :data => commits_data,
                    :title => l(:label_revision_plural)
                  )
                  graph.add_data(
                    :data => changes_data,
                    :title => l(:label_change_plural)
                  )
                  graph.burn
                end
                def disposition(path)
                  if Redmine::MimeType.is_type?('image', @path) || Redmine::MimeType.of(@path) == "application/pdf"
                    'inline'
                  else
                    'attachment'
                  end
                end
              end

app/helpers/repositories_helper.rb +1 -1

              # encoding: utf-8
              #
              # Redmine - project management software
              # Copyright (C) 2006-2016  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.
              module RepositoriesHelper
                def format_revision(revision)
                  if revision.respond_to? :format_identifier
                    revision.format_identifier
                  else
                    revision.to_s
                  end
                end
                def truncate_at_line_break(text, length = 255)
                  if text
                    text.gsub(%r{^(.{#{length}}[^\n]*)\n.+$}m, '\\1...')
                  end
                end
                def render_properties(properties)
                  unless properties.nil? || properties.empty?
                    content = ''
                    properties.keys.sort.each do |property|
                      content << content_tag('li', "<b>#{h property}</b>: <span>#{h properties[property]}</span>".html_safe)
                    end
                    content_tag('ul', content.html_safe, :class => 'properties')
                  end
                end
                def render_changeset_changes
                  changes = @changeset.filechanges.limit(1000).reorder('path').collect do |change|
                    case change.action
                    when 'A'
                      # Detects moved/copied files
                      if !change.from_path.blank?
                        change.action =
                           @changeset.filechanges.detect {|c| c.action == 'D' && c.path == change.from_path} ? 'R' : 'C'
                      end
                      change
                    when 'D'
                      @changeset.filechanges.detect {|c| c.from_path == change.path} ? nil : change
                    else
                      change
                    end
                  end.compact
                  tree = { }
                  changes.each do |change|
                    p = tree
                    dirs = change.path.to_s.split('/').select {|d| !d.blank?}
                    path = ''
                    dirs.each do |dir|
                      path += '/' + dir
                      p[:s] ||= {}
                      p = p[:s]
                      p[path] ||= {}
                      p = p[path]
                    end
                    p[:c] = change
                  end
                  render_changes_tree(tree[:s])
                end
                def render_changes_tree(tree)
                  return '' if tree.nil?
                  output = ''
                  output << '<ul>'
                  tree.keys.sort.each do |file|
                    style = 'change'
                    text = File.basename(h(file))
                    if s = tree[file][:s]
                      style << ' folder'
                      path_param = to_path_param(@repository.relative_path(file))
                      text = link_to(h(text), :controller => 'repositories',
                                           :action => 'show',
                                           :id => @project,
                                           :repository_id => @repository.identifier_param,
                                           :path => path_param,
                                           :rev => @changeset.identifier)
                      output << "<li class='#{style}'>#{text}"
                      output << render_changes_tree(s)
                      output << "</li>"
                    elsif c = tree[file][:c]
                      style << " change-#{c.action}"
                      path_param = to_path_param(@repository.relative_path(c.path))
                      text = link_to(h(text), :controller => 'repositories',
                                           :action => 'entry',
                                           :id => @project,
                                           :repository_id => @repository.identifier_param,
                                           :path => path_param,
                                           :rev => @changeset.identifier) unless c.action == 'D'
                      text << " - #{h(c.revision)}" unless c.revision.blank?
                      text << ' ('.html_safe + link_to(l(:label_diff), :controller => 'repositories',
                                                     :action => 'diff',
                                                     :id => @project,
                                                     :repository_id => @repository.identifier_param,
                                                     :path => path_param,
                                                     :rev => @changeset.identifier) + ') '.html_safe if c.action == 'M'
                      text << ' '.html_safe + content_tag('span', h(c.from_path), :class => 'copied-from') unless c.from_path.blank?
                      output << "<li class='#{style}'>#{text}</li>"
                    end
                  end
                  output << '</ul>'
                  output.html_safe
                end
                def repository_field_tags(form, repository)
                  method = repository.class.name.demodulize.underscore + "_field_tags"
                  if repository.is_a?(Repository) &&
                      respond_to?(method) && method != 'repository_field_tags'
                    send(method, form, repository)
                  end
                end
                def scm_select_tag(repository)
                  scm_options = [["--- #{l(:actionview_instancetag_blank_option)} ---", '']]
                  Redmine::Scm::Base.all.each do |scm|
                  if Setting.enabled_scm.include?(scm) ||
                        (repository && repository.class.name.demodulize == scm)
                      scm_options << ["Repository::#{scm}".constantize.scm_name, scm]
                    end
                  end
                  select_tag('repository_scm',
                             options_for_select(scm_options, repository.class.name.demodulize),
                             :disabled => (repository && !repository.new_record?),
                             :data => {:remote => true, :method => 'get'})
                end
                def with_leading_slash(path)
                  path.to_s.starts_with?('/') ? path : "/#{path}"
                end
                def subversion_field_tags(form, repository)
                    content_tag('p', form.text_field(:url, :size => 60, :required => true,
                                     :disabled => !repository.safe_attribute?('url')) +
                                     scm_path_info_tag(repository)) +
                    content_tag('p', form.text_field(:login, :size => 30)) +
                    content_tag('p', form.password_field(
                                          :password, :size => 30, :name => 'ignore',
                                          :value => ((repository.new_record? || repository.password.blank?) ? '' : ('x'*15)),
                                          :onfocus => "this.value=''; this.name='repository[password]';",
                                          :onchange => "this.name='repository[password]';"))
                end
                def darcs_field_tags(form, repository)
                  content_tag('p', form.text_field(
                                   :url, :label => l(:field_path_to_repository),
                                   :size => 60, :required => true,
                                   :disabled => !repository.safe_attribute?('url')) +
                                   scm_path_info_tag(repository)) +
                  scm_log_encoding_tag(form, repository)
                end
                def mercurial_field_tags(form, repository)
                  content_tag('p', form.text_field(
                                     :url, :label => l(:field_path_to_repository),
                                     :size => 60, :required => true,
                                     :disabled => !repository.safe_attribute?('url')
                                       ) +
                                   scm_path_info_tag(repository)) +
                  scm_path_encoding_tag(form, repository)
                end
                def git_field_tags(form, repository)
                  content_tag('p', form.text_field(
                                     :url, :label => l(:field_path_to_repository),
                                     :size => 60, :required => true,
                                     :disabled => !repository.safe_attribute?('url')
                                       ) +
                                    scm_path_info_tag(repository)) +
                  scm_path_encoding_tag(form, repository) +
                  content_tag('p', form.check_box(
-                                     :extra_report_last_commit,
+                                     :report_last_commit,
                                      :label => l(:label_git_report_last_commit)
                                       ))
                end
                def cvs_field_tags(form, repository)
                  content_tag('p', form.text_field(
                                   :root_url,
                                   :label => l(:field_cvsroot),
                                   :size => 60, :required => true,
                                   :disabled => !repository.safe_attribute?('root_url')) +
                                   scm_path_info_tag(repository)) +
                  content_tag('p', form.text_field(
                                   :url,
                                   :label => l(:field_cvs_module),
                                   :size => 30, :required => true,
                                   :disabled => !repository.safe_attribute?('url'))) +
                  scm_log_encoding_tag(form, repository) +
                  scm_path_encoding_tag(form, repository)
                end
                def bazaar_field_tags(form, repository)
                  content_tag('p', form.text_field(
                                   :url, :label => l(:field_path_to_repository),
                                   :size => 60, :required => true,
                                   :disabled => !repository.safe_attribute?('url')) +
                                   scm_path_info_tag(repository)) +
                  scm_log_encoding_tag(form, repository)
                end
                def filesystem_field_tags(form, repository)
                  content_tag('p', form.text_field(
                                   :url, :label => l(:field_root_directory),
                                   :size => 60, :required => true,
                                   :disabled => !repository.safe_attribute?('url')) +
                                   scm_path_info_tag(repository)) +
                  scm_path_encoding_tag(form, repository)
                end
                def scm_path_info_tag(repository)
                  text = scm_path_info(repository)
                  if text.present?
                    content_tag('em', text, :class => 'info')
                  else
                    ''
                  end
                end
                def scm_path_info(repository)
                  scm_name = repository.scm_name.to_s.downcase
                  info_from_config = Redmine::Configuration["scm_#{scm_name}_path_info"].presence
                  return info_from_config.html_safe if info_from_config
                  l("text_#{scm_name}_repository_note", :default => '')
                end
                def scm_log_encoding_tag(form, repository)
                  select = form.select(
                    :log_encoding,
                    [nil] + Setting::ENCODINGS,
                    :label => l(:field_commit_logs_encoding),
                    :required => true
                  )
                  content_tag('p', select)
                end
                def scm_path_encoding_tag(form, repository)
                  select = form.select(
                    :path_encoding,
                    [nil] + Setting::ENCODINGS,
                    :label => l(:field_scm_path_encoding)
                  )
                  content_tag('p', select + content_tag('em', l(:text_scm_path_encoding_note), :class => 'info'))
                end
                def index_commits(commits, heads)
                  return nil if commits.nil? or commits.first.parents.nil?
                  refs_map = {}
                  heads.each do |head|
                    refs_map[head.scmid] ||= []
                    refs_map[head.scmid] << head
                  end
                  commits_by_scmid = {}
                  commits.reverse.each_with_index do |commit, commit_index|
                    commits_by_scmid[commit.scmid] = {
                      :parent_scmids => commit.parents.collect { |parent| parent.scmid },
                      :rdmid => commit_index,
                      :refs  => refs_map.include?(commit.scmid) ? refs_map[commit.scmid].join(" ") : nil,
                      :scmid => commit.scmid,
                      :href  => block_given? ? yield(commit.scmid) : commit.scmid
                    }
                  end
                  heads.sort! { |head1, head2| head1.to_s <=> head2.to_s }
                  space = nil
                  heads.each do |head|
                    if commits_by_scmid.include? head.scmid
                      space = index_head((space || -1) + 1, head, commits_by_scmid)
                    end
                  end
                  # when no head matched anything use first commit
                  space ||= index_head(0, commits.first, commits_by_scmid)
                  return commits_by_scmid, space
                end
                def index_head(space, commit, commits_by_scmid)
                  stack = [[space, commits_by_scmid[commit.scmid]]]
                  max_space = space
                  until stack.empty?
                    space, commit = stack.pop
                    commit[:space] = space if commit[:space].nil?
                    space -= 1
                    commit[:parent_scmids].each_with_index do |parent_scmid, parent_index|
                      parent_commit = commits_by_scmid[parent_scmid]
                      if parent_commit and parent_commit[:space].nil?
                        stack.unshift [space += 1, parent_commit]
                      end
                    end
                    max_space = space if max_space < space
                  end
                  max_space
                end
              end

app/models/repository/git.rb +7 -5

              # Redmine - project management software
              # Copyright (C) 2006-2016  Jean-Philippe Lang
              # Copyright (C) 2007  Patrick Aljord patcito@ŋmail.com
              #
              # This program is free software; you can redistribute it and/or
              # modify it under the terms of the GNU General Public License
              # as published by the Free Software Foundation; either version 2
              # of the License, or (at your option) any later version.
              #
              # This program is distributed in the hope that it will be useful,
              # but WITHOUT ANY WARRANTY; without even the implied warranty of
              # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
              # GNU General Public License for more details.
              #
              # You should have received a copy of the GNU General Public License
              # along with this program; if not, write to the Free Software
              # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
              require 'redmine/scm/adapters/git_adapter'
              class Repository::Git < Repository
                attr_protected :root_url
                validates_presence_of :url
+               safe_attributes 'report_last_commit'
                def self.human_attribute_name(attribute_key_name, *args)
                  attr_name = attribute_key_name.to_s
                  if attr_name == "url"
                    attr_name = "path_to_repository"
                  end
                  super(attr_name, *args)
                end
                def self.scm_adapter_class
                  Redmine::Scm::Adapters::GitAdapter
                end
                def self.scm_name
                  'Git'
                end
                def report_last_commit
-                 extra_report_last_commit
-               end
-               def extra_report_last_commit
                  return false if extra_info.nil?
                  v = extra_info["extra_report_last_commit"]
                  return false if v.nil?
                  v.to_s != '0'
                end
+               def report_last_commit=(arg)
+                 merge_extra_info "extra_report_last_commit" => arg
+               end
                def supports_directory_revisions?
                  true
                end
                def supports_revision_graph?
                  true
                end
                def repo_log_encoding
                  'UTF-8'
                end
                # Returns the identifier for the given git changeset
                def self.changeset_identifier(changeset)
                  changeset.scmid
                end
                # Returns the readable identifier for the given git changeset
                def self.format_changeset_identifier(changeset)
                  changeset.revision[0, 8]
                end
                def branches
                  scm.branches
                end
                def tags
                  scm.tags
                end
                def default_branch
                  scm.default_branch
                rescue Exception => e
                  logger.error "git: error during get default branch: #{e.message}"
                  nil
                end
                def find_changeset_by_name(name)
                  if name.present?
                    changesets.where(:revision => name.to_s).first ||
                      changesets.where('scmid LIKE ?', "#{name}%").first
                  end
                end
                def scm_entries(path=nil, identifier=nil)
-                 scm.entries(path, identifier, :report_last_commit => extra_report_last_commit)
+                 scm.entries(path, identifier, :report_last_commit => report_last_commit)
                end
                protected :scm_entries
                # With SCMs that have a sequential commit numbering,
                # such as Subversion and Mercurial,
                # Redmine is able to be clever and only fetch changesets
                # going forward from the most recent one it knows about.
                #
                # However, Git does not have a sequential commit numbering.
                #
                # In order to fetch only new adding revisions,
                # Redmine needs to save "heads".
                #
                # In Git and Mercurial, revisions are not in date order.
                # Redmine Mercurial fixed issues.
                #    * Redmine Takes Too Long On Large Mercurial Repository
                #      http://www.redmine.org/issues/3449
                #    * Sorting for changesets might go wrong on Mercurial repos
                #      http://www.redmine.org/issues/3567
                #
                # Database revision column is text, so Redmine can not sort by revision.
                # Mercurial has revision number, and revision number guarantees revision order.
                # Redmine Mercurial model stored revisions ordered by database id to database.
                # So, Redmine Mercurial model can use correct ordering revisions.
                #
                # Redmine Mercurial adapter uses "hg log -r 0:tip --limit 10"
                # to get limited revisions from old to new.
                # But, Git 1.7.3.4 does not support --reverse with -n or --skip.
                #
                # The repository can still be fully reloaded by calling #clear_changesets
                # before fetching changesets (eg. for offline resync)
                def fetch_changesets
                  scm_brs = branches
                  return if scm_brs.nil? || scm_brs.empty?
                  h1 = extra_info || {}
                  h  = h1.dup
                  repo_heads = scm_brs.map{ |br| br.scmid }
                  h["heads"] ||= []
                  prev_db_heads = h["heads"].dup
                  if prev_db_heads.empty?
                    prev_db_heads += heads_from_branches_hash
                  end
                  return if prev_db_heads.sort == repo_heads.sort
                  h["db_consistent"]  ||= {}
                  if changesets.count == 0
                    h["db_consistent"]["ordering"] = 1
                    merge_extra_info(h)
                    self.save
                  elsif ! h["db_consistent"].has_key?("ordering")
                    h["db_consistent"]["ordering"] = 0
                    merge_extra_info(h)
                    self.save
                  end
                  save_revisions(prev_db_heads, repo_heads)
                end
                def save_revisions(prev_db_heads, repo_heads)
                  h = {}
                  opts = {}
                  opts[:reverse]  = true
                  opts[:excludes] = prev_db_heads
                  opts[:includes] = repo_heads
                  revisions = scm.revisions('', nil, nil, opts)
                  return if revisions.blank?
                  # Make the search for existing revisions in the database in a more sufficient manner
                  #
                  # Git branch is the reference to the specific revision.
                  # Git can *delete* remote branch and *re-push* branch.
                  #
                  #  $ git push remote :branch
                  #  $ git push remote branch
                  #
                  # After deleting branch, revisions remain in repository until "git gc".
                  # On git 1.7.2.3, default pruning date is 2 weeks.
                  # So, "git log --not deleted_branch_head_revision" return code is 0.
                  #
                  # After re-pushing branch, "git log" returns revisions which are saved in database.
                  # So, Redmine needs to scan revisions and database every time.
                  #
                  # This is replacing the one-after-one queries.
                  # Find all revisions, that are in the database, and then remove them
                  # from the revision array.
                  # Then later we won't need any conditions for db existence.
                  # Query for several revisions at once, and remove them
                  # from the revisions array, if they are there.
                  # Do this in chunks, to avoid eventual memory problems
                  # (in case of tens of thousands of commits).
                  # If there are no revisions (because the original code's algorithm filtered them),
                  # then this part will be stepped over.
                  # We make queries, just if there is any revision.
                  limit = 100
                  offset = 0
                  revisions_copy = revisions.clone # revisions will change
                  while offset < revisions_copy.size
                    scmids = revisions_copy.slice(offset, limit).map{|x| x.scmid}
                    recent_changesets_slice = changesets.where(:scmid => scmids)
                    # Subtract revisions that redmine already knows about
                    recent_revisions = recent_changesets_slice.map{|c| c.scmid}
                    revisions.reject!{|r| recent_revisions.include?(r.scmid)}
                    offset += limit
                  end
                  revisions.each do |rev|
                    transaction do
                      # There is no search in the db for this revision, because above we ensured,
                      # that it's not in the db.
                      save_revision(rev)
                    end
                  end
                  h["heads"] = repo_heads.dup
                  merge_extra_info(h)
                  save(:validate => false)
                end
                private :save_revisions
                def save_revision(rev)
                  parents = (rev.parents || []).collect{|rp| find_changeset_by_name(rp)}.compact
                  changeset = Changeset.create(
                            :repository   => self,
                            :revision     => rev.identifier,
                            :scmid        => rev.scmid,
                            :committer    => rev.author,
                            :committed_on => rev.time,
                            :comments     => rev.message,
                            :parents      => parents
                            )
                  unless changeset.new_record?
                    rev.paths.each { |change| changeset.create_change(change) }
                  end
                  changeset
                end
                private :save_revision
                def heads_from_branches_hash
                  h1 = extra_info || {}
                  h  = h1.dup
                  h["branches"] ||= {}
                  h['branches'].map{|br, hs| hs['last_scmid']}
                end
                def latest_changesets(path,rev,limit=10)
                  revisions = scm.revisions(path, nil, rev, :limit => limit, :all => false)
                  return [] if revisions.nil? || revisions.empty?
                  changesets.where(:scmid => revisions.map {|c| c.scmid}).to_a
                end
                def clear_extra_info_of_changesets
                  return if extra_info.nil?
                  v = extra_info["extra_report_last_commit"]
                  write_attribute(:extra_info, nil)
                  h = {}
                  h["extra_report_last_commit"] = v
                  merge_extra_info(h)
                  save(:validate => false)
                end
                private :clear_extra_info_of_changesets
                def clear_changesets
                  super
                  clear_extra_info_of_changesets
                end
                private :clear_changesets
              end

test/functional/repositories_controller_test.rb +10 0

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 RepositoriesControllerTest < Redmine::ControllerTest
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles, :enabled_modules,
                         :repositories, :issues, :issue_statuses, :changesets, :changes,
                         :issue_categories, :enumerations, :custom_fields, :custom_values, :trackers
                def setup
                  User.current = nil
                end
                def test_new
                  @request.session[:user_id] = 1
                  get :new, :project_id => 'subproject1'
                  assert_response :success
                  assert_select 'select[name=?]', 'repository_scm' do
                    assert_select 'option[value=?][selected=selected]', 'Subversion'
                  end
                  assert_select 'input[name=?]:not([disabled])', 'repository[url]'
                end
                def test_new_should_propose_enabled_scm_only
                  @request.session[:user_id] = 1
                  with_settings :enabled_scm => ['Mercurial', 'Git'] do
                    get :new, :project_id => 'subproject1'
                  end
                  assert_response :success
                  assert_select 'select[name=repository_scm]' do
                    assert_select 'option', 3
                    assert_select 'option[value=Mercurial][selected=selected]'
                    assert_select 'option[value=Git]:not([selected])'
                  end
                end
+               def test_get_new_with_type
+                 @request.session[:user_id] = 1
+                 get :new, :project_id => 'subproject1', :repository_scm => 'Git'
+                 assert_response :success
+                 assert_select 'select[name=?]', 'repository_scm' do
+                   assert_select 'option[value=?][selected=selected]', 'Git'
+                 end
+               end
                def test_create
                  @request.session[:user_id] = 1
                  assert_difference 'Repository.count' do
                    post :create, :project_id => 'subproject1',
                         :repository_scm => 'Subversion',
                         :repository => {:url => 'file:///test', :is_default => '1', :identifier => ''}
                  end
                  assert_response 302
                  repository = Repository.order('id DESC').first
                  assert_kind_of Repository::Subversion, repository
                  assert_equal 'file:///test', repository.url
                end
                def test_create_with_failure
                  @request.session[:user_id] = 1
                  assert_no_difference 'Repository.count' do
                    post :create, :project_id => 'subproject1',
                         :repository_scm => 'Subversion',
                         :repository => {:url => 'invalid'}
                  end
                  assert_response :success
                  assert_select_error /URL is invalid/
                  assert_select 'select[name=?]', 'repository_scm' do
                    assert_select 'option[value=?][selected=selected]', 'Subversion'
                  end
                end
                def test_edit
                  @request.session[:user_id] = 1
                  get :edit, :id => 11
                  assert_response :success
                  assert_select 'input[name=?][value=?][disabled=disabled]', 'repository[url]', 'svn://localhost/test'
                end
                def test_update
                  @request.session[:user_id] = 1
                  put :update, :id => 11, :repository => {:password => 'test_update'}
                  assert_response 302
                  assert_equal 'test_update', Repository.find(11).password
                end
                def test_update_with_failure
                  @request.session[:user_id] = 1
                  put :update, :id => 11, :repository => {:password => 'x'*260}
                  assert_response :success
                  assert_select_error /Password is too long/
                end
                def test_destroy
                  @request.session[:user_id] = 1
                  assert_difference 'Repository.count', -1 do
                    delete :destroy, :id => 11
                  end
                  assert_response 302
                  assert_nil Repository.find_by_id(11)
                end
                def test_show_with_autofetch_changesets_enabled_should_fetch_changesets
                  Repository::Subversion.any_instance.expects(:fetch_changesets).once
                  with_settings :autofetch_changesets => '1' do
                    get :show, :id => 1
                  end
                end
                def test_show_with_autofetch_changesets_disabled_should_not_fetch_changesets
                  Repository::Subversion.any_instance.expects(:fetch_changesets).never
                  with_settings :autofetch_changesets => '0' do
                    get :show, :id => 1
                  end
                end
                def test_show_with_closed_project_should_not_fetch_changesets
                  Repository::Subversion.any_instance.expects(:fetch_changesets).never
                  Project.find(1).close
                  with_settings :autofetch_changesets => '1' do
                    get :show, :id => 1
                  end
                end
                def test_revisions
                  get :revisions, :id => 1
                  assert_response :success
                  assert_select 'table.changesets'
                end
                def test_revisions_for_other_repository
                  repository = Repository::Subversion.create!(:project_id => 1, :identifier => 'foo', :url => 'file:///foo')
                  get :revisions, :id => 1, :repository_id => 'foo'
                  assert_response :success
                  assert_select 'table.changesets'
                end
                def test_revisions_for_invalid_repository
                  get :revisions, :id => 1, :repository_id => 'foo'
                  assert_response 404
                end
                def test_revision
                  get :revision, :id => 1, :rev => 1
                  assert_response :success
                  assert_select 'h2', :text => 'Revision 1'
                end
                def test_revision_should_show_add_related_issue_form
                  Role.find(1).add_permission! :manage_related_issues
                  @request.session[:user_id] = 2
                  get :revision, :id => 1, :rev => 1
                  assert_response :success
                  assert_select 'form[action=?]', '/projects/ecookbook/repository/revisions/1/issues' do
                    assert_select 'input[name=?]', 'issue_id'
                  end
                end
                def test_revision_should_not_change_the_project_menu_link
                  get :revision, :id => 1, :rev => 1
                  assert_response :success
                  assert_select '#main-menu a.repository[href=?]', '/projects/ecookbook/repository'
                end
                def test_revision_with_before_nil_and_afer_normal
                  get :revision, {:id => 1, :rev => 1}
                  assert_response :success
                  assert_select 'div.contextual' do
                    assert_select 'a[href=?]', '/projects/ecookbook/repository/revisions/0', 0
                    assert_select 'a[href=?]', '/projects/ecookbook/repository/revisions/2'
                  end
                end
                def test_add_related_issue
                  @request.session[:user_id] = 2
                  assert_difference 'Changeset.find(103).issues.size' do
                    xhr :post, :add_related_issue, :id => 1, :rev => 4, :issue_id => 2, :format => 'js'
                    assert_response :success
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_equal [2], Changeset.find(103).issue_ids
                  assert_include 'related-issues', response.body
                  assert_include 'Feature request #2', response.body
                end
                def test_add_related_issue_should_accept_issue_id_with_sharp
                  @request.session[:user_id] = 2
                  assert_difference 'Changeset.find(103).issues.size' do
                    xhr :post, :add_related_issue, :id => 1, :rev => 4, :issue_id => "#2", :format => 'js'
                  end
                  assert_equal [2], Changeset.find(103).issue_ids
                end
                def test_add_related_issue_with_invalid_issue_id
                  @request.session[:user_id] = 2
                  assert_no_difference 'Changeset.find(103).issues.size' do
                    xhr :post, :add_related_issue, :id => 1, :rev => 4, :issue_id => 9999, :format => 'js'
                    assert_response :success
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_include 'alert("Issue is invalid")', response.body
                end
                def test_remove_related_issue
                  Changeset.find(103).issues << Issue.find(1)
                  Changeset.find(103).issues << Issue.find(2)
                  @request.session[:user_id] = 2
                  assert_difference 'Changeset.find(103).issues.size', -1 do
                    xhr :delete, :remove_related_issue, :id => 1, :rev => 4, :issue_id => 2, :format => 'js'
                    assert_response :success
                    assert_equal 'text/javascript', response.content_type
                  end
                  assert_equal [1], Changeset.find(103).issue_ids
                  assert_include 'related-issue-2', response.body
                end
                def test_graph_commits_per_month
                  # Make sure there's some data to display
                  latest = Project.find(1).repository.changesets.maximum(:commit_date)
                  assert_not_nil latest
                  Date.stubs(:today).returns(latest.to_date + 10)
                  get :graph, :id => 1, :graph => 'commits_per_month'
                  assert_response :success
                  assert_equal 'image/svg+xml', @response.content_type
                end
                def test_graph_commits_per_author
                  get :graph, :id => 1, :graph => 'commits_per_author'
                  assert_response :success
                  assert_equal 'image/svg+xml', @response.content_type
                end
                def test_get_committers
                  @request.session[:user_id] = 2
                  # add a commit with an unknown user
                  Changeset.create!(
                      :repository => Project.find(1).repository,
                      :committer  => 'foo',
                      :committed_on => Time.now,
                      :revision => 100,
                      :comments => 'Committed by foo.'
                   )
                  get :committers, :id => 10
                  assert_response :success
                  assert_select 'input[value=dlopper] + select option[value="3"][selected=selected]', :text => 'Dave Lopper'
                  assert_select 'input[value=foo] + select option[selected=selected]', 0 # no option selected
                end
                def test_get_committers_without_changesets
                  Changeset.delete_all
                  @request.session[:user_id] = 2
                  get :committers, :id => 10
                  assert_response :success
                end
                def test_post_committers
                  @request.session[:user_id] = 2
                  # add a commit with an unknown user
                  c = Changeset.create!(
                          :repository => Project.find(1).repository,
                          :committer  => 'foo',
                          :committed_on => Time.now,
                          :revision => 100,
                          :comments => 'Committed by foo.'
                        )
                  assert_no_difference "Changeset.where(:user_id => 3).count" do
                    post :committers, :id => 10, :committers => { '0' => ['foo', '2'], '1' => ['dlopper', '3']}
                    assert_response 302
                    assert_equal User.find(2), c.reload.user
                  end
                end
              end

test/functional/repositories_git_controller_test.rb +4 -4

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 RepositoriesGitControllerTest < Redmine::ControllerTest
                tests RepositoriesController
                fixtures :projects, :users, :email_addresses, :roles, :members, :member_roles,
                         :repositories, :enabled_modules
                REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s
                REPOSITORY_PATH.gsub!(/\//, "\\") if Redmine::Platform.mswin?
                PRJ_ID     = 3
                CHAR_1_HEX = "\xc3\x9c".force_encoding('UTF-8')
                FELIX_HEX  = "Felix Sch\xC3\xA4fer".force_encoding('UTF-8')
                NUM_REV = 28
                ## Git, Mercurial and CVS path encodings are binary.
                ## Subversion supports URL encoding for path.
                ## Redmine Mercurial adapter and extension use URL encoding.
                ## Git accepts only binary path in command line parameter.
                ## So, there is no way to use binary command line parameter in JRuby.
                JRUBY_SKIP     = (RUBY_PLATFORM == 'java')
                JRUBY_SKIP_STR = "TODO: This test fails in JRuby"
                def setup
                  @ruby19_non_utf8_pass = Encoding.default_external.to_s != 'UTF-8'
                  User.current = nil
                  @project    = Project.find(PRJ_ID)
                  @repository = Repository::Git.create(
                                    :project       => @project,
                                    :url           => REPOSITORY_PATH,
                                    :path_encoding => 'ISO-8859-1'
                                    )
                  assert @repository
                end
                def test_create_and_update
                  @request.session[:user_id] = 1
                  assert_difference 'Repository.count' do
                    post :create, :project_id => 'subproject1',
                                  :repository_scm => 'Git',
                                  :repository => {
                                     :url => '/test',
                                     :is_default => '0',
                                     :identifier => 'test-create',
-                                    :extra_report_last_commit => '1',
+                                    :report_last_commit => '1',
                                   }
                  end
                  assert_response 302
                  repository = Repository.order('id DESC').first
                  assert_kind_of Repository::Git, repository
                  assert_equal '/test', repository.url
-                 assert_equal true, repository.extra_report_last_commit
+                 assert_equal true, repository.report_last_commit
                  put :update, :id => repository.id,
                               :repository => {
-                                  :extra_report_last_commit => '0'
+                                :report_last_commit => '0'
                               }
                  assert_response 302
                  repo2 = Repository.find(repository.id)
-                 assert_equal false, repo2.extra_report_last_commit
+                 assert_equal false, repo2.report_last_commit
                end
                if File.directory?(REPOSITORY_PATH)
                  ## Ruby uses ANSI api to fork a process on Windows.
                  ## Japanese Shift_JIS and Traditional Chinese Big5 have 0x5c(backslash) problem
                  ## and these are incompatible with ASCII.
                  ## Git for Windows (msysGit) changed internal API from ANSI to Unicode in 1.7.10
                  ## http://code.google.com/p/msysgit/issues/detail?id=80
                  ## So, Latin-1 path tests fail on Japanese Windows
                  WINDOWS_PASS = (Redmine::Platform.mswin? &&
                                       Redmine::Scm::Adapters::GitAdapter.client_version_above?([1, 7, 10]))
                  WINDOWS_SKIP_STR = "TODO: This test fails in Git for Windows above 1.7.10"
                  def test_get_new
                    @request.session[:user_id] = 1
                    @project.repository.destroy
                    get :new, :project_id => 'subproject1', :repository_scm => 'Git'
                    assert_response :success
                    assert_select 'select[name=?]', 'repository_scm' do
                      assert_select 'option[value=?][selected=selected]', 'Git'
                    end
                  end
                  def test_browse_root
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID
                    assert_response :success
                    assert_select 'table.entries tbody' do
                      assert_select 'tr', 9
                      assert_select 'tr.dir td.filename_no_report a', :text => 'images'
                      assert_select 'tr.dir td.filename_no_report a', :text => 'this_is_a_really_long_and_verbose_directory_name'
                      assert_select 'tr.dir td.filename_no_report a', :text => 'sources'
                      assert_select 'tr.file td.filename_no_report a', :text => 'README'
                      assert_select 'tr.file td.filename_no_report a', :text => 'copied_README'
                      assert_select 'tr.file td.filename_no_report a', :text => 'new_file.txt'
                      assert_select 'tr.file td.filename_no_report a', :text => 'renamed_test.txt'
                      assert_select 'tr.file td.filename_no_report a', :text => 'filemane with spaces.txt'
                      assert_select 'tr.file td.filename_no_report a', :text => 'filename with a leading space.txt'
                    end
                    assert_select 'table.changesets tbody' do
                      assert_select 'tr'
                    end
                  end
                  def test_browse_branch
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :rev => 'test_branch'
                    assert_response :success
                    assert_select 'table.entries tbody' do
                      assert_select 'tr', 4
                      assert_select 'tr.dir td.filename_no_report a', :text => 'images'
                      assert_select 'tr.dir td.filename_no_report a', :text => 'sources'
                      assert_select 'tr.file td.filename_no_report a', :text => 'README'
                      assert_select 'tr.file td.filename_no_report a', :text => 'test.txt'
                    end
                    assert_select 'table.changesets tbody' do
                      assert_select 'tr'
                    end
                  end
                  def test_browse_tag
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                     [
                      "tag00.lightweight",
                      "tag01.annotated",
                     ].each do |t1|
                      get :show, :id => PRJ_ID, :rev => t1
                      assert_response :success
                      assert_select 'table.entries tbody tr'
                      assert_select 'table.changesets tbody tr'
                    end
                  end
                  def test_browse_directory
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param]
                    assert_response :success
                    assert_select 'table.entries tbody' do
                      assert_select 'tr', 1
                      assert_select 'tr.file td.filename_no_report a', :text => 'edit.png'
                    end
                    assert_select 'table.changesets tbody tr'
                  end
                  def test_browse_at_given_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :show, :id => PRJ_ID, :path => repository_path_hash(['images'])[:param],
                        :rev => '7234cb2750b63f47bff735edc50a1c0a433c2518'
                    assert_response :success
                    assert_select 'table.entries tbody' do
                      assert_select 'tr', 1
                      assert_select 'tr.file td.filename_no_report a', :text => 'delete.png'
                    end
                  end
                  def test_changes
                    get :changes, :id => PRJ_ID,
                        :path => repository_path_hash(['images', 'edit.png'])[:param]
                    assert_response :success
                    assert_select 'h2', :text => /edit.png/
                  end
                  def test_entry_show
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    # Line 11
                    assert_select 'tr#L11 td.line-code', :text => /WITHOUT ANY WARRANTY/
                  end
                  def test_entry_show_latin_1
                    if @ruby19_non_utf8_pass
                      puts_ruby19_non_utf8_pass()
                    elsif WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                        ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|
                          get :entry, :id => PRJ_ID,
                              :path => repository_path_hash(['latin-1-dir', "test-#{CHAR_1_HEX}.txt"])[:param],
                              :rev => r1
                          assert_response :success
                          assert_select 'tr#L1 td.line-code', :text => /test-#{CHAR_1_HEX}.txt/
                        end
                      end
                    end
                  end
                  def test_entry_download
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],
                        :format => 'raw'
                    assert_response :success
                    # File content
                    assert @response.body.include?('WITHOUT ANY WARRANTY')
                  end
                  def test_directory_entry
                    get :entry, :id => PRJ_ID,
                        :path => repository_path_hash(['sources'])[:param]
                    assert_response :success
                    assert_select 'h2 a', :text => 'sources'
                    assert_select 'table.entries tbody'
                  end
                  def test_diff
                    assert_equal true, @repository.is_default
                    assert @repository.identifier.blank?
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    # Full diff of changeset 2f9c0091
                    ['inline', 'sbs'].each do |dt|
                      get :diff,
                          :id   => PRJ_ID,
                          :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                          :type => dt
                      assert_response :success
                      # Line 22 removed
                      assert_select 'th.line-num:contains(22) ~ td.diff_out', :text => /def remove/
                      assert_select 'h2', :text => /2f9c0091/
                    end
                  end
                  def test_diff_with_rev_and_path
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    with_settings :diff_max_lines_displayed => 1000 do
                      # Full diff of changeset 2f9c0091
                      ['inline', 'sbs'].each do |dt|
                        get :diff,
                            :id   => PRJ_ID,
                            :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                            :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],
                            :type => dt
                        assert_response :success
                        # Line 22 removed
                        assert_select 'th.line-num:contains(22) ~ td.diff_out', :text => /def remove/
                        assert_select 'h2', :text => /2f9c0091/
                      end
                    end
                  end
                  def test_diff_truncated
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    with_settings :diff_max_lines_displayed => 5 do
                      # Truncated diff of changeset 2f9c0091
                      with_cache do
                        with_settings :default_language => 'en' do
                          get :diff, :id   => PRJ_ID, :type => 'inline',
                              :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                          assert_response :success
                          assert @response.body.include?("... This diff was truncated")
                        end
                        with_settings :default_language => 'fr' do
                          get :diff, :id   => PRJ_ID, :type => 'inline',
                              :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                          assert_response :success
                          assert ! @response.body.include?("... This diff was truncated")
                          assert @response.body.include?("... Ce diff")
                        end
                      end
                    end
                  end
                  def test_diff_two_revs
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['inline', 'sbs'].each do |dt|
                      get :diff,
                          :id     => PRJ_ID,
                          :rev    => '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                          :rev_to => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                          :type   => dt
                      assert_response :success
                      assert_select 'h2', :text => /2f9c0091:61b685fb/
                      assert_select 'form[action=?]', '/projects/subproject1/repository/revisions/61b685fbe55ab05b5ac68402d5720c1a6ac973d1/diff'
                      assert_select 'input#rev_to[type=hidden][name=rev_to][value=?]', '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                    end
                  end
                  def test_diff_path_in_subrepo
                    repo = Repository::Git.create(
                                    :project       => @project,
                                    :url           => REPOSITORY_PATH,
                                    :identifier => 'test-diff-path',
                                    :path_encoding => 'ISO-8859-1'
                                    )
                    assert repo
                    assert_equal false, repo.is_default
                    assert_equal 'test-diff-path', repo.identifier
                    get :diff,
                        :id     => PRJ_ID,
                        :repository_id => 'test-diff-path',
                        :rev    => '61b685fbe55ab05b',
                        :rev_to => '2f9c0091c754a91a',
                        :type   => 'inline'
                    assert_response :success
                    assert_select 'form[action=?]', '/projects/subproject1/repository/test-diff-path/revisions/61b685fbe55ab05b/diff'
                    assert_select 'input#rev_to[type=hidden][name=rev_to][value=?]', '2f9c0091c754a91a'
                  end
                  def test_diff_latin_1
                    if @ruby19_non_utf8_pass
                      puts_ruby19_non_utf8_pass()
                    else
                      with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                        ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|
                          ['inline', 'sbs'].each do |dt|
                            get :diff, :id => PRJ_ID, :rev => r1, :type => dt
                            assert_response :success
                            assert_select 'table' do
                              assert_select 'thead th.filename', :text => /latin-1-dir\/test-#{CHAR_1_HEX}.txt/
                              assert_select 'tbody td.diff_in', :text => /test-#{CHAR_1_HEX}.txt/
                            end
                          end
                        end
                      end
                    end
                  end
                  def test_diff_should_show_filenames
                    get :diff, :id => PRJ_ID, :rev => 'deff712f05a90d96edbd70facc47d944be5897e3', :type => 'inline'
                    assert_response :success
                    # modified file
                    assert_select 'th.filename', :text => 'sources/watchers_controller.rb'
                    # deleted file
                    assert_select 'th.filename', :text => 'test.txt'
                  end
                  def test_save_diff_type
                    user1 = User.find(1)
                    user1.pref[:diff_type] = nil
                    user1.preference.save
                    user = User.find(1)
                    assert_nil user.pref[:diff_type]
                    @request.session[:user_id] = 1 # admin
                    get :diff,
                        :id   => PRJ_ID,
                        :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7'
                    assert_response :success
                    user.reload
                    assert_equal "inline", user.pref[:diff_type]
                    get :diff,
                        :id   => PRJ_ID,
                        :rev  => '2f9c0091c754a91af7a9c478e36556b4bde8dcf7',
                        :type => 'sbs'
                    assert_response :success
                    user.reload
                    assert_equal "sbs", user.pref[:diff_type]
                  end
                  def test_annotate
                    get :annotate, :id => PRJ_ID,
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    # Line 23, changeset 2f9c0091
                    assert_select 'tr' do
                      assert_select 'th.line-num', :text => '23'
                      assert_select 'td.revision', :text => /2f9c0091/
                      assert_select 'td.author', :text => 'jsmith'
                      assert_select 'td', :text => /remove_watcher/
                    end
                  end
                  def test_annotate_at_given_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :annotate, :id => PRJ_ID, :rev => 'deff7',
                        :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param]
                    assert_response :success
                    assert_select 'h2', :text => /@ deff712f/
                  end
                  def test_annotate_binary_file
                    with_settings :default_language => 'en' do
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash(['images', 'edit.png'])[:param]
                      assert_response :success
                      assert_select 'p#errorExplanation', :text => /cannot be annotated/
                    end
                  end
                  def test_annotate_error_when_too_big
                    with_settings :file_max_size_displayed => 1 do
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash(['sources', 'watchers_controller.rb'])[:param],
                          :rev => 'deff712f'
                      assert_response :success
                      assert_select 'p#errorExplanation', :text => /exceeds the maximum text file size/
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash(['README'])[:param],
                          :rev => '7234cb2'
                      assert_response :success
                    end
                  end
                  def test_annotate_latin_1
                    if @ruby19_non_utf8_pass
                      puts_ruby19_non_utf8_pass()
                    elsif WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      with_settings :repositories_encodings => 'UTF-8,ISO-8859-1' do
                        ['57ca437c', '57ca437c0acbbcb749821fdf3726a1367056d364'].each do |r1|
                          get :annotate, :id => PRJ_ID,
                              :path => repository_path_hash(['latin-1-dir', "test-#{CHAR_1_HEX}.txt"])[:param],
                              :rev => r1
                          assert_select "th.line-num", :text => '1' do
                            assert_select "+ td.revision" do
                              assert_select "a", :text => '57ca437c'
                              assert_select "+ td.author", :text => "jsmith" do
                                assert_select "+ td",
                                              :text => "test-#{CHAR_1_HEX}.txt"
                              end
                            end
                          end
                        end
                      end
                    end
                  end
                  def test_annotate_latin_1_author
                    ['83ca5fd546063a3c7dc2e568ba3355661a9e2b2c', '83ca5fd546063a'].each do |r1|
                      get :annotate, :id => PRJ_ID,
                          :path => repository_path_hash([" filename with a leading space.txt "])[:param],
                          :rev => r1
                      assert_select "th.line-num", :text => '1' do
                        assert_select "+ td.revision" do
                          assert_select "a", :text => '83ca5fd5'
                          assert_select "+ td.author", :text => FELIX_HEX do
                            assert_select "+ td",
                                          :text => "And this is a file with a leading and trailing space..."
                          end
                        end
                      end
                    end
                  end
                  def test_revisions
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    get :revisions, :id => PRJ_ID
                    assert_select 'form[method=get][action=?]', '/projects/subproject1/repository/revision'
                  end
                  def test_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['61b685fbe55ab05b5ac68402d5720c1a6ac973d1', '61b685f'].each do |r|
                      get :revision, :id => PRJ_ID, :rev => r
                      assert_response :success
                    end
                  end
                  def test_empty_revision
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['', ' ', nil].each do |r|
                      get :revision, :id => PRJ_ID, :rev => r
                      assert_response 404
                      assert_select_error /was not found/
                    end
                  end
                  def test_destroy_valid_repository
                    @request.session[:user_id] = 1 # admin
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                  def test_destroy_invalid_repository
                    @request.session[:user_id] = 1 # admin
                    @project.repository.destroy
                    @repository = Repository::Git.create!(
                                    :project       => @project,
                                    :url           => "/invalid",
                                    :path_encoding => 'ISO-8859-1'
                                    )
                    @repository.fetch_changesets
                    @repository.reload
                    assert_equal 0, @repository.changesets.count
                    assert_difference 'Repository.count', -1 do
                      delete :destroy, :id => @repository.id
                    end
                    assert_response 302
                    @project.reload
                    assert_nil @project.repository
                  end
                  private
                  def puts_ruby19_non_utf8_pass
                    puts "TODO: This test fails " +
                         "when Encoding.default_external is not UTF-8. " +
                         "Current value is '#{Encoding.default_external.to_s}'"
                  end
                else
                  puts "Git test repository NOT FOUND. Skipping functional tests !!!"
                  def test_fake; assert true end
                end
                private
                def with_cache(&block)
                  before = ActionController::Base.perform_caching
                  ActionController::Base.perform_caching = true
                  block.call
                  ActionController::Base.perform_caching = before
                end
              end

test/unit/repository_git_test.rb +4 -13

              # Redmine - project management software
              # Copyright (C) 2006-2016  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 RepositoryGitTest < ActiveSupport::TestCase
                fixtures :projects, :repositories, :enabled_modules, :users, :roles
                include Redmine::I18n
                REPOSITORY_PATH = Rails.root.join('tmp/test/git_repository').to_s
                REPOSITORY_PATH.gsub!(/\//, "\\") if Redmine::Platform.mswin?
                NUM_REV = 28
                NUM_HEAD = 6
                FELIX_HEX  = "Felix Sch\xC3\xA4fer".force_encoding('UTF-8')
                CHAR_1_HEX = "\xc3\x9c".force_encoding('UTF-8')
                ## Git, Mercurial and CVS path encodings are binary.
                ## Subversion supports URL encoding for path.
                ## Redmine Mercurial adapter and extension use URL encoding.
                ## Git accepts only binary path in command line parameter.
                ## So, there is no way to use binary command line parameter in JRuby.
                JRUBY_SKIP     = (RUBY_PLATFORM == 'java')
                JRUBY_SKIP_STR = "TODO: This test fails in JRuby"
                def setup
                  @project = Project.find(3)
                  @repository = Repository::Git.create(
                                      :project       => @project,
                                      :url           => REPOSITORY_PATH,
                                      :path_encoding => 'ISO-8859-1'
                                      )
                  assert @repository
                end
                def test_nondefault_repo_with_blank_identifier_destruction
                  Repository.delete_all
                  repo1 = Repository::Git.new(
                                        :project    => @project,
                                        :url        => REPOSITORY_PATH,
                                        :identifier => '',
                                        :is_default => true
                                      )
                  assert repo1.save
                  repo1.fetch_changesets
                  repo2 = Repository::Git.new(
                                        :project    => @project,
                                        :url        => REPOSITORY_PATH,
                                        :identifier => 'repo2',
                                        :is_default => true
                                  )
                  assert repo2.save
                  repo2.fetch_changesets
                  repo1.reload
                  repo2.reload
                  assert !repo1.is_default?
                  assert  repo2.is_default?
                  assert_difference 'Repository.count', -1 do
                    repo1.destroy
                  end
                end
                def test_blank_path_to_repository_error_message
                  set_language_if_valid 'en'
                  repo = Repository::Git.new(
                                        :project      => @project,
                                        :identifier   => 'test'
                                      )
                  assert !repo.save
                  assert_include "Path to repository cannot be blank",
                                 repo.errors.full_messages
                end
                def test_blank_path_to_repository_error_message_fr
                  set_language_if_valid 'fr'
                  str = "Chemin du d\xc3\xa9p\xc3\xb4t doit \xc3\xaatre renseign\xc3\xa9(e)".force_encoding('UTF-8')
                  repo = Repository::Git.new(
                                        :project      => @project,
                                        :url          => "",
                                        :identifier   => 'test',
                                        :path_encoding => ''
                                      )
                  assert !repo.save
                  assert_include str, repo.errors.full_messages
                end
                if File.directory?(REPOSITORY_PATH)
                  ## Ruby uses ANSI api to fork a process on Windows.
                  ## Japanese Shift_JIS and Traditional Chinese Big5 have 0x5c(backslash) problem
                  ## and these are incompatible with ASCII.
                  ## Git for Windows (msysGit) changed internal API from ANSI to Unicode in 1.7.10
                  ## http://code.google.com/p/msysgit/issues/detail?id=80
                  ## So, Latin-1 path tests fail on Japanese Windows
                  WINDOWS_PASS = (Redmine::Platform.mswin? &&
                                       Redmine::Scm::Adapters::GitAdapter.client_version_above?([1, 7, 10]))
                  WINDOWS_SKIP_STR = "TODO: This test fails in Git for Windows above 1.7.10"
                  def test_scm_available
                    klass = Repository::Git
                    assert_equal "Git", klass.scm_name
                    assert klass.scm_adapter_class
                    assert_not_equal "", klass.scm_command
                    assert_equal true, klass.scm_available
                  end
                  def test_entries
                    entries = @repository.entries
                    assert_kind_of Redmine::Scm::Adapters::Entries, entries
                  end
                  def test_fetch_changesets_from_scratch
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_equal 39, @repository.filechanges.count
                    commit = @repository.changesets.find_by_revision("7234cb2750b63f47bff735edc50a1c0a433c2518")
                    assert_equal "7234cb2750b63f47bff735edc50a1c0a433c2518", commit.scmid
                    assert_equal "Initial import.\nThe repository contains 3 files.", commit.comments
                    assert_equal "jsmith <jsmith@foo.bar>", commit.committer
                    assert_equal User.find_by_login('jsmith'), commit.user
                    # TODO: add a commit with commit time <> author time to the test repository
                    assert_equal Time.gm(2007, 12, 14, 9, 22, 52), commit.committed_on
                    assert_equal "2007-12-14".to_date, commit.commit_date
                    assert_equal 3, commit.filechanges.count
                    change = commit.filechanges.sort_by(&:path).first
                    assert_equal "README", change.path
                    assert_equal nil, change.from_path
                    assert_equal "A", change.action
                    assert_equal NUM_HEAD, @repository.extra_info["heads"].size
                  end
                  def test_fetch_changesets_incremental
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    extra_info_heads = @repository.extra_info["heads"].dup
                    assert_equal NUM_HEAD, extra_info_heads.size
                    extra_info_heads.delete_if { |x| x == "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c" }
                    assert_equal 4, extra_info_heads.size
                    del_revs = [
                        "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c",
                        "ed5bb786bbda2dee66a2d50faf51429dbc043a7b",
                        "4f26664364207fa8b1af9f8722647ab2d4ac5d43",
                        "deff712f05a90d96edbd70facc47d944be5897e3",
                        "32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf",
                        "7e61ac704deecde634b51e59daa8110435dcb3da",
                       ]
                    @repository.changesets.each do |rev|
                      rev.destroy if del_revs.detect {|r| r == rev.scmid.to_s }
                    end
                    @project.reload
                    cs1 = @repository.changesets
                    assert_equal NUM_REV - 6, cs1.count
                    extra_info_heads << "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8"
                    h = {}
                    h["heads"] = extra_info_heads
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    assert @repository.extra_info["heads"].index("4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8")
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_equal NUM_HEAD, @repository.extra_info["heads"].size
                    assert @repository.extra_info["heads"].index("83ca5fd546063a3c7dc2e568ba3355661a9e2b2c")
                  end
                  def test_fetch_changesets_history_editing
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    extra_info_heads = @repository.extra_info["heads"].dup
                    assert_equal NUM_HEAD, extra_info_heads.size
                    extra_info_heads.delete_if { |x| x == "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c" }
                    assert_equal 4, extra_info_heads.size
                    del_revs = [
                        "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c",
                        "ed5bb786bbda2dee66a2d50faf51429dbc043a7b",
                        "4f26664364207fa8b1af9f8722647ab2d4ac5d43",
                        "deff712f05a90d96edbd70facc47d944be5897e3",
                        "32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf",
                        "7e61ac704deecde634b51e59daa8110435dcb3da",
                       ]
                    @repository.changesets.each do |rev|
                      rev.destroy if del_revs.detect {|r| r == rev.scmid.to_s }
                    end
                    @project.reload
                    assert_equal NUM_REV - 6, @repository.changesets.count
                    c = Changeset.new(:repository   => @repository,
                                      :committed_on => Time.now,
                                      :revision     => "abcd1234efgh",
                                      :scmid        => "abcd1234efgh",
                                      :comments     => 'test')
                    assert c.save
                    @project.reload
                    assert_equal NUM_REV - 5, @repository.changesets.count
                    extra_info_heads << "1234abcd5678"
                    h = {}
                    h["heads"] = extra_info_heads
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    h1 = @repository.extra_info["heads"].dup
                    assert h1.index("1234abcd5678")
                    assert_equal 5, h1.size
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV - 5, @repository.changesets.count
                    h2 = @repository.extra_info["heads"].dup
                    assert_equal h1, h2
                  end
-                 def test_keep_extra_report_last_commit_in_clear_changesets
+                 def test_clear_changesets_should_keep_report_last_commit
                    assert_nil @repository.extra_info
-                   h = {}
-                   h["extra_report_last_commit"] = "1"
-                   @repository.merge_extra_info(h)
+                   @repository.report_last_commit = "1"
                    @repository.save
-                   @project.reload
-                   assert_equal 0, @repository.changesets.count
-                   @repository.fetch_changesets
-                   @project.reload
-                   assert_equal NUM_REV, @repository.changesets.count
                    @repository.send(:clear_changesets)
-                   assert_equal 1, @repository.extra_info.size
-                   assert_equal "1", @repository.extra_info["extra_report_last_commit"]
+                   assert_equal true, @repository.report_last_commit
                  end
                  def test_refetch_after_clear_changesets
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    @repository.send(:clear_changesets)
                    @project.reload
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                  end
                  def test_parents
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    r1 = @repository.find_changeset_by_name("7234cb2750b63")
                    assert_equal [], r1.parents
                    r2 = @repository.find_changeset_by_name("899a15dba03a3")
                    assert_equal 1, r2.parents.length
                    assert_equal "7234cb2750b63f47bff735edc50a1c0a433c2518",
                                 r2.parents[0].identifier
                    r3 = @repository.find_changeset_by_name("32ae898b720c2")
                    assert_equal 2, r3.parents.length
                    r4 = [r3.parents[0].identifier, r3.parents[1].identifier].sort
                    assert_equal "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8", r4[0]
                    assert_equal "7e61ac704deecde634b51e59daa8110435dcb3da", r4[1]
                  end
                  def test_db_consistent_ordering_init
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal 1, @repository.extra_info["db_consistent"]["ordering"]
                  end
                  def test_db_consistent_ordering_before_1_2
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_not_nil @repository.extra_info
                    h = {}
                    h["heads"] = []
                    h["branches"] = {}
                    h["db_consistent"] = {}
                    @repository.merge_extra_info(h)
                    @repository.save
                    assert_equal NUM_REV, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal 0, @repository.extra_info["db_consistent"]["ordering"]
                    extra_info_heads = @repository.extra_info["heads"].dup
                    extra_info_heads.delete_if { |x| x == "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c" }
                    del_revs = [
                        "83ca5fd546063a3c7dc2e568ba3355661a9e2b2c",
                        "ed5bb786bbda2dee66a2d50faf51429dbc043a7b",
                        "4f26664364207fa8b1af9f8722647ab2d4ac5d43",
                        "deff712f05a90d96edbd70facc47d944be5897e3",
                        "32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf",
                        "7e61ac704deecde634b51e59daa8110435dcb3da",
                       ]
                    @repository.changesets.each do |rev|
                      rev.destroy if del_revs.detect {|r| r == rev.scmid.to_s }
                    end
                    @project.reload
                    cs1 = @repository.changesets
                    assert_equal NUM_REV - 6, cs1.count
                    assert_equal 0, @repository.extra_info["db_consistent"]["ordering"]
                    extra_info_heads << "4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8"
                    h = {}
                    h["heads"] = extra_info_heads
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    assert @repository.extra_info["heads"].index("4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8")
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    assert_equal NUM_HEAD, @repository.extra_info["heads"].size
                    assert_equal 0, @repository.extra_info["db_consistent"]["ordering"]
                  end
                  def test_heads_from_branches_hash
                    assert_nil @repository.extra_info
                    assert_equal 0, @repository.changesets.count
                    assert_equal [], @repository.heads_from_branches_hash
                    h = {}
                    h["branches"] = {}
                    h["branches"]["test1"] = {}
                    h["branches"]["test1"]["last_scmid"] = "1234abcd"
                    h["branches"]["test2"] = {}
                    h["branches"]["test2"]["last_scmid"] = "abcd1234"
                    @repository.merge_extra_info(h)
                    @repository.save
                    @project.reload
                    assert_equal ["1234abcd", "abcd1234"], @repository.heads_from_branches_hash.sort
                  end
                  def test_latest_changesets
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    # with limit
                    changesets = @repository.latest_changesets('', 'master', 2)
                    assert_equal 2, changesets.size
                    # with path
                    changesets = @repository.latest_changesets('images', 'master')
                    assert_equal [
                            'deff712f05a90d96edbd70facc47d944be5897e3',
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', nil)
                    assert_equal [
                            '32ae898b720c2f7eec2723d5bdd558b4cb2d3ddf',
                            '4a07fe31bffcf2888791f3e6cbc9c4545cefe3e8',
                            '713f4944648826f558cf548222f813dabe7cbb04',
                            '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    # with path, revision and limit
                    changesets = @repository.latest_changesets('images', '899a15dba')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('images', '899a15dba', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', '899a15dba')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', '899a15dba', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    # with path, tag and limit
                    changesets = @repository.latest_changesets('images', 'tag01.annotated')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('images', 'tag01.annotated', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'tag01.annotated')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'tag01.annotated', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    # with path, branch and limit
                    changesets = @repository.latest_changesets('images', 'test_branch')
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('images', 'test_branch', 1)
                    assert_equal [
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'test_branch')
                    assert_equal [
                            '713f4944648826f558cf548222f813dabe7cbb04',
                            '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                            '899a15dba03a3b350b89c3f537e4bbe02a03cdc9',
                            '7234cb2750b63f47bff735edc50a1c0a433c2518',
                        ], changesets.collect(&:revision)
                    changesets = @repository.latest_changesets('README', 'test_branch', 2)
                    assert_equal [
                            '713f4944648826f558cf548222f813dabe7cbb04',
                            '61b685fbe55ab05b5ac68402d5720c1a6ac973d1',
                        ], changesets.collect(&:revision)
                    if WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      # latin-1 encoding path
                      changesets = @repository.latest_changesets(
                                    "latin-1-dir/test-#{CHAR_1_HEX}-2.txt", '64f1f3e89')
                      assert_equal [
                            '64f1f3e89ad1cb57976ff0ad99a107012ba3481d',
                            '4fc55c43bf3d3dc2efb66145365ddc17639ce81e',
                        ], changesets.collect(&:revision)
                      changesets = @repository.latest_changesets(
                                  "latin-1-dir/test-#{CHAR_1_HEX}-2.txt", '64f1f3e89', 1)
                      assert_equal [
                            '64f1f3e89ad1cb57976ff0ad99a107012ba3481d',
                        ], changesets.collect(&:revision)
                    end
                  end
                  def test_latest_changesets_latin_1_dir
                    if WINDOWS_PASS
                      puts WINDOWS_SKIP_STR
                    elsif JRUBY_SKIP
                      puts JRUBY_SKIP_STR
                    else
                      assert_equal 0, @repository.changesets.count
                      @repository.fetch_changesets
                      @project.reload
                      assert_equal NUM_REV, @repository.changesets.count
                      changesets = @repository.latest_changesets(
                                  "latin-1-dir/test-#{CHAR_1_HEX}-subdir", '1ca7f5ed')
                      assert_equal [
                            '1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127',
                        ], changesets.collect(&:revision)
                    end
                  end
                  def test_find_changeset_by_name
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['7234cb2750b63f47bff735edc50a1c0a433c2518', '7234cb2750b'].each do |r|
                      assert_equal '7234cb2750b63f47bff735edc50a1c0a433c2518',
                                   @repository.find_changeset_by_name(r).revision
                    end
                  end
                  def test_find_changeset_by_empty_name
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    ['', ' ', nil].each do |r|
                      assert_nil @repository.find_changeset_by_name(r)
                    end
                  end
                  def test_identifier
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    c = @repository.changesets.find_by_revision(
                                        '7234cb2750b63f47bff735edc50a1c0a433c2518')
                    assert_equal c.scmid, c.identifier
                  end
                  def test_format_identifier
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    c = @repository.changesets.find_by_revision(
                                        '7234cb2750b63f47bff735edc50a1c0a433c2518')
                    assert_equal '7234cb27', c.format_identifier
                  end
                  def test_activities
                    c = Changeset.new(:repository => @repository,
                                      :committed_on => Time.now,
                                      :revision => 'abc7234cb2750b63f47bff735edc50a1c0a433c2',
                                      :scmid    => 'abc7234cb2750b63f47bff735edc50a1c0a433c2',
                                      :comments => 'test')
                    assert c.event_title.include?('abc7234c:')
                    assert_equal 'abc7234cb2750b63f47bff735edc50a1c0a433c2', c.event_url[:rev]
                  end
                  def test_log_utf8
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    c = @repository.changesets.find_by_revision(
                                      'ed5bb786bbda2dee66a2d50faf51429dbc043a7b')
                    assert_equal "#{FELIX_HEX} <felix@fachschaften.org>", c.committer
                  end
                  def test_previous
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127 1ca7f5ed|.each do |r1|
                      changeset = @repository.find_changeset_by_name(r1)
                      %w|64f1f3e89ad1cb57976ff0ad99a107012ba3481d 64f1f3e89ad1|.each do |r2|
                        assert_equal @repository.find_changeset_by_name(r2), changeset.previous
                      end
                    end
                  end
                  def test_previous_nil
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|7234cb2750b63f47bff735edc50a1c0a433c2518 7234cb275|.each do |r1|
                      changeset = @repository.find_changeset_by_name(r1)
                      assert_nil changeset.previous
                    end
                  end
                  def test_next
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|64f1f3e89ad1cb57976ff0ad99a107012ba3481d 64f1f3e89ad1|.each do |r2|
                      changeset = @repository.find_changeset_by_name(r2)
                      %w|1ca7f5ed374f3cb31a93ae5215c2e25cc6ec5127 1ca7f5ed|.each do |r1|
                      assert_equal @repository.find_changeset_by_name(r1), changeset.next
                      end
                    end
                  end
                  def test_next_nil
                    assert_equal 0, @repository.changesets.count
                    @repository.fetch_changesets
                    @project.reload
                    assert_equal NUM_REV, @repository.changesets.count
                    %w|2a682156a3b6e77a8bf9cd4590e8db757f3c6c78 2a682156a3b6e77a|.each do |r1|
                      changeset = @repository.find_changeset_by_name(r1)
                      assert_nil changeset.next
                    end
                  end
                else
                  puts "Git test repository NOT FOUND. Skipping unit tests !!!"
                  def test_fake; assert true 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