media_types 0.6.2 → 2.1.0

data/Rakefile

@@ -1,12 +1,12 @@
-# frozen_string_literal: true
-
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'test'
-  t.libs << 'lib'
-  t.test_files = FileList['test/**/*_test.rb']
-end
-
-task default: :test
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/lib/media_types.rb

@@ -7,11 +7,67 @@ require 'media_types/hash'
 require 'media_types/object'
 require 'media_types/scheme'
 require 'media_types/dsl'
+require 'media_types/errors'
 
 require 'media_types/views'
-require 'media_types/integrations'
 
 module MediaTypes
-end
+  def self.set_organisation(mod, organisation)
+    @organisation_prefixes ||= {}
+    @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

@@ -28,11 +28,6 @@ module MediaTypes
       with(view: view)
     end
 
-    def suffix(suffix = NO_ARG)
-      return opts[:suffix] if suffix == NO_ARG
-      with(suffix: suffix)
-    end
-
     def collection
       view(COLLECTION_VIEW)
     end
@@ -73,20 +68,46 @@ module MediaTypes
       to_str.split(pattern, *limit)
     end
 
+    def as_key
+      [type, view&.to_s, version]
+    end
+
     def hash
-      to_str.hash
+      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
 
     def to_str(qualifier = nil)
-      # TODO: remove warning by slicing out these arguments if they don't appear in the format
       qualified(
         qualifier,
-        Formatter.call(opts)
+        __getobj__.media_type_name_for.call(
+          type: opts[:type],
+          view: opts[:view],
+          version: opts[:version],
+          suffix: suffix
+        )
       )
     end
 
+    def available_validations
+      return [] if !validatable?
+      [self]
+    end
+
     def valid?(output, **validation_opts)
-      __getobj__.valid?(
+      raise ArgumentError, "Unable to validate #{to_s} type without a corresponding validation. Please mark objects that should be empty with 'empty'." unless validatable?
+
+      __getobj__.valid_unsafe?(
         output,
         self,
         **validation_opts
@@ -94,7 +115,9 @@ module MediaTypes
     end
 
     def validate!(output, **validation_opts)
-      __getobj__.validate!(
+      raise ArgumentError, "Unable to validate #{to_s} type without a corresponding validation. Please mark objects that should be empty with 'empty'." unless validatable?
+
+      __getobj__.validate_unsafe!(
         output,
         self,
         **validation_opts
@@ -102,11 +125,14 @@ module MediaTypes
     end
 
     def validatable?
+      return false unless media_type_combinations.include? as_key
+
       __getobj__.validatable?(self)
     end
 
     alias inspect to_str
     alias to_s to_str
+    alias identifier to_str
 
     private
 

data/lib/media_types/dsl.rb

@@ -1,43 +1,72 @@
 # frozen_string_literal: true
 
 require 'media_types/constructable'
-require 'media_types/defaults'
-require 'media_types/registrar'
 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, :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 valid?(output, media_type = to_constructable, **opts)
-        validations.find(String(media_type)).valid?(output, backtrace: ['.'], **opts)
+      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!(output, media_type = to_constructable, **opts)
-        validations.find(String(media_type)).validate(output, backtrace: ['.'], **opts)
+      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
 
       def validatable?(media_type = to_constructable)
         return false unless validations
 
-        validations.find(String(media_type), -> { nil })
+        resolved = validations.find(media_type, -> { nil })
+
+        !resolved.nil?
       end
 
       def register
@@ -47,43 +76,95 @@ module MediaTypes
         end
       end
 
-      private
+      def view(v)
+        to_constructable.view(v)
+      end
 
-      def media_type(name, defaults: {})
+      def version(v)
+        to_constructable.version(v)
+      end
 
-        unless defined?(:base_format)
-          define_method(:base_format) do
-            raise format('Implement the class method "base_format" in %<klass>s', klass: self)
-          end
+      def identifier_format
+        self.media_type_name_for = proc do |type:, view:, version:, suffix:|
+          yield(type: type, view: view, version: version, suffix: suffix)
         end
+      end
 
-        self.media_type_constructable = Constructable.new(self, format: base_format, type: name)
-                                                     .version(defaults.fetch(:version) { nil })
-                                                     .suffix(defaults.fetch(:suffix) { nil })
-                                                     .view(defaults.fetch(:view) { nil })
-        self
+      def identifier
+        to_constructable.to_s
       end
 
-      def defaults(&block)
-        return media_type_constructable unless block_given?
-        self.media_type_constructable = Defaults.new(to_constructable, &block).to_constructable
+      def available_validations
+        media_type_combinations.map do |a|
+          _, view, version = a
+          view(view).version(version)
+        end
+      end
 
-        self
+      def schema_for(constructable)
+        validations.find(constructable)
       end
 
-      def registrations(symbol = nil, &block)
-        return media_type_registrar unless block_given?
-        self.media_type_registrar = Registrar.new(self, symbol: symbol, &block)
+      def assert_sane!
+        return if media_type_validations.scheme.asserted_sane?
 
-        self
+        media_type_validations.run_fixture_validations(symbol_keys?)
+      end
+
+      private
+
+      def use_name(name)
+        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)
+
+              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?
+
+            result = "application/vnd.#{resolved_org}.#{type}"
+            result += ".v#{version}" unless version.nil?
+            result += ".#{view}" unless view.nil?
+            result += "+#{suffix}" unless suffix.nil?
+            result
+          end
+        end
+        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)
-        return media_type_validations unless block_given?
+        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'
@@ -18,6 +20,48 @@ require 'media_types/scheme/output_type_guard'
 require 'media_types/scheme/rules_exhausted_guard'
 
 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
+
   ##
   # Media Type Schemes can validate content to a media type, by itself. Used by the `validations` dsl.
   #
@@ -51,10 +95,18 @@ 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, :fixtures
+    attr_reader :rules, :asserted_sane
+
+    alias asserted_sane? asserted_sane
+
     ##
     # Checks if the +output+ is valid
     #
@@ -93,6 +145,7 @@ module MediaTypes
     #
     def validate(output, options = nil, **opts)
       options ||= ValidationOptions.new(**opts)
+      options.context = output
 
       catch(:end) do
         validate!(output, options, context: nil)
@@ -149,7 +202,11 @@ module MediaTypes
     #   MyMedia.valid?({ foo: { bar: 'my-string' }})
     #   # => true
     #
-    def attribute(key, type = ::Object, optional: false, **opts, &block)
+    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)
       end
@@ -202,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
@@ -289,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,
@@ -346,6 +407,21 @@ module MediaTypes
       end.link(*args, **opts, &block)
     end
 
+    ##
+    # Mark object as a valid empty object
+    #
+    # @example Empty object
+    #
+    #   class MyMedia
+    #     include MediaTypes::Dsl
+    #
+    #     validations do
+    #       empty
+    #     end
+    #   end
+    def empty
+    end
+
     def inspect(indentation = 0)
       tabs = '  ' * indentation
       [
@@ -355,8 +431,83 @@ module MediaTypes
       ].join("\n")
     end
 
+    def assert_pass(fixture)
+      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)
+      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, 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
+    end
+
     private
 
-    attr_accessor :rules
+    attr_writer :rules, :asserted_sane
+
   end
 end