Add ability to declare some attributes as loosly validated

Allows skipping certain attributes when the loose argument is set

Author: thexa4

CHANGELOG.md

@@ -2,7 +2,8 @@
 
 ## 2.2.0
 
- - Add ability to define multiple versions using one block
+ - Add ability to define multiple versions using one block.
+ - Added ability to mark certain attributes as optional when validating with `loose: true` and required otherwise.
 
 ## 2.1.1
 

README.md

@@ -81,7 +81,7 @@ class Venue
 
     version 1 do
       attribute :name, String
-      attribute :coords, String
+      attribute :coords, String, optional: :loose
       attribute :updated_at, String
 
       link :self
@@ -467,8 +467,8 @@ class MyMedia
     { "foo": { "bar": "string" } }
     FIXTURE
     assert_fail '{"foo": {}}'
-    assert_fail '{"foo": null}'
-    assert_fail '{"foo": [42]}'
+    assert_fail '{"foo": null}', loose: true
+    assert_fail '{"foo": [42]}', loose: false
   end
 end
 

lib/media_types/scheme.rb

@@ -51,13 +51,14 @@ def message
   end
 
   class FixtureData
-    def initialize(caller:, fixture:, expect_to_pass:)
+    def initialize(caller:, fixture:, expect_to_pass:, loose:)
       self.caller = caller
       self.fixture = fixture
       self.expect_to_pass = expect_to_pass
+      self.loose = loose
     end
 
-    attr_accessor :caller, :fixture, :expect_to_pass
+    attr_accessor :caller, :fixture, :expect_to_pass, :loose
 
     alias expect_to_pass? expect_to_pass
   end
@@ -431,14 +432,14 @@ def inspect(indentation = 0)
       ].join("\n")
     end
 
-    def assert_pass(fixture)
+    def assert_pass(fixture, loose: false)
       reduced_stack = remove_current_dir_from_stack(caller_locations)
-      @fixtures << FixtureData.new(caller: reduced_stack.first, fixture: fixture, expect_to_pass: true)
+      @fixtures << FixtureData.new(caller: reduced_stack.first, fixture: fixture, expect_to_pass: true, loose: loose)
     end
 
-    def assert_fail(fixture)
+    def assert_fail(fixture, loose: false)
       reduced_stack = remove_current_dir_from_stack(caller_locations)
-      @fixtures << FixtureData.new(caller: reduced_stack.first, fixture: fixture, expect_to_pass: false)
+      @fixtures << FixtureData.new(caller: reduced_stack.first, fixture: fixture, expect_to_pass: false, loose: loose)
     end
 
     # Removes all calls originating in current dir from given stack
@@ -496,7 +497,7 @@ def validate_fixture(fixture_data, expect_symbol_keys, backtrace = [])
       expected_key_type = expect_symbol_keys ? Symbol : String
 
       begin
-        validate(json, expected_key_type: expected_key_type, backtrace: backtrace)
+        validate(json, expected_key_type: expected_key_type, backtrace: backtrace, loose: fixture_data.loose)
         unless fixture_data.expect_to_pass?
           raise UnexpectedValidationResultError.new(fixture_data.caller, 'No error encounterd whilst expecting to')
         end

lib/media_types/scheme/output_empty_guard.rb

@@ -29,15 +29,15 @@ def call
       attr_accessor :output, :options, :rules
 
       def allow_empty?
-        rules.allow_empty? || rules.required.empty?
+        rules.allow_empty? || rules.required(loose: options.loose).empty?
       end
 
       def raise_empty!(backtrace:, found:)
         raise EmptyOutputError, format(
-          'Expected output, got empty at %<backtrace>s. Required are: %<required>s. Found: %<found>s',
+          'The object at %<backtrace>s was empty but I expected contents. Required keys are: %<required>s.',
           backtrace: backtrace.join('->'),
-          required: rules.required.keys,
-          found: (found.is_a? Hash) ? found.keys : found.class.name,
+          required: rules.required(loose: options.loose).keys,
+          found: (found.respond_to? :keys) ? found.keys : found.class.name,
         )
       end
     end

lib/media_types/scheme/rules.rb

@@ -14,6 +14,7 @@ def initialize(allow_empty:, expected_type:)
         self.allow_empty = allow_empty
         self.expected_type = expected_type
         self.optional_keys = []
+        self.strict_keys = []
         self.original_key_type = {}
 
         self.default = MissingValidation.new
@@ -32,7 +33,11 @@ def add(key, val, optional: false)
 
         normalized_key = normalize_key(key)
         __getobj__[normalized_key] = val
-        optional_keys << normalized_key if optional
+        if optional == :loose
+          strict_keys << normalized_key
+        else
+          optional_keys << normalized_key if optional
+        end
         original_key_type[normalized_key] = key.class
 
         self
@@ -87,11 +92,16 @@ def delete(key)
       #
       # @return [Array<Symbol>] required keys
       #
-      def required
+      def required(loose:)
         clone.tap do |cloned|
           optional_keys.each do |key|
             cloned.delete(key)
           end
+          if loose
+            strict_keys.each do |key|
+              cloned.delete(key)
+            end
+          end
         end
       end
 
@@ -113,6 +123,9 @@ def merge(rules)
           if rules.respond_to?(:optional_keys, true)
             optional_keys.push(*rules.send(:optional_keys))
           end
+          if rules.respond_to?(:strict_keys, true)
+            strict_keys.push(*rules.send(:strict_keys))
+          end
 
           self
         end
@@ -123,7 +136,7 @@ def inspect(indent = 0)
         return "#{prefix}[Error]Depth limit reached[/Error]" if indent > 5_000
 
         [
-          "#{prefix}[Rules n=#{keys.length} optional=#{optional_keys.length} allow_empty=#{allow_empty?}]",
+          "#{prefix}[Rules n=#{keys.length} optional=#{optional_keys.length} strict=#{strict_keys.length} allow_empty=#{allow_empty?}]",
           "#{prefix}  #{inspect_format_attribute(indent, '*', default)}",
           *keys.map { |key| "#{prefix}  #{inspect_format_attribute(indent, key)}" },
           "#{prefix}[/Rules]"
@@ -162,7 +175,7 @@ def default=(input_default)
 
       private
 
-      attr_accessor :allow_empty, :optional_keys, :original_key_type
+      attr_accessor :allow_empty, :strict_keys, :optional_keys, :original_key_type
       attr_writer :expected_type
 
       def normalize_key(key)

lib/media_types/scheme/rules_exhausted_guard.rb

@@ -26,7 +26,7 @@ def call
           return iterate(EMPTY_MARK)
         end
 
-        required_rules = rules.required
+        required_rules = rules.required(loose: options.loose)
         # noinspection RubyScope
         result = iterate(->(key) { required_rules.remove(key) })
         return result if required_rules.empty?

lib/media_types/scheme/validation_options.rb

@@ -3,18 +3,19 @@
 module MediaTypes
   class Scheme
     class ValidationOptions
-      attr_accessor :exhaustive, :strict, :backtrace, :context, :expected_key_type
+      attr_accessor :exhaustive, :strict, :backtrace, :context, :expected_key_type, :loose
 
-      def initialize(context = {}, exhaustive: true, strict: true, backtrace: [], expected_key_type:)
+      def initialize(context = {}, exhaustive: true, strict: true, backtrace: [], loose: false, expected_key_type:)
         self.exhaustive = exhaustive
         self.strict = strict
         self.backtrace = backtrace
         self.context = context
         self.expected_key_type = expected_key_type
+        self.loose = loose
       end
 
       def inspect
-        "backtrack: #{backtrace.inspect}, strict: #{strict.inspect}, exhaustive: #{exhaustive}, current_obj: #{scoped_output.to_json}"
+        "backtrack: #{backtrace.inspect}, strict: #{strict.inspect}, loose: #{loose}, exhaustive: #{exhaustive}, current_obj: #{scoped_output.to_json}"
       end
 
       def scoped_output
@@ -28,15 +29,15 @@ def scoped_output
       end
 
       def with_backtrace(backtrace)
-        ValidationOptions.new(context, exhaustive: exhaustive, strict: strict, backtrace: backtrace, expected_key_type: expected_key_type)
+        ValidationOptions.new(context, exhaustive: exhaustive, strict: strict, backtrace: backtrace, expected_key_type: expected_key_type, loose: loose)
       end
 
       def trace(*traces)
         with_backtrace(backtrace.dup.concat(traces))
       end
 
       def exhaustive!
-        ValidationOptions.new(context, exhaustive: true, strict: strict, backtrace: backtrace, expected_key_type: expected_key_type)
+        ValidationOptions.new(context, exhaustive: true, strict: strict, backtrace: backtrace, expected_key_type: expected_key_type, loose: loose)
       end
     end
   end

test/media_types/loose_validation_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+class LooseValidationTest < Minitest::Test
+  ### Attribute ###
+
+  class TestLooseAttributes
+    include MediaTypes::Dsl
+
+    def self.organisation
+      'domain.test'
+    end
+
+    use_name 'TestThatWholeContextOfBlockIsUsedAttribute'
+
+    # default attribute (=hash object)
+    validations do
+      attribute :foo do
+        attribute :bar, Numeric, optional: :loose
+      end
+      assert_pass '{"foo":{}}', loose: true
+      assert_fail '{"foo":{}}', loose: false
+    end
+  end
+
+  [TestLooseAttributes].each do |type|
+    create_specification_tests_for type
+  end
+end