Move helpers back to original directory

app/controllers/application_controller.rb

 require 'gon'
 class ApplicationController < ActionController::Base
-  def self.railtie_helpers_paths
-    "app/helpers/gitlab"
-  end
-
   include Gitlab::CurrentSettings
-  include Gitlab::GitlabRoutingHelper
-  include Gitlab::PageLayoutHelper
+  include GitlabRoutingHelper
+  include PageLayoutHelper
   PER_PAGE = 20

app/controllers/oauth/applications_controller.rb

 class Oauth::ApplicationsController < Doorkeeper::ApplicationsController
   include Gitlab::CurrentSettings
-  include Gitlab::PageLayoutHelper
-  
+  include PageLayoutHelper
+
   before_action :verify_user_oauth_applications_enabled
   before_action :authenticate_user!

app/controllers/oauth/authorized_applications_controller.rb

 class Oauth::AuthorizedApplicationsController < Doorkeeper::AuthorizedApplicationsController
-  include Gitlab::PageLayoutHelper
+  include PageLayoutHelper
   layout 'profile'

app/controllers/projects/network_controller.rb

 class Projects::NetworkController < Projects::ApplicationController
   include ExtractsPath
-  include Gitlab::ApplicationHelper
+  include ApplicationHelper
   before_action :require_non_empty_project
   before_action :assign_ref_vars

app/controllers/projects/refs_controller.rb

 class Projects::RefsController < Projects::ApplicationController
   include ExtractsPath
-  include Gitlab::TreeHelper
+  include TreeHelper
   before_action :require_non_empty_project
   before_action :assign_ref_vars

app/controllers/projects/wikis_controller.rb

@@ -5,7 +5,7 @@ class Projects::WikisController < Projects::ApplicationController
   before_action :authorize_create_wiki!, only: [:edit, :create, :history]
   before_action :authorize_admin_wiki!, only: :destroy
   before_action :load_project_wiki
-  include Gitlab::WikiHelper
+  #include WikiHelper
   def pages
     @wiki_pages = Kaminari.paginate_array(@project_wiki.pages).page(params[:page]).per(PER_PAGE)

app/controllers/search_controller.rb

 class SearchController < ApplicationController
-  include Gitlab::SearchHelper
+  include SearchHelper
   layout 'search'

app/helpers/appearances_helper.rb

+module AppearancesHelper
+  def brand_item
+    nil
+  end
+
+  def brand_title
+    'GitLab Community Edition'
+  end
+
+  def brand_image
+    nil
+  end
+
+  def brand_text
+    nil
+  end
+
+  def brand_header_logo
+    image_tag 'logo.svg'
+  end
+end

app/helpers/application_helper.rb

+require 'digest/md5'
+require 'uri'
+
+module ApplicationHelper
+  # Check if a particular controller is the current one
+  #
+  # args - One or more controller names to check
+  #
+  # Examples
+  #
+  #   # On TreeController
+  #   current_controller?(:tree)           # => true
+  #   current_controller?(:commits)        # => false
+  #   current_controller?(:commits, :tree) # => true
+  def current_controller?(*args)
+    args.any? { |v| v.to_s.downcase == controller.controller_name }
+  end
+
+  # Check if a particular action is the current one
+  #
+  # args - One or more action names to check
+  #
+  # Examples
+  #
+  #   # On Projects#new
+  #   current_action?(:new)           # => true
+  #   current_action?(:create)        # => false
+  #   current_action?(:new, :create)  # => true
+  def current_action?(*args)
+    args.any? { |v| v.to_s.downcase == action_name }
+  end
+
+  def project_icon(project_id, options = {})
+    project =
+      if project_id.is_a?(Project)
+        project = project_id
+      else
+        Project.find_with_namespace(project_id)
+      end
+
+    if project.avatar_url
+      image_tag project.avatar_url, options
+    else # generated icon
+      project_identicon(project, options)
+    end
+  end
+
+  def project_identicon(project, options = {})
+    allowed_colors = {
+      red: 'FFEBEE',
+      purple: 'F3E5F5',
+      indigo: 'E8EAF6',
+      blue: 'E3F2FD',
+      teal: 'E0F2F1',
+      orange: 'FBE9E7',
+      gray: 'EEEEEE'
+    }
+
+    options[:class] ||= ''
+    options[:class] << ' identicon'
+    bg_key = project.id % 7
+    style = "background-color: ##{ allowed_colors.values[bg_key] }; color: #555"
+
+    content_tag(:div, class: options[:class], style: style) do
+      project.name[0, 1].upcase
+    end
+  end
+
+  def avatar_icon(user_email = '', size = nil)
+    user = User.find_by(email: user_email)
+
+    if user
+      user.avatar_url(size) || default_avatar
+    else
+      gravatar_icon(user_email, size)
+    end
+  end
+
+  def gravatar_icon(user_email = '', size = nil)
+    GravatarService.new.execute(user_email, size) ||
+      default_avatar
+  end
+
+  def default_avatar
+    image_path('no_avatar.png')
+  end
+
+  def last_commit(project)
+    if project.repo_exists?
+      time_ago_with_tooltip(project.repository.commit.committed_date)
+    else
+      'Never'
+    end
+  rescue
+    'Never'
+  end
+
+  def grouped_options_refs
+    repository = @project.repository
+
+    options = [
+      ['Branches', repository.branch_names],
+      ['Tags', VersionSorter.rsort(repository.tag_names)]
+    ]
+
+    # If reference is commit id - we should add it to branch/tag selectbox
+    if(@ref && !options.flatten.include?(@ref) &&
+       @ref =~ /\A[0-9a-zA-Z]{6,52}\z/)
+      options << ['Commit', [@ref]]
+    end
+
+    grouped_options_for_select(options, @ref || @project.default_branch)
+  end
+
+  def emoji_autocomplete_source
+    # should be an array of strings
+    # so to_s can be called, because it is sufficient and to_json is too slow
+    Emoji.names.to_s
+  end
+
+  # Define whenever show last push event
+  # with suggestion to create MR
+  def show_last_push_widget?(event)
+    # Skip if event is not about added or modified non-master branch
+    return false unless event && event.last_push_to_non_root? && !event.rm_ref?
+
+    project = event.project
+
+    # Skip if project repo is empty or MR disabled
+    return false unless project && !project.empty_repo? && project.merge_requests_enabled
+
+    # Skip if user already created appropriate MR
+    return false if project.merge_requests.where(source_branch: event.branch_name).opened.any?
+
+    # Skip if user removed branch right after that
+    return false unless project.repository.branch_names.include?(event.branch_name)
+
+    true
+  end
+
+  def hexdigest(string)
+    Digest::SHA1.hexdigest string
+  end
+
+  def simple_sanitize(str)
+    sanitize(str, tags: %w(a span))
+  end
+
+  def body_data_page
+    path = controller.controller_path.split('/')
+    namespace = path.first if path.second
+
+    [namespace, controller.controller_name, controller.action_name].compact.join(':')
+  end
+
+  # shortcut for gitlab config
+  def gitlab_config
+    Gitlab.config.gitlab
+  end
+
+  # shortcut for gitlab extra config
+  def extra_config
+    Gitlab.config.extra
+  end
+
+  def search_placeholder
+    if @project && @project.persisted?
+      'Search in this project'
+    elsif @snippet || @snippets || @show_snippets
+      'Search snippets'
+    elsif @group && @group.persisted?
+      'Search in this group'
+    else
+      'Search'
+    end
+  end
+
+  def broadcast_message
+    BroadcastMessage.current
+  end
+
+  # Render a `time` element with Javascript-based relative date and tooltip
+  #
+  # time       - Time object
+  # placement  - Tooltip placement String (default: "top")
+  # html_class - Custom class for `time` element (default: "time_ago")
+  # skip_js    - When true, exclude the `script` tag (default: false)
+  #
+  # By default also includes a `script` element with Javascript necessary to
+  # initialize the `timeago` jQuery extension. If this method is called many
+  # times, for example rendering hundreds of commits, it's advisable to disable
+  # this behavior using the `skip_js` argument and re-initializing `timeago`
+  # manually once all of the elements have been rendered.
+  #
+  # A `js-timeago` class is always added to the element, even when a custom
+  # `html_class` argument is provided.
+  #
+  # Returns an HTML-safe String
+  def time_ago_with_tooltip(time, placement: 'top', html_class: 'time_ago', skip_js: false)
+    element = content_tag :time, time.to_s,
+      class: "#{html_class} js-timeago",
+      datetime: time.getutc.iso8601,
+      title: time.in_time_zone.stamp('Aug 21, 2011 9:23pm'),
+      data: { toggle: 'tooltip', placement: placement }
+
+    element += javascript_tag "$('.js-timeago').timeago()" unless skip_js
+
+    element
+  end
+
+  def render_markup(file_name, file_content)
+    if gitlab_markdown?(file_name)
+      Haml::Helpers.preserve(markdown(file_content))
+    elsif asciidoc?(file_name)
+      asciidoc(file_content)
+    elsif plain?(file_name)
+      content_tag :pre, class: 'plain-readme' do
+        file_content
+      end
+    else
+      GitHub::Markup.render(file_name, file_content).
+        force_encoding(file_content.encoding).html_safe
+    end
+  rescue RuntimeError
+    simple_format(file_content)
+  end
+
+  def plain?(filename)
+    Gitlab::MarkupHelper.plain?(filename)
+  end
+
+  def markup?(filename)
+    Gitlab::MarkupHelper.markup?(filename)
+  end
+
+  def gitlab_markdown?(filename)
+    Gitlab::MarkupHelper.gitlab_markdown?(filename)
+  end
+
+  def asciidoc?(filename)
+    Gitlab::MarkupHelper.asciidoc?(filename)
+  end
+
+  def promo_host
+    'about.gitlab.com'
+  end
+
+  def promo_url
+    'https://' + promo_host
+  end
+
+  def page_filter_path(options = {})
+    without = options.delete(:without)
+
+    exist_opts = {
+      state: params[:state],
+      scope: params[:scope],
+      label_name: params[:label_name],
+      milestone_id: params[:milestone_id],
+      assignee_id: params[:assignee_id],
+      author_id: params[:author_id],
+      sort: params[:sort],
+    }
+
+    options = exist_opts.merge(options)
+
+    if without.present?
+      without.each do |key|
+        options.delete(key)
+      end
+    end
+
+    path = request.path
+    path << "?#{options.to_param}"
+    path
+  end
+
+  def outdated_browser?
+    browser.ie? && browser.version.to_i < 10
+  end
+
+  def path_to_key(key, admin = false)
+    if admin
+      admin_user_key_path(@user, key)
+    else
+      profile_key_path(key)
+    end
+  end
+
+  def state_filters_text_for(entity, project)
+    titles = {
+      opened: "Open"
+    }
+
+    entity_title = titles[entity] || entity.to_s.humanize
+
+    count =
+      if project.nil?
+        nil
+      elsif current_controller?(:issues)
+        project.issues.send(entity).count
+      elsif current_controller?(:merge_requests)
+        project.merge_requests.send(entity).count
+      end
+
+    html = content_tag :span, entity_title
+
+    if count.present?
+      html += " "
+      html += content_tag :span, number_with_delimiter(count), class: 'badge'
+    end
+
+    html.html_safe
+  end
+end

app/helpers/application_settings_helper.rb

+module ApplicationSettingsHelper
+  def gravatar_enabled?
+    current_application_settings.gravatar_enabled?
+  end
+
+  def twitter_sharing_enabled?
+    current_application_settings.twitter_sharing_enabled?
+  end
+
+  def signup_enabled?
+    current_application_settings.signup_enabled?
+  end
+
+  def signin_enabled?
+    current_application_settings.signin_enabled?
+  end
+
+  def extra_sign_in_text
+    current_application_settings.sign_in_text
+  end
+
+  def user_oauth_applications?
+    current_application_settings.user_oauth_applications
+  end
+
+  # Return a group of checkboxes that use Bootstrap's button plugin for a
+  # toggle button effect.
+  def restricted_level_checkboxes(help_block_id)
+    Gitlab::VisibilityLevel.options.map do |name, level|
+      checked = restricted_visibility_levels(true).include?(level)
+      css_class = 'btn'
+      css_class += ' active' if checked
+      checkbox_name = 'application_setting[restricted_visibility_levels][]'
+
+      label_tag(checkbox_name, class: css_class) do
+        check_box_tag(checkbox_name, level, checked,
+                      autocomplete: 'off',
+                      'aria-describedby' => help_block_id) + name
+      end
+    end
+  end
+
+  # Return a group of checkboxes that use Bootstrap's button plugin for a
+  # toggle button effect.
+  def import_sources_checkboxes(help_block_id)
+    Gitlab::ImportSources.options.map do |name, source|
+      checked = current_application_settings.import_sources.include?(source)
+      css_class = 'btn'
+      css_class += ' active' if checked
+      checkbox_name = 'application_setting[import_sources][]'
+
+      label_tag(checkbox_name, class: css_class) do
+        check_box_tag(checkbox_name, source, checked,
+                      autocomplete: 'off',
+                      'aria-describedby' => help_block_id) + name
+      end
+    end
+  end
+end

app/helpers/auth_helper.rb

+module AuthHelper
+  PROVIDERS_WITH_ICONS = %w(twitter github gitlab bitbucket google_oauth2).freeze
+  FORM_BASED_PROVIDERS = [/\Aldap/, 'kerberos', 'crowd'].freeze
+
+  def ldap_enabled?
+    Gitlab.config.ldap.enabled
+  end
+
+  def provider_has_icon?(name)
+    PROVIDERS_WITH_ICONS.include?(name.to_s)
+  end
+
+  def auth_providers
+    Gitlab::OAuth::Provider.providers
+  end
+
+  def label_for_provider(name)
+    Gitlab::OAuth::Provider.label_for(name)
+  end
+
+  def form_based_provider?(name)
+    FORM_BASED_PROVIDERS.any? { |pattern| pattern === name.to_s }
+  end
+
+  def form_based_providers
+    auth_providers.select { |provider| form_based_provider?(provider) }
+  end
+
+  def crowd_enabled?
+    auth_providers.include? :crowd
+  end
+
+  def button_based_providers
+    auth_providers.reject { |provider| form_based_provider?(provider) }
+  end
+
+  def provider_image_tag(provider, size = 64)
+    label = label_for_provider(provider)
+
+    if provider_has_icon?(provider)
+      file_name = "#{provider.to_s.split('_').first}_#{size}.png"
+
+      image_tag(image_path("auth_buttons/#{file_name}"), alt: label, title: "Sign in with #{label}")
+    else
+      label
+    end
+  end
+
+  def auth_active?(provider)
+    current_user.identities.exists?(provider: provider.to_s)
+  end
+
+  extend self
+end

app/helpers/blob_helper.rb

+module BlobHelper
+  def highlight(blob_name, blob_content, nowrap: false, continue: false)
+    @formatter ||= Rouge::Formatters::HTMLGitlab.new(
+      nowrap: nowrap,
+      cssclass: 'code highlight',
+      lineanchors: true,
+      lineanchorsid: 'LC'
+    )
+
+    begin
+      @lexer ||= Rouge::Lexer.guess(filename: blob_name, source: blob_content).new
+      result = @formatter.format(@lexer.lex(blob_content, continue: continue)).html_safe
+    rescue
+      @lexer = Rouge::Lexers::PlainText
+      result = @formatter.format(@lexer.lex(blob_content)).html_safe
+    end
+
+    result
+  end
+
+  def no_highlight_files
+    %w(credits changelog news copying copyright license authors)
+  end
+
+  def edit_blob_link(project, ref, path, options = {})
+    blob =
+      begin
+        project.repository.blob_at(ref, path)
+      rescue
+        nil
+      end
+
+    if blob && blob.text?
+      text = 'Edit'
+      after = options[:after] || ''
+      from_mr = options[:from_merge_request_id]
+      link_opts = {}
+      link_opts[:from_merge_request_id] = from_mr if from_mr
+      cls = 'btn btn-small'
+      if allowed_tree_edit?(project, ref)
+        link_to(text,
+                namespace_project_edit_blob_path(project.namespace, project,
+                                                 tree_join(ref, path),
+                                                 link_opts),
+                class: cls
+               )
+      else
+        content_tag :span, text, class: cls + ' disabled'
+      end + after.html_safe
+    else
+      ''
+    end
+  end
+
+  def leave_edit_message
+    "Leave edit mode?\nAll unsaved changes will be lost."
+  end
+
+  def editing_preview_title(filename)
+    if Gitlab::MarkupHelper.previewable?(filename)
+      'Preview'
+    else
+      'Preview changes'
+    end
+  end
+
+  # Return an image icon depending on the file mode and extension
+  #
+  # mode - File unix mode
+  # mode - File name
+  def blob_icon(mode, name)
+    icon("#{file_type_icon_class('file', mode, name)} fw")
+  end
+end

app/helpers/branches_helper.rb

+module BranchesHelper
+  def can_remove_branch?(project, branch_name)
+    if project.protected_branch? branch_name
+      false
+    elsif branch_name == project.repository.root_ref
+      false
+    else
+      can?(current_user, :push_code, project)
+    end
+  end
+
+  def can_push_branch?(project, branch_name)
+    return false unless project.repository.branch_names.include?(branch_name)
+    
+    ::Gitlab::GitAccess.new(current_user, project).can_push_to_branch?(branch_name)
+  end
+end

app/helpers/broadcast_messages_helper.rb

+module BroadcastMessagesHelper
+  def broadcast_styling(broadcast_message)
+    styling = ''
+
+    if broadcast_message.color.present?
+      styling << "background-color: #{broadcast_message.color}"
+      styling << '; ' if broadcast_message.font.present?
+    end
+
+    if broadcast_message.font.present?
+      styling << "color: #{broadcast_message.font}"
+    end
+
+    styling
+  end
+end

app/helpers/commits_helper.rb

+# encoding: utf-8
+module CommitsHelper
+  # Returns a link to the commit author. If the author has a matching user and
+  # is a member of the current @project it will link to the team member page.
+  # Otherwise it will link to the author email as specified in the commit.
+  #
+  # options:
+  #  avatar: true will prepend the avatar image
+  #  size:   size of the avatar image in px
+  def commit_author_link(commit, options = {})
+    commit_person_link(commit, options.merge(source: :author))
+  end
+
+  # Just like #author_link but for the committer.
+  def commit_committer_link(commit, options = {})
+    commit_person_link(commit, options.merge(source: :committer))
+  end
+
+  def image_diff_class(diff)
+    if diff.deleted_file
+      "deleted"
+    elsif diff.new_file
+      "added"
+    else
+      nil
+    end
+  end
+
+  def commit_to_html(commit, project, inline = true)
+    template = inline ? "inline_commit" : "commit"
+    escape_javascript(render "projects/commits/#{template}", commit: commit, project: project) unless commit.nil?
+  end
+
+  # Breadcrumb links for a Project and, if applicable, a tree path
+  def commits_breadcrumbs
+    return unless @project && @ref
+
+    # Add the root project link and the arrow icon
+    crumbs = content_tag(:li) do
+      link_to(
+        @project.path,
+        namespace_project_commits_path(@project.namespace, @project, @ref)
+      )
+    end
+
+    if @path
+      parts = @path.split('/')
+
+      parts.each_with_index do |part, i|
+        crumbs << content_tag(:li) do
+          # The text is just the individual part, but the link needs all the parts before it
+          link_to(
+            part,
+            namespace_project_commits_path(
+              @project.namespace,
+              @project,
+              tree_join(@ref, parts[0..i].join('/'))
+            )
+          )
+        end
+      end
+    end
+
+    crumbs.html_safe
+  end
+
+  # Return Project default branch, if it present in array
+  # Else - first branch in array (mb last actual branch)
+  def commit_default_branch(project, branches)
+    branches.include?(project.default_branch) ? branches.delete(project.default_branch) : branches.pop
+  end
+
+  # Returns the sorted alphabetically links to branches, separated by a comma
+  def commit_branches_links(project, branches)
+    branches.sort.map do |branch|
+      link_to(
+        namespace_project_tree_path(project.namespace, project, branch)
+      ) do
+        content_tag :span, class: 'label label-gray' do
+          icon('code-fork') + ' ' + branch
+        end
+      end
+    end.join(" ").html_safe
+  end
+
+  # Returns the sorted links to tags, separated by a comma
+  def commit_tags_links(project, tags)
+    sorted = VersionSorter.rsort(tags)
+    sorted.map do |tag|
+      link_to(
+        namespace_project_commits_path(project.namespace, project,
+                                       project.repository.find_tag(tag).name)
+      ) do
+        content_tag :span, class: 'label label-gray' do
+          icon('tag') + ' ' + tag
+        end
+      end
+    end.join(" ").html_safe
+  end
+
+  def link_to_browse_code(project, commit)
+    if current_controller?(:projects, :commits)
+      if @repo.blob_at(commit.id, @path)
+        return link_to(
+          "Browse File »",
+          namespace_project_blob_path(project.namespace, project,
+                                      tree_join(commit.id, @path)),
+          class: "pull-right"
+        )
+      elsif @path.present?
+        return link_to(
+          "Browse Dir »",
+          namespace_project_tree_path(project.namespace, project,
+                                      tree_join(commit.id, @path)),
+          class: "pull-right"
+        )
+      end
+    end
+    link_to(
+      "Browse Code »",
+      namespace_project_tree_path(project.namespace, project, commit),
+      class: "pull-right"
+    )
+  end
+
+  protected
+
+  # Private: Returns a link to a person. If the person has a matching user and
+  # is a member of the current @project it will link to the team member page.
+  # Otherwise it will link to the person email as specified in the commit.
+  #
+  # options:
+  #  source: one of :author or :committer
+  #  avatar: true will prepend the avatar image
+  #  size:   size of the avatar image in px
+  def commit_person_link(commit, options = {})
+    user = commit.send(options[:source])
+    
+    source_name = clean(commit.send "#{options[:source]}_name".to_sym)
+    source_email = clean(commit.send "#{options[:source]}_email".to_sym)
+
+    person_name = user.try(:name) || source_name
+    person_email = user.try(:email) || source_email
+
+    text =
+      if options[:avatar]
+        avatar = image_tag(avatar_icon(person_email, options[:size]), class: "avatar #{"s#{options[:size]}" if options[:size]}", width: options[:size], alt: "")
+        %Q{#{avatar} <span class="commit-#{options[:source]}-name">#{person_name}</span>}
+      else
+        person_name
+      end
+
+    options = {
+      class: "commit-#{options[:source]}-link has_tooltip",
+      data: { :'original-title' => sanitize(source_email) }
+    }
+
+    if user.nil?
+      mail_to(source_email, text.html_safe, options)
+    else
+      link_to(text.html_safe, user_path(user), options)
+    end
+  end
+
+  def view_file_btn(commit_sha, diff, project)
+    link_to(
+      namespace_project_blob_path(project.namespace, project,
+                                  tree_join(commit_sha, diff.new_path)),
+      class: 'btn btn-small view-file js-view-file'
+    ) do
+      raw('View file @') + content_tag(:span, commit_sha[0..6],
+                                       class: 'commit-short-id')
+    end
+  end
+
+  def truncate_sha(sha)
+    Commit.truncate_sha(sha)
+  end
+
+  def clean(string)
+    Sanitize.clean(string, remove_contents: true)
+  end
+end

app/helpers/compare_helper.rb

+module CompareHelper
+  def create_mr_button?(from = params[:from], to = params[:to], project = @project)
+    from.present? &&
+      to.present? &&
+      from != to &&
+      project.merge_requests_enabled &&
+      project.repository.branch_names.include?(from) &&
+      project.repository.branch_names.include?(to)
+  end
+
+  def create_mr_path(from = params[:from], to = params[:to], project = @project)
+    new_namespace_project_merge_request_path(
+      project.namespace,
+      project,
+      merge_request: {
+        source_branch: to,
+        target_branch: from
+      }
+    )
+  end
+end

app/helpers/dashboard_helper.rb

+module DashboardHelper
+  def assigned_issues_dashboard_path
+    issues_dashboard_path(assignee_id: current_user.id)
+  end
+
+  def assigned_mrs_dashboard_path
+    merge_requests_dashboard_path(assignee_id: current_user.id)
+  end
+end

app/helpers/diff_helper.rb

+module DiffHelper
+  def allowed_diff_size
+    if diff_hard_limit_enabled?
+      Commit::DIFF_HARD_LIMIT_FILES
+    else
+      Commit::DIFF_SAFE_FILES
+    end
+  end
+
+  def allowed_diff_lines
+    if diff_hard_limit_enabled?
+      Commit::DIFF_HARD_LIMIT_LINES
+    else
+      Commit::DIFF_SAFE_LINES
+    end
+  end
+
+  def safe_diff_files(diffs)
+    lines = 0
+    safe_files = []
+    diffs.first(allowed_diff_size).each do |diff|
+      lines += diff.diff.lines.count
+      break if lines > allowed_diff_lines
+      safe_files << Gitlab::Diff::File.new(diff)
+    end
+    safe_files
+  end
+
+  def diff_hard_limit_enabled?
+    # Enabling hard limit allows user to see more diff information
+    if params[:force_show_diff].present?
+      true
+    else
+      false
+    end
+  end
+
+  def generate_line_code(file_path, line)
+    Gitlab::Diff::LineCode.generate(file_path, line.new_pos, line.old_pos)
+  end
+
+  def parallel_diff(diff_file, index)
+    lines = []
+    skip_next = false
+
+    # Building array of lines
+    #
+    # [
+    # left_type, left_line_number, left_line_content, left_line_code,
+    # right_line_type, right_line_number, right_line_content, right_line_code
+    # ]
+    #
+    diff_file.diff_lines.each do |line|
+
+      full_line = line.text
+      type = line.type
+      line_code = generate_line_code(diff_file.file_path, line)
+      line_new = line.new_pos
+      line_old = line.old_pos
+
+      next_line = diff_file.next_line(line.index)
+
+      if next_line
+        next_line_code = generate_line_code(diff_file.file_path, next_line)
+        next_type = next_line.type
+        next_line = next_line.text
+      end
+
+      if type == 'match' || type.nil?
+        # line in the right panel is the same as in the left one
+        line = [type, line_old, full_line, line_code, type, line_new, full_line, line_code]
+        lines.push(line)
+      elsif type == 'old'
+        if next_type == 'new'
+          # Left side has text removed, right side has text added
+          line = [type, line_old, full_line, line_code, next_type, line_new, next_line, next_line_code]
+          lines.push(line)
+          skip_next = true
+        elsif next_type == 'old' || next_type.nil?
+          # Left side has text removed, right side doesn't have any change
+          # No next line code, no new line number, no new line text
+          line = [type, line_old, full_line, line_code, next_type, nil, "&nbsp;", nil]
+          lines.push(line)
+        end
+      elsif type == 'new'
+        if skip_next
+          # Change has been already included in previous line so no need to do it again
+          skip_next = false
+          next
+        else
+          # Change is only on the right side, left side has no change
+          line = [nil, nil, "&nbsp;", line_code, type, line_new, full_line, line_code]
+          lines.push(line)
+        end
+      end
+    end
+    lines
+  end
+
+  def unfold_bottom_class(bottom)
+    (bottom) ? 'js-unfold-bottom' : ''
+  end
+
+  def unfold_class(unfold)
+    (unfold) ? 'unfold js-unfold' : ''
+  end
+
+  def diff_line_content(line)
+    if line.blank?
+      " &nbsp;"
+    else
+      line
+    end
+  end
+
+  def line_comments
+    @line_comments ||= @line_notes.select(&:active?).group_by(&:line_code)
+  end
+
+  def organize_comments(type_left, type_right, line_code_left, line_code_right)
+    comments_left = comments_right = nil
+
+    unless type_left.nil? && type_right == 'new'
+      comments_left = line_comments[line_code_left]
+    end
+
+    unless type_left.nil? && type_right.nil?
+      comments_right = line_comments[line_code_right]
+    end
+
+    [comments_left, comments_right]
+  end
+
+  def inline_diff_btn
+    params_copy = params.dup
+    params_copy[:view] = 'inline'
+    # Always use HTML to handle case where JSON diff rendered this button
+    params_copy.delete(:format)
+
+    link_to url_for(params_copy), id: "inline-diff-btn", class: (params[:view] != 'parallel' ? 'btn btn-sm active' : 'btn btn-sm') do
+      'Inline'
+    end
+  end
+
+  def parallel_diff_btn
+    params_copy = params.dup
+    params_copy[:view] = 'parallel'
+    # Always use HTML to handle case where JSON diff rendered this button
+    params_copy.delete(:format)
+
+    link_to url_for(params_copy), id: "parallel-diff-btn", class: (params[:view] == 'parallel' ? 'btn active btn-sm' : 'btn btn-sm') do
+      'Side-by-side'
+    end
+  end
+
+  def submodule_link(blob, ref, repository = @repository)
+    tree, commit = submodule_links(blob, ref, repository)
+    commit_id = if commit.nil?
+                  blob.id[0..10]
+                else
+                  link_to "#{blob.id[0..10]}", commit
+                end
+
+    [
+      content_tag(:span, link_to(truncate(blob.name, length: 40), tree)),
+      '@',
+      content_tag(:span, commit_id, class: 'monospace'),
+    ].join(' ').html_safe
+  end
+end

app/helpers/emails_helper.rb

+module EmailsHelper
+
+  # Google Actions
+  # https://developers.google.com/gmail/markup/reference/go-to-action
+  def email_action(url)
+    name = action_title(url)
+    if name
+      data = {
+        "@context" => "http://schema.org",
+        "@type" => "EmailMessage",
+        "action" => {
+          "@type" => "ViewAction",
+          "name" => name,
+          "url" => url,
+          }
+        }
+
+      content_tag :script, type: 'application/ld+json' do
+        data.to_json.html_safe
+      end
+    end
+  end
+
+  def action_title(url)
+    return unless url
+    ["merge_requests", "issues", "commit"].each do |action|
+      if url.split("/").include?(action)
+        return "View #{action.humanize.singularize}"
+      end
+    end
+  end
+
+  def color_email_diff(diffcontent)
+    formatter = Rouge::Formatters::HTML.new(css_class: 'highlight', inline_theme: 'github')
+    lexer = Rouge::Lexers::Diff
+    raw formatter.format(lexer.lex(diffcontent))
+  end
+
+  def password_reset_token_valid_time
+    valid_hours = Devise.reset_password_within / 60 / 60
+    if valid_hours >= 24
+      unit = 'day'
+      valid_length = (valid_hours / 24).floor
+    else
+      unit = 'hour'
+      valid_length = valid_hours.floor
+    end
+
+    pluralize(valid_length, unit)
+  end
+
+  def reset_token_expire_message
+    link_tag = link_to('request a new one', new_user_password_url(user_email: @user.email))
+    msg = "This link is valid for #{password_reset_token_valid_time}.  "
+    msg << "After it expires, you can #{link_tag}."
+  end
+end

app/helpers/events_helper.rb

+module EventsHelper
+  def link_to_author(event)
+    author = event.author
+
+    if author
+      link_to author.name, user_path(author.username)
+    else
+      event.author_name
+    end
+  end
+
+  def event_action_name(event)
+    target =  if event.target_type
+                if event.note?
+                  event.note_target_type
+                else
+                  event.target_type.titleize.downcase
+                end
+              else
+                'project'
+              end
+
+    [event.action_name, target].join(" ")
+  end
+
+  def event_filter_link(key, tooltip)
+    key = key.to_s
+    active = 'active' if @event_filter.active?(key)
+    link_opts = {
+      class: "event-filter-link btn btn-default #{active}",
+      id:    "#{key}_event_filter",
+      title: "Filter by #{tooltip.downcase}",
+    }
+
+    link_to request.path, link_opts do
+      content_tag(:span, ' ' + tooltip)
+    end
+  end
+
+  def icon_for_event
+    {
+      EventFilter.push     => 'upload',
+      EventFilter.merged   => 'check-square-o',
+      EventFilter.comments => 'comments',
+      EventFilter.team     => 'user',
+    }
+  end
+
+  def event_feed_title(event)
+    words = []
+    words << event.author_name
+    words << event_action_name(event)
+
+    if event.push?
+      words << event.ref_type
+      words << event.ref_name
+      words << "at"
+    elsif event.commented?
+      if event.note_commit?
+        words << event.note_short_commit_id
+      else
+        words << "##{truncate event.note_target_iid}"
+      end
+      words << "at"
+    elsif event.target
+      words << "##{event.target_iid}:"
+      words << event.target.title if event.target.respond_to?(:title)
+      words << "at"
+    end
+
+    words << event.project_name
+
+    words.join(" ")
+  end
+
+  def event_feed_url(event)
+    if event.issue?
+      namespace_project_issue_url(event.project.namespace, event.project,
+                                  event.issue)
+    elsif event.merge_request?
+      namespace_project_merge_request_url(event.project.namespace,
+                                          event.project, event.merge_request)
+    elsif event.note? && event.note_commit?
+      namespace_project_commit_url(event.project.namespace, event.project,
+                                   event.note_target)
+    elsif event.note?
+      if event.note_target
+        if event.note_commit?
+          namespace_project_commit_path(event.project.namespace, event.project,
+                                        event.note_commit_id,
+                                        anchor: dom_id(event.target))
+        elsif event.note_project_snippet?
+          namespace_project_snippet_path(event.project.namespace,
+                                         event.project, event.note_target)
+        else
+          event_note_target_path(event)
+        end
+      end
+    elsif event.push?
+      if event.push_with_commits? && event.md_ref?
+        if event.commits_count > 1
+          namespace_project_compare_url(event.project.namespace, event.project,
+                                        from: event.commit_from, to:
+                                        event.commit_to)
+        else
+          namespace_project_commit_url(event.project.namespace, event.project,
+                                       id: event.commit_to)
+        end
+      else
+        namespace_project_commits_url(event.project.namespace, event.project,
+                                      event.ref_name)
+      end
+    end
+  end
+
+  def event_feed_summary(event)
+    if event.issue?
+      render "events/event_issue", issue: event.issue
+    elsif event.push?
+      render "events/event_push", event: event
+    elsif event.merge_request?
+      render "events/event_merge_request", merge_request: event.merge_request
+    elsif event.note?
+      render "events/event_note", note: event.note
+    end
+  end
+
+  def event_note_target_path(event)
+    if event.note? && event.note_commit?
+      namespace_project_commit_path(event.project.namespace, event.project,
+                                    event.note_target)
+    else
+      polymorphic_path([event.project.namespace.becomes(Namespace),
+                        event.project, event.note_target],
+                       anchor: dom_id(event.target))
+    end
+  end
+
+  def event_note_title_html(event)
+    if event.note_target
+      if event.note_commit?
+        link_to(
+          namespace_project_commit_path(event.project.namespace, event.project,
+                                        event.note_commit_id,
+                                        anchor: dom_id(event.target)),
+          class: "commit_short_id"
+        ) do
+          "#{event.note_target_type} #{event.note_short_commit_id}"
+        end
+      elsif event.note_project_snippet?
+        link_to(namespace_project_snippet_path(event.project.namespace,
+                                               event.project,
+                                               event.note_target)) do
+          "#{event.note_target_type} ##{truncate event.note_target_id}"
+        end
+      else
+        link_to event_note_target_path(event) do
+          "#{event.note_target_type} ##{truncate event.note_target_iid}"
+        end
+      end
+    else
+      content_tag :strong do
+        "(deleted)"
+      end
+    end
+  end
+
+  def event_note(text, options = {})
+    text = first_line_in_markdown(text, 150, options)
+    sanitize(text, tags: %w(a img b pre code p span))
+  end
+
+  def event_commit_title(message)
+    escape_once(truncate(message.split("\n").first, length: 70))
+  rescue
+    "--broken encoding"
+  end
+
+  def event_to_atom(xml, event)
+    if event.proper?
+      xml.entry do
+        event_link = event_feed_url(event)
+        event_title = event_feed_title(event)
+        event_summary = event_feed_summary(event)
+
+        xml.id      "tag:#{request.host},#{event.created_at.strftime("%Y-%m-%d")}:#{event.id}"
+        xml.link    href: event_link
+        xml.title   truncate(event_title, length: 80)
+        xml.updated event.created_at.xmlschema
+        xml.media   :thumbnail, width: "40", height: "40", url: avatar_icon(event.author_email)
+        xml.author do |author|
+          xml.name event.author_name
+          xml.email event.author_email
+        end
+
+        xml.summary(type: "xhtml") { |x| x << event_summary unless event_summary.nil? }
+      end
+    end
+  end
+end