summaryrefslogtreecommitdiffstats
path: root/app/helpers/repositories_helper.rb
blob: 7a6978979fb776546287a79e12a2ea348a13b27e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
# frozen_string_literal: true

# Redmine - project management software
# Copyright (C) 2006-  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_pagination
    pagination_links_each @paginator do |text, parameters, options|
      if entry = @entries[parameters[:page] - 1]
        ent_path = Redmine::CodesetUtil.replace_invalid_utf8(entry.path)
        link_to text, {action: 'entry', id: @project, repository_id: @repository.identifier_param, path: to_path_param(ent_path), rev: @rev}
      end
    end if @paginator
  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').filter_map do |change|
      case change.action
      when 'A'
        # Detects moved/copied files
        if change.from_path.present?
          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

    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', :url => new_project_repository_path(repository.project)})
  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 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(
                  :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_by!(&: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