Redmine

  # Adds a related issue to a changeset

  # POST /projects/:project_id/repository/(:repository_id/)revisions/:rev/issues

  def add_related_issue

    @issue = @changeset.find_referenced_issue_by_id(issue_id)

    if @issue && (!@issue.visible? || @changeset.issues.include?(@issue))

      @issue = nil

    @deliveries = ActionMailer::Base.perform_deliveries

    @guessed_host_and_path = request.host_with_port.dup

    @commit_update_keywords = Setting.commit_update_keywords.dup

    @commit_update_keywords = [{}] unless @commit_update_keywords.is_a?(Array) && @commit_update_keywords.any?

  def permissions

    if @roles && @trackers

      @custom_fields = @trackers.map(&:custom_fields).flatten.uniq.sort

      @permissions = WorkflowPermission.rules_by_status_id(@trackers, @roles)

      @statuses.each {|status| @permissions[status.id] ||= {}}

    case detail.property

    when 'attr'

      case detail.prop_key

      when 'due_date', 'start_date'

        value = format_date(detail.value.to_date) if detail.value

                        :sortable => "#{Issue.table_name}.is_private", :groupable => true)

    end

    disabled_fields << "total_estimated_hours" if disabled_fields.include?("estimated_hours")

    @available_columns.reject! do |column|

      disabled_fields.include?(column.name.to_s)

  def sql_for_notes_field(field, operator, value)

    subquery = "SELECT 1 FROM #{Journal.table_name}" +

      " WHERE #{Journal.table_name}.journalized_type='Issue' AND #{Journal.table_name}.journalized_id=#{Issue.table_name}.id" +

      " AND (#{Journal.visible_notes_condition(User.current, :skip_pre_condition => true)})"

    "#{/^!/.match?(operator) ? "NOT EXISTS" : "EXISTS"} (#{subquery})"

  end

  def initialize(field, options)

    @field = field.to_s

    @options = options

    # Consider filters with a Proc for values as remote by default

    @remote = options.key?(:remote) ? options[:remote] : options[:values].is_a?(Proc)

  end

  <% Tracker::CORE_FIELDS.each do |field| %>

  <label class="block">

    <%= check_box_tag 'tracker[core_fields][]', field, @tracker.core_fields.include?(field), :id => nil %>

  </label>

  <% end %>

</p>

      </tr>

      <% Tracker::CORE_FIELDS.each do |field| %>

      <tr>

        <td class="name">

          <%= link_to_function('', "toggleCheckboxesBySelector('input.core-field-#{field}')",

                               :title => "#{l(:button_check_all)}/#{l(:button_uncheck_all)}",

  class Base

    # Translate attribute names for validation errors display

    def self.human_attribute_name(attr, options = {})

      class_prefix = name.underscore.tr('/', '_')

      redmine_default = [

      if both_git_diff

        if file_name && arg == "/dev/null"

          # keep the original file name

        else

          # remove leading a/

          # remove leading b/

          @previous_file_name = nil if @previous_file_name == @file_name

        end

        Dir.glob(

          "#{Redmine::Plugin.directory}/*/app/views/my/blocks/_*.{rhtml,erb}"

        ).inject({}) do |h, file|

          h[name] = {:label => name.to_sym, :partial => "my/blocks/#{name}"}

          h

        end

      def assets(dir, ext=nil)

        if ext

        else

          Dir.glob("#{path}/#{dir}/*").collect {|f| File.basename(f)}

        end

      end

      def shortened_filename(source_file)

      end

      def link_to_source_file(source_file)

  def custom_field_classes

    files =

      Dir.glob(File.join(Rails.root, 'app/models/*_custom_field.rb')).

    classes = files.map {|x| x.classify.constantize}

    assert classes.size > 0

    classes