media_types 2.3.0 → 2.3.2

data/lib/media_types/scheme/rules.rb

@@ -1,186 +1,186 @@
-# frozen_string_literal: true
-
-require 'media_types/scheme/missing_validation'
-
-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.strict_keys = []
-        self.original_key_type = {}
-
-        self.default = MissingValidation.new
-      end
-
-      def allow_empty?
-        allow_empty
-      end
-
-      def [](key)
-        __getobj__[normalize_key(key)]
-      end
-
-      def add(key, val, optional: false)
-        validate_input(key, val)
-
-        normalized_key = normalize_key(key)
-        __getobj__[normalized_key] = val
-        if optional == :loose
-          strict_keys << normalized_key
-        else
-          optional_keys << normalized_key if optional
-        end
-        original_key_type[normalized_key] = key.class
-
-        self
-      end
-
-      def validate_input(key, val)
-        raise KeyTypeError, "Unexpected key type #{key.class.name}, please use either a symbol or string." unless key.is_a?(String) || key.is_a?(Symbol)
-
-        validate_key_name(key, val)
-      end
-
-      def validate_key_name(key, val)
-        return unless has_key?(key)
-
-        if key.is_a?(Symbol)
-          duplicate_symbol_key_name(key, val)
-        else
-          duplicate_string_key_name(key, val)
-        end
-      end
-
-      def duplicate_symbol_key_name(key, val)
-        raise DuplicateSymbolKeyError.new(val.class.name.split('::').last, key) if get_original_key_type(key) == Symbol
-
-        raise SymbolOverwritingStringError.new(val.class.name.split('::').last, key)
-      end
-
-      def duplicate_string_key_name(key, val)
-        raise DuplicateStringKeyError.new(val.class.name.split('::').last, key) if get_original_key_type(key) == String
-
-        raise StringOverwritingSymbolError.new(val.class.name.split('::').last, key)
-      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
-
-      ##
-      # Returns the keys that are not options
-      #
-      # @see #add
-      # #see #merge
-      #
-      # @return [Array<Symbol>] required keys
-      #
-      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
-
-      def clone
-        super.tap do |cloned|
-          cloned.__setobj__(__getobj__.clone)
-        end
-      end
-
-      ##
-      # Merges another set of rules into a clone of this one
-      #
-      # @param [Rules, ::Hash] the other rules
-      # @return [Rules] a clone
-      #
-      def merge(rules)
-        clone.instance_exec do
-          __setobj__(__getobj__.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
-      end
-
-      def inspect(indent = 0)
-        prefix = '  ' * indent
-        return "#{prefix}[Error]Depth limit reached[/Error]" if indent > 5_000
-
-        [
-          "#{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]"
-        ].join("\n")
-      end
-
-      def inspect_format_attribute(indent, key, value = self[key])
-        [
-          [key.to_s, optional_keys.include?(key) && '(optional)' || nil].compact.join(' '),
-          value.is_a?(Scheme) || value.is_a?(Rules) ? "\n#{value.inspect(indent + 2)}" : value.inspect
-        ].join(': ')
-      end
-
-      def has_key?(key)
-        __getobj__.key?(normalize_key(key))
-      end
-
-      def get_original_key_type(key)
-        raise format('Key %<key>s does not exist', key: key) unless has_key?(key)
-
-        original_key_type[normalize_key(key)]
-      end
-
-      def default=(input_default)
-        unless default.nil?
-          raise DuplicateAnyRuleError if !(default.is_a?(MissingValidation) || default.is_a?(NotStrict)) && !(input_default.is_a?(MissingValidation) || input_default.is_a?(NotStrict))
-          raise DuplicateNotStrictRuleError if default.is_a?(NotStrict) && input_default.is_a?(NotStrict)
-          raise NotStrictOverwritingAnyError if !(default.is_a?(MissingValidation) || default.is_a?(NotStrict)) && input_default.is_a?(NotStrict)
-          raise AnyOverwritingNotStrictError if default.is_a?(NotStrict) && !(input_default.is_a?(MissingValidation) || input_default.is_a?(NotStrict))
-        end
-        super(input_default)
-      end
-
-      alias get []
-      alias remove delete
-
-      private
-
-      attr_accessor :allow_empty, :strict_keys, :optional_keys, :original_key_type
-      attr_writer :expected_type
-
-      def normalize_key(key)
-        String(key).to_sym
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'media_types/scheme/missing_validation'
+
+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.strict_keys = []
+        self.original_key_type = {}
+
+        self.default = MissingValidation.new
+      end
+
+      def allow_empty?
+        allow_empty
+      end
+
+      def [](key)
+        __getobj__[normalize_key(key)]
+      end
+
+      def add(key, val, optional: false)
+        validate_input(key, val)
+
+        normalized_key = normalize_key(key)
+        __getobj__[normalized_key] = val
+        if optional == :loose
+          strict_keys << normalized_key
+        else
+          optional_keys << normalized_key if optional
+        end
+        original_key_type[normalized_key] = key.class
+
+        self
+      end
+
+      def validate_input(key, val)
+        raise KeyTypeError, "Unexpected key type #{key.class.name}, please use either a symbol or string." unless key.is_a?(String) || key.is_a?(Symbol)
+
+        validate_key_name(key, val)
+      end
+
+      def validate_key_name(key, val)
+        return unless has_key?(key)
+
+        if key.is_a?(Symbol)
+          duplicate_symbol_key_name(key, val)
+        else
+          duplicate_string_key_name(key, val)
+        end
+      end
+
+      def duplicate_symbol_key_name(key, val)
+        raise DuplicateSymbolKeyError.new(val.class.name.split('::').last, key) if get_original_key_type(key) == Symbol
+
+        raise SymbolOverwritingStringError.new(val.class.name.split('::').last, key)
+      end
+
+      def duplicate_string_key_name(key, val)
+        raise DuplicateStringKeyError.new(val.class.name.split('::').last, key) if get_original_key_type(key) == String
+
+        raise StringOverwritingSymbolError.new(val.class.name.split('::').last, key)
+      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
+
+      ##
+      # Returns the keys that are not options
+      #
+      # @see #add
+      # #see #merge
+      #
+      # @return [Array<Symbol>] required keys
+      #
+      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
+
+      def clone
+        super.tap do |cloned|
+          cloned.__setobj__(__getobj__.clone)
+        end
+      end
+
+      ##
+      # Merges another set of rules into a clone of this one
+      #
+      # @param [Rules, ::Hash] the other rules
+      # @return [Rules] a clone
+      #
+      def merge(rules)
+        clone.instance_exec do
+          __setobj__(__getobj__.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
+      end
+
+      def inspect(indent = 0)
+        prefix = '  ' * indent
+        return "#{prefix}[Error]Depth limit reached[/Error]" if indent > 5_000
+
+        [
+          "#{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]"
+        ].join("\n")
+      end
+
+      def inspect_format_attribute(indent, key, value = self[key])
+        [
+          [key.to_s, optional_keys.include?(key) && '(optional)' || nil].compact.join(' '),
+          value.is_a?(Scheme) || value.is_a?(Rules) ? "\n#{value.inspect(indent + 2)}" : value.inspect
+        ].join(': ')
+      end
+
+      def has_key?(key)
+        __getobj__.key?(normalize_key(key))
+      end
+
+      def get_original_key_type(key)
+        raise format('Key %<key>s does not exist', key: key) unless has_key?(key)
+
+        original_key_type[normalize_key(key)]
+      end
+
+      def default=(input_default)
+        unless default.nil?
+          raise DuplicateAnyRuleError if !(default.is_a?(MissingValidation) || default.is_a?(NotStrict)) && !(input_default.is_a?(MissingValidation) || input_default.is_a?(NotStrict))
+          raise DuplicateNotStrictRuleError if default.is_a?(NotStrict) && input_default.is_a?(NotStrict)
+          raise NotStrictOverwritingAnyError if !(default.is_a?(MissingValidation) || default.is_a?(NotStrict)) && input_default.is_a?(NotStrict)
+          raise AnyOverwritingNotStrictError if default.is_a?(NotStrict) && !(input_default.is_a?(MissingValidation) || input_default.is_a?(NotStrict))
+        end
+        super(input_default)
+      end
+
+      alias get []
+      alias remove delete
+
+      private
+
+      attr_accessor :allow_empty, :strict_keys, :optional_keys, :original_key_type
+      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

@@ -1,73 +1,75 @@
-# 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(loose: options.loose)
-        # 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, found: output)
-      end
-
-      def iterate(mark)
-        OutputIteratorWithPredicate.call(output, options, rules: rules) do |key, value, options:, context:|
-          unless key.class == options.expected_key_type || rules.get(key).class == NotStrict
-            raise ValidationError,
-                format(
-                  'Expected key as %<type>s, got %<actual>s at [%<backtrace>s]',
-                  type: options.expected_key_type,
-                  actual: key.class,
-                  backtrace: options.trace(key).backtrace.join('->')
-                )
-          end
-
-          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:, found:)
-        raise ExhaustedOutputError, format(
-          'Missing keys in output: %<missing_keys>s at [%<backtrace>s]. I did find: %<found>s',
-          missing_keys: missing_keys,
-          backtrace: backtrace.join('->'),
-          found: (found.is_a? Hash) ? found.keys : found.class.name,
-        )
-      end
-    end
-  end
-end
+# 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(loose: options.loose)
+        # 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, found: output)
+      end
+
+      def iterate(mark)
+        OutputIteratorWithPredicate.call(output, options, rules: rules) do |key, value, options:, context:|
+          unless key.class == options.expected_key_type || rules.get(key).class == NotStrict
+            raise ValidationError,
+                format(
+                  'Expected key as %<type>s, got %<actual>s at [%<backtrace>s]',
+                  type: options.expected_key_type,
+                  actual: key.class,
+                  backtrace: options.trace(key).backtrace.join('->')
+                )
+          end
+
+          mark.call(key)
+
+          catch(:end) do
+            rules.get(key).validate!(
+              value,
+              options.trace(key),
+              context: context
+            )
+          end
+        end
+      end
+
+      private
+
+      attr_accessor :rules, :options, :output
+
+      def raise_exhausted!(missing_keys:, backtrace:, found:)
+        raise ExhaustedOutputError, format(
+          'Missing keys in output: %<missing_keys>s at [%<backtrace>s]. I did find: %<found>s',
+          missing_keys: missing_keys,
+          backtrace: backtrace.join('->'),
+          found: (found.is_a? Hash) ? found.keys : found.class.name,
+        )
+      end
+    end
+  end
+end

data/lib/media_types/scheme/validation_options.rb

@@ -1,44 +1,44 @@
-# frozen_string_literal: true
-
-module MediaTypes
-  class Scheme
-    class ValidationOptions
-      attr_accessor :exhaustive, :strict, :backtrace, :context, :expected_key_type, :loose
-
-      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}, loose: #{loose}, exhaustive: #{exhaustive}, current_obj: #{scoped_output.to_json}"
-      end
-
-      def scoped_output
-        current = context
-
-        backtrace.drop(1).first([0, backtrace.size - 2].max).each do |e|
-          current = current[e] unless current.nil?
-        end
-
-        current
-      end
-
-      def with_backtrace(backtrace)
-        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, loose: loose)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module MediaTypes
+  class Scheme
+    class ValidationOptions
+      attr_accessor :exhaustive, :strict, :backtrace, :context, :expected_key_type, :loose
+
+      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}, loose: #{loose}, exhaustive: #{exhaustive}, current_obj: #{scoped_output.to_json}"
+      end
+
+      def scoped_output
+        current = context
+
+        backtrace.drop(1).first([0, backtrace.size - 2].max).each do |e|
+          current = current[e] unless current.nil?
+        end
+
+        current
+      end
+
+      def with_backtrace(backtrace)
+        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, loose: loose)
+      end
+    end
+  end
+end