media_types 0.4.1 → 0.5.0

data/lib/media_types/scheme/any_of.rb

@@ -10,6 +10,10 @@ module MediaTypes
       def ===(other)
         any? { |it| it === other } # rubocop:disable Style/CaseEquality
       end
+
+      def inspect
+        "[Scheme::AnyOf(#{__getobj__})]"
+      end
     end
 
     # noinspection RubyInstanceMethodNamingConvention

data/lib/media_types/scheme/attribute.rb

@@ -35,6 +35,10 @@ module MediaTypes
               )
       end
 
+      def inspect
+        "[Scheme::Attribute type=#{type} nil=#{allow_nil}]"
+      end
+
       private
 
       attr_accessor :allow_nil, :type

data/lib/media_types/scheme/enumeration_context.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module MediaTypes
   class Scheme
     class EnumerationContext
-      def initialize(validations:)
-        self.validations = validations
+      def initialize(rules:)
+        self.rules = rules
       end
 
       def enumerate(val)
@@ -10,7 +12,7 @@ module MediaTypes
         self
       end
 
-      attr_accessor :validations, :key
+      attr_accessor :rules, :key
     end
   end
 end

data/lib/media_types/scheme/enumeration_of_type.rb

@@ -25,6 +25,10 @@ module MediaTypes
           validate_items!(output, options)
       end
 
+      def inspect
+        "[Scheme::EnumerationOfType #{item_type} collection=#{enumeration_type} empty=#{allow_empty}]"
+      end
+
       private
 
       attr_accessor :allow_empty, :enumeration_type, :item_type

data/lib/media_types/scheme/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module MediaTypes
+  class Scheme
+
+    # Base class for all validations errors
+    class ValidationError < ArgumentError; end
+
+    # Raised when it did not expect more data, but there was more left
+    class StrictValidationError < ValidationError; end
+
+    # Raised when it expected not to be empty, but it was
+    class EmptyOutputError < ValidationError; end
+
+    # Raised when a value did not have the expected type
+    class OutputTypeMismatch < ValidationError; end
+
+    # Raised when it expected more data but there wasn't any left
+    class ExhaustedOutputError < ValidationError; end
+  end
+end

data/lib/media_types/scheme/links.rb

@@ -1,27 +1,33 @@
 # frozen_string_literal: true
 
+require 'media_types/scheme/rules'
+
 module MediaTypes
   class Scheme
     class Links
       def initialize
-        self.links = {}
+        self.links = Rules.new(allow_empty: false, expected_type: ::Hash)
       end
 
-      def link(key, allow_nil: false, &block)
-        scheme = Scheme.new
-        scheme.attribute :href, String, allow_nil: allow_nil
-        scheme.instance_exec(&block) if block_given?
+      def link(key, allow_nil: false, optional: false, &block)
+        links.add(
+          key,
+          Scheme.new do
+            attribute :href, String, allow_nil: allow_nil
+            instance_exec(&block) if block_given?
+          end,
+          optional: optional
+        )
 
-        links[String(key)] = scheme
+        self
       end
 
       def validate!(output, options, **_opts)
-        links.all? do |key, value|
-          value.validate!(
-            output[key] || output[key.to_sym],
-            options.trace(key).exhaustive!
-          )
-        end
+        RulesExhaustedGuard.call(output, options, rules: links)
+      end
+
+      def inspect
+        "[Scheme::Links #{links.keys}]"
       end
 
       private

data/lib/media_types/scheme/missing_validation.rb

@@ -7,7 +7,7 @@ module MediaTypes
       def validate!(_output, options, context:, **_opts)
         # Check that no unknown keys are present
         return true unless options.strict
-        raise_strict!(key: context.key, strict_keys: context.validations, backtrace: options.backtrace)
+        raise_strict!(key: context.key, strict_keys: context.rules, backtrace: options.backtrace)
       end
 
       def raise_strict!(key:, backtrace:, strict_keys:)

data/lib/media_types/scheme/not_strict.rb

@@ -6,6 +6,10 @@ module MediaTypes
       def validate!(*_args, **_opts)
         true
       end
+
+      def inspect
+        '[Scheme::NotStrict]'
+      end
     end
   end
 end

data/lib/media_types/scheme/output_empty_guard.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'media_types/scheme/errors'
+require 'media_types/object'
+
+module MediaTypes
+  class Scheme
+    class OutputEmptyGuard
+      class << self
+        def call(*args, **opts, &block)
+          new(*args, **opts).call(&block)
+        end
+      end
+
+      def initialize(output, options, rules:)
+        self.output = output
+        self.options = options
+        self.rules = rules
+      end
+
+      def call
+        return unless MediaTypes::Object.new(output).empty?
+        throw(:end, true) if allow_empty?
+        raise_empty!(backtrace: options.backtrace)
+      end
+
+      private
+
+      attr_accessor :output, :options, :rules
+
+      def allow_empty?
+        rules.allow_empty? || rules.required.empty?
+      end
+
+      def raise_empty!(backtrace:)
+        raise EmptyOutputError, format('Expected output, got empty at %<backtrace>s', backtrace: backtrace.join('->'))
+      end
+    end
+  end
+end

data/lib/media_types/scheme/output_iterator_with_predicate.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'media_types/scheme/enumeration_context'
+
+module MediaTypes
+  class Scheme
+    class OutputIteratorWithPredicate
+
+      class << self
+        def call(*args, **opts, &block)
+          new(*args, **opts).call(&block)
+        end
+      end
+
+      def initialize(enumerable, options, rules:)
+        self.enumerable = enumerable
+        self.options = options
+        self.rules = rules
+      end
+
+      ##
+      # Mimics Enumerable#all? with mandatory +&block+
+      #
+      def call
+        if hash?
+          return iterate_hash { |*args, **opts| yield(*args, **opts) }
+        end
+
+        iterate { |*args, **opts| yield(*args, **opts) }
+      end
+
+      private
+
+      attr_accessor :enumerable, :options, :rules
+
+      def hash?
+        enumerable.is_a?(::Hash) || enumerable.respond_to?(:key)
+      end
+
+      def iterate_hash
+        context = EnumerationContext.new(rules: rules)
+
+        enumerable.all? do |key, value|
+          yield key, value, options: options, context: context.enumerate(key)
+        end
+      end
+
+      def iterate(&block)
+        Array(enumerable).each_with_index.all? do |array_like_element, i|
+          OutputIteratorWithPredicate.call(array_like_element, options.trace(i), rules: rules, &block)
+        end
+      end
+    end
+  end
+end

data/lib/media_types/scheme/output_type_guard.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'media_types/scheme/errors'
+
+module MediaTypes
+  class Scheme
+    class OutputTypeGuard
+      class << self
+        def call(*args, **opts, &block)
+          new(*args, **opts).call(&block)
+        end
+      end
+
+      def initialize(output, options, rules:)
+        self.output = output
+        self.options = options
+        self.expected_type = rules.expected_type
+      end
+
+      def call
+        return unless expected_type && !(expected_type === output) # rubocop:disable Style/CaseEquality
+        raise_type_error!(type: output.class, backtrace: options.backtrace)
+      end
+
+      private
+
+      attr_accessor :output, :options, :expected_type
+
+      def raise_type_error!(type:, backtrace:)
+        raise OutputTypeMismatch, format(
+          'Expected a %<expected>s, got a %<actual>s at %<backtrace>s',
+          expected: expected_type,
+          actual: type,
+          backtrace: backtrace.join('->')
+        )
+      end
+    end
+  end
+end

data/lib/media_types/scheme/rules.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module MediaTypes
+  class Scheme
+    class Rules < DelegateClass(::Hash)
+
+      attr_reader :expected_type
+
+      def initialize(allow_empty:, expected_type:)
+        super({})
+
+        self.allow_empty = allow_empty
+        self.expected_type = expected_type
+        self.optional_keys = []
+
+        self.default = MissingValidation.new
+      end
+
+      def allow_empty?
+        allow_empty
+      end
+
+      def [](key)
+        __getobj__[normalize_key(key)]
+      end
+
+      def add(key, val, optional: false)
+        normalized_key = normalize_key(key)
+        __getobj__[normalized_key] = val
+        optional_keys << normalized_key if optional
+
+        self
+      end
+
+      def []=(key, val)
+        add(key, val, optional: false)
+      end
+
+      def fetch(key, &block)
+        __getobj__.fetch(normalize_key(key), &block)
+      end
+
+      def delete(key)
+        __getobj__.delete(normalize_key(key))
+        self
+      end
+
+      def required
+        clone.tap do |cloned|
+          optional_keys.each do |key|
+            cloned.delete(key)
+          end
+        end
+      end
+
+      def clone
+        super.tap do |cloned|
+          cloned.__setobj__(__getobj__.clone)
+        end
+      end
+
+      def merge(rules)
+        __getobj__.merge!(rules)
+        self
+      end
+
+      def inspect
+        "[Scheme::Rules n=#{keys.length} default=#{default}]"
+      end
+
+      alias get []
+      alias remove delete
+
+      private
+
+      attr_accessor :allow_empty, :optional_keys
+      attr_writer :expected_type
+
+      def normalize_key(key)
+        String(key).to_sym
+      end
+    end
+  end
+end

data/lib/media_types/scheme/rules_exhausted_guard.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'media_types/scheme/errors'
+require 'media_types/scheme/output_iterator_with_predicate'
+
+module MediaTypes
+  class Scheme
+    class RulesExhaustedGuard
+
+      EMPTY_MARK = ->(_) {}
+
+      class << self
+        def call(*args, **opts, &block)
+          new(*args, **opts).call(&block)
+        end
+      end
+
+      def initialize(output, options, rules:)
+        self.rules = rules
+        self.output = output
+        self.options = options
+      end
+
+      def call
+        unless options.exhaustive
+          return iterate(EMPTY_MARK)
+        end
+
+        required_rules = rules.required
+        # noinspection RubyScope
+        result = iterate(->(key) { required_rules.remove(key) })
+        return result if required_rules.empty?
+
+        raise_exhausted!(missing_keys: required_rules.keys, backtrace: options.backtrace)
+      end
+
+      def iterate(mark)
+        OutputIteratorWithPredicate.call(output, options, rules: rules) do |key, value, options:, context:|
+          mark.call(key)
+
+          rules.get(key).validate!(
+            value,
+            options.trace(key),
+            context: context
+          )
+        end
+      end
+
+      private
+
+      attr_accessor :rules, :options, :output
+
+      def raise_exhausted!(missing_keys:, backtrace:)
+        raise ExhaustedOutputError, format(
+          'Missing keys in output: %<missing_keys>s at [%<backtrace>s]',
+          missing_keys: missing_keys,
+          backtrace: backtrace.join('->')
+        )
+      end
+    end
+  end
+end

data/lib/media_types/version.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
-module MediaTypes
-  VERSION = '0.4.1'
-end
+# frozen_string_literal: true
+
+module MediaTypes
+  VERSION = '0.5.0'
+end