easy_json_matcher 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2fc40b15589acbb444020f137e9e079241f73ee9
-  data.tar.gz: 05197c5eac34a9b66d83405debaf0d17ce1b0602
+  metadata.gz: 83a0d1798ca42d453ea4ec8997c8a66c482c6d8f
+  data.tar.gz: 306a4d081f0dc1f6886bab938e121b5a43428c7b
 SHA512:
-  metadata.gz: 448e3d74f73b2abbe9dd43256c06bbd3bee7ce29c29789b95672b32a314af43af6878b5d49b7a17780f96fdfe2d26d3609243cae4e8a1b2e66fb3b829b54ea9b
-  data.tar.gz: 51c81f2acd450002ce9f50c703613cefb43390aad04b8802b411d75c883d23bfca153b9d78420edb73116a3c7939c748569c9a5896e5b90a798a0fb6e39f98cf
+  metadata.gz: 9cef9865bdd10d6e3c7127743f682ee7918a3ab4a98e695f5b012728e74edfd8fcb59c249a4f2f47671243c96a52d47fcc39672c3cbb70e76cf7277a1aabab69
+  data.tar.gz: a5a1888234ab415e6f2a09da2ff720d5913fa50302904d80abc86d346f5495fee5acfd1d81ca825fbc48a628ac30a5421873ffbdf907367562a2366e1c665fd6

data/lib/easy_json_matcher.rb

@@ -1,3 +1,4 @@
+require "easy_json_matcher/container"
 require "easy_json_matcher/node"
 require "easy_json_matcher/schema_generator"
 require "easy_json_matcher/validator_set"

data/lib/easy_json_matcher/array_content_validator.rb

@@ -7,10 +7,10 @@ module EasyJSONMatcher
       @verifier = verify_with
     end
 
-    def check(value:)
+    def call(value:)
       errors = []
       value.each do |val|
-        errors += verifier.check(value: val)
+        errors += verifier.call(value: val)
       end
       errors
     end

data/lib/easy_json_matcher/array_generator.rb

@@ -2,19 +2,20 @@ require "easy_json_matcher/array_validator"
 
 module EasyJSONMatcher
   class ArrayGenerator
+    include AutoInject.kwargs[:array_validator]
 
     WHITELIST = [:required, :not_required]
 
-    attr_reader :opts, :content_opts, :target_class
+    attr_reader :opts, :content_opts, :array_validator
 
-    def initialize(local_opts:, global_opts:, target_class: ArrayValidator)
-      @target_class = target_class
+    def initialize(local_opts:, global_opts:, **args)
+      super(**args)
       @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)
+      array_validator.new(opts: opts, verify_content_as: content_opts)
     end
 
     def elements_should(be:)

data/lib/easy_json_matcher/array_validator.rb

@@ -12,8 +12,8 @@ module EasyJSONMatcher
       @verifier.concat(container.new(verify_with: chain))
     end
 
-    def check(value:, errors: [])
-      verifier.check(value: value)
+    def call(value:)
+      verifier.call(value: value)
     end
   end
 end

data/lib/easy_json_matcher/attribute_generator.rb

@@ -1,15 +1,16 @@
 module EasyJSONMatcher
   class AttributeGenerator
+    include AutoInject.kwargs[:chain_factory]
 
     attr_reader :opts, :factory
 
-    def initialize(attribute_factory: ValidationChainFactory, local_opts:, global_opts:)
-      @factory = attribute_factory
+    def initialize(local_opts:, global_opts:, **args)
+      super(**args)
       @opts = extract_opts(locals: local_opts, globals: global_opts)
     end
 
     def generate_attribute
-      factory.get_chain(steps: opts)
+      chain_factory.get_chain(steps: opts)
     end
 
     def extract_opts(locals:, globals:)

data/lib/easy_json_matcher/attribute_type_methods.rb

@@ -1,7 +1,5 @@
 module AttributeTypeMethods
 
-
-
     def has_boolean(key:, opts: [])
       has_attribute(key: key, opts: opts + [:boolean])
     end
@@ -26,4 +24,32 @@ module AttributeTypeMethods
       has_attribute(key: key, opts: opts + [:string])
     end
 
+    def has_strings(keys:, opts: [])
+      mass_assign(keys: keys, opts: opts, meth: :has_string)
+    end
+
+    def has_booleans(keys:, opts: [])
+      mass_assign(keys: keys, opts: opts, meth: :has_boolean)
+    end
+
+    def has_numbers(keys:, opts: [])
+      mass_assign(keys: keys, opts: opts, meth: :has_number)
+    end
+
+    def has_objects(keys:, opts: [])
+      mass_assign(keys: keys, opts: opts, meth: :has_object)
+    end
+
+    def has_values(keys:, opts: [])
+      mass_assign(keys: keys, opts: opts, meth: :has_value)
+    end
+
+    def has_dates(keys:, opts: [])
+      mass_assign(keys: keys, opts: opts, meth: :has_date)
+    end
+
+
+    def mass_assign(keys:, opts: [], meth:)
+      keys.each { |k| self.send(meth, { key: k, opts: opts }) }
+    end
 end

data/lib/easy_json_matcher/container.rb

@@ -0,0 +1,35 @@
+require "dry-container"
+require "dry-auto_inject"
+
+module EasyJSONMatcher
+  class Container
+    extend Dry::Container::Mixin
+  end
+
+  AutoInject = Dry::AutoInject(Container)
+
+  require "easy_json_matcher/node"
+  require "easy_json_matcher/array_generator"
+  require "easy_json_matcher/attribute_generator"
+  require "easy_json_matcher/schema_library"
+  require "easy_json_matcher/node_generator"
+  require "easy_json_matcher/validation_chain_factory"
+  require "easy_json_matcher/validator_set"
+  require "easy_json_matcher/array_validator"
+  require "easy_json_matcher/json_coercer"
+  require "easy_json_matcher/array_content_validator"
+  require "easy_json_matcher/validator"
+
+  Container.register :node_generator, -> { NodeGenerator }
+  Container.register :array_generator, -> { ArrayGenerator }
+  Container.register :attribute_generator, -> { AttributeGenerator }
+  Container.register :schema_library, -> { SchemaLibrary }
+  Container.register :chain_factory, -> { ValidationChainFactory }
+  Container.register :root_wrapper, -> { Validator }
+  Container.register :node_content_validator, -> { ValidatorSet }
+  Container.register :node, -> { Node }
+  Container.register :array_validator, -> { ArrayValidator }
+  Container.register :coercer, -> { JsonCoercer.new }
+  Container.register :array_content_validator, -> { ArrayContentValidator }
+  Container.register :validator, -> { Validator }
+end

data/lib/easy_json_matcher/json_coercer.rb

@@ -6,19 +6,10 @@ module EasyJSONMatcher
 
     def coerce(json:)
       begin
-        coerced = JSON.parse(json)
+        JSON.parse(json)
       rescue JSON::ParserError, TypeError
         raise CoercionError.new invalid_string: json
       end
     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

@@ -2,17 +2,19 @@ require "easy_json_matcher/validation_step"
 
 module EasyJSONMatcher
   class Node 
+    include AutoInject.kwargs[:node_content_validator, :chain_factory]
 
     attr_reader :node_validator, :validators
 
-    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)
+    def initialize(opts: [], strict: false, validators:, **args)
+      super(**args)
+      @node_validator = chain_factory.get_chain(steps: opts + [:object])
+      @validators = node_content_validator.new(validators: validators, strict: strict)
       @node_validator.concat(@validators)
     end
 
-    def check(value:)
-      node_validator.check(value: value)
+    def call(value:)
+      node_validator.call(value: value)
     end
   end
 end

data/lib/easy_json_matcher/node_generator.rb

@@ -7,11 +7,13 @@ require "easy_json_matcher/array_generator"
 
 module EasyJSONMatcher
   class NodeGenerator
+    include AutoInject.kwargs[:node, :attribute_generator, :array_generator, :schema_library]
     include AttributeTypeMethods
 
     attr_reader :validators, :attribute_opts, :node_opts, :array_opts, :global_opts
 
-    def initialize(opts: [], global_opts: [])
+    def initialize(opts: [], global_opts: [], **args)
+      super(**args)
       @validators = {} 
       @node_opts = extract_opts(local: opts, global: global_opts)
       @global_opts = global_opts
@@ -19,11 +21,11 @@ module EasyJSONMatcher
 
     def generate_node
       strict = node_opts.delete(:strict)
-      Node.new(opts: node_opts, strict: strict, validators: validators)
+      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)
+    def has_attribute(key:, opts: [])
+      validator = attribute_generator.new(local_opts: opts, global_opts: global_opts)
       validators[key] = validator.generate_attribute
     end
 
@@ -34,19 +36,19 @@ module EasyJSONMatcher
     end
 
     def contains_array(key:, opts: [])
-      validator = ArrayGenerator.new(local_opts: opts, global_opts: global_opts)
+      validator = array_generator.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)
+      schema = schema_library.get_schema(name: name)
       validators[key] = schema
     end
 
     def extract_opts(local:, global:)
       conflicts = { required: :not_required }
-      opts = global.map do |opt| 
+      global.map do |opt| 
         if conflicts.keys.include? opt
           local.include?(conflicts[opt]) ? conflicts[opt] : opt
         else

data/lib/easy_json_matcher/schema_generator.rb

@@ -1,32 +1,34 @@
-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
+    include AutoInject.kwargs[
+      :schema_library,
+      :chain_factory,
+      :node,
+      :root_wrapper,
+      :node_generator,
+      :validator
+    ]
+
 
     attr_reader :node, :glob_opts, :att_glob_opts
 
-    def initialize(opts: [], global_opts: [])
+    def initialize(opts: [], global_opts: [], **args)
+      super(**args)
       @glob_opts = global_opts
       @att_glob_opts = glob_opts.dup
       @att_glob_opts.delete(:strict)
-      @node = node_generator(opts: opts, globals: global_opts)
+      @node = new_node_generator(opts: opts, globals: global_opts)
       yield node if block_given?
     end
 
     def create_node(opts:)
-      Node.new(opts: opts)
+      node.new(opts: opts)
     end
 
     def has_attribute(key:, opts:)
       opts = override_globals(local_opts: opts)
       opts = opts - [:strict]
-      validator = ValidationChainFactory.get_chain(steps: opts)
+      validator = validation_chain_factory.get_chain(steps: opts)
       node.add_validator key: key, validator: validator
     end
 
@@ -42,19 +44,19 @@ module EasyJSONMatcher
     ################ Methods for adding specific attribute types ##############
 
     def contains_node(key:, opts: [])
-      generator = node_generator(opts: opts)
+      generator = new_node_generator(opts: opts)
       yield generator if block_given?
       node.add_validator key: key, validator: generator.node
     end
 
     def contains_array(key:, opts: [], with_content:)
-      array_validator = ArrayValidator.new opts: opts, verify_content_as: with_content
+      array_validator = array_validator.new opts: opts, verify_content_as: with_content
       yield array_validator if block_given?
       node.add_validator key: key, validator: array_validator
     end
 
     def has_schema(key:, name:)
-      schema = SchemaLibrary.get_schema(name: name)
+      schema = schema_library.get_schema(name: name)
       node.add_validator key: key, validator: schema
     end
 
@@ -65,16 +67,16 @@ module EasyJSONMatcher
     end
 
     def generate_schema
-      Validator.new validate_with: generate_node
+      validator.new validate_with: generate_node
     end
 
     def register(as:)
-      SchemaLibrary.add_schema(name: as, schema: generate_node)
+      schema_library.add_schema(name: as, schema: generate_node)
       generate_schema
     end
 
-    def node_generator(opts:, globals:)
-      NodeGenerator.new(opts: opts, global_opts: globals)
+    def new_node_generator(opts:, globals:)
+      node_generator.new(opts: opts, global_opts: globals)
     end
   end
 end

data/lib/easy_json_matcher/schema_library.rb

@@ -8,34 +8,33 @@ module EasyJSONMatcher
     class << self
 
       def available_schemas
-       SCHEMAS.keys
+        SCHEMAS.keys
       end
 
       def schema_for(name)
-       SCHEMAS[name]
+        SCHEMAS[name]
       end
 
       def add_schema(name:, schema:)
-       SCHEMAS[name] = schema
+        SCHEMAS[name] = schema
       end
 
+      # TODO: error message should read "called #{name}, not with #{name}"
       def get_schema(name:, opts: {})
-        schema = _find_and_clone_schema(name) or raise MissingSchemaException.new("No schema with #{name} has been registered")
-        schema
+        if schema = SCHEMAS[name]
+          schema
+        else
+          lambda do |value|
+            SCHEMAS[name]&.call(value: value) or raise MissingSchemaException.new(schema_name: name)
+          end
+        end
       end
 
-      def use_schema(name:, wrap_with: Validator)
-        wrap_with.new validate_with: SCHEMAS[name]
-      end
-
-      def _find_and_clone_schema(name)
-        s = SCHEMAS[name]
-        return s.dup if s or nil
-      end
-
-      def _set_schema_key(schema, key)
-        schema.key = key
+        # TODO: this method should use get_schema to ensure schema presence is
+        # checked
+        def use_schema(name:, wrap_with: Validator)
+          wrap_with.new validate_with: get_schema(name: name)
+        end
       end
     end
   end
-end

data/lib/easy_json_matcher/validation_chain_factory.rb

@@ -29,20 +29,18 @@ module EasyJSONMatcher
           using.new verify_with: validating
         elsif verifier = standard_validator(with: validating)
           using.new verify_with: verifier
+        elsif schema = SchemaLibrary.get_schema(name: validating)
+          schema
         else
-          begin
-           return SchemaLibrary.get_schema(name: validating)
-          rescue MissingSchemaException => ex
-            #TODO this needs a little finesse: How will the user know if it was a missing schema?
-            raise UnknownValidationStepError.new(type: validating)
-          end
+          #TODO this needs a little finesse: How will the user know if it was a missing schema?
+          raise UnknownValidationStepError.new(type: validating)
         end
       end
+    end
 
-      def standard_validator(with:)
-        require "easy_json_matcher/validation_rules"
-        VALIDATION_RULES[with]
-      end
+    def self.standard_validator(with:)
+      require "easy_json_matcher/validation_rules"
+      VALIDATION_RULES[with]
     end
   end
 end

data/lib/easy_json_matcher/validation_step.rb

@@ -12,12 +12,12 @@ module EasyJSONMatcher
       @verifier = verify_with
     end
 
-    def check(value:)
+    def call(value:)
       errors = []
       if verifier.call(value, errors) == false || is_tail?
         errors
       else
-        errors + next_step.check(value: value)
+        errors + next_step.call(value: value)
       end
     end
 

data/lib/easy_json_matcher/validator.rb

@@ -2,13 +2,14 @@ require 'easy_json_matcher/json_coercer'
 
 module EasyJSONMatcher
   class Validator
+    include AutoInject.kwargs[:coercer]
 
     attr_reader :validation_chain, :coercer
     attr_accessor :key
 
-    def initialize(validate_with:, coerce_with: JsonCoercer.new)
+    def initialize(validate_with:, **args)
+      super(**args)
       @validation_chain = validate_with
-      @coercer = coerce_with
     end
 
     # Hook. Allows further setup to be carried out by subclasses
@@ -21,7 +22,7 @@ module EasyJSONMatcher
 
     def validate(candidate:)
       candidate = coercer.coerce(json: candidate)
-      validation_chain.check(value: candidate)
+      validation_chain.call(value: candidate)
     end
   end
 end

data/lib/easy_json_matcher/validator_set.rb

@@ -10,15 +10,16 @@ module EasyJSONMatcher
       @strict = strict
     end
 
-    def check(value:, errors:[])
+    def call(value:)
       error_hash = validators.each_with_object({}) do |k_v, errors_found|
         key = k_v[0]
         val = value[key]
         validator = k_v[1]
-        results = validator.check(value: val)
+        results = validator.call(value: val)
         errors_found[key] = results unless results.empty?
       end
       validate_strict_keyset(keys: validators.keys, candidates: value.keys, errors: error_hash) if strict
+      errors = []
       errors << error_hash unless error_hash.empty?
       errors
     end

data/lib/easy_json_matcher/version.rb

@@ -1,3 +1,3 @@
 module EasyJSONMatcher
-  VERSION = "0.3.3".freeze
+  VERSION = "0.3.4".freeze
 end

data/test/array_content_validator_test.rb

@@ -4,13 +4,13 @@ require "easy_json_matcher/array_content_validator"
 module EasyJSONMatcher
   describe ArrayContentValidator do
 
-    it "should check all the elements in an array" do
+    it "should call all the elements in an array" do
       mock_values = (1..5).map do |n| 
         mock_val = Minitest::Mock.new
         mock_val.expect(:hello, "hi")
       end
       subject = ArrayContentValidator.new( verify_with: ValidationStep.new(verify_with: ->(value, errors) { value.hello }))
-      subject.check value: mock_values
+      subject.call value: mock_values
       mock_values.each(&:verify)
     end
   end

data/test/managing_schemas_test.rb

@@ -15,6 +15,24 @@ module EasyJSONMatcher
       assert(SchemaLibrary.available_schemas.include?(:test), ":test not found in available_nodes")
     end
 
+    test "The order in which schemas are defined should not matter" do
+      test_schema = SchemaGenerator.new { |sc|
+        sc.has_schema key: "lazy", name: :lazily_evaluated
+      }.register as: :outer
+
+      lazy = SchemaGenerator.new { |sc|
+        sc.has_attribute key: "val"
+      }.register as: :lazily_evaluated
+
+      valid_json = {
+        lazy: {
+          val: 1
+        }
+      }.to_json
+
+      assert test_schema.valid?(candidate: valid_json)
+    end
+
     test "As as user I want to reuse a saved schema"  do
       candidate = {
         name: "Green Mandarin"
@@ -24,8 +42,18 @@ module EasyJSONMatcher
     end
 
     test "SchemaLibrary should thrown a MissingSchemaException if an unregistered schema is requested" do
+      schema = SchemaLibrary.get_schema(name: "#{@name.to_s}-wibble")
       assert_raises(MissingSchemaException) do
-        SchemaLibrary.get_schema(name: "#{@name.to_s}-wibble")
+        schema.call(value: {}.to_json)
+      end
+    end
+
+    test "SchemaLibrary should tell the user which schema is missing" do
+      schema = SchemaLibrary.get_schema(name: :womble)
+      begin
+        schema.call(value: {}.to_json)
+      rescue MissingSchemaException => ex
+        assert ex.message =~ /womble/
       end
     end
 

data/test/node_test.rb

@@ -7,21 +7,21 @@ module EasyJSONMatcher
 
     describe "#add_validator" do
 
-      it "should respond to #check" do
-        Node.new(validators: nil).must_respond_to :check
+      it "should respond to #call" do
+        Node.new(validators: nil).must_respond_to :call
       end
 
       it "should send call to its own validator" do
-        test_value = { "a" => 1, "b" => 2, "c" => 3 }
-        validators = ("a".."c").each_with_object({}) do |n, h|
+        test_value = { a: 1, b: 2, c: 3 }
+        validators = (:a..:c).each_with_object({}) do |n, h|
           h[n] = ValidationChainFactory.get_chain(steps: [:string])
         end
         node = Node.new(opts: [:required], validators: validators)
-        expected = [{"a" => ["1 is not a String"],
-                     "b" => ["2 is not a String"],
-                     "c" => ["3 is not a String"]
+        expected = [{a: ["1 is not a String"],
+                     b: ["2 is not a String"],
+                     c: ["3 is not a String"]
         }]
-        node.check(value: test_value).must_be :==, expected
+        node.call(value: test_value).must_be :==, expected
       end
     end
   end

data/test/plural_key_defs_test.rb

@@ -0,0 +1,119 @@
+require "test_helper"
+
+module EasyJSONMatcher
+
+  describe NodeGenerator do
+
+    before do 
+      @generator = NodeGenerator.new
+    end
+
+    describe "#has_strings" do
+
+      it "should allow you to require multiple strings" do
+        @generator.has_strings(keys: [:a, :b, :c])
+        schema = @generator.generate_node
+        test_val = { a: "a", b: "b", c: "c" }
+        schema.call(value: test_val).empty?.must_be :==, true
+      end
+
+      it "allows the user to set the same constraints on each key" do
+        @generator.has_strings(keys: [:a, :b], opts: [:required])
+        schema = @generator.generate_node
+        test_val = {}
+        schema.call(value: test_val)[0].keys.must_include :a
+        schema.call(value: test_val)[0].keys.must_include :b
+      end
+    end
+
+    describe "has_booleans" do
+
+      it "should allow you to require multiple booleans" do
+        @generator.has_booleans(keys: [:true, :false])
+        schema = @generator.generate_node
+        test_val = { true: true, false: false }
+        schema.call(value: test_val).empty?.must_be :==, true
+      end
+
+      it "allows the user to set the same constraints on each key" do
+        @generator.has_booleans(keys: [:true, :false], opts: [:required])
+        schema = @generator.generate_node
+        test_val = {}
+        schema.call(value: test_val)[0].keys.must_include :true
+        schema.call(value: test_val)[0].keys.must_include :false
+      end
+    end
+
+    describe "#has_numbers" do
+
+      it "should allow you to require multiple numbers" do
+        @generator.has_numbers(keys: [:one, :two])
+        schema = @generator.generate_node
+        test_val = {one: 1, two: 2}
+        schema.call(value: test_val).empty?.must_be :==, true
+      end
+
+      it "allows the user to set the same constraints on each key" do
+        @generator.has_booleans(keys: [:one, :two], opts: [:required])
+        schema = @generator.generate_node
+        test_val = {}
+        schema.call(value: test_val)[0].keys.must_include :one
+        schema.call(value: test_val)[0].keys.must_include :two
+      end
+    end
+
+    describe "#has_dates" do
+
+      it "should allow you to require multiple dates" do
+        @generator.has_dates(keys: [:now, :then])
+        schema = @generator.generate_node
+        test_val = {now: "2016-06-24", then: "2016-06-23"}
+        schema.call(value: test_val).empty?.must_be :==, true
+      end
+
+      it "should allow you to require multiple dates" do
+        @generator.has_dates(keys: [:now, :then], opts: [:required])
+        schema = @generator.generate_node
+        test_val = {}
+        schema.call(value: test_val)[0].keys.must_include :now
+        schema.call(value: test_val)[0].keys.must_include :then
+      end
+    end
+
+    describe "#has_objects" do
+
+      it "should allow you to require multiple objects" do
+        @generator.has_objects(keys: [:a, :b])
+        schema = @generator.generate_node
+        test_val = {a: {}, b: {}}
+        schema.call(value: test_val).empty?.must_be :==, true
+      end
+
+      it "should allow you to require multiple objects" do
+        @generator.has_objects(keys: [:a, :b], opts: [:required])
+        schema = @generator.generate_node
+        test_val = {}
+        schema.call(value: test_val)[0].keys.must_include :a
+        schema.call(value: test_val)[0].keys.must_include :b
+      end
+    end
+
+    describe "#has_values" do
+
+      it "should allow you to require multiple objects" do
+        @generator.has_values(keys: [:a, :b])
+        schema = @generator.generate_node
+        test_val = {a: nil, b: nil}
+        schema.call(value: test_val).empty?.must_be :==, true
+      end
+
+      it "should allow you to require multiple objects" do
+        @generator.has_values(keys: [:a, :b], opts: [:required])
+        schema = @generator.generate_node
+        test_val = {}
+        schema.call(value: test_val)[0].keys.must_include :a
+        schema.call(value: test_val)[0].keys.must_include :b
+      end
+    end
+  end
+end

data/test/primitives_boolean_test.rb

@@ -6,7 +6,7 @@ require 'json'
 
 module EasyJSONMatcher
 
-  describe "Basic Type Validations" do
+  describe "Boolean Primitive Test" do
 
     before do
       @test_schema = SchemaGenerator.new { |g|

data/test/primitives_string_test.rb

@@ -6,7 +6,7 @@ require 'json'
 
 module EasyJSONMatcher
 
-  describe "String Primitives" do
+  describe "Primitive String Validation" do
 
     before do
       @test_schema = SchemaGenerator.new { |g|

data/test/strict_mode_test.rb

@@ -5,7 +5,7 @@ module EasyJSONMatcher
   describe "Strict Mode" do
 
     subject {
-      SchemaGenerator.new(global_opts: [:strict]) { |s|
+      SchemaGenerator.new(global_opts: [ :strict ]) { |s|
         s.has_attribute key: "a", opts: []
         s.has_attribute key: "b", opts: []
       }.generate_schema

data/test/validation_chain_factory_test.rb

@@ -23,6 +23,7 @@ module EasyJSONMatcher
       end
 
       it "should otherwise raise an error" do
+        skip "Leave for future release"
         cannot_use = String.new
         -> { ValidationChainFactory.get_step_for(validating: cannot_use) }.
           must_raise UnknownValidationStepError
@@ -33,12 +34,12 @@ module EasyJSONMatcher
 
       it "should move :required validation to the start of the chain" do
         chain = ValidationChainFactory.get_chain(steps: [:string, :required])
-        chain.check(value: nil)[0].must_match /no value found/
+        chain.call(value: nil)[0].must_match /(no value found)/
       end
 
       it "should put :not_required at the start if :required is not specified" do
         chain = ValidationChainFactory.get_chain(steps: [:string])
-        chain.check(value: nil).must_be :empty?
+        chain.call(value: nil).must_be :empty?
       end
     end
   end

data/test/validation_chain_test_helper.rb

@@ -8,6 +8,6 @@ module ValidationChainTestHelper
 
   def assert_chain_verifies(type:, test_value:, outcome:)
     v_step = get_instance(type: type)
-    expect(v_step.check(value: test_value).empty?).must_be :==, outcome
+    expect(v_step.call(value: test_value).empty?).must_be :==, outcome
   end
 end

data/test/validation_step_array_test.rb

@@ -12,15 +12,15 @@ module EasyJSONMatcher
     describe "Validating Array Types" do
 
       it "should return valid for empty arrays" do
-        @subject.check(value: []).must_be :empty?
+        @subject.call(value: []).must_be :empty?
       end
 
       it "should return errors for any other object" do
-        @subject.check(value: 1).wont_be :empty?
+        @subject.call(value: 1).wont_be :empty?
       end
 
-      it "should check all the content is of a particular type" do
-        @subject.check(value: [1,2,3]).wont_be :empty?
+      it "should call all the content is of a particular type" do
+        @subject.call(value: [1, 2, 3]).wont_be :empty?
       end
     end
   end

data/test/validation_step_not_required_test.rb

@@ -12,15 +12,15 @@ module EasyJSONMatcher
       it "should halt the chain if the value is missing" do
         head, tail = get_validation_chain
         test_value = nil
-        head.check(value: test_value).must_be :empty?
+        head.call(value: test_value).must_be :empty?
       end
 
       it "should allow the chain to continue if the value is present" do
         head, tail = get_validation_chain
         test_value = 1
-        tail.expect(:check, [], [{ value: 1 }])
+        tail.expect(:call, [], [{ value: 1 }])
         tail.expect(:nil?, false)
-        head.check(value: test_value)
+        head.call(value: test_value)
         tail.verify
       end
     end

data/test/validation_step_test.rb

@@ -9,8 +9,8 @@ module EasyJSONMatcher
       @subject = ValidationStep.new(verify_with: ->(value, errors) {} )
     end
 
-    test "it_should_respond_to_check" do
-      assert_respond_to(@subject, :check)
+    test "it_should_respond_to_call" do
+      assert_respond_to(@subject, :call)
     end
 
     test "It should allow the user to chain validation steps together" do
@@ -18,9 +18,9 @@ module EasyJSONMatcher
       tail = MiniTest::Mock.new
       test_value = "hello!"
       head >> tail
-      tail.expect(:check, [], [Hash])
+      tail.expect(:call, [], [Hash])
       tail.expect(:nil?, false)
-      head.check(value: test_value)
+      head.call(value: test_value)
       tail.verify
     end
 
@@ -29,7 +29,7 @@ module EasyJSONMatcher
       subject = ValidationStep.new(verify_with: verifier)
       test_value = "verify me"
       verifier.expect(:call, nil, [test_value, []])
-      subject.check(value: test_value)
+      subject.call(value: test_value)
     end
 
     test "If the verifier returns :stop the chain will be halted" do
@@ -38,10 +38,10 @@ module EasyJSONMatcher
       tail = MiniTest::Mock.new
       test_value = "verify me"
       @subject >> middle >> tail
-      @subject.check(value: test_value)
-      # There is no official way to check that something wasn't called in
+      @subject.call(value: test_value)
+      # There is no official way to call that something wasn't called in
       # MiniTest, so we'll just have to assume that since verify passes, then
-      # check wasn't called in tail
+      # call wasn't called in tail
       tail.verify
     end
 
@@ -49,7 +49,7 @@ module EasyJSONMatcher
       head = ValidationStep.new(verify_with: ->(value, errors) { errors << 1 })
       tail = ValidationStep.new(verify_with: ->(value, errors) { errors << 2 })
       head >> tail
-      assert(head.check(value: "Oh! Mrs. Mogs") == [1, 2])
+      assert(head.call(value: "Oh! Mrs. Mogs") == [1, 2])
     end
   end
 end

data/test/validator_set_test.rb

@@ -11,18 +11,10 @@ module EasyJSONMatcher
       subject.validators.values.include?(test_val).must_be :==, true
     end
 
-    it "should validate with keys and symbols" do
-      mock_validators = { key_1: mock_validator, "key_2" => mock_validator }
-      subject = ValidatorSet.new validators: mock_validators
-      test_val = { "key_1" => 1, key_2: 2 }
-      subject.check(value: test_val)
-      mock_validators.each_value(&:verify)
-    end
-
     it "should return true if all its validators validate their candidates" do
       mock_validators = { key1: mock_validator, key2: mock_validator }
       subject = ValidatorSet.new validators: mock_validators
-      subject.check(value: {}).must_be :empty?
+      subject.call(value: {}).must_be :empty?
     end
 
     it "should return false if any of its validators find an invalid value" do
@@ -31,12 +23,12 @@ module EasyJSONMatcher
         key2: mock_validator(validity: false)
       }
       subject = ValidatorSet.new validators: mock_validators
-      subject.check(value: { key1: "test", key2: "test" }).wont_be :empty?
+      subject.call(value: { key1: "test", key2: "test" }).wont_be :empty?
     end
 
     it "should return error messages in a Array" do
       subject = ValidatorSet.new validators: { invalid: mock_validator }
-      assert(subject.check(value: {}).is_a?(Array))
+      assert(subject.call(value: {}).is_a?(Array))
     end
 
     it "should return the error messages for all its validators" do
@@ -46,12 +38,12 @@ module EasyJSONMatcher
       }
       subject = ValidatorSet.new(validators: error_validators)
       expected_error_message = [{ a: ["a"], b: ["b"] }]
-      assert_equal(expected_error_message, subject.check(value: {}))
+      assert_equal(expected_error_message, subject.call(value: {}))
     end
 
     def mock_validator(validity: true, error_message: nil)
       mock = MiniTest::Mock.new
-      mock.expect(:check, validity ? [] : [error_message], [Object])
+      mock.expect(:call, validity ? [] : [error_message], [Object])
     end
   end
 end

data/test/validator_test.rb

@@ -12,18 +12,18 @@ describe Validator do
     end
 
     it "should use a ValidationStep chain to verify candidates" do
-      @v_step.expect(:check, {}, [Hash])
+      @v_step.expect(:call, {}, [Hash])
       @subject.valid? candidate: Hash.new.to_json
       @v_step.verify
     end
 
     it "should return false if any errors are generated" do
-      @v_step.expect(:check, { a: 1, b: 2,c: 3 }, [Hash])
+      @v_step.expect(:call, { a: 1, b: 2, c: 3 }, [Hash])
       @subject.valid?(candidate: Hash.new.to_json).must_be :==, false
     end
 
     it "should return true if no errors are generated" do
-      @v_step.expect(:check, {}, [Hash])
+      @v_step.expect(:call, {}, [Hash])
       @subject.valid?(candidate: Hash.new.to_json).must_be :==, true
     end
   end
@@ -35,8 +35,8 @@ describe Validator do
       @subject = Validator.new(validate_with: @v_step)
     end
 
-    it "should call check on its verifier" do
-      @v_step.expect(:check, Hash.new, [Hash])
+    it "should call call on its verifier" do
+      @v_step.expect(:call, Hash.new, [Hash])
       test_value = { a: 1, b: 2, c: 3 }.to_json
       @subject.validate(candidate: test_value)
     end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: easy_json_matcher
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - WJD Hamilton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-19 00:00:00.000000000 Z
-dependencies: []
+date: 2016-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-auto_inject
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 description: Test your JSON output in Ruby, with a DSL that makes reasoning about
   your JSON very straightforward. See the Homepage for docs.
 email:
@@ -28,6 +56,7 @@ files:
 - lib/easy_json_matcher/attribute_generator.rb
 - lib/easy_json_matcher/attribute_type_methods.rb
 - lib/easy_json_matcher/coercion_error.rb
+- lib/easy_json_matcher/container.rb
 - lib/easy_json_matcher/content_wrapper.rb
 - lib/easy_json_matcher/easy_json_matcher_error.rb
 - lib/easy_json_matcher/exceptions.rb
@@ -51,6 +80,7 @@ files:
 - test/json_coercer_test.rb
 - test/managing_schemas_test.rb
 - test/node_test.rb
+- test/plural_key_defs_test.rb
 - test/primitives_boolean_test.rb
 - test/primitives_date_test.rb
 - test/primitives_number_test.rb
@@ -108,6 +138,7 @@ test_files:
 - test/json_coercer_test.rb
 - test/managing_schemas_test.rb
 - test/node_test.rb
+- test/plural_key_defs_test.rb
 - test/primitives_boolean_test.rb
 - test/primitives_date_test.rb
 - test/primitives_number_test.rb
@@ -133,3 +164,4 @@ test_files:
 - test/validation_step_value_test.rb
 - test/validator_set_test.rb
 - test/validator_test.rb
+has_rdoc: