textmate_grammar 0.0.0

data/lib/textmate_grammar/pattern_variations/legacy_pattern.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "./base_pattern.rb"
+
+#
+# LegacyPattern allows for a hash to be treated as a Pattern
+# It implements the minimum required to be sucessfully generated by the grammar
+#
+class LegacyPattern < PatternBase
+    def initialize(hash)
+        super("placeholder")
+        @hash = hash.transform_keys(&:to_sym)
+    end
+
+    # LegacyPattern cannot be evaluated
+    def evaluate(*_ignored)
+        raise "LegacyPattern cannot be used as a part of a Pattern"
+    end
+
+    # LegacyPattern cannot be chained
+    def insert!(_pattern)
+        raise "LegacyPattern cannot be used as a part of a Pattern"
+    end
+
+    #
+    # (see PatternBase#to_tag)
+    #
+    # @return [Hash] The hash it was constructed with
+    #
+    def to_tag
+        @hash
+    end
+
+    #
+    # (see PatternBase#run_tests)
+    #
+    def run_tests
+        true
+    end
+
+    #
+    # (see PatternBase#map!)
+    #
+    def map!(*)
+        self
+    end
+
+    #
+    # (see PatternBase#start_pattern)
+    #
+    def start_pattern
+        ""
+    end
+
+    #
+    # (see PatternBase#__deep_clone__)
+    #
+    def __deep_clone__
+        self.class.new(@hash)
+    end
+end

data/lib/textmate_grammar/pattern_variations/pattern.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "./repeatable_pattern.rb"
+
+#
+# Pattern is a class alias for RepeatablePattern
+#
+# class Pattern # <- encase people ctrl+F for "class Pattern"
+Pattern = RepeatablePattern

data/lib/textmate_grammar/pattern_variations/pattern_range.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require_relative "./base_pattern.rb"
+
+#
+# Provides the ability to create begin/end and begin/while rules
+#
+class PatternRange < PatternBase
+    attr_reader :start_pattern
+
+    #
+    # Creates a new PatternRange
+    #
+    # @param [Hash] arguments options
+    # @option arguments [PatternBase,Regexp,String] :start_pattern the start pattern
+    # @option arguments [PatternBase,Regexp,String] :end_pattern the end pattern
+    # @option arguments [PatternBase,Regexp,String] :while_pattern the while pattern
+    # @option arguments [String] :tag_as the tag for this pattern
+    # @option arguments [String] :tag_contents_as the tag for contents of this pattern
+    # @option arguments [String] :tag_start_as the tag for the start pattern
+    # @option arguments [String] :tag_end_as the tag for the end pattern
+    # @option arguments [String] :tag_while_as the tag for the continuation pattern
+    #
+    # Plugins may add additional options
+    # @note exactly one of :end_pattern or :while_pattern is required
+    #
+    def initialize(arguments)
+        @original_arguments = arguments
+        @match = nil
+        @next_pattern = nil
+
+        raise "PatternRange.new() expects a hash" unless arguments.is_a? Hash
+
+        # ensure end_pattern: XOR while_pattern: is provided
+        if arguments[:end_pattern].nil? && arguments[:while_pattern].nil?
+            raise "one of `while_pattern:` or `end_pattern` must be supplied"
+        end
+
+        if !arguments[:end_pattern].nil? && !arguments[:while_pattern].nil?
+            raise "only one of `while_pattern:` or `end_pattern` must be supplied"
+        end
+
+        @start_pattern = arguments[:start_pattern]
+        @stop_pattern  = arguments[:end_pattern] || arguments[:while_pattern]
+
+        # convert to patterns if needed
+        @start_pattern = PatternBase.new(@start_pattern) unless @start_pattern.is_a? PatternBase
+        @stop_pattern = PatternBase.new(@stop_pattern) unless @stop_pattern.is_a? PatternBase
+
+        # store originals for to_s
+        @original_start_pattern = @start_pattern
+        @original_stop_pattern  = @stop_pattern
+
+        if arguments[:tag_start_as]
+            @start_pattern = PatternBase.new(
+                match: @start_pattern,
+                tag_as: arguments[:tag_start_as],
+            )
+        end
+
+        tag_stop_as = arguments[:tag_end_as] || arguments[:tag_while_as]
+
+        if tag_stop_as
+            @stop_pattern = PatternBase.new(
+                match: @stop_pattern,
+                tag_as: tag_stop_as,
+            )
+        end
+
+        raise "match: is not supported in a PatternRange" if arguments[:match]
+
+        @stop_type = arguments[:end_pattern] ? :end_pattern : :while_pattern
+
+        arguments.delete(:start_pattern)
+        arguments.delete(:end_pattern)
+        arguments.delete(:while_pattern)
+
+        # ensure that includes is either nil or a flat array
+        if arguments[:includes]
+            arguments[:includes] = [arguments[:includes]] unless arguments[:includes].is_a? Array
+            arguments[:includes] = arguments[:includes].flatten
+        end
+
+        #canonize end_pattern_last
+        arguments[:end_pattern_last] = arguments[:apply_end_pattern_last] if arguments[:apply_end_pattern_last]
+        arguments[:end_pattern_last] = arguments[:applyEndPatternLast] if arguments[:applyEndPatternLast]
+
+        arguments.delete(:apply_end_pattern_last)
+        arguments.delete(:applyEndPatternLast)
+
+        @arguments = arguments
+    end
+
+    #
+    # (see PatternBase#__deep_clone__)
+    #
+    def __deep_clone__
+        options = @arguments.__deep_clone__
+        options[:start_pattern] = @original_start_pattern.__deep_clone__
+        if @stop_type == :end_pattern
+            options[:end_pattern] = @original_stop_pattern.__deep_clone__
+        else
+            options[:while_pattern] = @original_stop_pattern.__deep_clone__
+        end
+        self.class.new(options)
+    end
+
+    #
+    # Raises an error to prevent use inside a pattern list
+    #
+    # @param _ignored ignored
+    #
+    # @return [void]
+    #
+    def evaluate(*_ignored)
+        raise "PatternRange cannot be used as a part of a Pattern"
+    end
+
+    #
+    # Raises an error to prevent use inside a pattern list
+    #
+    # @param _ignored ignored
+    #
+    # @return [void]
+    #
+    def do_evaluate_self(*_ignored)
+        raise "PatternRange cannot be used as a part of a Pattern"
+    end
+
+    #
+    # Generate a Textmate rule from the PatternRange
+    #
+    # @return [Hash] The Textmate rule
+    #
+    def to_tag
+        match_key = { end_pattern: "end", while_pattern: "while" }[@stop_type]
+        capture_key = { end_pattern: "endCaptures", while_pattern: "whileCaptures" }[@stop_type]
+
+        start_groups = @start_pattern.collect_group_attributes
+        stop_groups = @stop_pattern.collect_group_attributes
+
+        output = {
+            "begin" => @start_pattern.evaluate,
+            # this is supposed to be start_groups as back references in end and while
+            # refer to the start pattern
+            match_key => @stop_pattern.evaluate(start_groups, fixup_refereces: true),
+            "beginCaptures" => convert_group_attributes_to_captures(start_groups),
+            capture_key => convert_group_attributes_to_captures(stop_groups),
+        }
+
+        output[:name] = @arguments[:tag_as] unless @arguments[:tag_as].nil?
+        output[:contentName] = @arguments[:tag_content_as] unless @arguments[:tag_content_as].nil?
+
+        output["begin"]   = output["begin"][1..-2]   if @start_pattern.optimize_outer_group?
+        output[match_key] = output[match_key][1..-2] if @stop_pattern.optimize_outer_group?
+
+        if @arguments[:includes].is_a? Array
+            output[:patterns] = convert_includes_to_patterns(@arguments[:includes])
+        elsif !@arguments[:includes].nil?
+            output[:patterns] = convert_includes_to_patterns([@arguments[:includes]])
+        end
+
+        # end_pattern_last
+        output["applyEndPatternLast"] = 1 if @arguments[:end_pattern_last]
+
+        output
+    end
+
+    #
+    # Displays this pattern range as source code that would generate it
+    #
+    # @return [String] The PatternRange as source code
+    #
+    def to_s
+        start_pattern = @original_start_pattern.to_s(2, true)
+        stop_pattern = @original_stop_pattern.to_s(2, true)
+
+        output = "PatternRange.new("
+        output += "\n  start_pattern: " + start_pattern.lstrip
+        output += ",\n  #{@stop_type}: " + stop_pattern.lstrip
+        [:tag_as, :tag_content_as, :tag_start_as, :tag_end_as, :tag_while_as].each do |tag|
+            next if @arguments[tag].nil?
+
+            output += ",\n  #{tag}: \"" + @arguments[tag] + "\"" if @arguments[tag].is_a? String
+        end
+        output += ",\n  includes: " + @arguments[:includes].to_s if @arguments[:includes]
+        output += ",\n  end_pattern_last: #{@arguments[:end_pattern_last]}"  if @arguments[:end_pattern_last]
+        output += ",\n)"
+
+        output
+    end
+
+    #
+    # (see PatternBase#map!)
+    #
+    def map!(map_includes = false, &block)
+        yield self
+
+        @start_pattern.map!(map_includes, &block)
+        @stop_pattern.map!(map_includes, &block)
+        map_includes!(&block) if map_includes
+
+        self
+    end
+
+    #
+    # (see PatternBase#transform_includes)
+    #
+    def transform_includes(&block)
+        copy = __deep_clone__
+        copy.arguments[:includes].map!(&block) if copy.arguments[:includes].is_a? Array
+
+        copy.map!(true) do |s|
+            s.arguments[:includes].map!(&block) if s.arguments[:includes].is_a? Array
+        end.freeze
+    end
+
+    #
+    # (see PatternBase#run_tests)
+    #
+    def run_tests
+        s = @start_pattern.run_tests
+        e = @stop_pattern.run_tests
+        s && e
+    end
+
+    #
+    # (see PatternBase#inspect)
+    #
+    def inspect
+        super.split(" ")[0] + " start_pattern:" + @start_pattern.inspect + ">"
+    end
+end

data/lib/textmate_grammar/pattern_variations/repeatable_pattern.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative "./base_pattern.rb"
+
+#
+# RepeatablePattern provides quantifiers for patterns
+#
+class RepeatablePattern < PatternBase
+    # @return [Integer,nil] the minimum amount that can be matched
+    attr_accessor :at_least
+    # @return [Integer,nil] the maximum amount that can be matched
+    attr_accessor :at_most
+    # (see PatternBase#initialize)
+    def initialize(*arguments)
+        super(*arguments)
+
+        @at_least = nil
+        @at_most = nil
+        process_quantifiers_from_arguments
+    end
+
+    #
+    # sets @at_least and @at_most based on arguments
+    #
+    # @return [void]
+    #
+    # @api private
+    #
+    def process_quantifiers_from_arguments
+        # this sets the @at_most and @at_least value based on the arguments
+
+        #
+        # Simplify the quantity down to just :at_least and :at_most
+        #
+        attributes_clone = @arguments.clone
+        # convert Enumerators to numbers
+        [:at_least, :at_most, :how_many_times?].each do |each|
+            if attributes_clone[each].is_a?(Enumerator)
+                attributes_clone[each] = attributes_clone[each].size
+            end
+        end
+
+        # canonize dont_back_track? and as_few_as_possible?
+        @arguments[:dont_back_track?] ||= @arguments[:possessive?]
+        @arguments[:as_few_as_possible?] ||= @arguments[:lazy?]
+        if @arguments[:greedy?]
+            @arguments[:dont_back_track?] = false
+            @arguments[:as_few_as_possible?] = false
+        end
+        # extract the data
+        at_least       = attributes_clone[:at_least]
+        at_most        = attributes_clone[:at_most]
+        how_many_times = attributes_clone[:how_many_times?]
+        # simplify to at_least and at_most
+        at_least = at_most = how_many_times if how_many_times.is_a?(Integer)
+
+        # check if quantifying is allowed
+        # check after everything else in case additional quantifying options
+        # are created in the future
+        if quantifying_allowed?
+            @at_least = at_least
+            @at_most = at_most
+        # if a quantifying value was set and quantifying is not allowed, raise an error
+        # telling the user that its not allowed
+        elsif !(at_most.nil? && at_least.nil?)
+            raise <<-HEREDOC.remove_indent
+
+                Inside of the #{name} pattern, there are some quantity arguments like:
+                    :at_least
+                    :at_most
+                    or :how_many_times?
+                These are not allowed in this kind of #{do_get_to_s_name}) pattern
+                If you did this intentionally please wrap it inside of a Pattern.new()
+                ex: #{do_get_to_s_name} Pattern.new( *your_arguments* ) )
+            HEREDOC
+        end
+
+        return unless @arguments[:dont_back_track?] && @arguments[:as_few_as_possible?]
+
+        raise ":dont_back_track? and :as_few_as_possible? cannot both be provided"
+    end
+
+    #
+    # converts @at_least and @at_most into the appropriate quantifier
+    # this is a simple_quantifier because it does not include atomic-ness
+    #
+    # @return [String] the quantifier
+    #
+    def simple_quantifier
+        # Generate the ending based on :at_least and :at_most
+
+        # by default assume no quantifiers
+        quantifier = ""
+        # if there is no at_least, at_most, or how_many_times, then theres no quantifier
+        if @at_least.nil? and @at_most.nil?
+            quantifier = ""
+        # if there is a quantifier
+        else
+            # if there's no at_least, then assume at_least = 1
+            @at_least = 1 if @at_least.nil?
+
+            quantifier =
+                if @at_least == 1 and @at_most == 1
+                    # no qualifier
+                    ""
+                elsif @at_least == 0 and @at_most == 1
+                    # this is just a different way of "maybe"
+                    "?"
+                elsif @at_least == 0 and @at_most.nil?
+                    # this is just a different way of "zeroOrMoreOf"
+                    "*"
+                elsif @at_least == 1 and @at_most.nil?
+                    # this is just a different way of "oneOrMoreOf"
+                    "+"
+                elsif @at_least == @at_most
+                    # exactly N times
+                    "{#{@at_least}}"
+                else
+                    # if it is more complicated than that, just use a range
+                    "{#{@at_least},#{@at_most}}"
+                end
+        end
+        # quantifiers can be made possessive without requiring atomic groups
+        quantifier += "+" if quantifier != "" && @arguments[:dont_back_track?] == true
+        quantifier += "?" if quantifier != "" && @arguments[:as_few_as_possible?] == true
+        quantifier
+    end
+
+    #
+    # Adds quantifiers to match
+    #
+    # @param [String, PatternBase] match the pattern to add a quantifier to
+    # @param [Array] groups group information, used for evaluating match
+    #
+    # @return [String] match with quantifiers applied
+    #
+    def add_quantifier_options_to(match, groups)
+        match = match.evaluate(groups) if match.is_a? PatternBase
+        quantifier = simple_quantifier
+        # check if there are quantifiers
+        if quantifier != ""
+            # if the match is not a single entity, then it needs to be wrapped
+            match = "(?:#{match})" unless string_single_entity?(match)
+            # add the quantified ending
+            match += quantifier
+        elsif @arguments[:dont_back_track?] == true
+            # make atomic, which allows arbitrary expression to be prevented from backtracking
+            match = "(?>#{match})"
+        end
+        if @arguments[:word_cannot_be_any_of]
+            word_pattern = @arguments[:word_cannot_be_any_of].map { |w| Regexp.escape w }.join "|"
+            match = "(?!\\b(?:#{word_pattern})\\b)#{match}"
+        end
+        match
+    end
+
+    # (see PatternBase#do_evaluate_self)
+    def do_evaluate_self(groups)
+        add_capture_group_if_needed(add_quantifier_options_to(@match, groups))
+    end
+
+    # controls weather @arguments[:at_most] et. al. set @at_most et. al.
+    # @note override when inheriting. Return false unless the subclass allow quantifying
+    # @return [Boolean] if quantifying is allowed
+    # @note the default implementation returns True
+    def quantifying_allowed?
+        true
+    end
+
+    #
+    # (see PatternBase#do_add_attributes)
+    #
+    def do_add_attributes(indent)
+        # rubocop:disable Metrics/LineLength
+        output = ""
+        # special #then arguments
+        if quantifying_allowed?
+            output += ",\n#{indent}  at_least: " + @arguments[:at_least].to_s if @arguments[:at_least]
+            output += ",\n#{indent}  at_most: " + @arguments[:at_most].to_s if @arguments[:at_most]
+            output += ",\n#{indent}  how_many_times: " + @arguments[:how_many_times].to_s if @arguments[:how_many_times]
+            output += ",\n#{indent}  word_cannot_be_any_of: " + @arguments[:word_cannot_be_any_of].to_s if @arguments[:word_cannot_be_any_of]
+        end
+        output += ",\n#{indent}  dont_back_track?: " + @arguments[:dont_back_track?].to_s if @arguments[:dont_back_track?]
+        output
+        # rubocop:enable Metrics/LineLength
+    end
+
+    #
+    # Does this pattern potentially rematch any capture groups
+    #
+    # @note this is used by FixRepeatedTagAs to modify patterns
+    # The answer of true is a safe, but expensive to runtime, default
+    #
+    # @return [Boolean] True if this pattern potentially rematches capture groups
+    #
+    def self_capture_group_rematch
+        # N or more
+        return true if @at_most.nil? && !@at_least.nil?
+        # up to N
+        return true if !@at_most.nil? && @at_most > 1
+
+        false
+    end
+end