easy_json_matcher 0.0.2.pre.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08815b61dd12963ba183f268f8ed79ef4871e942
-  data.tar.gz: 70c09b58d1a58df1310b78f92ac7f12f8ea6c22e
+  metadata.gz: 550d51e3fa5dcd2a06ade6049b34666c957e3c06
+  data.tar.gz: 073104ceb62af67ae2dfbf2cb4ac800cd584b809
 SHA512:
-  metadata.gz: d2415e588006089aab89ef53870839493258f6bd5d71d9573d515c6ee10aacbb3f6dd3db1b979d5c843a07e52356d75456e72242b2ee2706093c8da78a2c1d6c
-  data.tar.gz: 954f6c4a709230a0e8d8250e6a3a4f020fbd723071a741fb478a968bd008077c6cc587b42819d179038fce6ae48db62089227614fe2fdbc2db7f669b3fcb5a42
+  metadata.gz: 2a512cdd2cde619c1b9beaf88efb96167077c8d96c6fd19cf76d5c74c8e89c5e95f274b643901fe344cd96d1dc7d086721731962bad243942ea95c174b705735
+  data.tar.gz: 01960e66aa4bdf8ce3bb31df5ddc474622f10d19bca0b414bd1c7ab8d1b70c5ab16da3c75ea770dd0836cf1c7825dc8dfa20d18a98f16aae2896359772e36579

data/lib/easy_json_matcher/array_validator.rb

@@ -2,9 +2,45 @@ require 'easy_json_matcher/validator'
 module EasyJSONMatcher
   class ArrayValidator < Validator
     attr_reader :validators, :validator_results
+######################### Methods for requiring values by type #################
+
+    def should_only_contain_strings(opts: {})
+      should_only_contain type: :string, opts: opts
+    end
+
+    def should_only_contain_objects(opts: {})
+      should_only_contain type: :object, opts: opts
+    end
+
+    def should_only_contain_values(opts: {})
+      should_only_contain type: :value, opts: opts
+    end
+
+    def should_only_contain_numbers(opts: {})
+      should_only_contain type: :number, opts: opts
+    end
+
+    def should_only_contain_booleans(opts: {})
+      should_only_contain type: :boolean, opts: opts
+    end
+
+    def should_only_contain_dates(opts: {})
+      should_only_contain type: :date, opts: opts
+    end
+
+    def should_only_contain_schema(name:, opts: {})
+      should_only_contain type: :schema, opts: opts.merge({name: name})
+    end
+
+    def should_only_contain(type:,opts: {})
+      _clear_validators
+      _add_validator(_create_validator(type: type, opts: opts))
+    end
+
+######################## Private methods #######################################
 
     def _validate
-      return false unless _content_is_array?
+      errors << "#{content} is not an Array" unless _content_is_array?
       _validate_content
     end
 
@@ -14,14 +50,8 @@ module EasyJSONMatcher
 
     def _validate_content
       validators.each do |val|
-        _run_validator(val)
+        _accumulate_errors val
       end
-      _validation_result
-    end
-
-    def should_only_contain(type:,opts: {})
-      _clear_validators
-      _add_validator(_create_validator(type: type, opts: opts))
     end
 
     def _clear_validators
@@ -36,18 +66,19 @@ module EasyJSONMatcher
       @validators ||= []
     end
 
-    def _run_validator(v)
-      content.each do |value|
-        validator_results << v.valid?(value)
+    def _accumulate_errors(validator)
+      content.each do |candidate|
+        _run_validator(validator, candidate)
       end
+      errors << validator.errors unless validator._no_errors?
     end
 
-    def _validation_result
-      !validator_results.include? false
+    def _run_validator(validator, candidate)
+      validator.valid? candidate
     end
 
-    def validator_results
-      @validator_results ||= []
+    def _validation_result
+      !validator_results.include? false
     end
   end
 end

data/lib/easy_json_matcher/boolean_validator.rb

@@ -1,7 +1,12 @@
 require 'easy_json_matcher/validator'
 module EasyJSONMatcher
   class BooleanValidator < Validator
+
     def _validate
+      errors << "#{content} is not a Boolean" unless _content_is_boolean?
+    end
+
+    def _content_is_boolean?
       clazz = content.class
       (clazz == TrueClass) || (clazz == FalseClass)
     end

data/lib/easy_json_matcher/content_wrapper.rb

@@ -1,18 +1,16 @@
 module EasyJSONMatcher
-  class ContentWrapper
-
-    attr_reader :content
-
-    def initialize(content)
-      @content = content
-    end
+  module ContentWrapper
 
     def [](key)
       content[key.to_s]
     end
 
-    def method_missing(method, *args)
-      content.send(method, *args)
+    def method_missing(method, *args, &block)
+      content.send(method, *args, &block)
+    end
+
+    def keys
+      content.keys.map(&:to_sym)
     end
   end
 end

data/lib/easy_json_matcher/date_validator.rb

@@ -12,14 +12,15 @@ module EasyJSONMatcher
     end
 
     def _validate
-      _validate_as_string && _validate_as_date
+      _validate_string
+      _validate_date
     end
 
-    def _validate_as_string
+    def _content_is_a_string?
       string_validator.valid? content
     end
 
-    def _validate_as_date
+    def _content_is_a_date?
       require 'date'
       begin
         Date.strptime(content, date_format)
@@ -31,5 +32,13 @@ module EasyJSONMatcher
     def date_format
       @date_format || DEFAULT_DATE_FORMAT
     end
+
+    def _validate_string
+      errors << "#{content} must be provided as a String for Date validation" unless _content_is_a_string?
+    end
+
+    def _validate_date
+      errors << "#{content} is not a Date" unless _content_is_a_date?
+    end
   end
 end

data/lib/easy_json_matcher/exceptions.rb

@@ -1,4 +1,3 @@
-require 'easy_json_matcher'
 module EasyJSONMatcher
   # Override of Ruby error for namespacing
   class Error < RuntimeError; end

data/lib/easy_json_matcher/node.rb

@@ -1,30 +1,51 @@
-require 'easy_json_matcher'
 require 'easy_json_matcher/validator_factory'
 require 'json'
 require 'easy_json_matcher/content_wrapper'
-require 'forwardable'
 module EasyJSONMatcher
   class Node < Validator
-    extend Forwardable
+    include ContentWrapper
 
-    attr_reader :validators
-
-    def_delegators :content, :[]
+    attr_reader :validators, :validity, :strict
 
     def initialize(opts: {})
       super(options: opts)
       @validators = []
+      @validity = true
     end
 
     def add_validator(validator)
       validators << validator
     end
 
+    def _post_initialise(options)
+      @strict = options[:strict]
+    end
+
     def _validate
+      _validate_strict_keyset
       validators.each do |val|
-        return false unless _use_validator val
+        @validity = false unless _use_validator val
+      end
+    end
+
+    def reset!
+      errors.clear
+      validators.each(&:reset!)
+    end
+
+    def _validate_strict_keyset
+      _validate_keyset if strict
+    end
+
+    def _validate_keyset
+      unexpected_keys = keys - _expected_keys
+      errors << "#{unexpected_keys} found in addition to expected keys" unless unexpected_keys.empty?
+    end
+
+    def _expected_keys
+      validators.each_with_object([]) do |validator, keyset|
+        keyset << validator.key
       end
-      true
     end
 
     def _use_validator(validator)
@@ -32,7 +53,7 @@ module EasyJSONMatcher
     end
 
     def _get_content_for(key)
-      content[key.to_s]
+      content[key]
     end
 
     def _get_validator_for(key)
@@ -40,25 +61,61 @@ module EasyJSONMatcher
     end
 
     def _set_content(candidate)
-      candidate = _prep_candidate(candidate)
-      @content = _is_root? ? candidate : candidate[key]
+      @content = _is_root? ? _prep_root_content(candidate) : candidate[key]
     end
 
     def _is_root?
       key.nil?
     end
 
-    def _prep_candidate(json)
-      if json.is_a? String
-        wrap_content(JSON.parse(json))
+    def get_errors
+      child_errors = _collect_child_errors
+      _wrap_errors(child_errors)
+    end
+
+    def _collect_child_errors
+      validators.each_with_object({}) do |val, container|
+        container.merge!(val.get_errors)
+      end
+    end
+
+    def _wrap_errors(child_errors)
+      _add_local_errors_to child_errors
+      unless _is_root?
+        _wrap_child_errors(child_errors)
       else
-        raise "Content for validation must be either a Hash or a String - you supplied #{json}, which is a #{json.class.name}" unless json.respond_to? :[]
-        wrap_content(json)
+        _root_errors(child_errors)
+      end
+    end
+
+    def _add_local_errors_to(child_errors)
+      child_errors.merge!({node_errors_: errors}) unless errors.empty?
+    end
+
+    def _wrap_child_errors(child_errors)
+      errors_wrapper = {}
+      errors_wrapper[key] = child_errors
+      errors_wrapper
+    end
+
+    def _root_errors(child_errors)
+      errors.length > 0 ? {root: errors} : child_errors
+    end
+
+    def _prep_root_content(candidate)
+       candidate.is_a?(String) ? _parse_and_verify_json(candidate) : candidate
+    end
+
+    def _parse_and_verify_json(json)
+      begin
+        JSON.parse(json)
+      rescue JSON::ParserError
+        errors << '#{json} is not a valid JSON String'
       end
     end
 
-    def wrap_content(json)
-      ContentWrapper.new(json)
+    def _no_errors?
+      validity && errors.empty?
     end
   end
 end

data/lib/easy_json_matcher/number_validator.rb

@@ -1,8 +1,14 @@
 # Asserts that a value is a double-precision floating point number in javascript format
 require 'easy_json_matcher/validator'
 module EasyJSONMatcher
+
   class NumberValidator < Validator
+
     def _validate
+      errors << "#{content} is not a Number" unless _content_is_a_number?
+    end
+
+    def _content_is_a_number?
       begin
         Kernel::Float(content)
         true
@@ -12,6 +18,5 @@ module EasyJSONMatcher
         false
       end
     end
-
   end
 end

data/lib/easy_json_matcher/object_validator.rb

@@ -2,7 +2,11 @@ require 'easy_json_matcher/validator'
 module EasyJSONMatcher
   class ObjectValidator < Validator
     def _validate
-      content.is_a? Hash
+      _content_is_object?
+    end
+
+    def _content_is_object?
+      errors << "#{content} is not an Object" unless content.is_a? Hash
     end
   end
 end

data/lib/easy_json_matcher/schema_generator.rb

@@ -5,71 +5,100 @@ require 'easy_json_matcher/exceptions'
 module EasyJSONMatcher
   class SchemaGenerator
 
-    attr_reader :node
-    attr_reader :name
+    attr_reader :node, :name, :options, :glob_opts
 
-    def initialize(opts: {})
-      @name = opts[:key]
+    def initialize(opts: {}, global_opts: {})
+      @name = opts.delete(:key)
+      @options = opts
+      @glob_opts = global_opts
       yield self if block_given?
     end
 
+    def has_attribute(key:, opts: {})
+      node.add_validator(_create_validator(key, opts))
+    end
+
+    ################ Methods for adding specific attribute types ##############
+
     def contains_node(key:, opts: {})
       generator = _node_generator _validator_opts(key, opts)
       yield generator if block_given?
-      node.add_validator generator.generate_node
+      node.add_validator generator.generate_schema
     end
 
-    def has_attribute(key:, opts: {})
-      node.add_validator(_create_validator(key, opts))
+    def has_boolean(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :boolean}))
     end
 
-    def contains_schema(schema_name:, opts: {})
-      key = opts[:key] || schema_name
-      schema = _create_validator(key, _prep_schema_opts(schema_name, opts))
-      _set_validator_key(schema, opts[:key] || schema_name)
-      node.add_validator schema
+    def has_number(key: , opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :number}))
     end
 
-    def _prep_schema_opts(schema_name, opts)
-      opts[:type] = :schema
-      opts[:name] = schema_name
-      opts
+    def has_date(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :date}))
     end
 
-    def _set_validator_key(validator, key)
-      validator.key = key
+    def has_object(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :object}))
+    end
+
+    def has_value(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :value}))
+    end
+
+    def has_string(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :string}))
     end
 
     def contains_array(key:, opts: {})
-      opts.merge!({type: :array})
+      opts = opts.merge!({type: :array})
       array_validator = _create_validator(key, opts)
       yield array_validator if block_given?
       node.add_validator array_validator
     end
 
-    def _validator_opts(key, opts)
-      opts[:key] = key
+    def has_schema(key:, opts: {})
+      has_attribute(key: key, opts: opts.merge({type: :schema}))
+    end
+
+    ################ Methods for generating the schema #########################
+
+    def generate_schema
+      node
+    end
+
+    def register(as:)
+      SchemaLibrary.add_schema(name: as, schema: generate_schema)
+      generate_schema
+    end
+
+    ################## Private methods #########################################
+
+    def _prep_schema_opts(schema_name, opts)
+      opts[:type] = :schema
+      opts[:name] = schema_name
       opts
     end
 
-    def _create_validator(key, opts)
-      ValidatorFactory.get_instance type: opts[:type], opts: _validator_opts(key, opts)
+    def _set_validator_key(validator, key)
+      validator.key = key
     end
 
-    def _node_generator(opts = {})
-     self.class.new opts: opts
+    def _validator_opts(key, opts)
+      opts[:key] = key
+      glob_opts.merge(opts)
     end
 
-    def generate_node
-      node
+    def _create_validator(key, opts)
+      ValidatorFactory.get_instance type: opts[:type], opts: _validator_opts(key, opts)
     end
 
-    def register(schema_name:)
-      SchemaLibrary.add_schema(name: schema_name, schema: generate_node)
+    def _node_generator(opts = {})
+     self.class.new opts: opts, global_opts: glob_opts
     end
 
     def node
-      @node ||= Node.new(opts: _validator_opts(name, {}))
+      @node ||= Node.new(opts: _validator_opts(name, options))
     end
   end
 end