media_types 2.0.1 → 2.1.0

data/lib/media_types.rb

@@ -7,6 +7,7 @@ require 'media_types/hash'
 require 'media_types/object'
 require 'media_types/scheme'
 require 'media_types/dsl'
+require 'media_types/errors'
 
 require 'media_types/views'
 
@@ -16,14 +17,57 @@ module MediaTypes
     @organisation_prefixes[mod.name] = organisation
   end
 
+  def self.expect_string_keys(mod)
+    set_key_expectation(mod, false)
+  end
+
+  def self.expect_symbol_keys(mod)
+    set_key_expectation(mod, true)
+  end
+
+  # Keep track of modules setting their key expectations
+  def self.set_key_expectation(mod, expect_symbol_keys)
+    @key_expectations ||= {}
+    @key_expectations_used ||= {}
+
+    raise KeyExpectationSetError.new(mod: mod) unless @key_expectations[mod.name].nil?
+    raise KeyExpectationUsedError.new(mod: mod) if @key_expectations_used[mod.name]
+
+    @key_expectations[mod.name] = expect_symbol_keys
+  end
+
+  SYMBOL_KEYS_DEFAULT = true
+
+  def self.get_key_expectation(mod)
+    @key_expectations ||= {}
+    @key_expectations_used ||= {}
+
+    expect_symbol = find_key_expectation(mod)
+
+    expect_symbol.nil? ? SYMBOL_KEYS_DEFAULT : expect_symbol
+  end
+
+  def self.find_key_expectation(mod)
+    modules = mod.name.split('::')
+    expect_symbol = nil
+
+    while modules.any? && expect_symbol.nil?
+      current_module = modules.join('::')
+      expect_symbol = @key_expectations[current_module]
+      @key_expectations_used[current_module] = true
+      modules.pop
+    end
+
+    expect_symbol
+  end
+
   def self.get_organisation(mod)
     name = mod.name
     prefixes = @organisation_prefixes.keys.select { |p| name.start_with? p }
     return nil unless prefixes.any?
+
     best = prefixes.max_by { |p| p.length }
 
     @organisation_prefixes[best]
   end
 end
-
-

data/lib/media_types/constructable.rb

@@ -76,7 +76,13 @@ module MediaTypes
       as_key.hash
     end
 
+    def override_suffix(suffix)
+      with(suffix: suffix)
+    end
+
     def suffix
+      return opts[:suffix] if opts.key?(:suffix)
+
       schema = schema_for(self)
       schema.type_attributes.fetch(:suffix, 'json')
     end
@@ -92,7 +98,7 @@ module MediaTypes
         )
       )
     end
-    
+
     def available_validations
       return [] if !validatable?
       [self]
@@ -120,7 +126,7 @@ module MediaTypes
 
     def validatable?
       return false unless media_type_combinations.include? as_key
-      
+
       __getobj__.validatable?(self)
     end
 

data/lib/media_types/dsl.rb

@@ -3,44 +3,61 @@
 require 'media_types/constructable'
 require 'media_types/validations'
 
+require 'media_types/dsl/errors'
+
 module MediaTypes
   module Dsl
-
     def self.included(base)
       base.extend ClassMethods
       base.class_eval do
         class << self
-          attr_accessor :media_type_name_for, :media_type_combinations
+          attr_accessor :media_type_name_for, :media_type_combinations, :media_type_validations, :symbol_keys
 
           private
 
-          attr_accessor :media_type_constructable, :symbol_base, :media_type_registrar, :media_type_validations
+          attr_accessor :media_type_constructable, :symbol_base, :media_type_registrar
         end
         base.media_type_combinations = Set.new
       end
     end
 
     module ClassMethods
-
       def to_constructable
+        raise UninitializedConstructable if media_type_constructable.nil?
+
         media_type_constructable.dup.tap do |constructable|
           constructable.__setobj__(self)
         end
       end
 
+      def symbol_keys?
+        if symbol_keys.nil?
+          MediaTypes.get_key_expectation(self)
+        else
+          symbol_keys
+        end
+      end
+
+      def string_keys?
+        !symbol_keys?
+      end
+
       def valid?(output, **opts)
         to_constructable.valid?(output, **opts)
       end
 
       def valid_unsafe?(output, media_type = to_constructable, **opts)
+        opts[:expected_key_type] = string_keys? ? String : Symbol
         validations.find(media_type).valid?(output, backtrace: ['.'], **opts)
       end
-      
+
       def validate!(output, **opts)
+        assert_sane!
         to_constructable.validate!(output, **opts)
       end
 
       def validate_unsafe!(output, media_type = to_constructable, **opts)
+        opts[:expected_key_type] = string_keys? ? String : Symbol
         validations.find(media_type).validate(output, backtrace: ['.'], **opts)
       end
 
@@ -58,16 +75,17 @@ module MediaTypes
           registerable
         end
       end
-      
+
       def view(v)
         to_constructable.view(v)
       end
+
       def version(v)
         to_constructable.version(v)
       end
-      
+
       def identifier_format
-        self.media_type_name_for = Proc.new do |type:, view:, version:, suffix:|
+        self.media_type_name_for = proc do |type:, view:, version:, suffix:|
           yield(type: type, view: view, version: version, suffix: suffix)
         end
       end
@@ -77,7 +95,7 @@ module MediaTypes
       end
 
       def available_validations
-        self.media_type_combinations.map do |a|
+        media_type_combinations.map do |a|
           _, view, version = a
           view(view).version(version)
         end
@@ -87,18 +105,27 @@ module MediaTypes
         validations.find(constructable)
       end
 
+      def assert_sane!
+        return if media_type_validations.scheme.asserted_sane?
+
+        media_type_validations.run_fixture_validations(symbol_keys?)
+      end
+
       private
 
       def use_name(name)
-        if self.media_type_name_for.nil?
-          self.media_type_name_for = Proc.new do |type:, view:, version:, suffix:|
+        if media_type_name_for.nil?
+          self.media_type_name_for = proc do |type:, view:, version:, suffix:|
             resolved_org = nil
             if defined?(organisation)
               resolved_org = organisation
             else
-              resolved_org = MediaTypes::get_organisation(self)
+              resolved_org = MediaTypes.get_organisation(self)
 
-              raise format('Implement the class method "organisation" in %<klass>s or specify a global organisation using MediaTypes::set_organisation', klass: self) if resolved_org.nil?
+              if resolved_org.nil?
+              raise OrganisationNotSetError,
+                format('Implement the class method "organisation" in %<klass>s or specify a global organisation using MediaTypes::set_organisation', klass: self)
+              end
             end
             raise ArgumentError, 'Unable to create a name for a schema with a nil name.' if type.nil?
             raise ArgumentError, 'Unable to create a name for a schema with a nil organisation.' if resolved_org.nil?
@@ -113,15 +140,31 @@ module MediaTypes
         self.media_type_constructable = Constructable.new(self, type: name)
       end
 
+      def expect_string_keys
+        raise KeyTypeExpectationError, 'Key expectation already set' unless symbol_keys.nil?
+
+        self.symbol_keys = false
+      end
+
+      def expect_symbol_keys
+        raise KeyTypeExpectationError, 'Key expectation already set' unless symbol_keys.nil?
+
+        self.symbol_keys = true
+      end
+
       def validations(&block)
-        unless block_given?
-          raise "No validations defined for #{self.name}" if media_type_validations.nil?
-          return media_type_validations
-        end
+        return lookup_validations unless block_given?
+
         self.media_type_validations = Validations.new(to_constructable, &block)
 
         self
       end
+
+      def lookup_validations
+        raise MissingValidationError, "No validations defined for #{name}" if media_type_validations.nil?
+
+        media_type_validations
+      end
     end
   end
 end

data/lib/media_types/dsl/errors.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module MediaTypes
+  module Dsl
+    class UninitializedConstructable < RuntimeError
+      def message
+        'Unable to generate constructable without a name, make sure to have called `use_name(name)` before.'
+      end
+    end
+
+    # Raised when an error occurs during setting expected key type
+    class KeyTypeExpectationError < StandardError; end
+
+    class MissingValidationError < StandardError; end
+
+    class OrganisationNotSetError < StandardError; end
+  end
+end

data/lib/media_types/errors.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module MediaTypes
+  module Errors
+    # Raised when trying to set a module key expectation twice
+    class KeyExpectationSetError < StandardError
+      def initialize(mod:)
+        super(format('%<mod>s already has a key expectation set', mod: mod.name))
+      end
+    end
+
+    # Raised when trying to set a module key expectation while default expectation already used
+    class KeyExpectationUsedError < StandardError
+      def initialize(mod:)
+        super(format('Unable to change key type expectation for %<mod>s since its current expectation is already used', mod: mod.name))
+      end
+    end
+  end
+end

data/lib/media_types/scheme.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 require 'media_types/scheme/validation_options'
 require 'media_types/scheme/enumeration_context'
 require 'media_types/scheme/errors'
@@ -17,10 +19,47 @@ require 'media_types/scheme/output_empty_guard'
 require 'media_types/scheme/output_type_guard'
 require 'media_types/scheme/rules_exhausted_guard'
 
-require 'json'
-
 module MediaTypes
   class AssertionError < StandardError
+    def initialize(errors)
+      @fixture_errors = errors
+    end
+
+    def message
+      fixture_errors.map(&:message).join(', ')
+    end
+
+    attr_reader :fixture_errors
+  end
+
+  class UnexpectedValidationResultError < StandardError
+    def initialize(fixture_caller, error)
+      self.fixture_caller = fixture_caller
+      self.error = error
+    end
+
+    def message
+      format(
+        '%<caller_path>s:%<caller_line>s -> %<error>s',
+        caller_path: fixture_caller.path,
+        caller_line: fixture_caller.lineno,
+        error: error.is_a?(MediaTypes::Scheme::ValidationError) ? "#{error.class}:#{error.message}" : error
+      )
+    end
+
+    attr_accessor :fixture_caller, :error
+  end
+
+  class FixtureData
+    def initialize(caller:, fixture:, expect_to_pass:)
+      self.caller = caller
+      self.fixture = fixture
+      self.expect_to_pass = expect_to_pass
+    end
+
+    attr_accessor :caller, :fixture, :expect_to_pass
+
+    alias expect_to_pass? expect_to_pass
   end
 
   ##
@@ -57,11 +96,16 @@ module MediaTypes
     def initialize(allow_empty: false, expected_type: ::Object, &block)
       self.rules = Rules.new(allow_empty: allow_empty, expected_type: expected_type)
       self.type_attributes = {}
+      self.fixtures = []
+      self.asserted_sane = false
 
       instance_exec(&block) if block_given?
     end
 
-    attr_accessor :type_attributes
+    attr_accessor :type_attributes, :fixtures
+    attr_reader :rules, :asserted_sane
+
+    alias asserted_sane? asserted_sane
 
     ##
     # Checks if the +output+ is valid
@@ -158,11 +202,10 @@ module MediaTypes
     #   MyMedia.valid?({ foo: { bar: 'my-string' }})
     #   # => true
     #
-    def attribute(key, type = ::Object, optional: false, **opts, &block)
-      raise KeyTypeError, "Unexpected key type #{key.class.name}, please use either a symbol or string." unless key.is_a?(String) || key.is_a?(Symbol)
-      raise DuplicateKeyError, "An attribute with key #{key.to_s} has already been defined. Please remove one of the two." if rules.has_key?(key)
-      raise DuplicateKeyError, "A string attribute with the same string representation as the symbol :#{key.to_s} already exists. Please remove one of the two." if key.is_a?(Symbol)&& rules.has_key?(key.to_s)
-      raise DuplicateKeyError, "A symbol attribute with the same string representation as the string '#{key}' already exists. Please remove one of the two." if key.is_a?(String) && rules.has_key?(key.to_sym)
+    def attribute(key, type = nil, optional: false, **opts, &block)
+      raise ConflictingTypeDefinitionError, 'You cannot apply a block to a non-hash typed attribute, either remove the type or the block' if type != ::Hash && block_given? && !type.nil?
+
+      type ||= ::Object
 
       if block_given?
         return collection(key, expected_type: ::Hash, optional: optional, **opts, &block)
@@ -216,6 +259,8 @@ module MediaTypes
     #   # => true
     #
     def any(scheme = nil, expected_type: ::Hash, allow_empty: false, &block)
+      raise ConflictingTypeDefinitionError, 'You cannot apply a block to a non-hash typed property, either remove the type or the block' if scheme != ::Hash && block_given? && !scheme.nil?
+
       unless block_given?
         if scheme.is_a?(Scheme)
           return rules.default = scheme
@@ -303,6 +348,8 @@ module MediaTypes
     #   # => true
     #
     def collection(key, scheme = nil, allow_empty: false, expected_type: ::Array, optional: false, &block)
+      raise ConflictingTypeDefinitionError, 'You cannot apply a block to a non-hash typed collection, either remove the type or the block' if scheme != ::Hash && block_given? && !scheme.nil?
+
       unless block_given?
         return rules.add(
           key,
@@ -385,24 +432,82 @@ module MediaTypes
     end
 
     def assert_pass(fixture)
-      json = JSON.parse(fixture, { symbolize_names: true })
-
-      validate(json)
+      reduced_stack = remove_current_dir_from_stack(caller_locations)
+      @fixtures << FixtureData.new(caller: reduced_stack.first, fixture: fixture, expect_to_pass: true)
     end
-    
+
     def assert_fail(fixture)
-      json = JSON.parse(fixture, { symbolize_names: true })
+      reduced_stack = remove_current_dir_from_stack(caller_locations)
+      @fixtures << FixtureData.new(caller: reduced_stack.first, fixture: fixture, expect_to_pass: false)
+    end
+
+    # Removes all calls originating in current dir from given stack
+    # We need this so that we find out the caller of an assert_pass/fail in the caller_locations
+    # Which gets polluted by Scheme consecutively executing blocks within the validation blocks
+    def remove_current_dir_from_stack(stack)
+      stack.reject { |location| location.path.include?(__dir__) }
+    end
+
+    def validate_scheme_fixtures(expect_symbol_keys, backtrace)
+      @fixtures.map do |fixture_data|
+        begin
+          validate_fixture(fixture_data, expect_symbol_keys, backtrace)
+          nil
+        rescue UnexpectedValidationResultError => e
+          e
+        end
+      end.compact
+    end
+
+    def validate_nested_scheme_fixtures(expect_symbol_keys, backtrace)
+      @rules.flat_map do |key, rule|
+        next unless rule.is_a?(Scheme) || rule.is_a?(Links)
+
+        begin
+          rule.run_fixture_validations(expect_symbol_keys, backtrace.dup.append(key))
+          nil
+        rescue AssertionError => e
+          e.fixture_errors
+        end
+      end.compact
+    end
+
+    def validate_default_scheme_fixtures(expect_symbol_keys, backtrace)
+      return [] unless @rules.default.is_a?(Scheme)
+
+      @rules.default.run_fixture_validations(expect_symbol_keys, backtrace.dup.append('*'))
+      []
+    rescue AssertionError => e
+      e.fixture_errors
+    end
+
+    def run_fixture_validations(expect_symbol_keys, backtrace = [])
+      fixture_errors = validate_scheme_fixtures(expect_symbol_keys, backtrace)
+      fixture_errors += validate_nested_scheme_fixtures(expect_symbol_keys, backtrace)
+      fixture_errors += validate_default_scheme_fixtures(expect_symbol_keys, backtrace)
+
+      raise AssertionError, fixture_errors unless fixture_errors.empty?
+
+      self.asserted_sane = true
+    end
+
+    def validate_fixture(fixture_data, expect_symbol_keys, backtrace = [])
+      json = JSON.parse(fixture_data.fixture, { symbolize_names: expect_symbol_keys })
+      expected_key_type = expect_symbol_keys ? Symbol : String
 
       begin
-        validate(json)
-      rescue MediaTypes::Scheme::ValidationError
-        return
+        validate(json, expected_key_type: expected_key_type, backtrace: backtrace)
+        unless fixture_data.expect_to_pass?
+          raise UnexpectedValidationResultError.new(fixture_data.caller, 'No error encounterd whilst expecting to')
+        end
+      rescue MediaTypes::Scheme::ValidationError => e
+        raise UnexpectedValidationResultError.new(fixture_data.caller, e) if fixture_data.expect_to_pass?
       end
-      raise AssertionError
     end
 
     private
 
-    attr_accessor :rules
+    attr_writer :rules, :asserted_sane
+
   end
 end