easy_json_matcher 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef40172819f1511b343e9f3dc378da1730ae0576
-  data.tar.gz: 56913c7ee1b59003fb4949180b7bc2985803cee6
+  metadata.gz: b4ae72ea8cf0f22e7214a77bef9d439db03eccff
+  data.tar.gz: ca161753385c81aa57e6a43418664d807b1425ae
 SHA512:
-  metadata.gz: 12e86e84712085c21d57f9db7606ea38577cfd2a590fe1c20b6b4ae67c6acb6bc09d630ec2cff2e70cc2c92c20b01a86a3a3da93302b53646a593242846f3549
-  data.tar.gz: 5ba4fffa36e432c1b5f52ebfb350734840931d04073c89651f9ded8729cdc90bf709d4b77c52dad5076a09f37a8fdc064463999b8af0005dedb27feb4079046e
+  metadata.gz: 73ba46ee4cb3a9333e3b5ee56f2d18dced83580c2bd90fc95cbe77d18afb89e443aa141f5eb22d5216e1cb399f2fffbbff402ffb8c01d7f412986b7de02f953c
+  data.tar.gz: 7e7c1f2f0fa7abcad1c6a20a27aa87119b8c1997566e6b74f9b2eec3fedf2f59ee6523c77b4747174d919ba963a08d4a4e64a8ce9a311d2287669884e3d6076f

data/lib/easy_json_matcher.rb

@@ -2,6 +2,7 @@ require "easy_json_matcher/container"
 require "easy_json_matcher/node"
 require "easy_json_matcher/schema_generator"
 require "easy_json_matcher/validator_set"
+require "easy_json_matcher/printer"
 
 module EasyJSONMatcher
 

data/lib/easy_json_matcher/array_content_validator.rb

@@ -1,7 +1,7 @@
 module EasyJSONMatcher
   class ArrayContentValidator
 
-    attr_reader :next_step, :verifier
+    attr_reader :verifier
 
     def initialize(verify_with:)
       @verifier = verify_with
@@ -10,13 +10,10 @@ module EasyJSONMatcher
     def call(value:)
       errors = []
       value.each do |val|
+        # TODO: You could remove the duplication of array content errors here
         errors += verifier.call(value: val)
       end
       errors
     end
-
-    def >> (step)
-      @next_step = step
-    end
   end
 end

data/lib/easy_json_matcher/array_validator.rb

@@ -15,5 +15,6 @@ module EasyJSONMatcher
     def call(value:)
       verifier.call(value: value)
     end
+
   end
 end

data/lib/easy_json_matcher/exceptions.rb

@@ -2,7 +2,18 @@ module EasyJSONMatcher
   # Override of Ruby error for namespacing
   class Error < RuntimeError; end
 
-  # Exception thrown by SchemaLibrary when a Schema is requested that has not
-  # already been registered
-  class MissingSchemaException < Error; end
+
+  class UnknownValidationStepError < Error
+
+    def error_message (type)
+      "No validator available for #{type}, 
+       you have either asked to validate a type that is not supported
+       or a schema that has not been defined. If it is the 
+       former, consider using a custom validator"
+    end
+
+    def initialize(type)
+      super error_message(type)
+    end
+  end
 end

data/lib/easy_json_matcher/node.rb

@@ -2,13 +2,13 @@ module EasyJSONMatcher
   class Node 
     include AutoInject.kwargs[:node_content_validator, :chain_factory]
 
-    attr_reader :node_validator, :validators
+    attr_reader :node_validator
 
     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)
+      validators = node_content_validator.new(validators: validators, strict: strict)
+      @node_validator.concat(validators)
     end
 
     def call(value:)

data/lib/easy_json_matcher/node_generator.rb

@@ -12,7 +12,6 @@ module EasyJSONMatcher
       @validators = {} 
       @node_opts = extract_opts(local: opts, global: global_opts)
       @global_opts = global_opts
-      yield self if block_given?
     end
 
     def generate_node
@@ -26,8 +25,8 @@ module EasyJSONMatcher
     end
 
     def contains_node(key:, opts: [], &block)
-      if key == "alpha_2" then byebug end
-      generator = self.class.new(opts: opts, global_opts: global_opts, &block)
+      generator = self.class.new(opts: opts, global_opts: global_opts)
+      generator.instance_eval &block if block_given?
       validators[key] = generator.generate_node
     end
 

data/lib/easy_json_matcher/printer.rb

@@ -0,0 +1,55 @@
+module EasyJSONMatcher
+
+  # Class which is used to convert a node to a human-readable format for 
+  # inspection purposes.
+
+  class Printer
+
+    attr_reader :n
+
+    def initialize(node:)
+      @n = node
+    end
+
+    def inspect
+      root_flag = "root: "
+      root_flag + pretty_print(n.validation_chain, root_flag.length)
+    end
+
+    def pretty_print(node, n)
+      depth = grow_s(n)
+      d = n + 1
+      case node
+      when Node
+        pretty_print node.node_validator, n
+      when Validator
+        pretty_print node.validation_chain, n
+      when ArrayValidator
+        pretty_print node.verifier, n
+      when ArrayContentValidator
+        pretty_print node.verifier, n
+      when ValidationRule
+        node.type.to_s
+      when ValidationStep
+        head = pretty_print node.verifier, d
+        tail = pretty_print node.next_step, n unless node.is_tail?
+        tail_string = tail ? "\n#{depth}#{tail}" : ""
+        "#{head} | #{tail_string}"
+      when ValidatorSet
+        parts = node.validators.each_with_object([]) do |k_v, out|
+          key_padding = d + k_v[0].length + 1
+          out << "#{k_v[0]}: #{pretty_print k_v[1], key_padding}\n"
+        end
+        parts.join(depth)
+      else
+        throw Error.new(node.class.to_s)
+      end
+    end
+
+    def grow_s(n)
+      buffer = ""
+      n.times { buffer << " " }
+      buffer
+    end
+  end
+end

data/lib/easy_json_matcher/schema_library.rb

@@ -21,20 +21,14 @@ module EasyJSONMatcher
 
       # TODO: error message should read "called #{name}, not with #{name}"
       def get_schema(name:, opts: {})
-        if schema = SCHEMAS[name]
-          schema
-        else
-          lambda do |value|
-            SCHEMAS[name]&.call(value: value) or raise MissingSchemaException.new(schema_name: name)
-          end
-        end
+          -> (value:) {
+            SCHEMAS[name]&.call(value: value) or raise UnknownValidationStepError.new(name)
+          }
       end
 
-        # 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
+      def use_schema(name:, wrap_with: Validator)
+        wrap_with.new validate_with: get_schema(name: name)
       end
     end
   end
+end

data/lib/easy_json_matcher/validation_chain_factory.rb

@@ -1,5 +1,4 @@
 require "easy_json_matcher/validation_step"
-require "easy_json_matcher/unknown_validation_step_error"
 require "easy_json_matcher/exceptions"
 
 module EasyJSONMatcher
@@ -15,24 +14,24 @@ module EasyJSONMatcher
 
       def assemble_chain(head:, steps:, step_type:)
         steps.inject(head) do |last_link, step|
-          last_link >> get_step_for(validating: step, using: step_type)
+          last_link >> get_step_for(validating: step, uses: step_type)
         end
       end
 
       def create_head_for(steps:, step_type:)
-        is_required = steps.include?(:required)
-        get_step_for validating: is_required ? :required : :not_required, using: step_type
+        is_required = steps.delete(:required)
+        get_step_for validating: is_required ? :required : :not_required, uses: step_type
       end
 
-      def get_step_for(validating:, using: ValidationStep)
+      def get_step_for(validating:, uses: ValidationStep)
         if validating.respond_to? :call
-          using.new verify_with: validating
+          uses.new verify_with: validating
         elsif verifier = standard_validator(with: validating)
-          using.new verify_with: verifier
+          uses.new verify_with: verifier
         elsif schema = SchemaLibrary.get_schema(name: validating)
           schema
         else
-          #TODO this needs a little finesse: How will the user know if it was a missing schema?
+          #This is just here as a catch-all. The prior step should always succeed. 
           raise UnknownValidationStepError.new(type: validating)
         end
       end

data/lib/easy_json_matcher/validation_rules.rb

@@ -1,58 +1,81 @@
 module EasyJSONMatcher
 
-  VALIDATION_RULES = {
-    object: -> (value, errors) {
-    unless value.is_a? Hash
-      errors << "#{value} is not an Object"
-      return false
-    end
-  },
-    string: -> (value, errors) {
-    unless value.is_a? String
-      errors << "#{value} is not a String"
-      return false
-    end
-  },
-    number: -> (value, errors){
-    error_message = "#{value} is not a Number"
-    begin
-      Kernel::Float(value)
-    rescue ArgumentError, TypeError
-      errors << error_message
-      false
-    end
-  },
-    date: ->(value, errors){
-    require "date"
-    error_message = "#{value} is not a valid SQL date"
-    begin
-      Date.strptime(value,"%Y-%m-%d")
-    rescue ArgumentError, TypeError
-      errors << error_message
-    end
-  },
-    boolean: ->(value, errors){
-    clazz = value.class
-    unless [ TrueClass, FalseClass].include? clazz
-      errors << "#{value} is not a Boolean"
-      false
+  class ValidationRule
+
+    attr_reader :rule, :type
+
+    def initialize(type, rule)
+      @type = type
+      @rule = rule
     end
-  },
-    array: ->(value, errors){
-    unless value.is_a? Array
-      errors << "Value was not an array"
-      false
+
+    def call(value, errors)
+      rule.call(value, errors)
     end
-  },
-    value: ->(value, errors){
-    # This is a bit of a toughie since value can be any value, including nil
-  },
-    not_required: ->(value, errors){
-    false if value.nil?
-  },
-    required: ->(value, errors){
+  end
+
+
+  VALIDATION_RULES = {
+    object: ValidationRule.new(:object, -> (value, errors) {
+      unless value.is_a? Hash
+        errors << "#{value} is not an Object"
+        return false
+      end
+    }),
+
+    string: ValidationRule.new(:string, -> (value, errors) {
+      unless value.is_a? String
+        errors << "#{value} is not a String"
+        return false
+      end
+    }),
+
+    number: ValidationRule.new(:number, -> (value, errors){
+      error_message = "#{value} is not a Number"
+      begin
+        Kernel::Float(value)
+      rescue ArgumentError, TypeError
+        errors << error_message
+        false
+      end
+    }),
+
+    date: ValidationRule.new(:date, ->(value, errors){
+      require "date"
+      error_message = "#{value} is not a valid SQL date"
+      begin
+        Date.strptime(value,"%Y-%m-%d")
+      rescue ArgumentError, TypeError
+        errors << error_message
+      end
+    }),
+
+    boolean: ValidationRule.new(:boolean, ->(value, errors){
+      clazz = value.class
+      unless [ TrueClass, FalseClass].include? clazz
+        errors << "#{value} is not a Boolean"
+        false
+      end
+    }),
+
+    array: ValidationRule.new(:array, ->(value, errors){
+      unless value.is_a? Array
+        errors << "Value was not an array"
+        false
+      end
+    }),
+
+    value: ValidationRule.new(:value, ->(value, errors){
+      # This is a bit of a toughie since value can be any value, including nil
+    }),
+
+    not_required: ValidationRule.new(:not_required, ->(value, errors){
+      false if value.nil?
+    }),
+
+    required: ValidationRule.new(:required, ->(value, errors){
       errors << "no value found" and return false if value.nil?
-  }
+    })
   }
 end
 

data/lib/easy_json_matcher/validator_set.rb

@@ -13,20 +13,29 @@ module EasyJSONMatcher
     def call(value:)
       error_hash = validators.each_with_object({}) do |k_v, errors_found|
         key = k_v[0]
-        val = value[key]
+        val = value[key.to_s]
         validator = k_v[1]
         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
+      if error_hash.empty? then [] else [error_hash] end
     end
 
     def validate_strict_keyset(keys:, errors:, candidates:)
+      missing_keys(keys: keys, errors: errors, candidates: candidates)
+      unexpected_keys(keys: keys, errors: errors, candidates: candidates)
+    end
+
+    def missing_keys(keys:, errors:, candidates:)
+      missing = keys - candidates
+      errors[:missing_keys] = "Missing keys: #{missing}" unless missing.empty?
+    end
+
+    def unexpected_keys(keys:, errors:, candidates:)
       rogue_keys = candidates - keys
       errors[:unexpected_keys] = "Unexpected keys: #{rogue_keys}" unless rogue_keys.empty?
     end
+
   end
 end

data/lib/easy_json_matcher/version.rb

@@ -1,3 +1,3 @@
 module EasyJSONMatcher
-  VERSION = "0.4.1".freeze
+  VERSION = "0.5.0".freeze
 end

data/test/managing_schemas_test.rb

@@ -10,6 +10,7 @@ module EasyJSONMatcher
         has_attribute(key: "name", opts: [ :string, :required ])
       }
       sc.register(as: @name)
+       byebug 
     end
 
     test "As a user I want to be able to register a Schema so I can reuse it later" do
@@ -42,9 +43,9 @@ module EasyJSONMatcher
       assert(schema.valid?(candidate: candidate), "test_schema did not validate correctly")
     end
 
-    test "SchemaLibrary should thrown a MissingSchemaException if an unregistered schema is requested" do
+    test "SchemaLibrary should thrown a UnknownValidationStepError if an unregistered schema is requested" do
       schema = SchemaLibrary.get_schema(name: "#{@name.to_s}-wibble")
-      assert_raises(MissingSchemaException) do
+      assert_raises(UnknownValidationStepError) do
         schema.call(value: {}.to_json)
       end
     end
@@ -53,7 +54,7 @@ module EasyJSONMatcher
       schema = SchemaLibrary.get_schema(name: :womble)
       begin
         schema.call(value: {}.to_json)
-      rescue MissingSchemaException => ex
+      rescue UnknownValidationStepError => ex
         assert ex.message =~ /womble/
       end
     end
@@ -68,8 +69,6 @@ module EasyJSONMatcher
         is_present: true,
       }
 
-      # assert_not(test_schema.valid?(invalid_json), "#{invalid_json} should not have been valid as it does not include the saved schema")
-
       valid_json = invalid_json.dup
       valid_json.store(@name, {name: "Achilles Tang"})
       valid_json = valid_json.to_json

data/test/node_test.rb

@@ -12,14 +12,14 @@ module EasyJSONMatcher
       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.call(value: test_value).must_be :==, expected
       end

data/test/printer_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+module EasyJSONMatcher
+  describe Printer do
+
+    it "should properly print a Schema" do
+      schema = SchemaGenerator.new {
+        string key: "val"
+        contains_node key: "node" do
+          string key: "inner_key"
+          string key: "another_key"
+          contains_node key: "another node" do
+            string key: "inner_inner_key"
+          end
+        end
+      }.generate_schema
+      pr = Printer.new(node: schema)
+      puts pr.inspect
+      end
+    end
+end

data/test/strict_mode_test.rb

@@ -30,5 +30,13 @@ module EasyJSONMatcher
 
       subject.validate(candidate: candidate).wont_be :empty?
     end
+
+    it "should not validate candidates missing keys" do
+      candidate = {
+        a: "a"
+      }.to_json
+
+      subject.validate(candidate: candidate).wont_be :empty?
+    end
   end
 end

data/test/validation_chain_factory_test.rb

@@ -1,6 +1,5 @@
 require "test_helper"
 require "easy_json_matcher/validation_chain_factory"
-require "easy_json_matcher/unknown_validation_step_error"
 
 module EasyJSONMatcher
 
@@ -23,7 +22,8 @@ module EasyJSONMatcher
       end
 
       it "should otherwise raise an error" do
-        skip "Leave for future release"
+        skip "This is currently unnecessary, but ought to be considered when
+              developing future versions"
         cannot_use = String.new
         -> { ValidationChainFactory.get_step_for(validating: cannot_use) }.
           must_raise UnknownValidationStepError

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_json_matcher
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - WJD Hamilton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-08 00:00:00.000000000 Z
+date: 2017-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-auto_inject
@@ -63,9 +63,9 @@ files:
 - lib/easy_json_matcher/json_coercer.rb
 - lib/easy_json_matcher/node.rb
 - lib/easy_json_matcher/node_generator.rb
+- lib/easy_json_matcher/printer.rb
 - lib/easy_json_matcher/schema_generator.rb
 - lib/easy_json_matcher/schema_library.rb
-- lib/easy_json_matcher/unknown_validation_step_error.rb
 - lib/easy_json_matcher/validation_chain_factory.rb
 - lib/easy_json_matcher/validation_rules.rb
 - lib/easy_json_matcher/validation_step.rb
@@ -87,6 +87,7 @@ files:
 - test/primitives_object_test.rb
 - test/primitives_string_test.rb
 - test/primtives_value_test.rb
+- test/printer_test.rb
 - test/required_validation_test.rb
 - test/schema_generator_test.rb
 - test/shortened_names_test.rb
@@ -153,6 +154,7 @@ test_files:
 - test/primitives_object_test.rb
 - test/shortened_names_test.rb
 - test/primitives_date_test.rb
+- test/printer_test.rb
 - test/global_validation_options_test.rb
 - test/validation_step_array_test.rb
 - test/required_validation_test.rb

data/lib/easy_json_matcher/unknown_validation_step_error.rb

@@ -1,10 +0,0 @@
-require "easy_json_matcher/easy_json_matcher_error"
-
-module EasyJSONMatcher
-  class UnknownValidationStepError < EasyJSONMatcherError
-
-    def initialize(type)
-      super "No validator available for #{type}, consider using a custom validator"
-    end
-  end
-end