jcrvalidator 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42b7b9f30fbdce18d3eb52e3fbea46a1a8a1350e
+  data.tar.gz: 80f3a34f4134303c2bc2c2e153330e316b4c0bef
+SHA512:
+  metadata.gz: 660737cced532d5aefa2de290c374eb3a69184d7628215ebfed9feac7d99f92ee7307fb470af295982641bb4dfb688497bfe15f45dc4bb6b53d134f5ad31488c
+  data.tar.gz: 6fd4e1d6b0cde8f89794d7529d5f19af9a13d6c51a8c1ab31c8350d1bd8dc58122c8e888304e496374899c4df20bcf92eca0ffd7a558a2637de059ce23250e00

data/bin/jcr

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# Copyright (c) 2014-2015 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.
+
+require 'rubygems'
+begin
+  require 'jcr'
+rescue LoadError
+  lib = File.expand_path("../lib",File.dirname(__FILE__))
+  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+  require 'jcr'
+end
+
+JCR.main
+

data/lib/jcr/check_groups.rb

@@ -0,0 +1,195 @@
+# Copyright (c) 2015 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.
+
+require 'jcr/parser'
+require 'jcr/map_rule_names'
+
+module JCR
+
+  def self.check_groups( tree, mapping )
+    if tree.is_a? Array
+      tree.each do |node|
+        check_groups( node, mapping )
+      end
+    else # is a hash
+      if tree[:rule]
+        check_groups( tree[:rule], mapping )
+      elsif tree[:primitive_rule]
+        check_value_for_group( tree[:primitive_rule], mapping )
+      elsif tree[:type_choice_signifier]
+        check_value_for_group( tree, mapping )
+      elsif tree[:member_rule]
+        check_member_for_group( tree[:member_rule], mapping )
+      elsif tree[:array_rule]
+        check_array_for_group( tree[:array_rule], mapping )
+      elsif tree[:object_rule]
+        check_object_for_group( tree[:object_rule], mapping )
+      end
+    end
+  end
+
+  def self.check_value_for_group node, mapping
+    if node[:group_rule]
+      disallowed_group_in_value?( node[:group_rule], mapping )
+    end
+  end
+
+  def self.disallowed_group_in_value? node, mapping
+    if node.is_a? Hash
+      node = [ node ]
+    end
+    node.each do |groupee|
+      if groupee[:sequence_combiner]
+        raise_group_error( 'AND (comma) operation in group rule of value rule', groupee[:sequence_combiner] )
+      end
+      if groupee[:group_rule]
+        disallowed_group_in_value?( groupee[:group_rule], mapping )
+      elsif groupee[:target_rule_name]
+        trule = get_name_mapping( groupee[:target_rule_name][:rule_name], mapping )
+        disallowed_group_in_value?( trule[:rule], mapping )
+      elsif groupee[:member_rule]
+        raise_group_error( "groups in value rules cannot have member rules", groupee[:member_rule] )
+      elsif groupee[:object_rule]
+        raise_group_error( "groups in value rules cannot have object rules", groupee[:member_rule] )
+      elsif groupee[:array_rule]
+        raise_group_error( "groups in value rules cannot have array rules", groupee[:member_rule] )
+      elsif groupee[:primitive_rule]
+        disallowed_group_in_value?( groupee[:primitive_rule], mapping )
+      end
+    end
+  end
+
+  def self.check_member_for_group node, mapping
+    if node[:target_rule_name]
+      trule = get_name_mapping( node[:target_rule_name][:rule_name], mapping )
+      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
+
+  def self.disallowed_group_in_member? node, mapping
+    if node.is_a? Hash
+      node = [ node ]
+    end
+    node.each do |groupee|
+      if groupee[:sequence_combiner]
+        raise_group_error( 'AND (comma) operation in group rule of member rule', groupee[:sequence_combiner] )
+      end
+      if groupee[:group_rule]
+        disallowed_group_in_member?( 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_member?( trule[:group_rule], mapping )
+        end
+      elsif groupee[:member_rule]
+        raise_group_error( "groups in member rules cannot have member rules", groupee[:member_rule] )
+      else
+        check_groups( groupee, mapping )
+      end
+    end
+  end
+
+  def self.check_array_for_group node, mapping
+    if node.is_a?( Array )
+      node.each do |child_node|
+        check_array_for_group( child_node, mapping )
+      end
+    elsif node.is_a? Hash
+      if node[:target_rule_name]
+        trule = get_name_mapping(node[:target_rule_name][:rule_name], mapping)
+        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
+
+  def self.disallowed_group_in_array? node, mapping
+    if node.is_a? Hash
+      node = [ node ]
+    end
+    node.each do |groupee|
+      if groupee[:group_rule]
+        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
+      elsif groupee[:member_rule]
+        raise_group_error( "groups in array rules cannot have member rules", groupee[:member_rule] )
+      else
+        check_groups( groupee, mapping )
+      end
+    end
+  end
+
+  def self.check_object_for_group node, mapping
+    if node.is_a?( Array )
+      node.each do |child_node|
+        check_object_for_group( child_node, mapping )
+      end
+    elsif node.is_a? Hash
+      if node[:target_rule_name]
+        trule = get_name_mapping(node[:target_rule_name][:rule_name], mapping)
+        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
+
+  def self.disallowed_group_in_object? node, mapping
+    if node.is_a? Hash
+      node = [ node ]
+    end
+    node.each do |groupee|
+      if groupee[:group_rule]
+        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
+      elsif groupee[:array_rule]
+        raise_group_error( "groups in object rules cannot have array rules", groupee[:member_rule] )
+      elsif groupee[:object_rule]
+        raise_group_error( "groups in object rules cannot have other object rules", groupee[:member_rule] )
+      elsif groupee[:primitive_rule]
+        raise_group_error( "groups in object rules cannot have value rules", groupee[:member_rule] )
+      else
+        check_groups( groupee, mapping )
+      end
+    end
+  end
+
+  def self.raise_group_error str, node
+    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
+    else
+      raise "group rule error with '" + node.to_s + "' :" + str
+    end
+  end
+
+end

data/lib/jcr/evaluate_array_rules.rb

@@ -0,0 +1,270 @@
+# Copyright (c) 2015 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.
+
+require 'ipaddr'
+require 'time'
+require 'addressable/uri'
+require 'addressable/template'
+require 'email_address_validator'
+require 'big-phoney'
+
+require 'jcr/parser'
+require 'jcr/map_rule_names'
+require 'jcr/check_groups'
+require 'jcr/evaluate_rules'
+
+module JCR
+
+  class ArrayBehavior
+    attr_accessor :checked_hash, :last_index, :ordered, :extra_prohibited
+
+    def initialize( current_behavior = nil )
+      if current_behavior
+        @checked_hash = {}
+        @checked_hash.merge!( current_behavior.checked_hash )
+        @last_index = current_behavior.last_index
+        @ordered = current_behavior.ordered
+        @extra_prohibited = false
+      else
+        @checked_hash = {}
+        @last_index = 0
+        @ordered = true
+        @extra_prohibited = true
+      end
+    end
+  end
+
+  def self.evaluate_array_rule jcr, rule_atom, data, econs, behavior = nil
+
+    rules, annotations = get_rules_and_annotations( jcr )
+
+    ordered = true
+
+    if behavior && behavior.is_a?( ArrayBehavior )
+      ordered = behavior.ordered
+    end
+
+    annotations.each do |a|
+      if a[:unordered_annotation]
+        ordered = false
+        break
+      end
+    end
+
+    # if the data is not an array
+    return evaluate_reject( annotations,
+      Evaluation.new( false, "#{data} is not an array at #{jcr} from #{rule_atom}") ) 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_reject( annotations,
+      Evaluation.new( true, nil ) ) 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_reject( annotations,
+      Evaluation.new( false, "Non-empty array at #{jcr} from #{rule_atom}" ) ) if rules.empty? && data.length != 0
+
+    if ordered
+      return evaluate_reject( annotations, evaluate_array_rule_ordered( rules, rule_atom, data, econs, behavior ) )
+    else
+      return evaluate_reject( annotations, evaluate_array_rule_unordered( rules, rule_atom, data, econs, behavior ) )
+    end
+  end
+
+  def self.evaluate_array_rule_ordered jcr, rule_atom, data, econs, behavior = nil
+    retval = nil
+
+    behavior = ArrayBehavior.new unless behavior
+    array_index = behavior.last_index
+
+
+    jcr.each do |rule|
+
+      # short circuit logic
+      if rule[:choice_combiner] && retval && retval.success
+        next
+      elsif rule[:sequence_combiner] && retval && !retval.success
+        break
+      end
+
+      repeat_min, repeat_max = get_repetitions( rule )
+
+      # group rules must be evaluated differently
+      # 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))
+
+        if repeat_min == 0
+          retval = Evaluation.new( true, nil )
+        else
+          for i in 1..repeat_min do
+            if array_index == data.length
+              return Evaluation.new( false, "array is not large enough for #{jcr} from #{rule_atom}" )
+            else
+              group_behavior = ArrayBehavior.new( behavior )
+              group_behavior.last_index = array_index
+              retval = evaluate_rule( grule, rule_atom, data, econs, group_behavior )
+              if retval.success
+                behavior.checked_hash.merge!( group_behavior.checked_hash )
+                array_index = group_behavior.last_index
+              else
+                break;
+              end
+            end
+          end
+        end
+        if !retval || retval.success
+          for i in behavior.checked_hash.length..repeat_max-1 do
+            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 )
+            if e.success
+              behavior.checked_hash.merge!( group_behavior.checked_hash )
+              array_index = group_behavior.last_index
+            else
+              break;
+            end
+          end
+        end
+
+      else # else not grule (group)
+
+        if repeat_min == 0
+          retval = Evaluation.new( true, nil )
+        else
+          for i in 1..repeat_min do
+            if array_index == data.length
+              return Evaluation.new( false, "array is not large enough for #{jcr} from #{rule_atom}" )
+            else
+              retval = evaluate_rule( rule, rule_atom, data[ array_index ], econs, nil )
+              break unless retval.success
+              array_index = array_index + 1
+              behavior.checked_hash[ i + behavior.last_index ] = retval.success
+            end
+          end
+        end
+        if !retval || retval.success
+          for i in behavior.checked_hash.length..repeat_max-1 do
+            break if array_index == data.length
+            e = evaluate_rule( rule, rule_atom, data[ array_index ], econs, nil )
+            break unless e.success
+            array_index = array_index + 1
+          end
+        end
+
+      end # end if grule else
+
+    end
+
+    behavior.last_index = array_index
+
+    if data.length > array_index && behavior.extra_prohibited
+      retval = Evaluation.new( false, "More itmes in array than specified for #{jcr} from #{rule_atom}" )
+    end
+
+    return retval
+
+  end
+
+  def self.evaluate_array_rule_unordered jcr, rule_atom, data, econs, behavior = nil
+
+    retval = nil
+    unless behavior
+      behavior = ArrayBehavior.new
+      behavior.ordered = false
+    end
+    highest_index = 0
+
+    jcr.each do |rule|
+
+      # short circuit logic
+      if rule[:choice_combiner] && retval && retval.success
+        next
+      elsif rule[:sequence_combiner] && retval && !retval.success
+        break
+      end
+
+      repeat_min, repeat_max = get_repetitions( rule )
+
+      # group rules must be evaluated differently
+      # 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))
+
+        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 )
+          if e.success
+            highest_index = group_behavior.last_index
+            behavior.checked_hash.merge!( group_behavior.checked_hash )
+            successes = successes + 1
+          else
+            break;
+          end
+        end
+
+        if successes == 0 && repeat_min > 0
+          retval = Evaluation.new( false, "array does not contain #{rule} for #{jcr} from #{rule_atom}")
+        elsif successes < repeat_min
+          retval = Evaluation.new( false, "array does not have enough #{rule} for #{jcr} from #{rule_atom}")
+        elsif successes > repeat_max
+          retval = Evaluation.new( false, "array has too many #{rule} for #{jcr} from #{rule_atom}")
+        else
+          retval = Evaluation.new( true, nil )
+        end
+
+      else # else not group rule
+
+        successes = 0
+        for i in behavior.last_index..data.length
+          break if successes == repeat_max
+          unless behavior.checked_hash[ i ]
+            e = evaluate_rule( rule, rule_atom, data[ i ], econs, nil )
+            if e.success
+              behavior.checked_hash[ i ] = e.success
+              highest_index = i if i > highest_index
+              successes = successes + 1
+            end
+          end
+        end
+
+        if successes == 0 && repeat_min > 0
+          retval = Evaluation.new( false, "array does not contain #{rule} for #{jcr} from #{rule_atom}")
+        elsif successes < repeat_min
+          retval = Evaluation.new( false, "array does not have enough #{rule} for #{jcr} from #{rule_atom}")
+        elsif successes > repeat_max
+          retval = Evaluation.new( false, "array has too many #{rule} for #{jcr} from #{rule_atom}")
+        else
+          retval = Evaluation.new( true, nil)
+        end
+
+      end # if grule else
+
+    end
+
+    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 #{jcr} from #{rule_atom}" )
+    end
+
+    return retval
+  end
+
+end

data/lib/jcr/evaluate_group_rules.rb

@@ -0,0 +1,46 @@
+# Copyright (c) 2015 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.
+
+require 'ipaddr'
+require 'time'
+require 'addressable/uri'
+require 'addressable/template'
+require 'email_address_validator'
+require 'big-phoney'
+
+require 'jcr/parser'
+require 'jcr/map_rule_names'
+require 'jcr/check_groups'
+
+module JCR
+
+  def self.evaluate_group_rule jcr, rule_atom, data, econs, behavior = nil
+
+    rules, annotations = get_rules_and_annotations( jcr )
+
+    retval = nil
+
+    rules.each do |rule|
+      if rule[:choice_combiner] && retval && retval.success
+        return evaluate_reject( annotations, retval ) # short circuit
+      elsif rule[:sequence_combiner] && retval && !retval.success
+        return evaluate_reject( annotations, retval ) # short circuit
+      end
+      retval = evaluate_rule( rule, rule_atom, data, econs, behavior )
+    end
+
+    return evaluate_reject( annotations, retval )
+  end
+
+end

data/lib/jcr/evaluate_member_rules.rb

@@ -0,0 +1,61 @@
+# Copyright (c) 2015 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.
+
+require 'ipaddr'
+require 'time'
+require 'addressable/uri'
+require 'addressable/template'
+require 'email_address_validator'
+require 'big-phoney'
+
+require 'jcr/parser'
+require 'jcr/map_rule_names'
+require 'jcr/check_groups'
+
+module JCR
+
+  def self.evaluate_member_rule jcr, rule_atom, data, econs
+
+    # 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
+    # second being the json data to be furthered on to other evaluation functions
+
+    rules, annotations = get_rules_and_annotations( jcr )
+    rule = rules[0]
+
+    member_match = false
+
+    if rule[:member_name]
+      match_spec = rule[:member_name][:q_string].to_s
+      if match_spec == data[ 0 ]
+        member_match = true
+      end
+    else # must be regex
+      match_spec = Regexp.new( rule[:member_regex][:regex].to_s )
+      if match_spec =~ data[ 0 ]
+        member_match = true
+      end
+    end
+
+    if member_match
+      e = evaluate_rule( rule, rule_atom, data[ 1 ], econs )
+      return evaluate_reject( annotations, e )
+    end
+
+    return evaluate_reject( annotations,
+       Evaluation.new( false, "#{match_spec} does not match #{data[0]} for #{jcr} from #{rule_atom}" ) )
+
+  end
+
+end