ruby_syntax.rb 1.96 KB
Newer Older
1 2 3 4 5 6 7 8
# frozen_string_literal: true

module Gitlab
  class UntrustedRegexp
    # This class implements support for Ruby syntax of regexps
    # and converts that to RE2 representation:
    # /<regexp>/<flags>
    class RubySyntax
9
      PATTERN = %r{^/(?<regexp>.*)/(?<flags>[ismU]*)$}.freeze
10 11 12 13 14 15 16 17 18

      # Checks if pattern matches a regexp pattern
      # but does not enforce it's validity
      def self.matches_syntax?(pattern)
        pattern.is_a?(String) && pattern.match(PATTERN).present?
      end

      # The regexp can match the pattern `/.../`, but may not be fabricatable:
      # it can be invalid or incomplete: `/match ( string/`
19 20
      def self.valid?(pattern, fallback: false)
        !!self.fabricate(pattern, fallback: fallback)
21 22
      end

23 24
      def self.fabricate(pattern, fallback: false)
        self.fabricate!(pattern, fallback: fallback)
25 26 27 28
      rescue RegexpError
        nil
      end

29
      def self.fabricate!(pattern, fallback: false)
30 31 32 33 34
        raise RegexpError, 'Pattern is not string!' unless pattern.is_a?(String)

        matches = pattern.match(PATTERN)
        raise RegexpError, 'Invalid regular expression!' if matches.nil?

35 36 37 38 39
        begin
          create_untrusted_regexp(matches[:regexp], matches[:flags])
        rescue RegexpError
          raise unless fallback &&
              Feature.enabled?(:allow_unsafe_ruby_regexp, default_enabled: false)
40

41 42
          create_ruby_regexp(matches[:regexp], matches[:flags])
        end
43
      end
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

      def self.create_untrusted_regexp(pattern, flags)
        pattern.prepend("(?#{flags})") if flags.present?

        UntrustedRegexp.new(pattern, multiline: false)
      end
      private_class_method :create_untrusted_regexp

      def self.create_ruby_regexp(pattern, flags)
        options = 0
        options += Regexp::IGNORECASE if flags&.include?('i')
        options += Regexp::MULTILINE if flags&.include?('m')

        Regexp.new(pattern, options)
      end
      private_class_method :create_ruby_regexp
60 61 62
    end
  end
end