easy_json_matcher 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29eb515cf0aae680f37f2c881b061c8d56fa5cc0
-  data.tar.gz: 5f617e24d4270c30f26e6bed85692402adad047e
+  metadata.gz: 55ae99f6f7c4b6ccee8c50a57555d58a5a4bd2b2
+  data.tar.gz: 713dc82d9dce7912117f6a59b419c3cfeff92441
 SHA512:
-  metadata.gz: 317e11578a3bd7420e88fa30ab294941a6d644a2303ecd2412cb2650973ed466ea565357455052bd0323acf4a1b30b4b9b63d89ce6b5266cb2205b09aadd6551
-  data.tar.gz: 5e12a27e3f4f436afec4951e26e8136df61662859a3b240c617b7c70d2d7aa891072724a976b1c6383334245446c654762b50da35652b88053feafb9c6b41ba9
+  metadata.gz: 012365ce1754864733914fcfcf7dd341d168168977e341014fd8804a7426a3c7e9bf005708e1c6f8e50d1c96a39dc82e048e303a0b30bfe98d445e0d718a270b
+  data.tar.gz: 51ecd2c9ca6f601ab1894da188fb1feecce8fb32a2d4ecd55c0001b2399b8c97a37a2a9c9cd3642630c732b283f8af8087faefa237f352ab65c90173dcae4a9c

data/lib/easy_json_matcher/array_content_validator.rb

@@ -0,0 +1,22 @@
+module EasyJSONMatcher
+  class ArrayContentValidator
+
+    attr_reader :next_step, :verifier
+
+    def initialize(verify_with:)
+      @verifier = verify_with
+    end
+
+    def check(value:)
+      errors = []
+      value.each do |val|
+        errors += verifier.check(value: val)
+      end
+      errors
+    end
+
+    def >> (step)
+      @next_step = step
+    end
+  end
+end

data/lib/easy_json_matcher/array_generator.rb

@@ -0,0 +1,41 @@
+module EasyJSONMatcher
+  class ArrayGenerator
+
+    WHITELIST = [:required, :not_required]
+
+    attr_reader :opts, :content_opts, :target_class
+
+    def initialize(local_opts:, global_opts:, target_class: ArrayValidator)
+      @target_class = target_class
+      @opts = extract_opts(locals: local_opts, globals: global_opts)
+      @content_opts = []
+    end
+
+    def generate_array
+      target_class.new(opts: opts, verify_content_as: content_opts)
+    end
+
+    def elements_should(be:)
+      @content_opts = be
+    end
+
+    def extract_opts(locals:, globals:)
+      (globals.select(&array_options_filter) + locals).map(&override_local_values(locals: locals))
+    end
+
+    def array_options_filter
+      ->(opt) { WHITELIST.include?(opt) }
+    end
+
+    def override_local_values(locals:)
+      conflicts = { required: :not_required }
+      ->(opt) { 
+        if conflicts.keys.include? opt
+          locals.include?(conflicts[opt]) ? conflicts[opt] : opt
+        else
+          opt
+        end
+      }
+    end
+  end
+end

data/lib/easy_json_matcher/array_validator.rb

@@ -1,84 +1,19 @@
-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
+require "easy_json_matcher/validator"
+require "easy_json_matcher/array_content_validator"
 
-    def should_only_contain(type:,opts: {})
-      _clear_validators
-      _add_validator(_create_validator(type: type, opts: opts))
-    end
-
-######################## Private methods #######################################
-
-    def _validate
-      errors << "#{content} is not an Array" unless _content_is_array?
-      _validate_content
-    end
-
-    def _content_is_array?
-      content.is_a? Array
-    end
-
-    def _validate_content
-      validators.each do |val|
-        _accumulate_errors val
-      end
-    end
-
-    def _clear_validators
-      validators.clear
-    end
-
-    def _add_validator(validator)
-      validators << validator
-    end
-
-    def validators
-      @validators ||= []
-    end
+module EasyJSONMatcher
+  class ArrayValidator 
 
-    def _accumulate_errors(validator)
-      content.each do |candidate|
-        _run_validator(validator, candidate)
-      end
-      errors << validator.errors unless validator._no_errors?
-    end
+    attr_reader :verifier
 
-    def _run_validator(validator, candidate)
-      validator.valid? candidate
+    def initialize(opts: [], verify_content_as:, container: ArrayContentValidator, factory: ValidationChainFactory)
+      chain = factory.get_chain(steps: verify_content_as)
+      @verifier = factory.get_chain(steps: opts + [:array])
+      @verifier.concat(container.new(verify_with: chain))
     end
 
-    def _validation_result
-      !validator_results.include? false
+    def check(value:, errors: [])
+      verifier.check(value: value)
     end
   end
 end

data/lib/easy_json_matcher/attribute_generator.rb

@@ -0,0 +1,37 @@
+module EasyJSONMatcher
+  class AttributeGenerator
+
+    attr_reader :opts, :factory
+
+    def initialize(attribute_factory: ValidationChainFactory, local_opts:, global_opts:)
+      @factory = attribute_factory
+      @opts = extract_opts(locals: local_opts, globals: global_opts)
+    end
+
+    def generate_attribute
+      factory.get_chain(steps: opts)
+    end
+
+    def extract_opts(locals:, globals:)
+      (globals.reject(&non_attribute_options_filter) + locals).map(&override_local_values(locals: locals))
+    end
+
+    #TODO this method should whitelist the options, and the options should be in a constant
+    # Remember to change extract_ops so that it uses globals.select afterwards
+    def non_attribute_options_filter
+      non_attribute_options = [:strict]
+      ->(opt) { non_attribute_options.include? opt }
+    end
+
+    def override_local_values(locals:)
+      conflicts = { required: :not_required }
+      ->(opt) { 
+        if conflicts.keys.include? opt
+          locals.include?(conflicts[opt]) ? conflicts[opt] : opt
+        else
+          opt
+        end
+      }
+    end
+  end
+end

data/lib/easy_json_matcher/attribute_type_methods.rb

@@ -0,0 +1,29 @@
+module AttributeTypeMethods
+
+
+
+    def has_boolean(key:, opts: [])
+      has_attribute(key: key, opts: opts + [:boolean])
+    end
+
+    def has_number(key: , opts: [])
+      has_attribute(key: key, opts: opts + [:number] )
+    end
+
+    def has_date(key:, opts: [])
+      has_attribute(key: key, opts: opts + [:date])
+    end
+
+    def has_object(key:, opts: [])
+      has_attribute(key: key, opts: opts + [:object])
+    end
+
+    def has_value(key:, opts: [])
+      has_attribute(key: key, opts: opts + [:value])
+    end
+
+    def has_string(key:, opts: [])
+      has_attribute(key: key, opts: opts + [:string])
+    end
+
+end

data/lib/easy_json_matcher/coercion_error.rb

@@ -0,0 +1,10 @@
+require "easy_json_matcher/easy_json_matcher_error"
+
+module EasyJSONMatcher
+  class CoercionError < EasyJSONMatcherError
+
+    def initialize(invalid_string:)
+      super "#{invalid_string} is not a valid json string"
+    end
+  end
+end

data/lib/easy_json_matcher/content_wrapper.rb

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

data/lib/easy_json_matcher/{validation_error.rb → easy_json_matcher_error.rb}

@@ -1,5 +1,6 @@
+
 module EasyJSONMatcher
-  class ValidationError < Error
+  class EasyJSONMatcherError < RuntimeError
 
     def initialize(error_details)
       super(error_details)

data/lib/easy_json_matcher/json_coercer.rb

@@ -0,0 +1,34 @@
+require "json"
+require "easy_json_matcher/coercion_error"
+
+module EasyJSONMatcher
+  class JsonCoercer
+
+    def coerce(json:)
+      begin
+        coerced = JSON.parse(json)
+        symbolize_keys(hash: coerced)
+      rescue JSON::ParserError, TypeError
+        raise CoercionError.new invalid_string: json
+      end
+    end
+
+    def symbolize_keys(hash:)
+      hash.keys.each do |key|
+        value = hash.delete(key)
+        convert_value(value)
+        hash[key.to_sym] = value
+      end
+      hash
+    end
+
+    def convert_value(value)
+      case value
+      when Hash
+        symbolize_keys(hash: value) if value.is_a? Hash
+      when Array
+        value.select {|val| val.is_a? Hash}.each {|h| symbolize_keys(hash: h) }
+      end
+    end
+  end
+end

data/lib/easy_json_matcher/node.rb

@@ -1,122 +1,18 @@
-require 'easy_json_matcher/validator_factory'
-require 'json'
-require 'easy_json_matcher/content_wrapper'
-module EasyJSONMatcher
-  class Node < Validator
-    include ContentWrapper
-
-    attr_reader :validators, :validity, :strict
-
-    def initialize(opts: {})
-      super(options: opts)
-      @validators = []
-      @validity = true
-    end
-
-    def add_validator(validator)
-      validators << validator
-    end
+require "easy_json_matcher/validation_step"
 
-    def _post_initialise(options)
-      @strict = options[:strict]
-    end
-
-    def _validate
-      _validate_strict_keyset
-      validators.each do |val|
-        @validity = false unless _use_validator val
-      end
-    end
-
-    def reset!
-      @validity = true
-      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
-    end
-
-    def _use_validator(validator)
-      validator.valid? self
-    end
-
-    def _get_content_for(key)
-      content[key]
-    end
-
-    def _get_validator_for(key)
-      validators[key]
-    end
-
-    def _set_content(candidate)
-      @content = _is_root? ? _prep_root_content(candidate) : candidate[key]
-    end
-
-    def _is_root?
-      key.nil?
-    end
-
-    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
-        _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
+module EasyJSONMatcher
+  class Node 
 
-    def _prep_root_content(candidate)
-       candidate.is_a?(String) ? _parse_and_verify_json(candidate) : candidate
-    end
+    attr_reader :node_validator, :validators
 
-    def _parse_and_verify_json(json)
-      begin
-        JSON.parse(json)
-      rescue JSON::ParserError
-        errors << '#{json} is not a valid JSON String'
-      end
+    def initialize(opts: [], strict: false, validators:, content_handler: ValidatorSet, factory: ValidationChainFactory)
+      @node_validator = factory.get_chain(steps: opts + [:object])
+      @validators = content_handler.new(validators: validators, strict: strict)
+      @node_validator.concat(@validators)
     end
 
-    def _no_errors?
-      validity && errors.empty?
+    def check(value:)
+      node_validator.check(value: value)
     end
   end
 end

data/lib/easy_json_matcher/node_generator.rb

@@ -0,0 +1,58 @@
+require "easy_json_matcher/validation_chain_factory"
+require "easy_json_matcher/node"
+require "easy_json_matcher/schema_library"
+require "easy_json_matcher/attribute_type_methods"
+require "easy_json_matcher/attribute_generator"
+require "easy_json_matcher/array_generator"
+
+module EasyJSONMatcher
+  class NodeGenerator
+    include AttributeTypeMethods
+
+    attr_reader :validators, :attribute_opts, :node_opts, :array_opts, :global_opts
+
+    def initialize(opts: [], global_opts: [])
+      @validators = {} 
+      @node_opts = extract_opts(local: opts, global: global_opts)
+      @global_opts = global_opts
+    end
+
+    def generate_node
+      strict = node_opts.delete(:strict)
+      Node.new(opts: node_opts, strict: strict, validators: validators)
+    end
+
+    def has_attribute(key:, opts:)
+      validator = AttributeGenerator.new(local_opts: opts, global_opts: global_opts)
+      validators[key] = validator.generate_attribute
+    end
+
+    def contains_node(key:, opts: [])
+      generator = self.class.new(opts: opts, global_opts: global_opts)
+      yield generator if block_given?
+      validators[key] = generator.generate_node
+    end
+
+    def contains_array(key:, opts: [])
+      validator = ArrayGenerator.new(local_opts: opts, global_opts: global_opts)
+      yield validator if block_given?
+      validators[key] = validator.generate_array
+    end
+
+    def has_schema(key:, name:)
+      schema = SchemaLibrary.get_schema(name: name)
+      validators[key] = schema
+    end
+
+    def extract_opts(local:, global:)
+      conflicts = { required: :not_required }
+      opts = global.map do |opt| 
+        if conflicts.keys.include? opt
+          local.include?(conflicts[opt]) ? conflicts[opt] : opt
+        else
+          opt
+        end
+      end
+    end
+  end
+end

data/lib/easy_json_matcher/schema_generator.rb

@@ -1,104 +1,80 @@
-require 'easy_json_matcher/validator_factory'
-require 'easy_json_matcher/node'
-require 'easy_json_matcher/schema_library'
-require 'easy_json_matcher/exceptions'
+require "easy_json_matcher/validation_chain_factory"
+require "easy_json_matcher/node"
+require "easy_json_matcher/schema_library"
+require "easy_json_matcher/validator"
+require "easy_json_matcher/attribute_type_methods"
+require "easy_json_matcher/node_generator"
+
 module EasyJSONMatcher
   class SchemaGenerator
+    include AttributeTypeMethods
 
-    attr_reader :node, :name, :options, :glob_opts
+    attr_reader :node, :glob_opts, :att_glob_opts
 
-    def initialize(opts: {}, global_opts: {})
-      @name = opts.delete(:key)
-      @options = opts
+    def initialize(opts: [], global_opts: [])
       @glob_opts = global_opts
-      yield self if block_given?
+      @att_glob_opts = glob_opts.dup
+      @att_glob_opts.delete(:strict)
+      @node = node_generator(opts: opts, globals: global_opts)
+      yield node if block_given?
     end
 
-    def has_attribute(key:, opts: {})
-      node.add_validator(_create_validator(key, opts))
+    def create_node(opts:)
+      Node.new(opts: 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_schema
+    def has_attribute(key:, opts:)
+      opts = override_globals(local_opts: opts)
+      opts = opts - [:strict]
+      validator = ValidationChainFactory.get_chain(steps: opts)
+      node.add_validator key: key, validator: validator
     end
 
-    def has_boolean(key:, opts: {})
-      has_attribute(key: key, opts: opts.merge({type: :boolean}))
+    # TODO pretty hacky but can be cleaned later
+    def override_globals(local_opts:)
+      if local_opts.include?(:not_required) && glob_opts.include?(:required)
+         (local_opts + (glob_opts - [:required]))
+      else
+        local_opts + glob_opts
+      end
     end
 
-    def has_number(key: , opts: {})
-      has_attribute(key: key, opts: opts.merge({type: :number}))
-    end
-
-    def has_date(key:, opts: {})
-      has_attribute(key: key, opts: opts.merge({type: :date}))
-    end
-
-    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
+    ################ Methods for adding specific attribute types ##############
 
-    def has_string(key:, opts: {})
-      has_attribute(key: key, opts: opts.merge({type: :string}))
+    def contains_node(key:, opts: [])
+      generator = node_generator(opts: opts)
+      yield generator if block_given?
+      node.add_validator key: key, validator: generator.node
     end
 
-    def contains_array(key:, opts: {})
-      opts = opts.merge!({type: :array})
-      array_validator = _create_validator(key, opts)
+    def contains_array(key:, opts: [], with_content:)
+      array_validator = ArrayValidator.new opts: opts, verify_content_as: with_content
       yield array_validator if block_given?
-      node.add_validator array_validator
+      node.add_validator key: key, validator: array_validator
     end
 
-    def has_schema(key:, opts: {})
-      has_attribute(key: key, opts: opts.merge({type: :schema}))
+    def has_schema(key:, name:)
+      schema = SchemaLibrary.get_schema(name: name)
+      node.add_validator key: key, validator: schema
     end
 
     ################ Methods for generating the schema #########################
 
+    def generate_node
+      node.generate_node
+    end
+
     def generate_schema
-      node
+      Validator.new validate_with: generate_node
     end
 
     def register(as:)
-      SchemaLibrary.add_schema(name: as, schema: generate_schema)
+      SchemaLibrary.add_schema(name: as, schema: generate_node)
       generate_schema
     end
 
-    ################## Private methods #########################################
-
-    def _prep_schema_opts(schema_name, opts)
-      opts[:type] = :schema
-      opts[:name] = schema_name
-      opts
-    end
-
-    def _set_validator_key(validator, key)
-      validator.key = key
-    end
-
-    def _validator_opts(key, opts)
-      opts[:key] = key
-      glob_opts.merge(opts)
-    end
-
-    def _create_validator(key, opts)
-      ValidatorFactory.get_instance type: opts[:type], opts: _validator_opts(key, opts)
-    end
-
-    def _node_generator(opts = {})
-     self.class.new opts: opts, global_opts: glob_opts
-    end
-
-    def node
-      @node ||= Node.new(opts: _validator_opts(name, options))
+    def node_generator(opts:, globals:)
+      NodeGenerator.new(opts: opts, global_opts: globals)
     end
   end
 end