Redmine

    # 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

        # 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)

      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