ruby_grammar_builder 1.1.10 → 1.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c847c5f5b831cc00f4067e4030639263c104b9923a85b42aa96d038355d79a66
-  data.tar.gz: e1dd84c95ef84fb92d50ac15b13004c303fa2bee43b328774f2b29773aeb7ddd
+  metadata.gz: 11a8a1b576e0b4aa298d5216fab27ecafbdfb89bdbcbe1604699b17f944e6773
+  data.tar.gz: 705f94bbb89097d41510042c581bab138bfbcb74bd703e540df429524547c6fd
 SHA512:
-  metadata.gz: 9734da744fd7cc482a30d69a6a51d2104cd7ca019bf7170652094b4114484e2c481839f0b950949955c8f69f6579acdfb0092acbdcd74a8b04fc73ef3008251d
-  data.tar.gz: 51214dc748e1e93d60e815cd5ad14c43dc07313a8194d9df89fbf88696e485f2574b234f86177ed39f3907c98de0e5a2b600088bd103fd91a114c515b5a6abc9
+  metadata.gz: e3121cb4e1efddf789f32c6c79a77ebd35bee9417ba654f33d6d99b4672ebffc09d4f54254826477f44ac75b38ff06c3efab0a1e73c73e56627021bc7c8e4411
+  data.tar.gz: 20de057ae05b377087bcbe77e3d42ddd12069640538e98a0507d05d90ffe75c2092be09820d9b7341327294ff86d4671896aeea21be4007d59954dee76196a45

data/lib/ruby_grammar_builder/pattern_extensions/or_pattern.rb

@@ -14,7 +14,61 @@ class OrPattern < PatternBase
     def evaluate_operator
         AlternationOperator.new
     end
+    
+    def run_self_tests
+        pass = [true]
 
+        # some patterns are not able to be evaluated
+        # do not attempt to unless required
+        return true unless [
+            :should_fully_match,
+            :should_not_fully_match,
+            :should_partially_match,
+            :should_not_partially_match,
+        ].any? { |k| @arguments.include? k }
+        
+        copy = @match.__deep_clone_self__
+        test_regex = copy.to_r
+        test_fully_regex = wrap_with_anchors(copy).to_r
+
+        warn = lambda do |symbol|
+            puts [
+                "",
+                "When testing the pattern #{test_regex.inspect}. The unit test for #{symbol} failed.",
+                "The unit test has the following patterns:",
+                "#{@arguments[symbol].to_yaml}",
+                "The Failing pattern is below:",
+                "#{self}",
+            ].join("\n")
+        end
+        if @arguments[:should_fully_match].is_a? Array
+            unless @arguments[:should_fully_match].all? { |test| test =~ test_fully_regex }
+                warn.call :should_fully_match
+                pass << false
+            end
+        end
+        if @arguments[:should_not_fully_match].is_a? Array
+            unless @arguments[:should_not_fully_match].none? { |test| test =~ test_fully_regex }
+                warn.call :should_not_fully_match
+                pass << false
+            end
+        end
+        if @arguments[:should_partially_match].is_a? Array
+            unless @arguments[:should_partially_match].all? { |test| test =~ test_regex }
+                warn.call :should_partially_match
+                pass << false
+            end
+        end
+        if @arguments[:should_not_partially_match].is_a? Array
+            unless @arguments[:should_not_partially_match].none? { |test| test =~ test_regex }
+                warn.call :should_not_partially_match
+                pass << false
+            end
+        end
+
+        pass.none?(&:!)
+    end
+    
     #
     # Raises an error to prevent use as initial type
     #

data/lib/ruby_grammar_builder/pattern_variations/base_pattern.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-
+$ruby_grammar_builder__unit_test_active = false
 #
 # Provides a base class to simplify the writing of complex regular expressions rules
 # This class completely handles capture numbers and provides convenience methods for
@@ -42,7 +42,7 @@ class PatternBase
     # @return [Boolean] can this capture become capture group 0
     #
     def optimize_outer_group?
-        needs_to_capture? and @next_pattern.nil?
+        self.needs_to_capture? and @next_pattern.nil?
     end
 
     #
@@ -73,18 +73,6 @@ class PatternBase
         new_pattern.insert!(pattern).freeze
     end
 
-    #
-    # Adds a capture group if needed
-    #
-    # @param [String] regex_as_string the pattern as a string
-    #
-    # @return [String] the pattern, potentially with a capture group
-    #
-    def add_capture_group_if_needed(regex_as_string)
-        regex_as_string = "(#{regex_as_string})" if needs_to_capture?
-        regex_as_string
-    end
-
     #
     # Uses a block to transform all Patterns in the list
     #
@@ -306,7 +294,7 @@ class PatternBase
     #
     def to_tag
         output = {
-            match: evaluate,
+            match: self.evaluate(),
         }
 
         output[:captures] = convert_group_attributes_to_captures(collect_group_attributes)
@@ -415,6 +403,8 @@ class PatternBase
     # @return [Boolean] If all test passed return true, otherwise false
     #
     def run_tests
+        original_flag_value = $ruby_grammar_builder__unit_test_active
+        $ruby_grammar_builder__unit_test_active = true
         pass = [
             run_self_tests,
         ]
@@ -427,6 +417,7 @@ class PatternBase
         elsif @arguments[:includes].is_a? PatternBase
             pass << @arguments[:includes].run_tests
         end
+        $ruby_grammar_builder__unit_test_active = original_flag_value
         pass.none?(&:!)
     end
 
@@ -448,8 +439,17 @@ class PatternBase
         ].any? { |k| @arguments.include? k }
 
         copy = __deep_clone_self__
-        test_regex = copy.to_r
-        test_fully_regex = wrap_with_anchors(copy).to_r
+        begin
+            test_regex = copy.to_r
+            test_fully_regex = wrap_with_anchors(copy).to_r
+        rescue => exception
+            raise <<~HEREDOC
+                
+                
+                error running unit tests for: #{copy}
+                #{exception}
+            HEREDOC
+        end
 
         warn = lambda do |symbol|
             puts [
@@ -558,7 +558,12 @@ class PatternBase
     def do_evaluate_self(groups)
         match = @match
         match = match.evaluate(groups) if match.is_a? PatternBase
-        add_capture_group_if_needed(match)
+        if self.needs_to_capture?
+            match = "(#{match})"
+        elsif not string_single_entity?(match)
+            match = "(?:#{match})"
+        end
+        return match
     end
 
     #
@@ -599,7 +604,7 @@ class PatternBase
 
     # (see string_single_entity)
     def single_entity?
-        string_single_entity? evaluate
+        return string_single_entity?( self.evaluate() )
     end
 
     # does this pattern contain no capturing groups
@@ -684,7 +689,7 @@ class PatternBase
     #
     def do_collect_self_groups(next_group)
         groups = []
-        groups << {group: next_group}.merge(@arguments) if needs_to_capture?
+        groups << {group: next_group}.merge(@arguments) if self.needs_to_capture?
         groups
     end
 
@@ -719,22 +724,31 @@ class PatternBase
         self_regex = self_regex.gsub(/\(\?\#\[:backreference:([^\\]+?):\]\)/) do
             match_reference = Regexp.last_match(1)
             if references[match_reference].nil?
-                raise "\nWhen processing the matchResultOf:#{match_reference}, I couldn't find the group it was referencing"
+                if $ruby_grammar_builder__unit_test_active
+                    "(?#would_be_backref_but_null_because_unit_test)A(?<=B)"
+                else
+                    raise "groups:#{groups}\nreferences: #{references}\nWhen processing the matchResultOf:#{match_reference}, I couldn't find the group it was referencing"
+                end
+            else
+                # if the reference does exist, then replace it with it's number
+                "(?:\\#{references[match_reference]})"
             end
-
-            # if the reference does exist, then replace it with it's number
-            "(?:\\#{references[match_reference]})"
         end
 
         # check for a subroutine to the Nth group, replace it with `\N`
         self_regex = self_regex.gsub(/\(\?\#\[:subroutine:([^\\]+?):\]\)/) do
             match_reference = Regexp.last_match(1)
             if references[match_reference].nil?
-                raise "\nWhen processing the recursivelyMatch:#{match_reference}, I couldn't find the group it was referencing"
+                if $ruby_grammar_builder__unit_test_active
+                    "(?#would_be_subroutine_but_null_because_unit_test)A(?<=B)"
+                else
+                    raise "groups:#{groups}\nreferences: #{references}\nWhen processing the recursivelyMatch:#{match_reference}, I couldn't find the group it was referencing"
+                end
+            else
+                # if the reference does exist, then replace it with it's number
+                "\\g<#{references[match_reference]}>"
             end
 
-            # if the reference does exist, then replace it with it's number
-            "\\g<#{references[match_reference]}>"
         end
         # rubocop:enable Metrics/LineLength
         self_regex

data/lib/ruby_grammar_builder/pattern_variations/repeatable_pattern.rb

@@ -43,10 +43,6 @@ class RepeatablePattern < PatternBase
         # 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]
@@ -91,7 +87,7 @@ class RepeatablePattern < PatternBase
 
         # by default assume no quantifiers
         quantifier = ""
-        # if there is no at_least, at_most, or how_many_times, then theres no 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
@@ -156,7 +152,13 @@ class RepeatablePattern < PatternBase
 
     # (see PatternBase#do_evaluate_self)
     def do_evaluate_self(groups)
-        add_capture_group_if_needed(add_quantifier_options_to(@match, groups))
+        match = add_quantifier_options_to(@match, groups)
+        if self.needs_to_capture?
+            match = "(#{match})"
+        elsif not string_single_entity?(match)
+            match = "(?:#{match})"
+        end
+        return match
     end
 
     # controls weather @arguments[:at_most] et. al. set @at_most et. al.
@@ -177,7 +179,7 @@ class RepeatablePattern < PatternBase
         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}  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?]

data/lib/ruby_grammar_builder/transforms/resolve_placeholders.rb

@@ -5,20 +5,25 @@
 #
 class ResolvePlaceholders < GrammarTransform
     def pre_transform(pattern, options)
+        # skip past anything that isn't a pattern
         return pattern unless pattern.is_a? PatternBase
         pattern_copy = pattern.__deep_clone__
+        # recursively fill in all of the placeholders by looking them up
         pattern_copy.map!(true) do |each_pattern_like|
             
             arguments = each_pattern_like.arguments
             repository = options[:repository]
-            
+            name_of_placeholder = arguments[:placeholder]
+            # 
+            # PlaceholderPattern
+            # 
             if each_pattern_like.is_a?(PlaceholderPattern)
-                
-                unless repository[arguments[:placeholder]].is_a? PatternBase
-                    raise ":#{arguments[:placeholder]} is not a pattern and cannot be substituted"
+                # error if can't find thing the placeholder is reffering to 
+                unless repository[name_of_placeholder].is_a? PatternBase
+                    raise ":#{name_of_placeholder} is not a pattern and cannot be substituted"
                 end
-
-                each_pattern_like.match = repository[arguments[:placeholder]].__deep_clone__
+                # if the pattern exists though, make the substitution
+                each_pattern_like.match = repository[name_of_placeholder].__deep_clone__
             #
             # token pattern
             #
@@ -50,72 +55,4 @@ end
                         
 # resolving placeholders has no dependencies and makes analyzing patterns much nicer
 # so it happens fairly early
-Grammar.register_transform(ResolvePlaceholders.new, 0)
-
-
-
-
-
-# # frozen_string_literal: true
-
-# #
-# # Resolves any embedded placeholders
-# #
-# class ResolvePlaceholders < GrammarTransform
-#     def pre_transform(pattern, options)
-#         # skip past anything that isn't a pattern
-#         return pattern unless pattern.is_a? PatternBase
-        
-#         pattern_copy = pattern.__deep_clone__
-#         # recursively fill in all of the placeholders by looking them up
-#         repository = options[:repository]
-#         pattern_copy.map!(true) do |each_pattern_like|
-#             arguments = each_pattern_like.arguments
-#             name_of_placeholder = arguments[:placeholder]
-#             #
-#             # placeholder pattern
-#             #
-#             if each_pattern_like.is_a?(PlaceholderPattern)
-#                 # error if can't find thing the placeholder is reffering to 
-#                 if !repository[name_of_placeholder].is_a?(PatternBase)
-#                     raise "\n#{arguments[:placeholder]} is not a pattern and cannot be substituted"
-#                 end
-                
-#                 # if the pattern exists though, make the substitution
-#                 arguments = { match:repository[arguments[:placeholder]].__deep_clone__ }
-#                 for each_key, each_value in each_pattern_like.arguments
-#                     arguments[each_key]  = each_value
-#                 end
-#                 each_pattern_like = Pattern.new(arguments)
-#             #
-#             # token pattern
-#             #
-#             elsif each_pattern_like.is_a?(TokenPattern)
-#                 qualifying_patterns = []
-#                 for each_key, each_value in repository
-#                     next unless each_value.is_a?(PatternBase)
-#                     qualifying_patterns << each_value if arguments[:pattern_filter][each_value]
-#                 end
-#                 if qualifying_patterns.size == 0
-#                     raise <<-HEREDOC.remove_indent
-                        
-                        
-#                         When creating a token filter #{arguments[:pattern_filter]}
-#                         all the patterns that are in the grammar repository were searched
-#                         but none of thier adjective lists matched the token filter
-#                     HEREDOC
-#                 end
-                
-                
-#                 # change this pattern right before the grammar is generated
-#                 each_pattern_like.match = oneOf(qualifying_patterns)
-#             end
-#             each_pattern_like
-#         end
-#         return pattern_copy
-#     end
-# end
-                        
-# # resolving placeholders has no dependencies and makes analyzing patterns much nicer
-# # so it happens fairly early
-# Grammar.register_transform(ResolvePlaceholders.new, 0)
+Grammar.register_transform(ResolvePlaceholders.new, 0)

data/lib/ruby_grammar_builder/util.rb

@@ -52,21 +52,23 @@ end
 # @return [Boolean] if the string represents an single regex entity
 def string_single_entity?(regex_string)
     normal_char = '[a-zA-Z0-9_\-@&%#\'"<>=\/\.,`~\s;:!]'
+    escape_sequence = '\\\\[\w\W]'
+    character_class_that_doesnt_contain_bracket = '\[[^\]]*\]'
     # normal char
     if regex_string =~ /^#{normal_char}$/
         return true
     end
     # escape sequence (all are valid, even stuff like \@ ("\\@") or "\\" + "\n" )
-    if regex_string =~ /^\\[\w\W]$/
+    if regex_string =~ /^#{escape_sequence}$/
         return true
     end
     # character class that doesn't contain ]
-    if regex_string =~ /^\[[^\]]*\]$/
+    if regex_string =~ /^#{character_class_that_doesnt_contain_bracket}$/
         return true
     end
     
     # fail if more than one of any of the above
-    if regex_string =~ /^(#{normal_char}|\\[\w\W]|\[[^\]]*\]){2,}$/
+    if regex_string =~ /^(#{normal_char}|#{escape_sequence}|#{character_class_that_doesnt_contain_bracket}){2,}$/
         return false
     end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_grammar_builder
 version: !ruby/object:Gem::Version
-  version: 1.1.10
+  version: 1.1.12
 platform: ruby
 authors:
 - Jeff Hykin
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-06 00:00:00.000000000 Z
+date: 2023-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_clone