jcrvalidator 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61807efb31326c093b5f71984a9ee55e41710598
-  data.tar.gz: d6184f8217ff27d09729397af1a43a493d972cff
+  metadata.gz: e15f3d872870b687c53a8cf98ab6668afec8c3c5
+  data.tar.gz: 01250f5fe01fe29a8025f6aac9da8c83766df494
 SHA512:
-  metadata.gz: 90dce4aefb3417a50651f442b5e14d329f339b7c9ddafb9dbddfdac8ef21c52555354024a776420ef619bc75398ba9935f682b90c905bd0db58fab4f19ba5d0a
-  data.tar.gz: 432da197590f3454f5eca393b33d9e43b7ce54a27b8a938af0a0397961e328ff6f8c6c62605819d6407c0ed7544df587fa55b0f52040205facea3c255b66cae9
+  metadata.gz: 6218f0d7f612b32759383f0869e39bbaf04850cdaf12cd4400796b164e745da40ffc371d9f564abd4e0135417805b5794c0c94af68f7282cb5c8284d3910e3fb
+  data.tar.gz: 4c1aebcccc76bd2806ca98d9d7e582e3353eda4c07a2fc1fb915a5ffcf192172b2ce04015046bfca5f566e0fa67a789164aa68421b90b3f3aee8df28e41fcc8d

data/lib/jcr/check_groups.rb

@@ -78,8 +78,6 @@ module JCR
       disallowed_group_in_member?( trule, mapping )
     elsif node[:group_rule]
       disallowed_group_in_member?( node[:group_rule], mapping )
-    else
-      check_groups( node, mapping )
     end
   end
 
@@ -117,8 +115,6 @@ module JCR
         disallowed_group_in_array?(trule, mapping)
       elsif node[:group_rule]
         disallowed_group_in_array?(node[:group_rule], mapping)
-      else
-        check_groups(node, mapping)
       end
     end
   end
@@ -132,9 +128,7 @@ module JCR
         disallowed_group_in_array?( groupee[:group_rule], mapping )
       elsif groupee[:target_rule_name]
         trule = get_name_mapping( groupee[:target_rule_name][:rule_name], mapping )
-        if trule[:group_rule]
-          disallowed_group_in_array?( trule[:group_rule], mapping )
-        end
+        disallowed_group_in_array?( trule, mapping )
       elsif groupee[:member_rule]
         raise_group_error( "groups in array rules cannot have member rules", groupee[:member_rule] )
       else
@@ -154,8 +148,6 @@ module JCR
         disallowed_group_in_object?(trule, mapping)
       elsif node[:group_rule]
         disallowed_group_in_object?(node[:group_rule], mapping)
-      else
-        check_groups(node, mapping)
       end
     end
   end
@@ -169,9 +161,7 @@ module JCR
         disallowed_group_in_object?( groupee[:group_rule], mapping )
       elsif groupee[:target_rule_name]
         trule = get_name_mapping( groupee[:target_rule_name][:rule_name], mapping )
-        if trule[:group_rule]
-          disallowed_group_in_object?( trule[:group_rule], mapping )
-        end
+        disallowed_group_in_object?( trule, mapping )
       elsif groupee[:array_rule]
         raise_group_error( "groups in object rules cannot have array rules", groupee[:member_rule] )
       elsif groupee[:object_rule]
@@ -188,9 +178,9 @@ module JCR
     if node.is_a?( Parslet::Slice )
       pos = node.line_and_column
       name = node.to_str
-      raise "group rule error at line " + pos[0].to_s + " column " + pos[1].to_s + " name '" + name + "' :" + str
+      raise JCR::JcrValidatorError, "group rule error at line " + pos[0].to_s + " column " + pos[1].to_s + " name '" + name + "' :" + str
     else
-      raise "group rule error with '" + node.to_s + "' :" + str
+      raise JCR::JcrValidatorError, "group rule error with '" + node.to_s + "' :" + str
     end
   end
 

data/lib/jcr/evaluate_array_rules.rb

@@ -45,19 +45,28 @@ module JCR
     end
   end
 
-  def self.evaluate_array_rule jcr, rule_atom, data, econs, behavior = nil
+  def self.evaluate_array_rule jcr, rule_atom, data, econs, behavior = nil, target_annotations = nil
 
     push_trace_stack( econs, jcr )
-    trace( econs, "Evaluating array rule starting at #{slice_to_s(jcr)} against", data )
-    trace_def( econs, "array", jcr, data )
-    retval = evaluate_array( jcr, rule_atom, data, econs, behavior )
-    trace_eval( econs, "Array", retval, jcr, data, "array" )
+    if behavior
+      trace( econs, "Evaluating group in array rule starting at #{slice_to_s(jcr)} against", data )
+      trace_def( econs, "array group", jcr, data )
+    else
+      trace( econs, "Evaluating array rule starting at #{slice_to_s(jcr)} against", data )
+      trace_def( econs, "array", jcr, data )
+    end
+    retval = evaluate_array( jcr, rule_atom, data, econs, behavior, target_annotations )
+    if behavior
+      trace_eval( econs, "Array group", retval, jcr, data, "array" )
+    else
+      trace_eval( econs, "Array", retval, jcr, data, "array" )
+    end
     pop_trace_stack( econs )
     return retval
 
   end
 
-  def self.evaluate_array jcr, rule_atom, data, econs, behavior = nil
+  def self.evaluate_array jcr, rule_atom, data, econs, behavior = nil, target_annotations = nil
 
     rules, annotations = get_rules_and_annotations( jcr )
 
@@ -76,20 +85,24 @@ module JCR
 
     # if the data is not an array
     return evaluate_not( annotations,
-      Evaluation.new( false, "#{data} is not an array #{raised_rule(jcr,rule_atom)}"), econs ) unless data.is_a? Array
+      Evaluation.new( false, "#{data} is not an array #{raised_rule(jcr,rule_atom)}"),
+                         econs, target_annotations ) unless data.is_a? Array
 
     # if the array is zero length and there are zero sub-rules (it is suppose to be empty)
     return evaluate_not( annotations,
-      Evaluation.new( true, nil ), econs ) if rules.empty? && data.empty?
+      Evaluation.new( true, nil ), econs, target_annotations ) if rules.empty? && data.empty?
 
     # if the array is not empty and there are zero sub-rules (it is suppose to be empty)
     return evaluate_not( annotations,
-      Evaluation.new( false, "Non-empty array for #{raised_rule(jcr,rule_atom)}" ), econs ) if rules.empty? && data.length != 0
+      Evaluation.new( false, "Non-empty array for #{raised_rule(jcr,rule_atom)}" ),
+                         econs, target_annotations ) if rules.empty? && data.length != 0
 
     if ordered
-      return evaluate_not( annotations, evaluate_array_rule_ordered( rules, rule_atom, data, econs, behavior ), econs )
+      return evaluate_not( annotations, evaluate_array_rule_ordered( rules, rule_atom, data, econs, behavior ),
+                           econs, target_annotations )
     else
-      return evaluate_not( annotations, evaluate_array_rule_unordered( rules, rule_atom, data, econs, behavior ), econs )
+      return evaluate_not( annotations, evaluate_array_rule_unordered( rules, rule_atom, data, econs, behavior ),
+                           econs, target_annotations )
     end
   end
 
@@ -115,7 +128,8 @@ module JCR
       # groups require the effects of the evaluation to be discarded if they are false
       # groups must also be given the entire array
 
-      if (grule = get_group(rule, econs))
+      grule, target_annotations = get_group( rule, econs )
+      if grule
 
         if repeat_min == 0
           retval = Evaluation.new( true, nil )
@@ -126,7 +140,7 @@ module JCR
             else
               group_behavior = ArrayBehavior.new( behavior )
               group_behavior.last_index = array_index
-              retval = evaluate_rule( grule, rule_atom, data, econs, group_behavior )
+              retval = evaluate_rule( grule, rule_atom, data, econs, group_behavior, target_annotations )
               if retval.success
                 behavior.checked_hash.merge!( group_behavior.checked_hash )
                 array_index = group_behavior.last_index
@@ -141,7 +155,7 @@ module JCR
             break if array_index == data.length
             group_behavior = ArrayBehavior.new( behavior )
             group_behavior.last_index = array_index
-            e = evaluate_rule( grule, rule_atom, data, econs, group_behavior )
+            e = evaluate_rule( grule, rule_atom, data, econs, group_behavior, target_annotations )
             if e.success
               behavior.checked_hash.merge!( group_behavior.checked_hash )
               array_index = group_behavior.last_index
@@ -187,7 +201,7 @@ module JCR
     behavior.last_index = array_index
 
     if data.length > array_index && behavior.extra_prohibited
-      retval = Evaluation.new( false, "More itmes in array than specified for #{raised_rule(jcr,rule_atom)}" )
+      retval = Evaluation.new( false, "More items in array (#{data.length}) than specified (#{array_index}) for #{raised_rule(jcr,rule_atom)}" )
     end
 
     return retval
@@ -218,14 +232,15 @@ module JCR
       # groups require the effects of the evaluation to be discarded if they are false
       # groups must also be given the entire array
 
-      if (grule = get_group(rule, econs))
+      grule,target_annotations = get_group(rule, econs)
+      if grule
 
         successes = 0
         for i in 0..repeat_max-1
           group_behavior = ArrayBehavior.new( behavior )
           group_behavior.last_index = highest_index
           group_behavior.ordered = false
-          e = evaluate_rule( grule, rule_atom, data, econs, group_behavior )
+          e = evaluate_rule( grule, rule_atom, data, econs, group_behavior, target_annotations )
           if e.success
             highest_index = group_behavior.last_index
             behavior.checked_hash.merge!( group_behavior.checked_hash )
@@ -236,13 +251,13 @@ module JCR
         end
 
         if successes == 0 && repeat_min > 0
-          retval = Evaluation.new( false, "array does not contain #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array does not contain #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif successes < repeat_min
-          retval = Evaluation.new( false, "array does not have enough #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array does not have enough #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif successes > repeat_max
-          retval = Evaluation.new( false, "array has too many #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array has too many #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif repeat_step && ( successes - repeat_min ) % repeat_step != 0
-          retval = Evaluation.new( false, "array matches (#{successes}) do not meet repetition step of #{repeat_max} % #{repeat_step} with #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array matches (#{successes}) do not meet repetition step of #{repeat_max} % #{repeat_step} with #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         else
           retval = Evaluation.new( true, nil )
         end
@@ -263,13 +278,13 @@ module JCR
         end
 
         if successes == 0 && repeat_min > 0
-          retval = Evaluation.new( false, "array does not contain #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array does not contain #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif successes < repeat_min
-          retval = Evaluation.new( false, "array does not have enough #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array does not have enough #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif successes > repeat_max
-          retval = Evaluation.new( false, "array has too many #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array has too many #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif repeat_step && ( successes - repeat_min ) % repeat_step != 0
-          retval = Evaluation.new( false, "array matches (#{successes}) do not meet repetition step of #{repeat_max} % #{repeat_step} with #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "array matches (#{successes}) do not meet repetition step of #{repeat_max} % #{repeat_step} with #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         else
           retval = Evaluation.new( true, nil)
         end
@@ -281,7 +296,7 @@ module JCR
     behavior.last_index = highest_index
 
     if data.length > behavior.checked_hash.length && behavior.extra_prohibited
-      retval = Evaluation.new( false, "More itmes in array than specified for #{raised_rule(jcr,rule_atom)}" )
+      retval = Evaluation.new( false, "More items in array than specified for #{raised_rule(jcr,rule_atom)}" )
     end
 
     return retval

data/lib/jcr/evaluate_group_rules.rb

@@ -26,19 +26,19 @@ require 'jcr/evaluate_rules'
 
 module JCR
 
-  def self.evaluate_group_rule jcr, rule_atom, data, econs, behavior = nil
+  def self.evaluate_group_rule jcr, rule_atom, data, econs, behavior = nil, target_annotations = nil
 
     push_trace_stack( econs, jcr )
     trace( econs, "Evaluating group rule against ", data )
     trace_def( econs, "group", jcr, data )
-    retval = evaluate_group( jcr, rule_atom, data, econs, behavior )
+    retval = evaluate_group( jcr, rule_atom, data, econs, behavior, target_annotations )
     trace_eval( econs, "Group", retval, jcr, data, "group" )
     pop_trace_stack( econs )
     return retval
 
   end
 
-  def self.evaluate_group jcr, rule_atom, data, econs, behavior = nil
+  def self.evaluate_group jcr, rule_atom, data, econs, behavior = nil, target_annotations = nil
 
     rules, annotations = get_rules_and_annotations( jcr )
 
@@ -46,14 +46,14 @@ module JCR
 
     rules.each do |rule|
       if rule[:choice_combiner] && retval && retval.success
-        return evaluate_not( annotations, retval, econs ) # short circuit
+        return evaluate_not( annotations, retval, econs, target_annotations ) # short circuit
       elsif rule[:sequence_combiner] && retval && !retval.success
-        return evaluate_not( annotations, retval, econs ) # short circuit
+        return evaluate_not( annotations, retval, econs, target_annotations ) # short circuit
       end
       retval = evaluate_rule( rule, rule_atom, data, econs, behavior )
     end
 
-    return evaluate_not( annotations, retval, econs )
+    return evaluate_not( annotations, retval, econs, target_annotations )
   end
 
   def self.group_to_s( jcr, shallow=true)

data/lib/jcr/evaluate_member_rules.rb

@@ -25,19 +25,19 @@ require 'jcr/check_groups'
 
 module JCR
 
-  def self.evaluate_member_rule jcr, rule_atom, data, econs
+  def self.evaluate_member_rule jcr, rule_atom, data, econs, behavior, target_annotations
 
     push_trace_stack( econs, jcr )
     trace( econs, "Evaluating member rule for key '#{data[0]}' starting at #{slice_to_s(jcr)} against ", data[1])
     trace_def( econs, "member", jcr, data )
-    retval = evaluate_member( jcr, rule_atom, data, econs )
+    retval = evaluate_member( jcr, rule_atom, data, econs, behavior, target_annotations )
     trace_eval( econs, "Member", retval, jcr, data, "member" )
     pop_trace_stack( econs )
     return retval
 
   end
 
-  def self.evaluate_member jcr, rule_atom, data, econs
+  def self.evaluate_member jcr, rule_atom, data, econs, behavior, target_annotations
 
     # unlike the other evaluate functions, here data is not just the json data.
     # it is an array, the first element being the member name or regex and the
@@ -68,13 +68,14 @@ module JCR
     end
 
     if member_match
-      e = evaluate_rule( rule, rule_atom, data[ 1 ], econs )
+      e = evaluate_rule( rule, rule_atom, data[ 1 ], econs, nil, target_annotations )
       e.member_found = true
-      return evaluate_not( annotations, e, econs )
+      return evaluate_not( annotations, e, econs, target_annotations )
     end
 
     return evaluate_not( annotations,
-       Evaluation.new( false, "#{match_spec} does not match #{data[0]} for #{raised_rule( jcr, rule_atom)}" ), econs )
+       Evaluation.new( false, "#{match_spec} does not match #{data[0]} for #{raised_rule( jcr, rule_atom)}" ),
+                         econs, target_annotations )
 
   end
 

data/lib/jcr/evaluate_object_rules.rb

@@ -27,33 +27,44 @@ module JCR
     end
   end
 
-  def self.evaluate_object_rule jcr, rule_atom, data, econs, behavior = nil
+  def self.evaluate_object_rule jcr, rule_atom, data, econs, behavior = nil, target_annotations = nil
 
     push_trace_stack( econs, jcr )
-    trace( econs, "Evaluating object rule starting at #{slice_to_s(jcr)} against", data )
-    trace_def( econs, "object", jcr, data )
-    retval = evaluate_object( jcr, rule_atom, data, econs, behavior )
-    trace_eval( econs, "Object", retval, jcr, data, "object" )
+    if behavior
+      trace( econs, "Evaluating group in object rule starting at #{slice_to_s(jcr)} against", data )
+      trace_def( econs, "object group", jcr, data )
+    else
+      trace( econs, "Evaluating object rule starting at #{slice_to_s(jcr)} against", data )
+      trace_def( econs, "object", jcr, data )
+    end
+    retval = evaluate_object( jcr, rule_atom, data, econs, behavior, target_annotations )
+    if behavior
+      trace_eval( econs, "Object group", retval, jcr, data, "object" )
+    else
+      trace_eval( econs, "Object", retval, jcr, data, "object" )
+    end
     pop_trace_stack( econs )
     return retval
 
   end
 
-  def self.evaluate_object jcr, rule_atom, data, econs, behavior = nil
+  def self.evaluate_object jcr, rule_atom, data, econs, behavior = nil, target_annotations = nil
 
     rules, annotations = get_rules_and_annotations( jcr )
 
     # if the data is not an object (Hash)
     return evaluate_not( annotations,
-      Evaluation.new( false, "#{data} is not an object for #{raised_rule(jcr,rule_atom)}"), econs ) unless data.is_a? Hash
+      Evaluation.new( false, "#{data} is not an object for #{raised_rule(jcr,rule_atom)}"),
+                      econs, target_annotations ) unless data.is_a? Hash
 
     # if the object has no members and there are zero sub-rules (it is suppose to be empty)
     return evaluate_not( annotations,
-      Evaluation.new( true, nil ), econs ) if rules.empty? && data.length == 0
+      Evaluation.new( true, nil ), econs, target_annotations ) if rules.empty? && data.length == 0
 
     # if the object has members and there are zero sub-rules (it is suppose to be empty)
     return evaluate_not( annotations,
-      Evaluation.new( false, "Non-empty object for #{raised_rule(jcr,rule_atom)}" ), econs ) if rules.empty? && data.length != 0
+      Evaluation.new( false, "Non-empty object for #{raised_rule(jcr,rule_atom)}" ),
+                         econs, target_annotations ) if rules.empty? && data.length != 0
 
     retval = nil
     behavior = ObjectBehavior.new unless behavior
@@ -64,7 +75,7 @@ module JCR
       if rule[:choice_combiner] && retval && retval.success
         next
       elsif rule[:sequence_combiner] && retval && !retval.success
-        return evaluate_not( annotations, retval, econs ) # short circuit
+        return evaluate_not( annotations, retval, econs, target_annotations ) # short circuit
       end
 
       repeat_min, repeat_max, repeat_step = get_repetitions( rule, econs )
@@ -76,13 +87,14 @@ module JCR
       # Also, groups must be handed the entire object, not key/values
       # as member rules use.
 
-      if (grule = get_group(rule, econs))
+      grule,gtarget_annotations = get_group(rule, econs)
+      if grule
 
         successes = 0
         for i in 0..repeat_max-1
           group_behavior = ObjectBehavior.new
           group_behavior.checked_hash.merge!( behavior.checked_hash )
-          e = evaluate_rule( grule, rule_atom, data, econs, group_behavior )
+          e = evaluate_rule( grule, rule_atom, data, econs, group_behavior, gtarget_annotations )
           if e.success
             behavior.checked_hash.merge!( group_behavior.checked_hash )
             successes = successes + 1
@@ -92,11 +104,11 @@ module JCR
         end
 
         if successes == 0 && repeat_min > 0
-          retval = Evaluation.new( false, "object does not contain group #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "object does not contain group #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif successes < repeat_min
-          retval = Evaluation.new( false, "object does not have contain necessary number of group #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "object does not have contain necessary number of group #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif repeat_step && ( successes - repeat_min ) % repeat_step != 0
-          retval = Evaluation.new( false, "object matches (#{successes}) do not have contain repetition #{repeat_max} % #{repeat_step} of group #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "object matches (#{successes}) do not have contain repetition #{repeat_max} % #{repeat_step} of group #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         else
           retval = Evaluation.new( true, nil )
         end
@@ -109,7 +121,7 @@ module JCR
         # if defined by a name, and not a regex, just pluck it from the object
         # and short-circuit the enumeration
 
-        lookahead = get_leaf_rule( rule, econs )
+        lookahead, ltarget_annotations = get_leaf_rule( rule, econs )
         lrules, lannotations = get_rules_and_annotations( lookahead[:member_rule] )
         if lrules[0][:member_name]
 
@@ -118,13 +130,13 @@ module JCR
           v = data[k]
           if v
             unless behavior.checked_hash[k]
-              e = evaluate_rule(rule, rule_atom, [k, v], econs, nil)
+              e = evaluate_rule(rule, rule_atom, [k, v], econs, nil, nil)
               behavior.checked_hash[k] = e.success
               repeat_results[ k ] = v if e.success
             end
           else
             trace( econs, "No member '#{k}' found in object.")
-            e = evaluate_rule(rule, rule_atom, [nil, nil], econs, nil)
+            e = evaluate_rule(rule, rule_atom, [nil, nil], econs, nil, nil)
             repeat_results[ nil ] = nil if e.success
           end
 
@@ -137,7 +149,7 @@ module JCR
           repeat_results = data.select do |k,v|
             unless behavior.checked_hash[k]
               if i < repeat_max
-                e = evaluate_rule(rule, rule_atom, [k, v], econs, nil)
+                e = evaluate_rule(rule, rule_atom, [k, v], econs, nil, nil)
                 behavior.checked_hash[k] = e.success
                 i = i + 1 if e.success
                 found = true if e.member_found
@@ -147,7 +159,7 @@ module JCR
           end
           unless found
             trace( econs, "No member matching #{regex} found in object.")
-            e = evaluate_rule(rule, rule_atom, [nil, nil], econs, nil)
+            e = evaluate_rule(rule, rule_atom, [nil, nil], econs, nil, nil)
             repeat_results[ nil ] = nil if e.success
           end
 
@@ -155,13 +167,13 @@ module JCR
 
         trace( econs, "Found #{repeat_results.length} matching members repetitions in object with min #{repeat_min} and max #{repeat_max}" )
         if repeat_results.length == 0 && repeat_min > 0
-          retval = Evaluation.new( false, "object does not contain #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "object does not contain #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif repeat_results.length < repeat_min
-          retval = Evaluation.new( false, "object does not have enough #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "object does not have enough #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif repeat_results.length > repeat_max
-          retval = Evaluation.new( false, "object has too many #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "object has too many #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         elsif repeat_step && ( repeat_results.length - repeat_min ) % repeat_step != 0
-          retval = Evaluation.new( false, "object matches (#{repeat_results.length}) does not match repetition step of #{repeat_max} & #{repeat_step} for #{rule} for #{raised_rule(jcr,rule_atom)}")
+          retval = Evaluation.new( false, "object matches (#{repeat_results.length}) does not match repetition step of #{repeat_max} & #{repeat_step} for #{jcr_to_s(rule)} for #{raised_rule(jcr,rule_atom)}")
         else
           retval = Evaluation.new( true, nil)
         end
@@ -169,7 +181,7 @@ module JCR
 
     end # end if grule else
 
-    return evaluate_not( annotations, retval, econs )
+    return evaluate_not( annotations, retval, econs, target_annotations )
   end
 
   def self.object_to_s( jcr, shallow=true )

data/lib/jcr/evaluate_rules.rb

@@ -68,8 +68,14 @@ module JCR
     end
 
     def report_failure failure
-      @failures[ failure.stack_level ] = Array.new unless @failures[ failure.stack_level ]
-      @failures[ failure.stack_level ] << failure
+      coord = JCR::trace_coord( self )
+      @failures[ coord ] = Array.new unless @failures[ coord ]
+      @failures[ coord ] << failure
+    end
+
+    def report_success
+      coord = JCR::trace_coord( self )
+      @failures.delete( coord )
     end
   end
 
@@ -91,7 +97,7 @@ module JCR
     end
   end
 
-  def self.evaluate_rule jcr, rule_atom, data, econs, behavior = nil
+  def self.evaluate_rule jcr, rule_atom, data, econs, behavior = nil, target_annotations = nil
     if jcr.is_a?( Hash )
       if jcr[:rule_name]
         rn = slice_to_s( jcr[:rule_name] )
@@ -102,26 +108,24 @@ module JCR
     retval = Evaluation.new( false, "failed to evaluate rule properly" )
     case
       when behavior.is_a?( ArrayBehavior )
-        retval = evaluate_array_rule( jcr, rule_atom, data, econs, behavior)
+        retval = evaluate_array_rule( jcr, rule_atom, data, econs, behavior, target_annotations )
       when behavior.is_a?( ObjectBehavior )
-        retval = evaluate_object_rule( jcr, rule_atom, data, econs, behavior)
+        retval = evaluate_object_rule( jcr, rule_atom, data, econs, behavior, target_annotations )
       when jcr[:rule]
-        retval = evaluate_rule( jcr[:rule], rule_atom, data, econs, behavior)
+        retval = evaluate_rule( jcr[:rule], rule_atom, data, econs, behavior, target_annotations)
       when jcr[:target_rule_name]
-        target = econs.mapping[ jcr[:target_rule_name][:rule_name].to_s ]
-        raise "Target rule not in mapping. This should have been checked earlier." unless target
-        trace( econs, "Referencing target rule #{slice_to_s(target)} from #{slice_to_s( jcr[:target_rule_name][:rule_name] )}" )
-        retval = evaluate_rule( target, target, data, econs, behavior )
+        target, target_annotations = get_target_rule( jcr, econs )
+        retval = evaluate_rule( target, target, data, econs, behavior, target_annotations )
       when jcr[:primitive_rule]
-        retval = evaluate_value_rule( jcr[:primitive_rule], rule_atom, data, econs)
+        retval = evaluate_value_rule( jcr[:primitive_rule], rule_atom, data, econs, nil, target_annotations )
       when jcr[:group_rule]
-        retval = evaluate_group_rule( jcr[:group_rule], rule_atom, data, econs, behavior)
+        retval = evaluate_group_rule( jcr[:group_rule], rule_atom, data, econs, behavior, target_annotations)
       when jcr[:array_rule]
-        retval = evaluate_array_rule( jcr[:array_rule], rule_atom, data, econs, behavior)
+        retval = evaluate_array_rule( jcr[:array_rule], rule_atom, data, econs, behavior, target_annotations )
       when jcr[:object_rule]
-        retval = evaluate_object_rule( jcr[:object_rule], rule_atom, data, econs, behavior)
+        retval = evaluate_object_rule( jcr[:object_rule], rule_atom, data, econs, behavior, target_annotations)
       when jcr[:member_rule]
-        retval = evaluate_member_rule( jcr[:member_rule], rule_atom, data, econs)
+        retval = evaluate_member_rule( jcr[:member_rule], rule_atom, data, econs, nil, target_annotations)
       else
         retval = Evaluation.new( true, nil )
     end
@@ -153,6 +157,13 @@ module JCR
     return retval
   end
 
+  def self.get_target_rule jcr, econs
+    target = econs.mapping[ jcr[:target_rule_name][:rule_name].to_s ]
+    raise "Target rule not in mapping. This should have been checked earlier." unless target
+    trace( econs, "Referencing target rule #{slice_to_s(target)} from #{slice_to_s( jcr[:target_rule_name][:rule_name] )}" )
+    return target,jcr[:target_rule_name][:annotations]
+  end
+
   def self.get_repetitions rule, econs
 
     repeat_min = 1
@@ -245,11 +256,20 @@ module JCR
     return new_rule
   end
 
-  def self.evaluate_not annotations, evaluation, econs
+  def self.evaluate_not annotations, evaluation, econs, target_annotations = nil
     is_not = false
+
+    target_annotations.each do |a|
+      if a[:not_annotation]
+        trace( econs, "Not annotation found on reference to rule.")
+        is_not = !is_not
+        break
+      end
+    end if target_annotations
+
     annotations.each do |a|
       if a[:not_annotation]
-        is_not = true
+        is_not = !is_not
         break
       end
     end
@@ -262,27 +282,23 @@ module JCR
   end
 
   def self.get_group rule, econs
-    return rule[:group_rule] if rule[:group_rule]
+    return rule[:group_rule], nil if rule[:group_rule]
     #else
     if rule[:target_rule_name]
-      target = econs.mapping[ rule[:target_rule_name][:rule_name].to_s ]
-      raise "Target rule not in mapping. This should have been checked earlier." unless target
-      trace( econs, "Referencing target rule #{slice_to_s(target)} from #{slice_to_s( rule[:target_rule_name][:rule_name] )}" )
-      return get_group( target, econs )
+      target, target_annotations = get_target_rule( rule, econs )
+      return get_group( target, econs )[0], target_annotations
     end
     #else
-    return false
+    return false, nil
   end
 
   def self.get_leaf_rule rule, econs
     if rule[:target_rule_name ]
-      target = econs.mapping[ rule[:target_rule_name][:rule_name].to_s ]
-      raise "Target rule not in mapping. This should have been checked earlier." unless target
-      trace( econs, "Referencing target rule #{slice_to_s(target)} from #{slice_to_s( rule[:target_rule_name][:rule_name] )}" )
-      return target
+      target, target_annotations = get_target_rule( rule, econs )
+      return target, target_annotations
     end
     #else
-    return rule
+    return rule, nil
   end
 
   def self.push_trace_stack econs, jcr
@@ -320,11 +336,16 @@ module JCR
         message = "#{message} data: #{rule_data( data )}"
       end
       last = econs.trace_stack.last
-      pos = "#{last.line_and_column}@#{last.offset}" if last
-      puts "[ #{econs.trace_stack.length}:#{pos} ] #{message}"
+      puts "[ depth=#{econs.trace_stack.length}:#{trace_coord(econs)} ] #{message}"
     end
   end
 
+  def self.trace_coord econs
+    last = econs.trace_stack.last
+    pos = "#{last.line_and_column}" if last
+    return "pos=#{pos}"
+  end
+
   def self.rule_def type, jcr
     s = ""
     case type
@@ -334,14 +355,18 @@ module JCR
         s = elide(member_to_s(jcr))
       when "object"
         s = elide(object_to_s(jcr))
+      when "object group"
+        s = elide(group_to_s(jcr))
       when "array"
         s = elide(array_to_s(jcr))
+      when "array group"
+        s = elide(array_to_s(jcr))
       when "group"
         s = elide(group_to_s(jcr))
       else
         s = "** unknown rule **"
     end
-    return "#{type} definition: #{s}"
+    return "#{type} definition << #{s} >>"
   end
 
   def self.trace_def econs, type, jcr, data
@@ -354,8 +379,12 @@ module JCR
           s = elide( member_to_s( jcr  ) )
         when "object"
           s = elide( object_to_s( jcr ) )
+        when "object group"
+          s = elide( group_to_s( jcr ) )
         when "array"
           s = elide( array_to_s( jcr ) )
+        when "array group"
+          s = elide( array_to_s( jcr ) )
         when "group"
           s = elide( group_to_s( jcr ) )
         else
@@ -367,6 +396,7 @@ module JCR
 
   def self.trace_eval econs, message, evaluation, jcr, data, type
     if evaluation.success
+      econs.report_success
       trace( econs, "#{message} evaluation is true" )
     else
       failure = Failure.new( data, jcr, type, evaluation, econs.trace_stack.length )
@@ -409,7 +439,28 @@ module JCR
   end
 
   def self.raised_rule jcr, rule_atom
-    " rule at #{slice_to_s(jcr)} [ #{jcr} ] from rule at #{slice_to_s(rule_atom)}"
+    " rule at #{slice_to_s(jcr)} #{jcr_to_s(jcr)} from rule at #{slice_to_s(rule_atom)}"
+  end
+
+  def self.jcr_to_s( jcr, shallow=true )
+    if jcr.is_a? Array
+      retval = ""
+      jcr.each_with_index do |item,idx|
+        if idx > 1
+          retval = retval + " , "
+        end
+        retval = retval + jcr_to_s( item, shallow )
+      end
+    elsif jcr.is_a? Parslet::Slice
+      retval = slice_to_s( jcr )
+    else
+      if jcr[:q_string]
+        retval = value_to_s( jcr )
+      else
+        retval = rule_to_s( jcr, shallow )
+      end
+    end
+    return "<< " + retval + " >>"
   end
 
   def self.rule_to_s( rule, shallow=true)

data/lib/jcr/evaluate_value_rules.rb

@@ -25,14 +25,15 @@ require 'jcr/check_groups'
 
 module JCR
 
-  def self.evaluate_value_rule jcr, rule_atom, data, econs
+  def self.evaluate_value_rule jcr, rule_atom, data, econs, behavior, target_annotations
 
     push_trace_stack( econs, jcr )
     trace( econs, "Evaluating value rule starting at #{slice_to_s(jcr)}" )
     trace_def( econs, "value", jcr, data )
     rules, annotations = get_rules_and_annotations( jcr )
 
-    retval = evaluate_not( annotations, evaluate_values( rules[0], rule_atom, data, econs ), econs )
+    retval = evaluate_not( annotations, evaluate_values( rules[0], rule_atom, data, econs ),
+                           econs, target_annotations )
     trace_eval( econs, "Value", retval, jcr, data, "value")
     pop_trace_stack( econs )
     return retval
@@ -401,7 +402,7 @@ module JCR
   end
 
   def self.bad_value jcr, rule_atom, expected, actual
-    Evaluation.new( false, "expected #{expected} but got #{actual} for #{raised_rule(jcr,rule_atom)}" )
+    Evaluation.new( false, "expected << #{expected} >> but got << #{actual} >> for #{raised_rule(jcr,rule_atom)}" )
   end
 
   def self.value_to_s( jcr, shallow=true )

data/lib/jcr/jcr.rb

@@ -17,6 +17,7 @@ require 'rubygems'
 require 'json'
 require 'pp'
 
+require 'jcr/jcr_validator_error'
 require 'jcr/parser'
 require 'jcr/evaluate_rules'
 require 'jcr/check_groups'
@@ -63,7 +64,7 @@ module JCR
       @trace = trace
       @failed_roots = []
       if ruleset
-        ingested = JCR.ingest_ruleset( ruleset, false, nil )
+        ingested = JCR.ingest_ruleset( ruleset, nil, nil )
         @mapping = ingested.mapping
         @callbacks = ingested.callbacks
         @id = ingested.id
@@ -73,7 +74,7 @@ module JCR
     end
 
     def override( ruleset )
-      overridden = JCR.ingest_ruleset( ruleset, true, nil )
+      overridden = JCR.ingest_ruleset( ruleset, @mapping, nil )
       mapping = {}
       mapping.merge!( @mapping )
       mapping.merge!( overridden.mapping )
@@ -87,7 +88,7 @@ module JCR
     end
 
     def override!( ruleset )
-      overridden = JCR.ingest_ruleset( ruleset, true, nil )
+      overridden = JCR.ingest_ruleset( ruleset, @mapping, nil )
       @mapping.merge!( overridden.mapping )
       @callbacks.merge!( overridden.callbacks )
       @roots.concat( overridden.roots )
@@ -95,11 +96,14 @@ module JCR
 
   end
 
-  def self.ingest_ruleset( ruleset, override = false, ruleset_alias=nil )
+  def self.ingest_ruleset( ruleset, existing_mapping = nil, ruleset_alias=nil )
     tree = JCR.parse( ruleset )
-    mapping = JCR.map_rule_names( tree, override, ruleset_alias )
-    JCR.check_rule_target_names( tree, mapping )
-    JCR.check_groups( tree, mapping )
+    mapping = JCR.map_rule_names( tree, ruleset_alias )
+    combined_mapping = {}
+    combined_mapping.merge!( existing_mapping ) if existing_mapping
+    combined_mapping.merge!( mapping )
+    JCR.check_rule_target_names( tree, combined_mapping )
+    JCR.check_groups( tree, combined_mapping )
     roots = JCR.find_roots( tree )
     ctx = Context.new
     ctx.tree = tree
@@ -114,19 +118,19 @@ module JCR
     roots = []
     if root_name
       root_rule = ctx.mapping[root_name]
-      raise "No rule by the name of #{root_name} for a root rule has been found" unless root_rule
+      raise JcrValidatorError, "No rule by the name of #{root_name} for a root rule has been found" unless root_rule
       root = JCR::Root.new( root_rule, root_name )
       roots << root
     else
       roots = ctx.roots
     end
 
-    raise "No root rule defined. Specify a root rule name" if roots.empty?
+    raise JcrValidatorError, "No root rule defined. Specify a root rule name" if roots.empty?
 
     retval = nil
     roots.each do |r|
       pp "Evaluating Root:", rule_to_s( r.rule, false ) if ctx.trace
-      raise "Root rules cannot be member rules" if r.rule[:member_rule]
+      raise JcrValidatorError, "Root rules cannot be member rules" if r.rule[:member_rule]
       econs = EvalConditions.new( ctx.mapping, ctx.callbacks, ctx.trace )
       retval = JCR.evaluate_rule( r.rule, r.rule, data, econs )
       break if retval.success
@@ -143,24 +147,40 @@ module JCR
     report = []
     ctx.failed_roots.each do |failed_root|
       if failed_root.name
-        report << "- ** Failures for root rule named '#{failed_root.name}'"
+        report << "- Failures for root rule named '#{failed_root.name}'"
       else
-        report << "- ** Failures for root rule at line #{failed_root.pos[0]}"
+        report << "- Failures for root rule at line #{failed_root.pos[0]}"
       end
       failed_root.failures.sort.map do |stack_level, failures|
         if failures.length > 1
-          report << "  - failure at rule depth #{stack_level} caused by one of the following #{failures.length} reasons"
+          report << "  - failure at rule #{stack_level} caused by one of the following #{failures.length} reasons"
         else
-          report << "  - failure at rule depth #{stack_level} caused by"
+          report << "  - failure at rule #{stack_level} caused by"
         end
         failures.each_with_index do |failure, index|
-          report << "    - #{failure.json_elided} failed rule #{failure.definition} at #{failure.pos} because #{failure.reason_elided}"
+          lines = breakup_message( "<< #{failure.json_elided} >> failed rule #{failure.definition} at #{failure.pos} because #{failure.evaluation.reason}", 75 )
+          lines.each_with_index do |l,i|
+            if i == 0
+              report << "    - #{l}"
+            else
+              report << "      #{l}"
+            end
+          end
         end
       end
     end
     return report
   end
 
+  def self.breakup_message( message, line_length )
+    line = message.gsub(/(.{1,#{line_length}})(\s+|\Z)/, "\\1\n")
+    lines = []
+    line.each_line do |l|
+      lines << l.strip
+    end
+    return lines
+  end
+
   def self.main my_argv=nil
 
     my_argv = ARGV unless my_argv
@@ -199,8 +219,9 @@ module JCR
         options[:testjcr] = true
       end
 
-      opt.on("--process-parts", "creates smaller files for specification writing" ) do |parts|
+      opt.on("--process-parts [DIRECTORY]", "creates smaller files for specification writing" ) do |directory|
         options[:process_parts] = true
+        options[:process_parts_directory] = directory
       end
 
       opt.on("-S STRING","name of root rule. All roots will be tried if none is specified") do |root_name|
@@ -248,15 +269,22 @@ module JCR
       opt.separator  ""
       opt.separator  "Return codes:"
       opt.separator  " 0 = success"
-      opt.separator  " 1 = parsing or other bad condition"
-      opt.separator  " 2 = fall through bad condition"
+      opt.separator  " 1 = bad JCR parsing or other bad condition"
+      opt.separator  " 2 = invalid option or bad use of command"
       opt.separator  " 3 = unsuccessful evaluation of JSON"
 
       opt.separator  ""
       opt.separator  "JCR Version " + JCR::VERSION
     end
 
-    opt_parser.parse! my_argv
+    begin
+      opt_parser.parse! my_argv
+    rescue OptionParser::InvalidOption => e
+      puts "Unable to interpret command or options"
+      puts e.message
+      puts "", "Use -h for help"
+      return 2
+    end
 
     if options[:help]
       puts "HELP","----",""
@@ -264,7 +292,7 @@ module JCR
       return 2
     elsif !options[:ruleset]
       puts "No ruleset passed! Use -R or -r options.", ""
-      puts opt_parser
+      puts "Use -h for help"
       return 2
     else
 
@@ -290,7 +318,13 @@ module JCR
 
         if options[:process_parts]
           parts = JCR::JcrParts.new
-          parts.process_ruleset( options[:ruleset] )
+          parts.process_ruleset( options[:ruleset], options[:process_parts_directory] )
+          if options[:overrides ]
+            options[:overrides].each do |ov|
+              parts = JCR::JcrParts.new
+              parts.process_ruleset( ov, options[:process_parts_directory] )
+            end
+          end
         end
 
         if options[:testjcr]
@@ -328,6 +362,9 @@ module JCR
           return ec
         end
 
+      rescue JCR::JcrValidatorError => jcr_error
+        puts jcr_error.message
+        return 1
       rescue Parslet::ParseFailed => failure
         puts failure.parse_failure_cause.ascii_tree unless options[:quiet]
         return 1

data/lib/jcr/jcr_validator_error.rb

@@ -0,0 +1,21 @@
+# Copyright (c) 2017 American Registry for Internet Numbers
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+# IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+module JCR
+
+  class JcrValidatorError < StandardError
+
+  end
+
+end

data/lib/jcr/map_rule_names.rb

@@ -12,11 +12,12 @@
 # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
 # IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
+require 'jcr/jcr_validator_error'
 require 'jcr/parser'
 
 module JCR
 
-  def self.map_rule_names( tree, override = false, ruleset_alias = nil )
+  def self.map_rule_names( tree, ruleset_alias = nil )
     prefix = ""
     if ruleset_alias
       prefix = ruleset_alias
@@ -31,8 +32,8 @@ module JCR
     tree.each do |node|
       if node[:rule]
         rn = prefix + node[:rule][:rule_name].to_str
-        if rule_name_maping[ rn ] && !override
-          raise "Rule #{rn} already exists and is defined more than once"
+        if rule_name_maping[ rn ]
+          raise JCR::JcrValidatorError, "Rule #{rn} already exists and is defined more than once"
         else
           rule_name_maping[ rn ] = node[:rule]
         end
@@ -76,7 +77,8 @@ module JCR
   def self.raise_rule_name_missing rule_name
     pos = rule_name.line_and_column
     name = rule_name.to_str
-    raise "rule '" + name + "' at line " + pos[0].to_s + " column " + pos[1].to_s + " does not exist"
+    raise JCR::JcrValidatorError,
+          "rule '" + name + "' at line " + pos[0].to_s + " column " + pos[1].to_s + " does not exist"
   end
 
 end

data/lib/jcr/parts.rb

@@ -68,19 +68,23 @@ module JCR
 
     # processes the lines
     # ruleset is to be a string read in using File.read
-    def process_ruleset( ruleset )
+    def process_ruleset( ruleset, dirname = nil )
+      all_file_names = []
       all_parts = []
       all_parts_name = nil
       current_part = nil
       current_part_name = nil
       ruleset.lines do |line|
         if !all_parts_name && ( all_parts_name = get_all( line ) )
-          # do_nothing
+          all_parts_name = File.join( dirname, all_parts_name ) if dirname
+          all_file_names << all_parts_name
         elsif ( current_part_name = get_start( line ) )
+          current_part_name = File.join( dirname, current_part_name ) if dirname
           if current_part
             current_part.close
           end
           current_part = File.open( current_part_name, "w" )
+          all_file_names << current_part_name
         elsif get_end( line ) && current_part
           current_part.close
           current_part = nil
@@ -101,6 +105,16 @@ module JCR
         end
         f.close
       end
+      if all_file_names.length
+        xml_fn = File.basename( all_file_names[0],".*" ) + "_xml_entity_refs"
+        xml_fn = File.join( File.dirname( all_file_names[0] ), xml_fn )
+        xml = File.open( xml_fn, "w" )
+        all_file_names.each do |fn|
+          bn = File.basename( fn, ".*" )
+          xml.puts( "<!ENTITY #{bn} PUBLIC '' '#{fn}'>")
+        end
+        xml.close
+      end
     end
 
   end

data/lib/jcr/process_directives.rb

@@ -74,7 +74,7 @@ module JCR
         ruleset = File.open( uri.path )
     end
 
-    import_ctx = JCR.ingest_ruleset( ruleset, false, ruleset_alias )
+    import_ctx = JCR.ingest_ruleset( ruleset, nil, ruleset_alias )
     ctx.mapping.merge!( import_ctx.mapping )
     ctx.roots.concat( import_ctx.roots )
 

data/lib/jcr/version.rb

@@ -1,4 +1,4 @@
-# Copyright (c) 2016 American Registry for Internet Numbers
+# Copyright (c) 2016-2017 American Registry for Internet Numbers
 #
 # Permission to use, copy, modify, and/or distribute this software for any
 # purpose with or without fee is hereby granted, provided that the above
@@ -15,6 +15,6 @@
 
 module JCR
 
-  VERSION = "0.8.0"
+  VERSION = "0.8.1"
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jcrvalidator
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Andrew Newton
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-08 00:00:00.000000000 Z
+date: 2017-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -85,6 +85,7 @@ files:
 - lib/jcr/evaluate_value_rules.rb
 - lib/jcr/find_roots.rb
 - lib/jcr/jcr.rb
+- lib/jcr/jcr_validator_error.rb
 - lib/jcr/map_rule_names.rb
 - lib/jcr/parser.rb
 - lib/jcr/parts.rb