j2119 0.1.0

data/lib/j2119/constraints.rb

@@ -0,0 +1,312 @@
+# Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may
+# not use this file except in compliance with the License. A copy of the
+# License is located at
+#
+#    http://aws.amazon.com/apache2.0/
+#
+# or in the LICENSE.txt file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+require 'date'
+
+module J2119
+
+  # These all respond_to
+  # check(node, path, problem)
+  #  - node is the JSON node being checked
+  #  - path is the current path, for reporting practices
+  #  - problems is a list of problem reports
+  # TODO: Add a "role" argument to enrich error reporting
+  class Constraint
+    def initialize
+      @conditions = []
+    end
+
+    def add_condition(condition)
+      @conditions << condition
+    end
+
+    def applies(node, role)
+      return @conditions.empty? ||
+        @conditions.map{|c| c.constraint_applies(node, role)}.any?
+    end
+  end
+
+  # Verify that there is only one of a selection of fields
+  #
+  class OnlyOneOfConstraint < Constraint
+    def initialize(fields)
+      super()
+      @fields = fields
+    end
+
+    def check(node, path, problems)
+      if (@fields & node.keys).size > 1
+        problems <<
+          "#{path} may have only one of #{@fields}"
+      end
+    end
+  end
+
+  # Verify that array field is not empty
+  #
+  class NonEmptyConstraint < Constraint
+    def initialize(name)
+      super()
+      @name = name
+    end
+
+    def to_s
+      conds = (@conditions.empty?) ? '' : " #{@conditions.size} conditions"
+      "<Array field #{@name} should not be empty#{conds}>"
+    end
+    
+    def check(node, path, problems)
+      if node[@name] && node[@name].is_a?(Array) && (node[@name].size == 0)
+        problems <<
+          "#{path}.#{@name} is empty, non-empty required"
+      end
+    end
+  end
+
+  # Verify node has the named field, or one of the named fields
+  #
+  class HasFieldConstraint < Constraint
+    def initialize(name)
+      super()
+      if name.is_a?(String)
+        @names = [ name ]
+      else
+        @names = name
+      end
+    end
+
+    def to_s
+      conds = (@conditions.empty?) ? '' : " #{@conditions.size} conditions"
+      "<Field #{@names} should be present#{conds}>"
+    end
+
+    def check(node, path, problems)
+      if (node.keys & @names).empty?
+        if @names.size == 1
+          problems <<
+            "#{path} does not have required field \"#{@names[0]}\""
+        else
+          problems <<
+            "#{path} does not have required field from #{@names}"
+        end
+      end
+    end
+  end
+
+  # Verify node does not have the named field
+  #
+  class DoesNotHaveFieldConstraint < Constraint
+    def initialize(name)
+      super()
+      @name = name
+    end
+    
+    def to_s
+      conds = (@conditions.empty?) ? '' : " #{@conditions.size} conditions"
+      "<Field #{@name} should be absent#{conds}>"
+    end
+
+    def check(node, path, problems)
+      if node[@name]
+        problems <<
+          "#{path} has forbidden field \"#{@name}\""
+      end
+    end
+  end
+
+  # Verify type of a field in a node
+  #
+  class FieldTypeConstraint < Constraint
+    def initialize(name, type, is_array, is_nullable)
+      super()
+      @name = name
+      @type = type
+      @is_array = is_array
+      @is_nullable = is_nullable
+    end
+
+    def to_s
+      conds = (@conditions.empty?) ? '' : " #{@conditions.size} conditions"
+      nullable = @is_nullable ? ' (nullable)' : ''
+      "<Field #{@name} should be of type #{@type}#{conds}>#{nullable}"
+    end
+
+    def check(node, path, problems)
+
+      # type-checking is orthogonal to existence checking
+      return if !node.key?(@name)
+
+      value = node[@name]
+      path = "#{path}.#{@name}"
+
+      if value == nil
+        if !@is_nullable
+          problems << "#{path} should be non-null"
+        end
+        return
+      end
+
+      if @is_array
+        if value.is_a?(Array)
+          i = 0
+          value.each do |element|
+            value_check(element, "#{path}[#{i}]", problems)
+            i += 1
+          end
+        else
+          report(path, value, 'an Array', problems)
+        end
+      else
+        value_check(value, path, problems)
+      end
+    end
+                 
+    def value_check(value, path, problems)
+      case @type
+      when :object
+        report(path, value, 'an Object', problems) if !value.is_a?(Hash)
+      when :array
+        report(path, value, 'an Array', problems) if !value.is_a?(Array)
+      when :string
+        report(path, value, 'a String', problems) if !value.is_a?(String)
+      when :integer
+        report(path, value, 'an Integer', problems) if !value.is_a?(Integer)
+      when :float
+        report(path, value, 'a Float', problems) if !value.is_a?(Float)
+      when :boolean
+        if value != true && value != false
+          report(path, value, 'a Boolean', problems)
+        end
+      when :numeric
+        report(path, value, 'numeric', problems) if !value.is_a?(Numeric)
+      when :json_path
+        report(path, value, 'a JSONPath', problems) if !JSONPathChecker.is_path?(value)
+      when :reference_path
+        report(path, value, 'a Reference Path', problems) if !JSONPathChecker.is_reference_path?(value)
+      when :timestamp
+        begin
+          DateTime.rfc3339 value
+        rescue
+          report(path, value, 'an RFC3339 timestamp', problems)
+        end
+      when :URI
+        if !(value.is_a?(String) && (value =~ /^[a-z]+:/))
+          report(path, value, 'A URI', problems) 
+        end
+      end
+      
+    end
+
+    def report(path, value, message, problems)
+      if value.is_a?(String)
+        value = '"' + value + '"'
+      end
+      problems << "#{path} is #{value} but should be #{message}"
+    end
+    
+  end      
+
+  # Verify constraints on values of a named field
+  #
+  class FieldValueConstraint < Constraint
+
+    def initialize(name, params)
+      super()
+      @name = name
+      @params = params
+    end
+
+    def to_s
+      conds = (@conditions.empty?) ? '' : " #{@conditions.size} conditions"
+      "<Field #{@name} has constraints #{@params}#{conds}>"
+    end
+
+    def check(node, path, problems)
+
+      # value-checking is orthogonal to existence checking
+      return if !node.key?(@name)
+
+      value = node[@name]
+
+      if @params[:enum]
+        if !(@params[:enum].include?(value))
+          problems <<
+            "#{path}.#{@name} is \"#{value}\", " +
+            "not one of the allowed values #{@params[:enum]}"
+        end
+        
+        # if enum constraint are provided, others are ignored
+        return
+      end
+
+      if @params[:equal]
+        begin
+          if value != @params[:equal]
+            problems <<
+              "#{path}.#{@name} is #{value} " +
+              "but required value is #{@params[:equal]}"
+          end
+        rescue Exception
+          # should be caught by type constraint
+        end
+      end
+      if @params[:floor]
+        begin
+          if value <= @params[:floor]
+            problems <<
+              "#{path}.#{@name} is #{value} " +
+              "but allowed floor is #{@params[:floor]}"
+          end
+        rescue Exception
+          # should be caught by type constraint
+        end
+      end
+      if @params[:min]
+        begin
+          if value < @params[:min]
+            problems <<
+              "#{path}.#{@name} is #{value} " +
+              "but allowed minimum is #{@params[:min]}"
+          end
+        rescue Exception
+          # should be caught by type constraint
+        end
+      end
+      if @params[:ceiling]
+        begin
+          if value >= @params[:ceiling]
+            problems <<
+              "#{path}.#{@name} is #{value} " +
+              "but allowed ceiling is #{@params[:ceiling]}"
+          end
+        rescue Exception
+          # should be caught by type constraint
+        end
+      end
+      if @params[:max]
+        begin
+          if value > @params[:max]
+            problems <<
+              "#{path}.#{@name} is #{value} " +
+              "but allowed maximum is #{@params[:max]}"
+          end
+        rescue Exception
+          # should be caught by type constraint
+        end
+      end
+    end
+  end
+
+end
+
+

data/lib/j2119/deduce.rb

@@ -0,0 +1,39 @@
+# Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may
+# not use this file except in compliance with the License. A copy of the
+# License is located at
+#
+#    http://aws.amazon.com/apache2.0/
+#
+# or in the LICENSE.txt file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+module J2119
+
+  class Deduce
+
+    # we have to deduce the JSON value from they way they expressed it as
+    #  text in the J2119 file.
+    #
+    def self.value(val)
+      case val
+      when /^"(.*)"$/
+        $1
+      when 'true'
+        true
+      when 'false'
+        false
+      when 'null'
+        nil
+      when /^\d+$/
+        val.to_i
+      else
+        val.to_f
+      end
+        
+    end
+  end
+end

data/lib/j2119/json_path_checker.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+# Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may
+# not use this file except in compliance with the License. A copy of the
+# License is located at
+#
+#    http://aws.amazon.com/apache2.0/
+#
+# or in the LICENSE.txt file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+# Examines fields which are supposed to be JSONPath expressions or Reference
+#  Paths, which are JSONPaths that are singular, i.e. don't produce array
+#  results
+#
+module J2119
+
+  INITIAL_NAME_CLASSES = [ 'Lu', 'Ll', 'Lt', 'Lm', 'Lo', 'Nl' ]
+  NON_INITIAL_NAME_CLASSES = [ 'Mn', 'Mc', 'Nd', 'Pc' ]
+  FOLLOWING_NAME_CLASSES = INITIAL_NAME_CLASSES | NON_INITIAL_NAME_CLASSES
+  DOT_SEPARATOR = '\.\.?'
+  
+  class JSONPathChecker
+
+    def self.classes_to_re classes
+      re_classes = classes.map  {|x| "\\p{#{x}}" }
+      "[#{re_classes.join('')}]"
+    end
+
+    @@name_re = classes_to_re(INITIAL_NAME_CLASSES) +
+                classes_to_re(FOLLOWING_NAME_CLASSES) + '*'
+    dot_step = DOT_SEPARATOR + '((' + @@name_re + ')|(\*))'
+    rp_dot_step = DOT_SEPARATOR + @@name_re
+    bracket_step = '\[' + "'" + @@name_re + "'" + '\]'
+    rp_num_index = '\[\d+\]'
+    num_index = '\[\d+(, *\d+)?\]'
+    star_index = '\[\*\]'
+    colon_index = '\[(-?\d+)?:(-?\d+)?\]'
+    index = '((' + num_index + ')|(' + star_index + ')|(' + colon_index + '))'
+    step = '((' + dot_step + ')|(' + bracket_step + '))' + '(' + index + ')?'
+    rp_step = '((' + rp_dot_step + ')|(' + bracket_step + '))' + '(' + rp_num_index + ')?'
+    path = '^\$' + '(' + step + ')+$'
+    reference_path = '^\$' + '(' + rp_step + ')+$'
+    @@path_re = Regexp.new(path)
+    @@reference_path_re = Regexp.new(reference_path);
+
+    def self.is_path?(s)
+      s.is_a?(String) && @@path_re.match(s)
+    end
+
+    def self.is_reference_path?(s)
+      s.is_a?(String) && @@reference_path_re.match(s)
+    end
+  end
+end

data/lib/j2119/matcher.rb

@@ -0,0 +1,233 @@
+# Copyright 2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may
+# not use this file except in compliance with the License. A copy of the
+# License is located at
+#
+#    http://aws.amazon.com/apache2.0/
+#
+# or in the LICENSE.txt file accompanying this file. This file is distributed
+# on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+module J2119
+
+  # Does the heavy lifting of parsing j2119 files to extract all
+  #  the assertions, making egregious use of regular expressions.
+  #
+  # This is the kind of thing I actively discourage when other
+  #  programmers suggest it.  If I were a real grown-up I'd
+  #  implement a proper lexer and bullet-proof parser.
+  #
+  class Matcher
+
+    # crutch for RE debugging
+    attr_reader :constraint_match, :roledef_match, :only_one_match
+
+    # actual exports
+    attr_reader :role_matcher, :eachof_match
+    
+    MUST = '(?<modal>MUST|MAY|MUST NOT)'
+    TYPES = [
+      'array',
+      'object',
+      'string',
+      'boolean',
+      'numeric',
+      'integer',
+      'float',
+      'timestamp',
+      'JSONPath',
+      'referencePath',
+      'URI'
+    ]
+    
+    RELATIONS = [
+      '', 'equal to', 'greater than', 'less than',
+      'greater than or equal to', 'less than or equal to'
+    ].join('|')
+    RELATION = "((?<relation>#{RELATIONS})\\s+)"
+
+    S = '"[^"]*"' # string
+    V = '\S+'     # non-string value: number, true, false, null
+    RELATIONAL = "#{RELATION}(?<target>#{S}|#{V})"
+
+    CHILD_ROLE = ';\s+((its\s+(?<child_type>value))|' +
+                 'each\s+(?<child_type>field|element))' +
+                 '\s+is\s+an?\s+' +
+                 '"(?<child_role>[^"]+)"'
+
+    @@initialized = false
+
+    # constants that need help from oxford
+    def constants
+      if !@@initialized
+        @@initialized = true
+
+        @@strings = Oxford.re(S, :capture_name => 'strings')
+        enum = "one\s+of\s+#{@@strings}"
+
+        @@predicate = "(#{RELATIONAL}|#{enum})"
+      end
+    end
+
+    def reconstruct
+      make_type_regex
+
+      # conditional clause
+      excluded_roles = "not\\s+" +
+                       Oxford.re(@role_matcher,
+                                 :capture_name => 'excluded',
+                                 :use_article => true) +
+                       "\\s+"
+      conditional = "which\\s+is\\s+" +
+                    excluded_roles
+
+      # regex for matching constraint lines
+      c_start = '^An?\s+' +
+                "(?<role>#{@role_matcher})" + '\s+' +
+                "(#{conditional})?" +
+                MUST + '\s+have\s+an?\s+'
+      field_list = "one\\s+of\\s+" +
+                   Oxford.re('"[^"]+"', :capture_name => 'field_list')
+      c_match = c_start + 
+                "((?<type>#{@type_regex})\\s+)?" +
+                "field\\s+named\\s+" +
+                "((\"(?<field_name>[^\"]+)\")|(#{field_list}))" +
+                '(\s+whose\s+value\s+MUST\s+be\s+' + @@predicate + ')?' +
+                '(' + CHILD_ROLE + ')?' +
+                '\.'
+
+      # regexp for matching lines of the form
+      #  "An X MUST have only one of "Y", "Z", and "W".
+      #  There's a pattern here, building a separate regex rather than
+      #  adding more complexity to @constraint_matcher.  Any further
+      #  additions should be done this way, and
+      #  TODO: Break @constraint_matcher into a bunch of smaller patterns
+      #  like this.
+      oo_start = '^An?\s+' +
+                "(?<role>#{@role_matcher})" + '\s+' +
+                 MUST + '\s+have\s+only\s+'
+      oo_field_list = "one\\s+of\\s+" +
+                      Oxford.re('"[^"]+"',
+                                :capture_name => 'field_list',
+                                :connector => 'and')
+      oo_match = oo_start + oo_field_list
+
+      # regex for matching role-def lines
+      val_match = "whose\\s+\"(?<fieldtomatch>[^\"]+)\"" +
+                  "\\s+field's\\s+value\\s+is\\s+" +
+                  "(?<valtomatch>(\"[^\"]*\")|([^\"\\s]\\S+))\\s+"
+      with_a_match = "with\\s+an?\\s+\"(?<with_a_field>[^\"]+)\"\\s+field\\s"
+
+      rd_match = '^An?\s+' +
+                 "(?<role>#{@role_matcher})" + '\s+' +
+                 "((?<val_match_present>#{val_match})|(#{with_a_match}))?" +
+                 "is\\s+an?\\s+" +
+                 "\"(?<newrole>[^\"]*)\"\\.\\s*$"
+      @roledef_match = Regexp.new(rd_match)
+
+      @constraint_start = Regexp.new(c_start)
+      @constraint_match = Regexp.new(c_match)
+
+      @only_one_start = Regexp.new(oo_start)
+      @only_one_match = Regexp.new(oo_match)
+                       
+      eo_match = "^Each\\s+of\\s" +
+                 Oxford.re(@role_matcher,
+                           :capture_name => 'each_of',
+                           :use_article => true,
+                           :connector => 'and') +
+                 "\\s+(?<trailer>.*)$"
+
+      @eachof_match = Regexp.new(eo_match)
+    end
+
+    def initialize(root)
+      constants
+      @roles = []
+      add_role root
+      reconstruct
+    end
+    
+    def add_role(role)
+      @roles << role
+      @role_matcher = @roles.join('|')
+      reconstruct
+    end
+
+    def self.tokenize_strings(s)
+      # should be a way to do this with capture groups but I'm not smart enough
+      strings = []
+      r = Regexp.new '^[^"]*"([^"]*)"'
+      while s =~ r
+        strings << $1
+        s = $'
+      end
+      strings
+    end
+
+    def tokenize_values(vals)
+      vals.gsub(',', ' ').gsub('or', ' ').split(/\s+/)
+    end
+    
+    def make_type_regex
+      
+      # add modified numeric types
+      types = TYPES.clone
+      number_types = [ 'float', 'integer', 'numeric' ]
+      number_modifiers = [ 'positive', 'negative', 'nonnegative' ]
+      number_types.each do |number_type|
+        number_modifiers.each do |number_modifier|
+          types << "#{number_modifier}-#{number_type}"
+        end
+      end
+      
+      # add array types
+      array_types = types.map { |t| "#{t}-array" }
+      types |= array_types
+      nonempty_array_types = array_types.map { |t| "nonempty-#{t}" }
+      types |= nonempty_array_types
+      nullable_types = types.map { |t| "nullable-#{t}" }
+      types |= nullable_types
+      @type_regex = types.join('|')
+    end
+
+    def is_role_def_line(line)
+      line =~ %r{is\s+an?\s+"[^"]*"\.\s*$}
+    end
+
+    def build_role_def(line)
+      build(@roledef_match, line)
+    end
+
+    def build(re, line)
+      data = {}
+      match = re.match(line)
+      match.names.each do |name|
+        data[name] = match[name]
+      end
+      data
+    end
+
+    def build_only_one(line)
+      build(@only_one_match, line)
+    end
+
+    def is_constraint_line(line)
+      line =~ @constraint_start
+    end
+
+    def is_only_one_match_line(line)
+      line =~ @only_one_start
+    end
+
+    def build_constraint(line)
+      build(@constraint_match, line)
+    end
+
+  end
+
+
+end