media_types 1.0.0 → 2.1.1

data/lib/media_types/scheme/errors.rb

@@ -2,10 +2,49 @@
 
 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
 
@@ -17,5 +56,32 @@ module MediaTypes
 
     # 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

@@ -31,6 +31,21 @@ module MediaTypes
         "[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

data/lib/media_types/scheme/missing_validation.rb

@@ -9,18 +9,21 @@ 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.rules, backtrace: options.backtrace)
+        raise_strict!(key: context.key, strict_keys: context.rules, backtrace: options.backtrace, found: options.scoped_output)
       end
 
-      def raise_strict!(key:, backtrace:, strict_keys:)
+      def raise_strict!(key:, backtrace:, strict_keys:, found:)
         raise StrictValidationError, format(
           "Unknown key %<key>s in data.\n" \
           "\tFound at: %<backtrace>s\n" \
           "\tExpected:\n\n" \
-          '%<strict_keys>s',
+          "%<strict_keys>s\n\n" \
+          "\tBut I Found:\n\n" \
+          '%<found>s',
           key: key.inspect,
           backtrace: backtrace.join('->'),
-          strict_keys: strict_keys.inspect(1)
+          strict_keys: keys_to_str(strict_keys.keys),
+          found: (found.respond_to? :keys) ? keys_to_str(found.keys) : found.class.name
         )
       end
 
@@ -28,6 +31,11 @@ module MediaTypes
         '((raise when strict))'
       end
 
+      def keys_to_str(keys)
+        converted = keys.map { |k| k.is_a?(Symbol) ? ":#{k}" : "'#{k}'" }
+        "[#{converted.join ', '}]"
+      end
+
     end
   end
 end

data/lib/media_types/scheme/output_empty_guard.rb

@@ -21,7 +21,7 @@ module MediaTypes
       def call
         return unless MediaTypes::Object.new(output).empty?
         throw(:end, true) if allow_empty?
-        raise_empty!(backtrace: options.backtrace)
+        raise_empty!(backtrace: options.backtrace, found: options.scoped_output)
       end
 
       private
@@ -32,11 +32,12 @@ module MediaTypes
         rules.allow_empty? || rules.required.empty?
       end
 
-      def raise_empty!(backtrace:)
+      def raise_empty!(backtrace:, found:)
         raise EmptyOutputError, format(
-          'Expected output, got empty at %<backtrace>s. Required are: %<required>s.',
+          'Expected output, got empty at %<backtrace>s. Required are: %<required>s. Found: %<found>s',
           backtrace: backtrace.join('->'),
-          required: rules.required.keys
+          required: rules.required.keys,
+          found: (found.is_a? Hash) ? found.keys : found.class.name,
         )
       end
     end

data/lib/media_types/scheme/output_iterator_with_predicate.rb

@@ -26,7 +26,11 @@ module MediaTypes
           return iterate_hash { |*args, **opts| yield(*args, **opts) }
         end
 
-        iterate { |*args, **opts| yield(*args, **opts) }
+        if array?
+          return iterate { |*args, **opts| yield(*args, **opts) }
+        end
+
+        raise "Internal consistency error, unexpected: #{enumerable.class}"
       end
 
       private
@@ -37,6 +41,10 @@ module MediaTypes
         enumerable.is_a?(::Hash) || enumerable.respond_to?(:key)
       end
 
+      def array?
+        enumerable.is_a?(::Array)
+      end
+
       def iterate_hash
         context = EnumerationContext.new(rules: rules)
 
@@ -46,7 +54,10 @@ module MediaTypes
       end
 
       def iterate(&block)
-        Array(enumerable).each_with_index.all? do |array_like_element, i|
+        hash_rule = Rules.new(allow_empty: false, expected_type: ::Hash)
+
+        enumerable.each_with_index.all? do |array_like_element, i|
+          OutputTypeGuard.call(array_like_element, options.trace(1), rules: hash_rule)
           OutputIteratorWithPredicate.call(array_like_element, options.trace(i), rules: rules, &block)
         end
       end

data/lib/media_types/scheme/output_type_guard.rb

@@ -28,7 +28,7 @@ module MediaTypes
 
       def raise_type_error!(type:, backtrace:)
         raise OutputTypeMismatch, format(
-          'Expected a %<expected>s, got a %<actual>s at %<backtrace>s',
+          'Expected %<expected>s, got %<actual>s at %<backtrace>s',
           expected: expected_type,
           actual: type,
           backtrace: backtrace.join('->')

data/lib/media_types/scheme/rules.rb

@@ -14,6 +14,7 @@ module MediaTypes
         self.allow_empty = allow_empty
         self.expected_type = expected_type
         self.optional_keys = []
+        self.original_key_type = {}
 
         self.default = MissingValidation.new
       end
@@ -27,13 +28,44 @@ module MediaTypes
       end
 
       def add(key, val, optional: false)
+        validate_input(key, val)
+
         normalized_key = normalize_key(key)
         __getobj__[normalized_key] = val
         optional_keys << normalized_key if optional
+        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
@@ -105,12 +137,32 @@ module MediaTypes
         ].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, :optional_keys
+      attr_accessor :allow_empty, :optional_keys, :original_key_type
       attr_writer :expected_type
 
       def normalize_key(key)

data/lib/media_types/scheme/rules_exhausted_guard.rb

@@ -31,11 +31,21 @@ module MediaTypes
         result = iterate(->(key) { required_rules.remove(key) })
         return result if required_rules.empty?
 
-        raise_exhausted!(missing_keys: required_rules.keys, backtrace: options.backtrace)
+        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!(
@@ -50,11 +60,12 @@ module MediaTypes
 
       attr_accessor :rules, :options, :output
 
-      def raise_exhausted!(missing_keys:, backtrace:)
+      def raise_exhausted!(missing_keys:, backtrace:, found:)
         raise ExhaustedOutputError, format(
-          'Missing keys in output: %<missing_keys>s at [%<backtrace>s]',
+          'Missing keys in output: %<missing_keys>s at [%<backtrace>s]. I did find: %<found>s',
           missing_keys: missing_keys,
-          backtrace: backtrace.join('->')
+          backtrace: backtrace.join('->'),
+          found: (found.is_a? Hash) ? found.keys : found.class.name,
         )
       end
     end

data/lib/media_types/scheme/validation_options.rb

@@ -3,20 +3,32 @@
 module MediaTypes
   class Scheme
     class ValidationOptions
-      attr_accessor :exhaustive, :strict, :backtrace
+      attr_accessor :exhaustive, :strict, :backtrace, :context, :expected_key_type
 
-      def initialize(exhaustive: true, strict: true, backtrace: [])
+      def initialize(context = {}, exhaustive: true, strict: true, backtrace: [], expected_key_type:)
         self.exhaustive = exhaustive
         self.strict = strict
         self.backtrace = backtrace
+        self.context = context
+        self.expected_key_type = expected_key_type
       end
 
       def inspect
-        "backtrack: #{backtrace.inspect}, strict: #{strict.inspect}, exhaustive: #{exhaustive}"
+        "backtrack: #{backtrace.inspect}, strict: #{strict.inspect}, 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(exhaustive: exhaustive, strict: strict, backtrace: backtrace)
+        ValidationOptions.new(context, exhaustive: exhaustive, strict: strict, backtrace: backtrace, expected_key_type: expected_key_type)
       end
 
       def trace(*traces)
@@ -24,7 +36,7 @@ module MediaTypes
       end
 
       def exhaustive!
-        ValidationOptions.new(exhaustive: true, strict: strict, backtrace: backtrace)
+        ValidationOptions.new(context, exhaustive: true, strict: strict, backtrace: backtrace, expected_key_type: expected_key_type)
       end
     end
   end

data/lib/media_types/testing/assertions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MediaTypes
+  module Testing
+    module Assertions
+      def assert_media_type_format(media_type, output, **opts)
+        return pass unless media_type.validatable?
+
+        assert media_type.validate!(output, **opts)
+      end
+
+      def assert_mediatype(mediatype)
+        mediatype.assert_sane!
+        assert mediatype.media_type_validations.scheme.asserted_sane?
+      rescue MediaTypes::AssertionError => e
+        flunk e.message
+      end
+    end
+  end
+end

data/lib/media_types/validations.rb

@@ -12,6 +12,8 @@ module MediaTypes
   #
   class Validations
 
+    attr_reader :scheme
+
     ##
     # Creates a new stack of validations
     #
@@ -44,14 +46,29 @@ module MediaTypes
       end
     end
 
-    def method_missing(method_name, *arguments, &block)
-      if scheme.respond_to?(method_name)
-        media_type.__getobj__.media_type_combinations.add(media_type.as_key)
-      
-        return scheme.send(method_name, *arguments, &block)
+
+    if Gem::Version.new(RUBY_VERSION) > Gem::Version.new('2.7.0')
+      def method_missing(method_name, *arguments, **kwargs, &block)
+        if scheme.respond_to?(method_name)
+          media_type.__getobj__.media_type_combinations ||= Set.new
+          media_type.__getobj__.media_type_combinations.add(media_type.as_key)
+
+          return scheme.send(method_name, *arguments, **kwargs, &block)
+        end
+
+        super
       end
+    else
+      def method_missing(method_name, *arguments, &block)
+        if scheme.respond_to?(method_name)
+          media_type.__getobj__.media_type_combinations ||= Set.new
+          media_type.__getobj__.media_type_combinations.add(media_type.as_key)
 
-      super
+          return scheme.send(method_name, *arguments, &block)
+        end
+
+        super
+      end
     end
 
     def respond_to_missing?(method_name, include_private = false)
@@ -60,7 +77,8 @@ module MediaTypes
 
     private
 
-    attr_accessor :media_type, :registry, :scheme
+    attr_accessor :media_type, :registry
+    attr_writer :scheme
 
     ##
     # Switches the inner block to a specific version
@@ -79,5 +97,9 @@ module MediaTypes
     def view(view, &block)
       Validations.new(media_type.view(view), registry, &block)
     end
+
+    def suffix(name)
+      scheme.type_attributes[:suffix] = name
+    end
   end
 end