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

    class << self

      # Returns true if the database is PostgreSQL

      def postgresql?

      end

      # Returns the PostgreSQL version or nil if another DBMS is used

      # Returns true if the database is MySQL

      def mysql?

      end

      # Returns a SQL statement for case/accent (if possible) insensitive match

        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')]

      def lock_nested_set

        lock = true

          lock = "WITH (ROWLOCK HOLDLOCK UPDLOCK)"

        end

        self.class.order(:id).lock(lock).ids

  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!(/([\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)