jcrvalidator 0.5.3 → 0.6.0

data/lib/jcr/evaluate_value_rules.rb

@@ -25,13 +25,20 @@ require 'jcr/check_groups'
 
 module JCR
 
-  def self.evaluate_value_rule jcr, rule_atom, data, mapping
+  def self.evaluate_value_rule jcr, rule_atom, data, econs
+
+    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 )
 
-    return evaluate_reject( annotations, evaluate_values( rules[0], rule_atom, data, mapping ) )
+    retval = evaluate_not( annotations, evaluate_values( rules[0], rule_atom, data, econs ), econs )
+    trace_eval( econs, "Value", retval)
+    pop_trace_stack( econs )
+    return retval
   end
 
-  def self.evaluate_values jcr, rule_atom, data, mapping
+  def self.evaluate_values jcr, rule_atom, data, econs
     case
 
       #
@@ -53,12 +60,34 @@ module JCR
       when jcr[:integer]
         i = jcr[:integer].to_s.to_i
         return bad_value( jcr, rule_atom, i, data ) unless data == i
+      when jcr[:integer_min] != nil && jcr[:integer_max] == nil
+        return bad_value( jcr, rule_atom, "integer", data ) unless data.is_a?( Fixnum )
+        min = jcr[:integer_min].to_s.to_i
+        return bad_value( jcr, rule_atom, min, data ) unless data >= min
+      when jcr[:integer_max] == nil && jcr[:integer_max] != nil
+        return bad_value( jcr, rule_atom, "integer", data ) unless data.is_a?( Fixnum )
+        max = jcr[:integer_max].to_s.to_i
+        return bad_value( jcr, rule_atom, max, data ) unless data <= max
       when jcr[:integer_min],jcr[:integer_max]
         return bad_value( jcr, rule_atom, "integer", data ) unless data.is_a?( Fixnum )
         min = jcr[:integer_min].to_s.to_i
         return bad_value( jcr, rule_atom, min, data ) unless data >= min
         max = jcr[:integer_max].to_s.to_i
         return bad_value( jcr, rule_atom, max, data ) unless data <= max
+      when jcr[:sized_int_v]
+        bits = jcr[:sized_int_v][:bits].to_i
+        return bad_value( jcr, rule_atom, "int" + bits.to_s, data ) unless data.is_a?( Fixnum )
+        min = -(2**(bits-1))
+        return bad_value( jcr, rule_atom, min, data ) unless data >= min
+        max = 2**(bits-1)-1
+        return bad_value( jcr, rule_atom, max, data ) unless data <= max
+      when jcr[:sized_uint_v]
+        bits = jcr[:sized_uint_v][:bits].to_i
+        return bad_value( jcr, rule_atom, "int" + bits.to_s, data ) unless data.is_a?( Fixnum )
+        min = 0
+        return bad_value( jcr, rule_atom, min, data ) unless data >= min
+        max = 2**bits-1
+        return bad_value( jcr, rule_atom, max, data ) unless data <= max
 
       #
       # floats
@@ -72,12 +101,25 @@ module JCR
       when jcr[:float]
         f = jcr[:float].to_s.to_f
         return bad_value( jcr, rule_atom, f, data ) unless data == f
+      when jcr[:float_min] != nil && jcr[:float_max] == nil
+        return bad_value( jcr, rule_atom, "float", data ) unless data.is_a?( Float )
+        min = jcr[:float_min].to_s.to_f
+        return bad_value( jcr, rule_atom, min, data ) unless data >= min
+      when jcr[:float_min] == nil && jcr[:float_max] != nil
+        return bad_value( jcr, rule_atom, "float", data ) unless data.is_a?( Float )
+        max = jcr[:float_max].to_s.to_f
+        return bad_value( jcr, rule_atom, max, data ) unless data <= max
       when jcr[:float_min],jcr[:float_max]
         return bad_value( jcr, rule_atom, "float", data ) unless data.is_a?( Float )
         min = jcr[:float_min].to_s.to_f
         return bad_value( jcr, rule_atom, min, data ) unless data >= min
         max = jcr[:float_max].to_s.to_f
         return bad_value( jcr, rule_atom, max, data ) unless data <= max
+      when jcr[:double_v]
+        sf = jcr[:double_v].to_s
+        if sf == "double"
+          return bad_value( jcr, rule_atom, "double", data ) unless data.is_a?( Float )
+        end
 
       #
       # boolean
@@ -113,7 +155,7 @@ module JCR
       # ip addresses
       #
 
-      when jcr[:ip4]
+      when jcr[:ipv4]
         return bad_value( jcr, rule_atom, "IPv4 Address", data ) unless data.is_a? String
         begin
           ip = IPAddr.new( data )
@@ -121,7 +163,7 @@ module JCR
           return bad_value( jcr, rule_atom, "IPv4 Address", data )
         end
         return bad_value( jcr, rule_atom, "IPv4 Address", data ) unless ip.ipv4?
-      when jcr[:ip6]
+      when jcr[:ipv6]
         return bad_value( jcr, rule_atom, "IPv6 Address", data ) unless data.is_a? String
         begin
           ip = IPAddr.new( data )
@@ -129,6 +171,14 @@ module JCR
           return bad_value( jcr, rule_atom, "IPv6 Address", data )
         end
         return bad_value( jcr, rule_atom, "IPv6 Address", data ) unless ip.ipv6?
+      when jcr[:ipaddr]
+        return bad_value( jcr, rule_atom, "IP Address", data ) unless data.is_a? String
+        begin
+          ip = IPAddr.new( data )
+        rescue IPAddr::InvalidAddressError
+          return bad_value( jcr, rule_atom, "IP Address", data )
+        end
+        return bad_value( jcr, rule_atom, "IP Address", data ) unless ip.ipv6? || ip.ipv4?
 
       #
       # domain names
@@ -202,25 +252,109 @@ module JCR
         p = BigPhoney::PhoneNumber.new( data )
         return bad_value( jcr, rule_atom, "Phone Number", data ) unless p.valid?
 
+      #
+      # hex values
+      #
+
+      when jcr[:hex]
+        return bad_value( jcr, rule_atom, "Hex Data", data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, "Hex Data", data ) unless data.length % 2 == 0
+        pad_start = false
+        data.each_char do |char|
+          unless (char >= '0' && char <='9') \
+              || (char >= 'A' && char <= 'F') \
+              || (char >= 'a' && char <= 'f')
+            return bad_value( jcr, rule_atom, "Hex Data", data )
+          end
+        end
+
+      #
+      # base32hex values
+      #
+
+      when jcr[:base32hex]
+        return bad_value( jcr, rule_atom, "Base32hex Data", data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, "Base32hex Data", data ) unless data.length % 8 == 0
+        pad_start = false
+        data.each_char do |char|
+          if char == '='
+            pad_start = true
+          elsif pad_start && char != '='
+            return bad_value( jcr, rule_atom, "Base32hex Data", data )
+          else 
+              unless (char >= '0' && char <='9') \
+                  || (char >= 'A' && char <= 'V') \
+                  || (char >= 'a' && char <= 'v')
+                return bad_value( jcr, rule_atom, "Base32hex Data", data )
+              end
+          end
+        end
+
+      #
+      # base32 values
+      #
+
+      when jcr[:base32]
+        return bad_value( jcr, rule_atom, "Base 32 Data", data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, "Base 32 Data", data ) unless data.length % 8 == 0
+        pad_start = false
+        data.each_char do |char|
+          if char == '='
+            pad_start = true
+          elsif pad_start && char != '='
+            return bad_value( jcr, rule_atom, "Base 32 Data", data )
+          else 
+              unless (char >= 'a' && char <= 'z') \
+                  || (char >= 'A' && char <= 'Z') \
+                  || (char >= '2' && char <='7')
+                return bad_value( jcr, rule_atom, "Base 32 Data", data )
+              end
+          end
+        end
+
+      #
+      # base64url values
+      #
+
+      when jcr[:base64url]
+        return bad_value( jcr, rule_atom, "Base64url Data", data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, "Base64url Data", data ) unless data.length % 4 == 0
+        pad_start = false
+        data.each_char do |char|
+          if char == '='
+            pad_start = true
+          elsif pad_start && char != '='
+            return bad_value( jcr, rule_atom, "Base64url Data", data )
+          else 
+              unless (char >= 'a' && char <= 'z') \
+                  || (char >= 'A' && char <= 'Z') \
+                  || (char >= '0' && char <='9') \
+                  || char == '-' || char == '_'
+                return bad_value( jcr, rule_atom, "Base64url Data", data )
+              end
+          end
+        end
+
       #
       # base64 values
       #
 
       when jcr[:base64]
         return bad_value( jcr, rule_atom, "Base 64 Data", data ) unless data.is_a? String
-        return bad_value( jcr, rule_atom, "Base 64 Data", data ) if data.empty?
+        return bad_value( jcr, rule_atom, "Base 64 Data", data ) unless data.length % 4 == 0
         pad_start = false
         data.each_char do |char|
-          if pad_start && char != '='
-            return bad_value( jcr, rule_atom, "Base 64 Data", data )
-          elsif char == '='
+          if char == '='
             pad_start = true
-          end
-          unless (char >= 'a' && char <= 'z') \
-              || (char >= 'A' && char <= 'Z') \
-              || (char >= '0' && char <='9') \
-              || char == '=' || char == '+' || char == '/'
+          elsif pad_start && char != '='
             return bad_value( jcr, rule_atom, "Base 64 Data", data )
+          else 
+              unless (char >= 'a' && char <= 'z') \
+                  || (char >= 'A' && char <= 'Z') \
+                  || (char >= '0' && char <='9') \
+                  || char == '+' || char == '/'
+                return bad_value( jcr, rule_atom, "Base 64 Data", data )
+              end
           end
         end
 
@@ -228,14 +362,14 @@ module JCR
       # time and date values
       #
 
-      when jcr[:date_time]
+      when jcr[:datetime]
         return bad_value( jcr, rule_atom, "Time and Date", data ) unless data.is_a? String
         begin
           Time.iso8601( data )
         rescue ArgumentError
           return bad_value( jcr, rule_atom, "Time and Date", data )
         end
-      when jcr[:full_date]
+      when jcr[:date]
         return bad_value( jcr, rule_atom, "Date", data ) unless data.is_a? String
         begin
           d = data + "T23:20:50.52Z"
@@ -243,7 +377,7 @@ module JCR
         rescue ArgumentError
           return bad_value( jcr, rule_atom, "Date", data )
         end
-      when jcr[:full_time]
+      when jcr[:time]
         return bad_value( jcr, rule_atom, "Time", data ) unless data.is_a? String
         begin
           t = "1985-04-12T" + data + "Z"
@@ -264,7 +398,7 @@ module JCR
       #
 
       when jcr[:group_rule]
-        return evaluate_group_rule jcr[:group_rule], rule_atom, data, mapping
+        return evaluate_group_rule jcr[:group_rule], rule_atom, data, econs
 
       else
         raise "unknown value rule evaluation. this shouldn't happen"
@@ -273,7 +407,110 @@ module JCR
   end
 
   def self.bad_value jcr, rule_atom, expected, actual
-    Evaluation.new( false, "expected #{expected} but got #{actual} at #{jcr} from #{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 )
+
+    rules, annotations = get_rules_and_annotations( jcr )
+
+    rule = rules[ 0 ]
+    retval = ""
+    case
+
+      when rule[:any]
+        retval =  "any"
+
+      when rule[:integer_v]
+        retval =  rule[:integer_v].to_s
+      when rule[:integer]
+        retval =  rule[:integer].to_s.to_i
+      when rule[:integer_min],rule[:integer_max]
+        min = "-INF"
+        max = "INF"
+        min = rule[:integer_min].to_s.to_i if rule[:integer_min]
+        max = rule[:integer_max].to_s.to_i if rule[:integer_max]
+        retval =  "#{min}..#{max}"
+      when rule[:sized_int_v]
+        retval =  "int" + rule[:sized_int_v][:bits].to_s
+      when rule[:sized_uint_v]
+        retval =  "uint" + rule[:sized_uint_v][:bits].to_s
+
+      when rule[:double_v]
+        retval =  rule[:double_v].to_s
+      when rule[:float_v]
+        retval =  rule[:float_v].to_s
+      when rule[:float]
+        retval =  rule[:float].to_s.to_f
+      when rule[:float_min],rule[:float_max]
+        min = "-INF"
+        max = "INF"
+        min = rule[:float_min].to_s.to_f if rule[:float_min]
+        max = rule[:float_max].to_s.to_f if rule[:float_max]
+        retval =  "#{min}..#{max}"
+
+      when rule[:true_v]
+        retval =  "true"
+      when rule[:false_v]
+        retval =  "false"
+      when rule[:boolean_v]
+        retval =  "boolean"
+
+      when rule[:string]
+        retval =  "string"
+      when rule[:q_string]
+        retval =  %Q|"#{rule[:q_string].to_s}"|
+
+      when rule[:regex]
+        retval =  "/#{rule[:regex].to_s}/"
+
+      when rule[:ipv4]
+        retval =  "ipv4"
+      when rule[:ipv6]
+        retval =  "ipv6"
+
+      when rule[:fqdn]
+        retval =  "fqdn"
+      when rule[:idn]
+        retval =  "idn"
+
+      when rule[:uri]
+        retval =  "URI"
+      when rule[:uri_template]
+        retval =  "URI template #{rule[:uri_template].to_s}"
+
+      when rule[:email]
+        retval =  "email"
+
+      when rule[:phone]
+        retval =  "phone"
+
+      when rule[:hex]
+        retval =  "hex"
+      when rule[:base32url]
+        retval =  "base32url"
+      when rule[:base64url]
+        retval =  "base64url"
+      when rule[:base64]
+        retval =  "base64"
+
+      when rule[:datetime]
+        retval =  "datetime"
+      when rule[:date]
+        retval =  "date"
+      when rule[:time]
+        retval =  "time"
+
+      when rule[:null]
+        retval =  "null"
+
+      when rule[:group_rule]
+        retval =  group_to_s( rule[:group_rule], shallow )
+
+      else
+        retval =  "** unknown value rule **"
+    end
+    return annotations_to_s( annotations ) + retval.to_s
   end
 
 end

data/lib/jcr/jcr.rb

@@ -15,6 +15,7 @@
 require 'optparse'
 require 'rubygems'
 require 'json'
+require 'pp'
 
 require 'jcr/parser'
 require 'jcr/evaluate_rules'
@@ -26,7 +27,7 @@ require 'jcr/process_directives'
 module JCR
 
   class Context
-    attr_accessor :mapping, :callbacks, :id, :tree, :roots, :catalog
+    attr_accessor :mapping, :callbacks, :id, :tree, :roots, :catalog, :trace
 
     def add_ruleset_alias( ruleset_alias, alias_uri )
       unless @catalog
@@ -56,7 +57,8 @@ module JCR
       JCR.evaluate_ruleset( data, self, root_name )
     end
 
-    def initialize( ruleset = nil )
+    def initialize( ruleset = nil, trace = false )
+      @trace = trace
       if ruleset
         ingested = JCR.ingest_ruleset( ruleset, false, nil )
         @mapping = ingested.mapping
@@ -121,8 +123,9 @@ module JCR
 
     retval = nil
     root_rules.each do |r|
+      pp "Evaluating Root:", rule_to_s( r, false ) if ctx.trace
       raise "Root rules cannot be member rules" if r[:member_rule]
-      retval = JCR.evaluate_rule( r, r, data, EvalConditions.new( ctx.mapping, ctx.callbacks ) )
+      retval = JCR.evaluate_rule( r, r, data, EvalConditions.new( ctx.mapping, ctx.callbacks, ctx.trace ) )
       break if retval.success
     end
 
@@ -163,6 +166,10 @@ module JCR
         options[:ruleset] = ruleset
       end
 
+      opt.on("--test-jcr", "parse and test the JCR only") do |testjcr|
+        options[:testjcr] = true
+      end
+
       opt.on("-S STRING","name of root rule. All roots will be tried if none is specified") do |root_name|
         if options[:root_name]
           puts "A root has already been specified. Use -h for help.", ""
@@ -214,35 +221,55 @@ module JCR
       return 2
     else
 
-      ctx = Context.new( options[:ruleset] )
-      if options[:overrides]
-        options[:overrides].each do |ov|
-          ctx.override!( ov )
+      begin
+
+        ctx = Context.new( options[:ruleset], options[:verbose] )
+        if options[:overrides]
+          options[:overrides].each do |ov|
+            ctx.override!( ov )
+          end
         end
-      end
 
-      if options[:json]
-        data = JSON.parse( options[:json] )
-        ec = cli_eval( ctx, data, options[:root_name], options[:verbose] )
-        return ec
-      elsif $stdin.tty?
-        ec = 0
-        if my_argv.empty?
-          ec = 2
-        else
-          my_argv.each do |fn|
-            data = JSON.parse( File.open( fn ).read )
-            tec = cli_eval( ctx, data, options[:root_name], options[:verbose] )
-            ec = tec if tec != 0 #record error but don't let non-error overwrite error
+        if options[:verbose]
+          pp "Ruleset Parse Tree", ctx.tree
+          pp "Ruleset Map"
+          ctx.mapping.each do |name,rule|
+            puts "Parsed Rule: #{name}"
+            puts rule_to_s( rule, false )
+            puts "Parsed Rule Structure: #{name}"
+            pp rule
           end
         end
-        return ec
-      else
-        data = JSON.parse( ARGF.read )
-        ec = cli_eval( ctx, data, options[:root_name], options[:verbose] )
-        return ec
-      end
 
+        if options[:testjcr]
+          #we got this far which means the JCR was already parsed without
+          #issue. therefore return 0
+          return 0
+        elsif options[:json]
+          data = JSON.parse( options[:json] )
+          ec = cli_eval( ctx, data, options[:root_name], options[:verbose] )
+          return ec
+        elsif $stdin.tty?
+          ec = 0
+          if my_argv.empty?
+            ec = 2
+          else
+            my_argv.each do |fn|
+              data = JSON.parse( File.open( fn ).read )
+              tec = cli_eval( ctx, data, options[:root_name], options[:verbose] )
+              ec = tec if tec != 0 #record error but don't let non-error overwrite error
+            end
+          end
+          return ec
+        else
+          data = JSON.parse( ARGF.read )
+          ec = cli_eval( ctx, data, options[:root_name], options[:verbose] )
+          return ec
+        end
+
+      rescue Parslet::ParseFailed => failure
+        puts failure.cause.ascii_tree
+      end
     end
 
   end