ruby_grammar_builder 0.0.1

data/lib/textmate_grammar/linters/start_match_empty.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'ruby_grammar_builder/util'
+
+#
+# Warns when a PatternRange has a start_pattern that matches the empty string
+#
+class StartMatchEmpty < GrammarLinter
+    #
+    # (see GrammarLinter#pre_lint)
+    #
+    def pre_lint(pattern, options)
+        return true unless pattern.is_a? PatternRange
+
+        regexp = with_no_warnings do
+            Regexp.new(pattern.start_pattern.evaluate.gsub("\\G", '\uFFFF'))
+        end
+        if "" =~ regexp and !options[:zeroLengthStart?]
+            puts "Warning: #{pattern.start_pattern.evaluate}"
+            puts "matches the zero length string (\"\").\n\n"
+            puts "This means that the patternRange always matches"
+            puts "You can disable this warning by setting :zeroLengthStart? to true."
+            puts "The pattern is:\n#{pattern}"
+        end
+        true # return true for warnings
+    end
+
+    #
+    # Contributes the option :zeroLengthStart?
+    #
+    # :zeroLengthStart? disables this linter
+    #
+    # @return (see GrammarPlugin.options)
+    #
+    def self.options
+        [:zeroLengthStart?]
+    end
+
+    #
+    # Displays the state of the options
+    #
+    # @return (see GrammarPlugin.display_options)
+    #
+    def self.display_options(indent, options)
+        ",\n#{indent}zeroLengthStart?: #{options[:zeroLengthStart?]}"
+    end
+end
+
+Grammar.register_linter(StartMatchEmpty.new)

data/lib/textmate_grammar/linters/tests.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+#
+# Runs the unit tests on each pattern
+#
+class RunPatternTests < GrammarLinter
+    #
+    # Runs the unit tests on each pattern
+    #
+    # @return [Boolean] the result of the unit tests
+    #
+    def pre_lint(pattern, _options)
+        return true unless pattern.is_a? PatternBase
+
+        pattern.run_tests
+    end
+end
+
+Grammar.register_linter(RunPatternTests.new)

data/lib/textmate_grammar/linters/unused_unresolved.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class UnusedUnresolvedLinter < GrammarLinter
+    def post_lint(grammar_hash)
+        true
+    end
+end
+
+Grammar.register_linter(UnusedUnresolvedLinter.new)

data/lib/textmate_grammar/pattern_extensions/look_ahead_for.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "./lookaround_pattern.rb"
+
+
+class PatternBase
+    #
+    # Equivalent to lookAround with type set to :lookAheadFor
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookAheadFor(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookAheadFor
+        else
+            pattern = {match: pattern, type: :lookAheadFor}
+        end
+        lookAround(pattern)
+    end
+end
+
+# (see PatternBase#lookAheadFor)
+def lookAheadFor(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookAheadFor
+    else
+        pattern = {match: pattern, type: :lookAheadFor}
+    end
+    lookAround(pattern)
+end

data/lib/textmate_grammar/pattern_extensions/look_ahead_to_avoid.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "./lookaround_pattern.rb"
+
+class PatternBase
+    #
+    # Equivalent to lookAround with type set to :lookAheadToAvoid
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookAheadToAvoid(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookAheadToAvoid
+        else
+            pattern = {match: pattern, type: :lookAheadToAvoid}
+        end
+        lookAround(pattern)
+    end
+end
+
+# (see PatternBase#lookAheadToAvoid)
+def lookAheadToAvoid(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookAheadToAvoid
+    else
+        pattern = {match: pattern, type: :lookAheadToAvoid}
+    end
+    lookAround(pattern)
+end

data/lib/textmate_grammar/pattern_extensions/look_behind_for.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "./lookaround_pattern.rb"
+
+class PatternBase
+    #
+    # Equivalent to lookAround with type set to :lookBehindFor
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookBehindFor(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookBehindFor
+        else
+            pattern = {match: pattern, type: :lookBehindFor}
+        end
+        lookAround(pattern)
+    end
+end
+
+# (see PatternBase#lookBehindFor)
+def lookBehindFor(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookBehindFor
+    else
+        pattern = {match: pattern, type: :lookBehindFor}
+    end
+    lookAround(pattern)
+end

data/lib/textmate_grammar/pattern_extensions/look_behind_to_avoid.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "./lookaround_pattern.rb"
+
+class PatternBase
+    #
+    # Equivalent to lookAround with type set to :lookBehindToAvoid
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookBehindToAvoid(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookBehindToAvoid
+        else
+            pattern = {match: pattern, type: :lookBehindToAvoid}
+        end
+        lookAround(pattern)
+    end
+end
+
+# (see PatternBase#lookBehindToAvoid)
+def lookBehindToAvoid(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookBehindToAvoid
+    else
+        pattern = {match: pattern, type: :lookBehindToAvoid}
+    end
+    lookAround(pattern)
+end

data/lib/textmate_grammar/pattern_extensions/lookaround_pattern.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+#
+# Implements lookarounds
+# for some pattern p this is equivalent to one of /(?=p)/, /(?!p)/, /(?<p)/, /(?<!p)/
+# depending on the type
+#
+class LookAroundPattern < PatternBase
+    # (see PatternBase#do_evaluate_self)
+    def do_evaluate_self(groups)
+        self_regex = @match
+        self_regex = @match.evaluate(groups) if @match.is_a? PatternBase
+
+        case @arguments[:type]
+        when :lookAheadFor      then self_regex = "(?=#{self_regex})"
+        when :lookAheadToAvoid  then self_regex = "(?!#{self_regex})"
+        when :lookBehindFor     then self_regex = "(?<=#{self_regex})"
+        when :lookBehindToAvoid then self_regex = "(?<!#{self_regex})"
+        end
+
+        if needs_to_capture?
+            raise "You cannot capture a lookAround\nconsider capturing the pattern inside"
+        end
+
+        self_regex
+    end
+
+    # (see PatternBase#do_get_to_s_name)
+    def do_get_to_s_name(top_level)
+        top_level ? "lookAround(" : ".lookAround("
+    end
+
+    # (see PatternBase#do_add_attributes)
+    def do_add_attributes(indent)
+        ",\n#{indent}  type: :#{@arguments[:type]}"
+    end
+
+    # (see PatternBase#single_entity?)
+    # @return [true]
+    def single_entity?
+        true
+    end
+end
+
+class PatternBase
+    #
+    # Looks around for the pattern
+    #
+    # @param [Hash] pattern pattern constructor
+    # option [Symbol] :type the look-around type
+    #   can be one of :lookAheadFor, :lookAheadToAvoid, :lookBehindFor, :lookBehindToAvoid
+    #
+    # @return [PatternBase] a pattern to append to
+    #
+    def lookAround(pattern)
+        insert(LookAroundPattern.new(pattern))
+    end
+
+    #
+    # Equivalent to lookAround with type set to :lookBehindToAvoid
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookBehindToAvoid(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookBehindToAvoid
+        else
+            pattern = {match: pattern, type: :lookBehindToAvoid}
+        end
+        lookAround(pattern)
+    end
+
+    #
+    # Equivalent to lookAround with type set to :lookBehindFor
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookBehindFor(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookBehindFor
+        else
+            pattern = {match: pattern, type: :lookBehindFor}
+        end
+        lookAround(pattern)
+    end
+
+    #
+    # Equivalent to lookAround with type set to :lookAheadToAvoid
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookAheadToAvoid(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookAheadToAvoid
+        else
+            pattern = {match: pattern, type: :lookAheadToAvoid}
+        end
+        lookAround(pattern)
+    end
+
+    #
+    # Equivalent to lookAround with type set to :lookAheadFor
+    #
+    # @param (see lookAround)
+    #
+    # @return (see lookAround)
+    #
+    def lookAheadFor(pattern)
+        if pattern.is_a? Hash
+            pattern[:type] = :lookAheadFor
+        else
+            pattern = {match: pattern, type: :lookAheadFor}
+        end
+        lookAround(pattern)
+    end
+end
+
+# (see PatternBase#lookAround)
+def lookAround(pattern)
+    LookAroundPattern.new(pattern)
+end
+
+# TODO: eliminate this code duplication
+
+# (see PatternBase#lookBehindToAvoid)
+def lookBehindToAvoid(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookBehindToAvoid
+    else
+        pattern = {match: pattern, type: :lookBehindToAvoid}
+    end
+    lookAround(pattern)
+end
+
+# (see PatternBase#lookBehindFor)
+def lookBehindFor(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookBehindFor
+    else
+        pattern = {match: pattern, type: :lookBehindFor}
+    end
+    lookAround(pattern)
+end
+
+# (see PatternBase#lookAheadToAvoid)
+def lookAheadToAvoid(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookAheadToAvoid
+    else
+        pattern = {match: pattern, type: :lookAheadToAvoid}
+    end
+    lookAround(pattern)
+end
+
+# (see PatternBase#lookAheadFor)
+def lookAheadFor(pattern)
+    if pattern.is_a? Hash
+        pattern[:type] = :lookAheadFor
+    else
+        pattern = {match: pattern, type: :lookAheadFor}
+    end
+    lookAround(pattern)
+end

data/lib/textmate_grammar/pattern_extensions/match_result_of.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+#
+# Implements back references
+# for some group N whose reference is "foo"
+# matchResultOf("foo") results in the pattern /\N/
+#
+class MatchResultOfPattern < PatternBase
+    def initialize(reference, deep_clone = nil, original_arguments = nil)
+        if reference.is_a? String
+            super(
+                match: Regexp.new("(?#[:backreference:#{reference}:])"),
+                backreference_key: reference
+            )
+        else
+            # most likely __deep_clone__ was called, just call the super initializer
+            super(reference, deep_clone, original_arguments)
+        end
+    end
+
+    # (see PatternBase#to_s)
+    def to_s(depth = 0, top_level = true)
+        output = top_level ? "matchResultOf(" : ".matchResultOf("
+        output += "\"#{@arguments[:backreference_key]}\")"
+        output += @next_pattern.to_s(depth, false).lstrip if @next_pattern
+        output
+    end
+
+    # (see PatternBase#single_entity?)
+    # @return [true]
+    def single_entity?
+        true
+    end
+
+    # (see PatternBase#self_scramble_references)
+    def self_scramble_references
+        scramble = lambda do |name|
+            return name if name.start_with?("__scrambled__")
+
+            "__scrambled__" + name
+        end
+
+        key = @arguments[:subroutine_key]
+        scrambled = scramble.call(key)
+
+        @match = @match.sub(key, scrambled)
+        @arguments[:subroutine_key] = scrambled
+    end
+end
+
+class PatternBase
+    #
+    # Match the result of some other pattern
+    #
+    # @param [String] reference a reference to match the result of
+    #
+    # @return [PatternBase] a pattern to append to
+    #
+    def matchResultOf(reference)
+        insert(MatchResultOfPattern.new(reference))
+    end
+end
+
+# (see PatternBase#matchResultOf)
+def matchResultOf(reference)
+    MatchResultOfPattern.new(reference)
+end