jcrvalidator 0.5.0

data/lib/jcr/evaluate_object_rules.rb

@@ -0,0 +1,115 @@
+# 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'
+require 'jcr/check_groups'
+require 'jcr/evaluate_rules'
+
+module JCR
+
+  class ObjectBehavior
+    attr_accessor :checked_hash
+
+    def initialize
+      @checked_hash = {}
+    end
+  end
+
+  def self.evaluate_object_rule jcr, rule_atom, data, econs, behavior = nil
+
+    rules, annotations = get_rules_and_annotations( jcr )
+
+    # if the data is not an object (Hash)
+    return evaluate_reject( annotations,
+      Evaluation.new( false, "#{data} is not an object at #{jcr} from #{rule_atom}") ) 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_reject( annotations,
+      Evaluation.new( true, nil ) ) 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_reject( annotations,
+      Evaluation.new( false, "Non-empty object at #{jcr} from #{rule_atom}" ) ) if rules.empty? && data.length != 0
+
+    retval = nil
+    behavior = ObjectBehavior.new unless behavior
+
+    rules.each do |rule|
+
+      # short circuit logic
+      if rule[:choice_combiner] && retval && retval.success
+        next
+      elsif rule[:sequence_combiner] && retval && !retval.success
+        return evaluate_reject( annotations, retval ) # short circuit
+      end
+
+      repeat_min, repeat_max = get_repetitions( rule )
+
+      # Pay attention here:
+      # Group rules need to be treated differently than other rules
+      # Groups must be evaluated as if they are rules evaluated in
+      # isolation until they evaluate as true.
+      # Also, groups must be handed the entire object, not key/values
+      # as member rules use.
+
+      if (grule = get_group(rule, econs))
+
+        successes = 0
+        for i in 0..repeat_max
+          group_behavior = ObjectBehavior.new
+          e = evaluate_rule( grule, rule_atom, data, econs, group_behavior )
+          if e.success
+            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, "object does not contain group #{rule} for #{jcr} from #{rule_atom}")
+        elsif successes < repeat_min
+          retval = Evaluation.new( false, "object does not have contain necessary number of group #{rule} for #{jcr} from #{rule_atom}")
+        else
+          retval = Evaluation.new( true, nil )
+        end
+
+      else # if not grule
+
+        repeat_results = data.select do |k,v|
+          unless behavior.checked_hash[k]
+            e = evaluate_rule(rule, rule_atom, [k, v], econs, nil)
+            behavior.checked_hash[k] = e.success
+            e.success
+          end
+        end
+
+        if repeat_results.length == 0 && repeat_min > 0
+          retval = Evaluation.new( false, "object does not contain #{rule} for #{jcr} from #{rule_atom}")
+        elsif repeat_results.length < repeat_min
+          retval = Evaluation.new( false, "object does not have enough #{rule} for #{jcr} from #{rule_atom}")
+        elsif repeat_results.length > repeat_max
+          retval = Evaluation.new( false, "object has too many #{rule} for #{jcr} from #{rule_atom}")
+        else
+          retval = Evaluation.new( true, nil)
+        end
+      end
+
+    end # end if grule else
+
+    return evaluate_reject( annotations, retval )
+  end
+
+end

data/lib/jcr/evaluate_rules.rb

@@ -0,0 +1,211 @@
+# 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_array_rules'
+require 'jcr/evaluate_object_rules'
+require 'jcr/evaluate_group_rules'
+require 'jcr/evaluate_member_rules'
+require 'jcr/evaluate_value_rules'
+
+
+# Adapted from Matt Sears
+class Proc
+  def jcr_callback(callable, *args)
+    self === Class.new do
+      method_name = callable.to_sym
+      define_method(method_name) { |&block| block.nil? ? true : block.call(*args) }
+      define_method("#{method_name}?") { true }
+      def method_missing(method_name, *args, &block) false; end
+    end.new
+  end
+end
+
+module JCR
+
+  class Evaluation
+    attr_accessor :success, :reason, :child_evaluation
+    def initialize success, reason
+      @success = success
+      @reason = reason
+    end
+  end
+
+  class EvalConditions
+    attr_accessor :mapping, :callbacks
+    def initialize mapping, callbacks
+      @mapping = mapping
+      if callbacks
+        @callbacks = callbacks
+      else
+        @callbacks = {}
+      end
+    end
+  end
+
+  def self.evaluate_rule jcr, rule_atom, data, econs, behavior = nil
+    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)
+      when behavior.is_a?( ObjectBehavior )
+        retval = evaluate_object_rule( jcr, rule_atom, data, econs, behavior)
+      when jcr[:rule]
+        retval = evaluate_rule( jcr[:rule], rule_atom, data, econs, behavior)
+      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
+        retval = evaluate_rule( target, target, data, econs, behavior )
+      when jcr[:primitive_rule]
+        retval = evaluate_value_rule( jcr[:primitive_rule], rule_atom, data, econs)
+      when jcr[:group_rule]
+        retval = evaluate_group_rule( jcr[:group_rule], rule_atom, data, econs, behavior)
+      when jcr[:array_rule]
+        retval = evaluate_array_rule( jcr[:array_rule], rule_atom, data, econs, behavior)
+      when jcr[:object_rule]
+        retval = evaluate_object_rule( jcr[:object_rule], rule_atom, data, econs, behavior)
+      when jcr[:member_rule]
+        retval = evaluate_member_rule( jcr[:member_rule], rule_atom, data, econs)
+      else
+        retval = Evaluation.new( true, nil )
+    end
+    if jcr.is_a?( Hash ) && jcr[:rule_name]
+      rn = jcr[:rule_name].to_s
+      if econs.callbacks[ rn ]
+        retval = evaluate_callback( jcr, data, econs, rn, retval )
+      end
+    end
+    return retval
+  end
+
+  def self.evaluate_callback jcr, data, econs, callback, e
+    retval = e
+    c = econs.callbacks[ callback ]
+    if e.success
+      retval = c.jcr_callback :rule_eval_true, jcr, data
+    else
+      retval = c.jcr_callback :rule_eval_false, jcr, data, e
+    end
+    if retval.is_a? TrueClass
+      retval = Evaluation.new( true, nil )
+    elsif retval.is_a? FalseClass
+      retval = Evaluation.new( false, nil )
+    elsif retval.is_a? String
+      retval = Evaluation.new( false, retval )
+    end
+    return retval
+  end
+
+  def self.get_repetitions rule
+
+    repeat_min = 1
+    repeat_max = 1
+    if rule[:optional]
+      repeat_min = 0
+      repeat_max = 1
+    elsif rule[:one_or_more]
+      repeat_min = 1
+      repeat_max = Float::INFINITY
+    elsif rule[:specific_repetition] && rule[:specific_repetition].is_a?( Parslet::Slice )
+      repeat_min = repeat_max = rule[:specific_repetition].to_s.to_i
+    else
+      o = rule[:repetition_interval]
+      if o
+        repeat_min = 0
+        repeat_max = Float::INFINITY
+      end
+      o = rule[:repetition_min]
+      if o
+        if o.is_a?( Parslet::Slice )
+          repeat_min = o.to_s.to_i
+        end
+      end
+      o = rule[:repetition_max]
+      if o
+        if o.is_a?( Parslet::Slice )
+          repeat_max = o.to_s.to_i
+        end
+      end
+    end
+
+    return repeat_min, repeat_max
+  end
+
+  def self.get_rules_and_annotations jcr
+    rules = []
+    annotations = []
+
+    if jcr.is_a?( Hash )
+      jcr = [ jcr ]
+    end
+
+    if jcr.is_a? Array
+      i = 0
+      jcr.each do |sub|
+        case
+          when sub[:unordered_annotation]
+            annotations << sub
+            i = i + 1
+          when sub[:reject_annotation]
+            annotations << sub
+            i = i + 1
+          when sub[:root_annotation]
+            annotations << sub
+            i = i + 1
+          when sub[:primitive_rule],sub[:object_rule],sub[:group_rule],sub[:array_rule],sub[:target_rule_name]
+            break
+        end
+      end
+      rules = jcr[i,jcr.length]
+    end
+
+    return rules, annotations
+  end
+
+  def self.evaluate_reject annotations, evaluation
+    reject = false
+    annotations.each do |a|
+      if a[:reject_annotation]
+        reject = true
+        break
+      end
+    end
+
+    if reject
+      evaluation.success = !evaluation.success
+    end
+    return evaluation
+  end
+
+  def self.get_group rule, econs
+    return rule[:group_rule] 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
+      return get_group( target, econs )
+    end
+    #else
+    return false
+  end
+end

data/lib/jcr/evaluate_value_rules.rb

@@ -0,0 +1,279 @@
+# 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_value_rule jcr, rule_atom, data, mapping
+    rules, annotations = get_rules_and_annotations( jcr )
+
+    return evaluate_reject( annotations, evaluate_values( rules[0], rule_atom, data, mapping ) )
+  end
+
+  def self.evaluate_values jcr, rule_atom, data, mapping
+    case
+
+      #
+      # any
+      #
+
+      when jcr[:any]
+        return Evaluation.new( true, nil )
+
+      #
+      # integers
+      #
+
+      when jcr[:integer_v]
+        si = jcr[:integer_v].to_s
+        if si == "integer"
+          return bad_value( jcr, rule_atom, "integer", data ) unless data.is_a?( Fixnum )
+        end
+      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],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
+
+      #
+      # floats
+      #
+
+      when jcr[:float_v]
+        sf = jcr[:float_v].to_s
+        if sf == "float"
+          return bad_value( jcr, rule_atom, "float", data ) unless data.is_a?( Float )
+        end
+      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],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
+
+      #
+      # boolean
+      #
+
+      when jcr[:true_v]
+        return bad_value( jcr, rule_atom, "true", data ) unless data
+      when jcr[:false_v]
+        return bad_value( jcr, rule_atom, "false", data ) if data
+      when jcr[:boolean_v]
+        return bad_value( jcr, rule_atom, "boolean", data ) unless ( data.is_a?( TrueClass ) || data.is_a?( FalseClass ) )
+
+      #
+      # strings
+      #
+
+      when jcr[:string]
+        return bad_value( jcr, rule_atom, "string", data ) unless data.is_a? String
+      when jcr[:q_string]
+        s = jcr[:q_string].to_s
+        return bad_value( jcr, rule_atom, s, data ) unless data == s
+
+      #
+      # regex
+      #
+
+      when jcr[:regex]
+        regex = Regexp.new( jcr[:regex].to_s )
+        return bad_value( jcr, rule_atom, regex, data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, regex, data ) unless data =~ regex
+
+      #
+      # ip addresses
+      #
+
+      when jcr[:ip4]
+        return bad_value( jcr, rule_atom, "IPv4 Address", data ) unless data.is_a? String
+        begin
+          ip = IPAddr.new( data )
+        rescue IPAddr::InvalidAddressError
+          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]
+        return bad_value( jcr, rule_atom, "IPv6 Address", data ) unless data.is_a? String
+        begin
+          ip = IPAddr.new( data )
+        rescue IPAddr::InvalidAddressError
+          return bad_value( jcr, rule_atom, "IPv6 Address", data )
+        end
+        return bad_value( jcr, rule_atom, "IPv6 Address", data ) unless ip.ipv6?
+
+      #
+      # domain names
+      #
+
+      when jcr[:fqdn]
+        return bad_value( jcr, rule_atom, "Fully Qualified Domain Name", data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, "Fully Qualified Domain Name", data ) if data.empty?
+        a = data.split( '.' )
+        a.each do |label|
+          return bad_value( jcr, rule_atom, "Fully Qualified Domain Name", data ) if label.start_with?( '-' )
+          return bad_value( jcr, rule_atom, "Fully Qualified Domain Name", data ) if label.end_with?( '-' )
+          label.each_char do |char|
+            unless (char >= 'a' && char <= 'z') \
+              || (char >= 'A' && char <= 'Z') \
+              || (char >= '0' && char <='9') \
+              || char == '-'
+              return bad_value( jcr, rule_atom, "Fully Qualified Domain Name", data )
+            end
+          end
+        end
+      when jcr[:idn]
+        return bad_value( jcr, rule_atom, "Internationalized Domain Name", data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, "Internationalized Domain Name", data ) if data.empty?
+        a = data.split( '.' )
+        a.each do |label|
+          return bad_value( jcr, rule_atom, "Internationalized Domain Name", data ) if label.start_with?( '-' )
+          return bad_value( jcr, rule_atom, "Internationalized Domain Name", data ) if label.end_with?( '-' )
+          label.each_char do |char|
+            unless (char >= 'a' && char <= 'z') \
+              || (char >= 'A' && char <= 'Z') \
+              || (char >= '0' && char <='9') \
+              || char == '-' \
+              || char.ord > 127
+              return bad_value( jcr, rule_atom, "Internationalized Domain Name", data )
+            end
+          end
+        end
+
+      #
+      # uri and uri templates
+      #
+
+      when jcr[:uri]
+        return bad_value( jcr, rule_atom, "URI", data ) unless data.is_a?( String )
+        uri = Addressable::URI.parse( data )
+        return bad_value( jcr, rule_atom, "URI", data ) unless uri.is_a?( Addressable::URI )
+      when jcr[:uri_template]
+        t = jcr[:uri_template].to_s
+        return bad_value( jcr, rule_atom, t, data ) unless data.is_a? String
+        template = Addressable::Template.new( t )
+        e = template.extract( data )
+        if e == nil
+          return bad_value( jcr, rule_atom, t, data )
+        else
+          e.each do |k,v|
+            return bad_value( jcr, rule_atom, t, data ) unless v
+          end
+        end
+
+      #
+      # phone and email value rules
+      #
+
+      when jcr[:email]
+        return bad_value( jcr, rule_atom, "Email Address", data ) unless data.is_a? String
+        return bad_value( jcr, rule_atom, "Email Address", data ) unless EmailAddressValidator.validate( data, true )
+
+      when jcr[:phone]
+        return bad_value( jcr, rule_atom, "Phone Number", data ) unless data.is_a? String
+        p = BigPhoney::PhoneNumber.new( data )
+        return bad_value( jcr, rule_atom, "Phone Number", data ) unless p.valid?
+
+      #
+      # 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?
+        pad_start = false
+        data.each_char do |char|
+          if pad_start && char != '='
+            return bad_value( jcr, rule_atom, "Base 64 Data", data )
+          elsif char == '='
+            pad_start = true
+          end
+          unless (char >= 'a' && char <= 'z') \
+              || (char >= 'A' && char <= 'Z') \
+              || (char >= '0' && char <='9') \
+              || char == '=' || char == '+' || char == '/'
+            return bad_value( jcr, rule_atom, "Base 64 Data", data )
+          end
+        end
+
+      #
+      # time and date values
+      #
+
+      when jcr[:date_time]
+        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]
+        return bad_value( jcr, rule_atom, "Date", data ) unless data.is_a? String
+        begin
+          d = data + "T23:20:50.52Z"
+          Time.iso8601( d )
+        rescue ArgumentError
+          return bad_value( jcr, rule_atom, "Date", data )
+        end
+      when jcr[:full_time]
+        return bad_value( jcr, rule_atom, "Time", data ) unless data.is_a? String
+        begin
+          t = "1985-04-12T" + data + "Z"
+          Time.iso8601( t )
+        rescue ArgumentError
+          return bad_value( jcr, rule_atom, "Time", data )
+        end
+
+      #
+      # null
+      #
+
+      when jcr[:null]
+        return bad_value( jcr, rule_atom, nil, data ) unless data == nil
+
+      #
+      # groups
+      #
+
+      when jcr[:group_rule]
+        return evaluate_group_rule jcr[:group_rule], rule_atom, data, mapping
+
+      else
+        raise "unknown value rule evaluation. this shouldn't happen"
+    end
+    return Evaluation.new( true, nil )
+  end
+
+  def self.bad_value jcr, rule_atom, expected, actual
+    Evaluation.new( false, "expected #{expected} but got #{actual} at #{jcr} from #{rule_atom}" )
+  end
+
+end

data/lib/jcr/find_roots.rb

@@ -0,0 +1,106 @@
+# 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/evaluate_rules'
+
+module JCR
+
+  class Root
+    attr_accessor :nameless, :name, :rule, :default
+
+    def initialize rule, name = nil, nameless = true, default = false
+      @rule = rule
+      @name = name
+      @nameless = nameless
+      if name
+        @nameless = false
+      end
+      @default = default
+    end
+  end
+
+  def self.find_roots( tree )
+    roots = Array.new
+    if tree.is_a? Hash
+      tree = [ tree ]
+    end
+    tree.each do |node|
+      if node[:rule]
+        roots.concat( find_roots_in_named( node ) )
+      elsif (top_rule = get_rule_by_type( node ))
+        roots << Root.new( node, nil, true, true )
+        roots.concat( find_roots_in_unnamed( top_rule ) )
+      end
+    end
+    return roots
+  end
+
+  def self.find_roots_in_named( node )
+    roots = Array.new
+    rn = node[:rule][:rule_name].to_str
+    rule = node[:rule]
+    ruledef = get_rule_by_type( rule )
+    if ruledef
+      if ruledef.is_a? Array
+        ruledef.each do |rdi|
+          if rdi[:root_annotation]
+            roots << Root.new( node, rn )
+          elsif (subrule = get_rule_by_type( rdi ))
+            roots.concat( find_roots_in_unnamed( subrule ) )
+          end
+        end
+      elsif ruledef.is_a? Hash
+        subrule = get_rule_by_type( ruledef )
+        roots.concat( find_roots_in_unnamed( subrule ) ) if subrule
+      end
+    end
+    return roots
+  end
+
+  def self.find_roots_in_unnamed( node )
+    roots = Array.new
+    if node.is_a? Array
+      node.each do |n|
+        if n[:root_annotation]
+          roots << Root.new( node )
+        elsif (subrule = get_rule_by_type( n ) )
+          roots.concat( find_roots_in_unnamed( subrule ) ) if subrule
+        end
+      end
+    else
+      subrule = get_rule_by_type( node )
+      roots.concat( find_roots_in_unnamed( subrule ) ) if subrule
+    end
+    return roots
+  end
+
+  def self.get_rule_by_type rule
+    retval = nil
+    case
+      when rule[:array_rule]
+        retval = rule[:array_rule]
+      when rule[:object_rule]
+        retval = rule[:object_rule]
+      when rule[:member_rule]
+        retval = rule[:member_rule]
+      when rule[:primitive_rule]
+        retval = rule[:primitive_rule]
+      when rule[:group_rule]
+        retval = rule[:group_rule]
+    end
+    return retval
+  end
+
+end