ruby_grammar_builder 1.1.10 → 1.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c847c5f5b831cc00f4067e4030639263c104b9923a85b42aa96d038355d79a66
-  data.tar.gz: e1dd84c95ef84fb92d50ac15b13004c303fa2bee43b328774f2b29773aeb7ddd
+  metadata.gz: 58d3e3e3fe4b1e992aa23abace8ae7ad9d0e7ca6b3e6b1237e1f9f800317fd81
+  data.tar.gz: 2b2423273398cc66d8637d97e41434d7a62c270477b224d5343c339e7f51a33b
 SHA512:
-  metadata.gz: 9734da744fd7cc482a30d69a6a51d2104cd7ca019bf7170652094b4114484e2c481839f0b950949955c8f69f6579acdfb0092acbdcd74a8b04fc73ef3008251d
-  data.tar.gz: 51214dc748e1e93d60e815cd5ad14c43dc07313a8194d9df89fbf88696e485f2574b234f86177ed39f3907c98de0e5a2b600088bd103fd91a114c515b5a6abc9
+  metadata.gz: 21fb51484f36fcdf93a619ac6e29a96ac2fb50d26dfd3e2a8eb79d2ef7a0c83ec930817045d7340abf9aff5edc9369cb09d2ca4d34fb2c90c280b67527cd817b
+  data.tar.gz: 10c1c631a8bca900ff2c40d9f38ada75cdd310bbcab36cace76f80d745b655f55fbe338fa5d015932a2eef694bbee5434c084e500f0afeb03803b9671b24a0bf

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
@@ -415,6 +415,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 +429,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 +451,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 [
@@ -719,22 +731,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
@@ -177,7 +173,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)

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.11
 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-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_clone