Redmine

      if (key = api_key_from_request)

        # Use API key

        user = User.find_by_api_key(key)

        # HTTP Basic, either username/password or API key/random

        authenticate_with_http_basic do |username, password|

          user = User.try_to_login(username, password) || User.find_by_api_key(username)

    path = uri.to_s

    # Ensure that the remaining URL starts with a slash, followed by a

    # non-slash character or the end

      return false

    end

      return false

    end

  # Returns a string that can be used as filename value in Content-Disposition header

  def filename_for_content_disposition(name)

  end

  def api_request?

    @rev = params[:rev].blank? ? @repository.default_branch : params[:rev].to_s.strip

    @rev_to = params[:rev_to]

      if @repository.branches.blank?

        raise InvalidRevisionParam

      end

    scope = Project.active.has_module(:repository)

    if params[:id]

      project = nil

        project = scope.find(params[:id])

      else

        project = scope.find_by_identifier(params[:id])

        group = :label_relations

      elsif field_options[:type] == :tree

        group = query.is_a?(IssueQuery) ? :label_relations : nil

        group = (field_options[:through] || field_options[:field]).try(:name)

      elsif field =~ /^(.+)\./

        # association filters

  end

  def is_diff?

  end

  def is_pdf?

  def self.disk_filename(filename, directory=nil)

    timestamp = DateTime.now.strftime("%y%m%d%H%M%S")

    ascii = ''

      ascii = filename

    else

      ascii = Digest::MD5.hexdigest(filename)

  # Returns the full path of the file to import

  # It is stored in tmp/imports with a random hex as filename

  def filepath

      File.join(Rails.root, "tmp", "imports", filename)

    else

      nil

    # Project and Tracker must be set before since new_statuses_allowed_to depends on it.

    if (p = attrs.delete('project_id')) && safe_attribute?('project_id')

        p_id = Project.find_by_identifier(p).try(:id)

      else

        p_id = p.to_i

    user = new_record? ? author : current_journal.try(:user)

    required_attribute_names(user).each do |attribute|

        attribute = attribute.to_i

        v = custom_field_values.detect {|v| v.custom_field_id == attribute }

        if v && Array(v.value).detect(&:present?).nil?

      value = email.header[key]

      if value

        value = value.to_s.downcase

          if logger

            logger.info "MailHandler: ignoring email with #{key}:#{value} header"

          end

      else

        regexp = %r{\A#{Regexp.escape(pattern).gsub("\\*", ".*")}\z}i

      end

        logger.info "MailHandler: ignoring attachment #{attachment.filename} matching #{pattern}"

        return false

      end

    principal ||= principals.detect {|a| keyword.casecmp(a.login.to_s) == 0}

    principal ||= principals.detect {|a| keyword.casecmp(a.mail.to_s) == 0}

      firstname, lastname = *(keyword.split) # "First Last Throwaway"

      principal ||= principals.detect {|a|

                                 a.is_a?(User) &&

  end

  def self.find(*args)

      project = find_by_identifier(*args)

      raise ActiveRecord::RecordNotFound, "Couldn't find Project with identifier=#{args.first}" if project.nil?

      project

      nil

    else

      # id is used for projects with a numeric identifier (compatibility)

    end

  end

      if values_for(field)

        case type_for(field)

        when :integer

        when :float

        when :date, :date_past

          case operator_for(field)

          when "=", ">=", "<=", "><"

            add_filter_error(field, :invalid) if values_for(field).detect {|v|

            }

          when ">t-", "<t-", "t-", ">t+", "<t+", "t+", "><t+", "><t-"

          end

        end

      end

      raise "Unknown #{queried_class.name} association #{assoc}" unless customized_class

    end

    where = sql_for_field(field, operator, value, db_table, db_field, true)

      where = "(#{where}) AND #{db_table}.#{db_field} <> ''"

    end

    "#{queried_table_name}.#{customized_key} #{not_in} IN (" +

  # Returns a Date or Time from the given filter value

  def parse_date(arg)

      Time.parse(arg) rescue nil

    else

      Date.parse(arg) rescue nil

  end

  def self.find_by_identifier_param(param)

      find_by_id(param)

    else

      find_by_identifier(param)

  def find_changeset_by_name(name)

    return nil if name.blank?

    s = name.to_s

      changesets.where("revision = ?", s).first

    else

      changesets.where("revision LIKE ?", s + '%').first

    regexp = Redmine::Configuration["scm_#{scm_name.to_s.downcase}_path_regexp"]

    if changes[attribute] && regexp.present?

      regexp = regexp.to_s.strip.gsub('%project%') {Regexp.escape(project.try(:identifier).to_s)}

        errors.add(attribute, :invalid)

      end

    end

  def find_changeset_by_name(name)

    return nil if name.blank?

    s = name.to_s

      cs = changesets.where(:scmid => s).first

    else

      cs = changesets.where(:revision => s).first

  def self.find_token(action, key, validity_days=nil)

    action = action.to_s

    key = key.to_s

    token = Token.where(:action => action, :value => key).first

    if token && (token.action == action) && (token.value == key) && token.user

  protected

  def validate_field_name

      errors.add :field_name, :invalid

    end

  end

    # dodge XRIs -- TODO: validate, don't just skip.

    unless ['=', '@', '+', '$', '!', '('].include?(identifier.at(0))

      # does it begin with http?  if not, add it.

      # strip any fragments

      identifier.gsub!(/\#(.*)$/, '')

      return str if str.nil?

      str.force_encoding('ASCII-8BIT')

      return str if str.empty?

      str.force_encoding('UTF-8')

      encodings = Setting.repositories_encodings.split(',').collect(&:strip)

      encodings.each do |encoding|

      # Checks the validness of regular expressions set for repository paths at startup

      def check_regular_expressions

        @config.each do |name, value|

            begin

              Regexp.new value.to_s.strip

            rescue => e

  def validate_each(record, attribute, value)

    before_type_cast = record.attributes_before_type_cast[attribute.to_s]

    if before_type_cast.is_a?(String) && before_type_cast.present?

        record.errors.add attribute, :not_a_date

      end

    end

        def self.attach(attachments, filename, encoding)

          filename_utf8 = Redmine::CodesetUtil.to_utf8(filename, encoding)

          atta = nil

            atta = Attachment.latest_attach(attachments, filename_utf8)

          end

          if atta && atta.readable? && atta.visible?

            [text, url]

          end

          links = texts_and_urls.sort_by(&:first).map do |text, url|

            view.link_to_if uri_with_safe_scheme?(url), text, url, :class => css_class

          end

          links.join(', ').html_safe

      def validate_single_value(custom_field, value, customized=nil)

        errs = super

        value = value.to_s

          errs << ::I18n.t('activerecord.errors.messages.invalid')

        end

        if custom_field.min_length && value.length < custom_field.min_length

            url = url_from_pattern(custom_field, value, customized)

          else

            url = value.to_s

              # no protocol found, use http by default

              url = "http://" + url

            end

          end

          view.link_to value.to_s.truncate(40), url, :class => css_class

        else

          value.to_s

      def validate_single_value(custom_field, value, customized=nil)

        errs = super

        errs

      end

      end

      def validate_single_value(custom_field, value, customized=nil)

          []

        else

          [::I18n.t('activerecord.errors.messages.not_a_date')]

  module Platform

    class << self

      def mswin?

      end

    end

  end

        def target(path, sq=true)

          path ||= ''

          str = "#{base}/#{path}".gsub(/[?<>\*]/, '')

          if sq

            str = shell_quote(str)

            file_state = nil

            branch_map = nil

            io.each_line() do |line|

                commit_log = String.new

                revision   = nil

                state      = "entry_start"

                  logger.debug("Path #{entry_path} <=> Name #{entry_name}")

                elsif /^head: (.+)$/ =~ line

                  entry_headRev = $1 #unless entry.nil?

                  state = "symbolic" #unless entry.nil?

                  commit_log = String.new

                  state      = "revision"

                end

        # Here we do not shell-out, so we do not want quotes.

        def target(path=nil)

          # Prevent the use of ..

            return "#{self.url}#{without_leading_slash(path)}"

          end

          return self.url

        # Runs 'hg' command with the given args

        def hg(*args, &block)

          # as of hg 4.4.1, early parsing of bool options is not terminated at '--'

            raise HgCommandArgumentError, "malicious command argument detected"

          end

            raise HgCommandArgumentError, "malicious command argument detected"

          end

        end

        def target(path = '')

          uri = "#{base}/#{path}"

          uri = URI.escape(URI.escape(uri), '[]')

          shell_quote(uri.gsub(/[?<>\*]/, ''))

    # Appends ASC/DESC to the sort criterion unless it has a fixed order

    def append_order(criterion, order)

        criterion

      else

        "#{criterion} #{order.to_s.upcase}"

          @parsing = true

        end

      else

          @parsing = false

          return false

        elsif line =~ /^@@ (\+|\-)(\d+)(,\d+)? (\+|\-)(\d+)(,\d+)? @@/

    def file_name=(arg)

      both_git_diff = false

      if file_name.nil?

      else

      end

      if both_git_diff

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

        true

      else

        write_offsets

          diff = Diff.new

          diff.line_right = line[1..-1]

          diff.nb_line_right = @line_num_r

      def auto_link!(text)

        text.gsub!(AUTO_LINK_RE) do

          all, leading, proto, url, post = $&, $1, $2, $3, $6

            # don't replace URLs that are already linked

            # and URLs prefixed with ! !> !< != (textile images)

            all

      def auto_mailto!(text)

        text.gsub!(/((?<!@)\b[\w\.!#\$%\-+.\/]+@[A-Za-z0-9\-]+(\.[A-Za-z0-9\-]+)+)/) do

          mail = $1

            mail

          else

            %(<a class="email" href="mailto:#{ERB::Util.html_escape mail}">#{ERB::Util.html_escape mail}</a>).html_safe

        # If a block of text is given, the closing tag }} must be at the start of a new line.

        def macro(name, options={}, &block)

          options.assert_valid_keys(:desc, :parse_args)

            raise "Invalid macro name: #{name} (only 0-9, A-Z, a-z and _ characters are accepted)"

          end

          unless block_given?

        filename = args.first

        raise 'Filename required' unless filename.present?

        size = options[:size]

        size = size.to_i

        size = 200 unless size > 0

        if obj && obj.respond_to?(:attachments) && attachment = Attachment.latest_attach(obj.attachments, filename)

    get '/my/account'

    assert_response 302

  end

  def test_lock_user_kills_sessions

    get '/my/account'

    assert_response 302

  end

  def test_update_user_does_not_kill_sessions

    assert_response :success

    assert_equal 'text/plain', @response.content_type

    # Redmine::Utils.relative_url_root does not effect on Rails 5.1.4.

  end

end

    Redmine::Configuration.with 'database_cipher_key' => 'secret' do

      r = Repository::Subversion.create!(:password => 'foo', :url => 'file:///tmp', :identifier => 'svn')

      assert_equal 'foo', r.password

    end

  end

      r = Repository.order('id DESC').first

      # password can not be deciphered

      assert_nothing_raised do

      end

    end

  end

      assert Repository.encrypt_all(:password)

      r = Repository.order('id DESC').first

      assert_equal 'bar', r.password

    end

  end

  def test_macro_hello_world

    text = "{{hello_world}}"

  end

  def test_macro_hello_world_should_escape_arguments

    assert_equal 30, issue.done_ratio

    assert_equal Issue.find(4), issue.parent

    # keywords should be removed from the email body

  end

  def test_add_issue_with_all_overrides

    assert_equal 'PostgreSQL', issue.custom_field_value(1)

    assert_equal 'Value for a custom field', issue.custom_field_value(2)

    assert_equal ['Mac OS X', 'Windows'], issue.custom_field_value(mutiple.id).sort

  end

  def test_add_issue_with_version_custom_fields

    assert_equal User.find_by_login('jsmith'), issue.assigned_to

    assert_equal "52.6", issue.custom_value_for(CustomField.find_by_name('Float field')).value

    # keywords should be removed from the email body

  end

  def test_update_issue_with_attachment

      assert_issue_created(issue)

      assert issue.description.include?('This paragraph is before delimiters')

      assert issue.description.include?('--- This line starts with a delimiter')

      assert !issue.description.include?('This paragraph is after the delimiter')

    end

  end

      journal = submit_email('issue_update_with_quoted_reply_above.eml')

      assert journal.is_a?(Journal)

      assert journal.notes.include?('An update to the issue by the sender.')

      assert !journal.notes.include?('Looks like the JSON api for projects was missed.')

    end

  end

      journal = submit_email('issue_update_with_multiple_quoted_reply_above.eml')

      assert journal.is_a?(Journal)

      assert journal.notes.include?('An update to the issue by the sender.')

      assert !journal.notes.include?('Looks like the JSON api for projects was missed.')

    end

  end

      assert issue.description.include?('This paragraph is before delimiters')

      assert !issue.description.include?('BREAK')

      assert !issue.description.include?('This paragraph is between delimiters')

      assert !issue.description.include?('This paragraph is after the delimiter')

    end

  end

    results = Principal.like('jsmi')

    assert results.any?

  end

  test "like scope should search firstname" do

    results = Principal.like('john')

    assert results.any?

  end

  test "like scope should search lastname" do

    results = Principal.like('smi')

    assert results.any?

  end

  test "like scope should search mail" do

    results = Principal.like('somenet')

    assert results.any?

  end

  test "like scope should search firstname and lastname" do