media_types 2.2.0 → 2.3.0

data/lib/media_types/scheme/any_of.rb

@@ -1,41 +1,41 @@
-# frozen_string_literal: true
-
-require 'delegate'
-
-module MediaTypes
-  class Scheme
-    class CaseEqualityWithList < SimpleDelegator
-
-      # True for Enumerable#any? {Object#===}
-      def ===(other)
-        any? { |it| it === other } # rubocop:disable Style/CaseEquality
-      end
-
-      def inspect
-        "[Scheme::AnyOf(#{__getobj__})]"
-      end
-    end
-
-    class << self
-      # noinspection RubyClassMethodNamingConvention
-      ##
-      # Allows +it+ to be any of the wrapped +klazzes+
-      #
-      # @param [Array<Class>] klazzes the classes that are valid for +it+
-      # @return [CaseEqualityWithList]
-      def AnyOf(*klazzes) # rubocop:disable Naming/MethodName
-        CaseEqualityWithList.new(klazzes)
-      end
-    end
-
-    # noinspection RubyInstanceMethodNamingConvention
-    ##
-    # Allows +it+ to be any of the wrapped +klazzes+
-    #
-    # @param [Array<Class>] klazzes the classes that are valid for +it+
-    # @return [CaseEqualityWithList]
-    def AnyOf(*klazzes) # rubocop:disable Naming/MethodName
-      self.class.AnyOf(*klazzes)
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'delegate'
+
+module MediaTypes
+  class Scheme
+    class CaseEqualityWithList < SimpleDelegator
+
+      # True for Enumerable#any? {Object#===}
+      def ===(other)
+        any? { |it| it === other } # rubocop:disable Style/CaseEquality
+      end
+
+      def inspect
+        "[Scheme::AnyOf(#{__getobj__})]"
+      end
+    end
+
+    class << self
+      # noinspection RubyClassMethodNamingConvention
+      ##
+      # Allows +it+ to be any of the wrapped +klazzes+
+      #
+      # @param [Array<Class>] klazzes the classes that are valid for +it+
+      # @return [CaseEqualityWithList]
+      def AnyOf(*klazzes) # rubocop:disable Naming/MethodName
+        CaseEqualityWithList.new(klazzes)
+      end
+    end
+
+    # noinspection RubyInstanceMethodNamingConvention
+    ##
+    # Allows +it+ to be any of the wrapped +klazzes+
+    #
+    # @param [Array<Class>] klazzes the classes that are valid for +it+
+    # @return [CaseEqualityWithList]
+    def AnyOf(*klazzes) # rubocop:disable Naming/MethodName
+      self.class.AnyOf(*klazzes)
+    end
+  end
+end

data/lib/media_types/scheme/attribute.rb

@@ -1,46 +1,46 @@
-# frozen_string_literal: true
-
-require 'media_types/scheme/errors'
-require 'media_types/scheme/allow_nil'
-
-module MediaTypes
-  class Scheme
-    class Attribute
-
-      ##
-      # An attribute that expects a value of type +type+
-      #
-      # @see AllowNil
-      # @see AnyOf
-      #
-      # @param [Class] type the class +it+ must be
-      # @param [TrueClass, FalseClass] allow_nil if true, nil? is allowed
-      #
-      def initialize(type, allow_nil: false)
-        self.type = allow_nil ? Scheme.AllowNil(type) : type
-
-        freeze
-      end
-
-      def validate!(output, options, **_opts)
-        return true if type === output # rubocop:disable Style/CaseEquality
-        raise ValidationError,
-              format(
-                'Expected %<type>s, got %<actual>s at [%<backtrace>s]',
-                type: type,
-                actual: output.inspect,
-                backtrace: options.backtrace.join('->')
-              )
-      end
-
-      def inspect
-        "[Scheme::Attribute of #{type.inspect}]"
-      end
-
-      private
-
-      attr_accessor :allow_nil, :type
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'media_types/scheme/errors'
+require 'media_types/scheme/allow_nil'
+
+module MediaTypes
+  class Scheme
+    class Attribute
+
+      ##
+      # An attribute that expects a value of type +type+
+      #
+      # @see AllowNil
+      # @see AnyOf
+      #
+      # @param [Class] type the class +it+ must be
+      # @param [TrueClass, FalseClass] allow_nil if true, nil? is allowed
+      #
+      def initialize(type, allow_nil: false)
+        self.type = allow_nil ? Scheme.AllowNil(type) : type
+
+        freeze
+      end
+
+      def validate!(output, options, **_opts)
+        return true if type === output # rubocop:disable Style/CaseEquality
+        raise ValidationError,
+              format(
+                'Expected %<type>s, got %<actual>s at [%<backtrace>s]',
+                type: type,
+                actual: output.inspect,
+                backtrace: options.backtrace.join('->')
+              )
+      end
+
+      def inspect
+        "[Scheme::Attribute of #{type.inspect}]"
+      end
+
+      private
+
+      attr_accessor :allow_nil, :type
+
+    end
+  end
+end

data/lib/media_types/scheme/enumeration_context.rb

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

data/lib/media_types/scheme/enumeration_of_type.rb

@@ -1,80 +1,80 @@
-# frozen_string_literal: true
-
-require 'media_types/scheme/errors'
-
-module MediaTypes
-  class Scheme
-    class EnumerationOfType
-
-      ##
-      # An attribute that expects a value of type +enumeration_type+ and each item of type +item_type+
-      #
-      # @param [Class] item_type the type of each item
-      # @param [Class] enumeration_type the type of the enumeration as a whole
-      # @param [TrueClass, FalseClass] allow_empty if true, an empty instance of +enumeration_type+ is valid
-      #
-      def initialize(item_type, enumeration_type: Array, allow_empty: false)
-        self.item_type = item_type
-        self.enumeration_type = enumeration_type
-        self.allow_empty = allow_empty
-
-        freeze
-      end
-
-      def validate!(output, options, **_opts)
-        validate_enumeration!(output, options) &&
-          validate_not_empty!(output, options) &&
-          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
-
-      def validate_enumeration!(output, options)
-        return true if enumeration_type === output # rubocop:disable Style/CaseEquality
-        raise ValidationError,
-              format(
-                'Expected collection as %<type>s, got %<actual>s at [%<backtrace>s]',
-                type: enumeration_type,
-                actual: output.inspect,
-                backtrace: options.backtrace.join('->')
-              )
-      end
-
-      def validate_not_empty!(output, options)
-        return true if allow_empty
-        return true if output.respond_to?(:length) && output.length.positive?
-        return true if output.respond_to?(:empty?) && !output.empty?
-
-        raise EmptyOutputError,
-              format(
-                'Expected collection to be not empty, got empty at [%<backtrace>s]',
-                backtrace: options.backtrace.join('->')
-              )
-      end
-
-      def validate_items!(output, options)
-        output.each_with_index.all? do |item, index|
-          next true if item_type === item # rubocop:disable Style/CaseEquality
-          if item_type.is_a?(Scheme)
-            item_type.validate(item, options.trace("[#{index}]"))
-            next true
-          end
-          raise ValidationError,
-                format(
-                  'Expected collection item as %<type>s, got %<actual>s at [%<backtrace>s]',
-                  type: item_type.inspect,
-                  actual: item.inspect,
-                  backtrace: options.backtrace.join('->')
-                )
-        end
-      end
-
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'media_types/scheme/errors'
+
+module MediaTypes
+  class Scheme
+    class EnumerationOfType
+
+      ##
+      # An attribute that expects a value of type +enumeration_type+ and each item of type +item_type+
+      #
+      # @param [Class] item_type the type of each item
+      # @param [Class] enumeration_type the type of the enumeration as a whole
+      # @param [TrueClass, FalseClass] allow_empty if true, an empty instance of +enumeration_type+ is valid
+      #
+      def initialize(item_type, enumeration_type: Array, allow_empty: false)
+        self.item_type = item_type
+        self.enumeration_type = enumeration_type
+        self.allow_empty = allow_empty
+
+        freeze
+      end
+
+      def validate!(output, options, **_opts)
+        validate_enumeration!(output, options) &&
+          validate_not_empty!(output, options) &&
+          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
+
+      def validate_enumeration!(output, options)
+        return true if enumeration_type === output # rubocop:disable Style/CaseEquality
+        raise ValidationError,
+              format(
+                'Expected collection as %<type>s, got %<actual>s at [%<backtrace>s]',
+                type: enumeration_type,
+                actual: output.inspect,
+                backtrace: options.backtrace.join('->')
+              )
+      end
+
+      def validate_not_empty!(output, options)
+        return true if allow_empty
+        return true if output.respond_to?(:length) && output.length.positive?
+        return true if output.respond_to?(:empty?) && !output.empty?
+
+        raise EmptyOutputError,
+              format(
+                'Expected collection to be not empty, got empty at [%<backtrace>s]',
+                backtrace: options.backtrace.join('->')
+              )
+      end
+
+      def validate_items!(output, options)
+        output.each_with_index.all? do |item, index|
+          next true if item_type === item # rubocop:disable Style/CaseEquality
+          if item_type.is_a?(Scheme)
+            item_type.validate(item, options.trace("[#{index}]"))
+            next true
+          end
+          raise ValidationError,
+                format(
+                  'Expected collection item as %<type>s, got %<actual>s at [%<backtrace>s]',
+                  type: item_type.inspect,
+                  actual: item.inspect,
+                  backtrace: options.backtrace.join('->')
+                )
+        end
+      end
+
+    end
+  end
+end

data/lib/media_types/scheme/errors.rb

@@ -1,87 +1,87 @@
-# frozen_string_literal: true
-
-module MediaTypes
-  class Scheme
-    class ConflictingTypeDefinitionError < ArgumentError; end
-
-    # Base class for all validations errors
-    class ValidationError < ArgumentError; end
-
-    # Raised when trying to register an attribute with a non-string key
-    class KeyTypeError < ArgumentError; end
-
-    # Raised when trying to register a key twice
-    class DuplicateKeyError < ArgumentError; end
-
-    class DuplicateSymbolKeyError < DuplicateKeyError
-      MESSAGE_TEMPLATE = '%<rule_type>s rule with key :%<key>s has already been defined. Please remove one of the two.'
-
-      def initialize(rule_type, key)
-        super(format(MESSAGE_TEMPLATE, rule_type: rule_type, key: key))
-      end
-    end
-
-    class DuplicateStringKeyError < DuplicateKeyError
-      MESSAGE_TEMPLATE = '%<rule_type>s rule with key %<key>s has already been defined. Please remove one of the two.'
-
-      def initialize(rule_type, key)
-        super(format(MESSAGE_TEMPLATE, { rule_type: rule_type, key: key }))
-      end
-    end
-
-    class StringOverwritingSymbolError < DuplicateKeyError
-      MESSAGE_TEMPLATE = 'Trying to add %<rule_type>s rule String key %<key>s while a Symbol with the same name already exists. Please remove one of the two.'
-
-      def initialize(rule_type, key)
-        super(format(MESSAGE_TEMPLATE, { rule_type: rule_type, key: key }))
-      end
-    end
-
-    class SymbolOverwritingStringError < DuplicateKeyError
-      MESSAGE_TEMPLATE = 'Trying to add %<rule_type>s rule with Symbol key :%<key>s while a String key with the same name already exists. Please remove one of the two.'
-
-      def initialize(rule_type, key)
-        super(format(MESSAGE_TEMPLATE, { rule_type: rule_type, key: key }))
-      end
-    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
-
-    # Raised when trying to override a non default rule scheme in the Rules Hash's default object method
-    class OverwritingRuleError < ArgumentError; end
-
-    class DuplicateAnyRuleError < OverwritingRuleError
-      def message
-        "An 'any' rule has already been defined. Please remove one of the two."
-      end
-    end
-
-    class DuplicateNotStrictRuleError < OverwritingRuleError
-      def message
-        "The 'not_strict' rule has already been defined. Please remove one of the two."
-      end
-    end
-
-    class NotStrictOverwritingAnyError < OverwritingRuleError
-      def message
-        "An 'any' rule has already been defined. Setting 'not_strict' will override that rule. Please remove one of the two."
-      end
-    end
-
-    class AnyOverwritingNotStrictError < OverwritingRuleError
-      def message
-        "The 'not_strict' rule has already been defined. Setting 'any' will override that rule. Please remove one of the two."
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module MediaTypes
+  class Scheme
+    class ConflictingTypeDefinitionError < ArgumentError; end
+
+    # Base class for all validations errors
+    class ValidationError < ArgumentError; end
+
+    # Raised when trying to register an attribute with a non-string key
+    class KeyTypeError < ArgumentError; end
+
+    # Raised when trying to register a key twice
+    class DuplicateKeyError < ArgumentError; end
+
+    class DuplicateSymbolKeyError < DuplicateKeyError
+      MESSAGE_TEMPLATE = '%<rule_type>s rule with key :%<key>s has already been defined. Please remove one of the two.'
+
+      def initialize(rule_type, key)
+        super(format(MESSAGE_TEMPLATE, rule_type: rule_type, key: key))
+      end
+    end
+
+    class DuplicateStringKeyError < DuplicateKeyError
+      MESSAGE_TEMPLATE = '%<rule_type>s rule with key %<key>s has already been defined. Please remove one of the two.'
+
+      def initialize(rule_type, key)
+        super(format(MESSAGE_TEMPLATE, { rule_type: rule_type, key: key }))
+      end
+    end
+
+    class StringOverwritingSymbolError < DuplicateKeyError
+      MESSAGE_TEMPLATE = 'Trying to add %<rule_type>s rule String key %<key>s while a Symbol with the same name already exists. Please remove one of the two.'
+
+      def initialize(rule_type, key)
+        super(format(MESSAGE_TEMPLATE, { rule_type: rule_type, key: key }))
+      end
+    end
+
+    class SymbolOverwritingStringError < DuplicateKeyError
+      MESSAGE_TEMPLATE = 'Trying to add %<rule_type>s rule with Symbol key :%<key>s while a String key with the same name already exists. Please remove one of the two.'
+
+      def initialize(rule_type, key)
+        super(format(MESSAGE_TEMPLATE, { rule_type: rule_type, key: key }))
+      end
+    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
+
+    # Raised when trying to override a non default rule scheme in the Rules Hash's default object method
+    class OverwritingRuleError < ArgumentError; end
+
+    class DuplicateAnyRuleError < OverwritingRuleError
+      def message
+        "An 'any' rule has already been defined. Please remove one of the two."
+      end
+    end
+
+    class DuplicateNotStrictRuleError < OverwritingRuleError
+      def message
+        "The 'not_strict' rule has already been defined. Please remove one of the two."
+      end
+    end
+
+    class NotStrictOverwritingAnyError < OverwritingRuleError
+      def message
+        "An 'any' rule has already been defined. Setting 'not_strict' will override that rule. Please remove one of the two."
+      end
+    end
+
+    class AnyOverwritingNotStrictError < OverwritingRuleError
+      def message
+        "The 'not_strict' rule has already been defined. Setting 'any' will override that rule. Please remove one of the two."
+      end
+    end
+  end
+end

data/lib/media_types/scheme/links.rb

@@ -1,54 +1,54 @@
-# frozen_string_literal: true
-
-require 'media_types/scheme/rules'
-require 'media_types/scheme/rules_exhausted_guard'
-
-module MediaTypes
-  class Scheme
-    class Links
-      def initialize
-        self.links = Rules.new(allow_empty: false, expected_type: ::Hash)
-      end
-
-      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
-        )
-
-        self
-      end
-
-      def validate!(output, options, **_opts)
-        RulesExhaustedGuard.call(output, options, rules: links)
-      end
-
-      def inspect
-        "[Scheme::Links #{links.keys}]"
-      end
-
-      def run_fixture_validations(expect_symbol_keys, backtrace = [])
-        fixture_errors = @links.flat_map {|key, rule|
-          if rule.is_a?(Scheme)
-            begin
-              rule.run_fixture_validations(expect_symbol_keys, backtrace.dup.append(key))
-              nil
-            rescue AssertionError => e
-              e.fixture_errors
-            end
-          end
-        }.compact
-
-        raise AssertionError.new(fixture_errors) unless fixture_errors.empty?
-      end
-
-      private
-
-      attr_accessor :links
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'media_types/scheme/rules'
+require 'media_types/scheme/rules_exhausted_guard'
+
+module MediaTypes
+  class Scheme
+    class Links
+      def initialize
+        self.links = Rules.new(allow_empty: false, expected_type: ::Hash)
+      end
+
+      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
+        )
+
+        self
+      end
+
+      def validate!(output, options, **_opts)
+        RulesExhaustedGuard.call(output, options, rules: links)
+      end
+
+      def inspect
+        "[Scheme::Links #{links.keys}]"
+      end
+
+      def run_fixture_validations(expect_symbol_keys, backtrace = [])
+        fixture_errors = @links.flat_map {|key, rule|
+          if rule.is_a?(Scheme)
+            begin
+              rule.run_fixture_validations(expect_symbol_keys, backtrace.dup.append(key))
+              nil
+            rescue AssertionError => e
+              e.fixture_errors
+            end
+          end
+        }.compact
+
+        raise AssertionError.new(fixture_errors) unless fixture_errors.empty?
+      end
+
+      private
+
+      attr_accessor :links
+    end
+  end
+end