media_types 0.4.1 → 0.5.0

data/lib/media_types/constructable.rb

@@ -3,6 +3,8 @@
 require 'delegate'
 require 'singleton'
 
+require 'media_types/formatter'
+
 module MediaTypes
   class Constructable < SimpleDelegator
 
@@ -13,22 +15,22 @@ module MediaTypes
 
     def type(name = NO_ARG)
       return opts[:type] if name == NO_ARG
-      Constructable.new(__getobj__, **with(type: name))
+      with(type: name)
     end
 
     def version(version = NO_ARG)
       return opts[:version] if version == NO_ARG
-      Constructable.new(__getobj__, **with(version: version))
+      with(version: version)
     end
 
     def view(view = NO_ARG)
       return opts[:view] if view == NO_ARG
-      Constructable.new(__getobj__, **with(view: view))
+      with(view: view)
     end
 
     def suffix(suffix = NO_ARG)
       return opts[:suffix] if suffix == NO_ARG
-      Constructable.new(__getobj__, **with(suffix: suffix))
+      with(suffix: suffix)
     end
 
     def collection
@@ -79,13 +81,7 @@ module MediaTypes
       # TODO: remove warning by slicing out these arguments if they don't appear in the format
       qualified(
         qualifier,
-        format(
-          opts.fetch(:format),
-          version: opts.fetch(:version),
-          suffix: opts.fetch(:suffix) { :json },
-          type: opts.fetch(:type),
-          view: format_view(opts[:view])
-        )
+        Formatter.call(opts)
       )
     end
 
@@ -123,16 +119,16 @@ module MediaTypes
     attr_accessor :opts
 
     def with(more_opts)
-      Hash(opts).clone.merge(more_opts)
+      merged_options = Kernel::Hash(opts).clone.tap do |cloned|
+        cloned.merge!(more_opts)
+      end
+
+      Constructable.new(__getobj__, **merged_options)
     end
 
     def qualified(qualifier, media_type)
       return media_type unless qualifier
       format('%<media_type>s; q=%<q>s', media_type: media_type, q: qualifier)
     end
-
-    def format_view(view)
-      MediaTypes::Object.new(view).present? && ".#{view}" || ''
-    end
   end
 end

data/lib/media_types/dsl.rb

@@ -48,6 +48,13 @@ module MediaTypes
       private
 
       def media_type(name, defaults: {})
+
+        unless defined?(:base_format)
+          define_method(:base_format) do
+            raise format('Implement the class method "base_format" in %<klass>s', klass: self)
+          end
+        end
+
         self.media_type_constructable = Constructable.new(self, format: base_format, type: name)
                                                      .version(defaults.fetch(:version) { nil })
                                                      .suffix(defaults.fetch(:suffix) { nil })

data/lib/media_types/formatter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'media_types/object'
+
+module MediaTypes
+  class Formatter < DelegateClass(Hash)
+
+    class << self
+      def call(*args, **options)
+        new(*args, **options).call
+      end
+    end
+
+    def call
+      filtered_arguments = arguments
+      return template if MediaTypes::Object.new(filtered_arguments).empty?
+
+      format(rework_template(filtered_arguments), filtered_arguments)
+    end
+
+    private
+
+    def template
+      fetch(:format)
+    end
+
+    def rework_template(filtered_arguments)
+      filtered_arguments.reduce(template) do |reworked, (key, value)|
+        next reworked if MediaTypes::Object.new(value).present?
+        start_of_template_variable = "%<#{key}>"
+
+        # noinspection RubyBlockToMethodReference
+        reworked.gsub("[\\.+](#{start_of_template_variable})") { start_of_template_variable }
+      end
+    end
+
+    def format_view(view)
+      MediaTypes::Object.new(view).present? && ".#{view}" || ''
+    end
+
+    def arguments
+      # noinspection RubyBlockToMethodReference
+      {
+        version: self[:version],
+        suffix: self[:suffix],
+        type: self[:type],
+        view: self[:view]
+      }.select { |argument,| argument_present?(argument) }
+    end
+
+    def argument_present?(argument)
+      template.include?("%<#{argument}>")
+    end
+  end
+end

data/lib/media_types/scheme.rb

@@ -2,6 +2,8 @@
 
 require 'media_types/scheme/validation_options'
 require 'media_types/scheme/enumeration_context'
+require 'media_types/scheme/errors'
+require 'media_types/scheme/rules'
 
 require 'media_types/scheme/allow_nil'
 require 'media_types/scheme/any_of'
@@ -11,6 +13,12 @@ require 'media_types/scheme/links'
 require 'media_types/scheme/missing_validation'
 require 'media_types/scheme/not_strict'
 
+require 'media_types/scheme/output_empty_guard'
+require 'media_types/scheme/output_type_guard'
+require 'media_types/scheme/rules_exhausted_guard'
+
+require 'awesome_print'
+
 module MediaTypes
   ##
   # Media Type Schemes can validate content to a media type, by itself. Used by the `validations` dsl.
@@ -35,35 +43,16 @@ module MediaTypes
   #
   class Scheme
 
-    # Base class for all validations errors
-    class ValidationError < ArgumentError; end
-
-    # Raised when it expected more data but there wasn't any left
-    class ExhaustedOutputError < ValidationError; 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 collection type
-    class CollectionTypeError < ValidationError; end
-
     ##
     # Creates a new scheme
     #
     # @param [TrueClass, FalseClass] allow_empty if true allows to be empty, if false raises EmptyOutputError if empty
-    # @param [NilClass, Class] force forces the type to be this type, if given
+    # @param [NilClass, Class] expected_type forces the type to be this type, if given
     #
     # @see MissingValidation
     #
-    def initialize(allow_empty: false, force: nil, &block)
-      self.validations = {}
-      self.allow_empty = allow_empty
-      self.force = force
-
-      validations.default = MissingValidation.new
+    def initialize(allow_empty: false, expected_type: ::Object, &block)
+      self.rules = Rules.new(allow_empty: allow_empty, expected_type: expected_type)
 
       instance_exec(&block) if block_given?
     end
@@ -116,19 +105,9 @@ module MediaTypes
     # @private
     #
     def validate!(output, call_options, **_opts)
-      empty_guard!(output, call_options)
-
-      exhaustive_guard!(validations.keys, call_options) do |mark|
-        all?(output, call_options) do |key, value, options:, context:|
-          mark.call(key)
-
-          validations[key].validate!(
-            value,
-            options.trace(key),
-            context: context
-          )
-        end
-      end
+      OutputTypeGuard.call(output, call_options, rules: rules)
+      OutputEmptyGuard.call(output, call_options, rules: rules)
+      RulesExhaustedGuard.call(output, call_options, rules: rules)
     end
 
     ##
@@ -171,16 +150,16 @@ module MediaTypes
     #   MyMedia.valid?({ foo: { bar: 'my-string' }})
     #   # => true
     #
-    def attribute(key, type = String, **opts, &block)
+    def attribute(key, type = String, optional: false, **opts, &block)
       if block_given?
-        return collection(key, force: ::Hash, **opts, &block)
+        return collection(key, expected_type: ::Hash, **opts, &block)
       end
 
       if type.is_a?(Scheme)
-        return validations[String(key)] = type
+        return rules.add(key, type, optional: optional)
       end
 
-      validations[String(key)] = Attribute.new(type, **opts, &block)
+      rules.add(key, Attribute.new(type, **opts, &block), optional: optional)
     end
 
     ##
@@ -189,7 +168,7 @@ module MediaTypes
     #
     # @param [Scheme, NilClass] scheme scheme to use if no +&block+ is given
     # @param [TrueClass, FalseClass] allow_empty if true, empty (no key/value present) is allowed
-    # @param [Class] force forces the validated object to have this type
+    # @param [Class] expected_type forces the validated object to have this type
     #
     # @see Scheme
     #
@@ -210,12 +189,29 @@ module MediaTypes
     #   MyMedia.valid?({ foo: [{ anything: { bar: 'my-string' }, other_thing: { bar: 'other-string' } }] })
     #   # => true
     #
-    def any(scheme = nil, force: ::Hash, allow_empty: false, &block)
+    # @example Any key, but all of them String or Numeric
+    #
+    #   class MyMedia
+    #     include MediaTypes::Dsl
+    #
+    #     validations do
+    #       any AnyOf(String, Numeric)
+    #     end
+    #   end
+    #
+    #   MyMedia.valid?({ foo: 'my-string', bar: 42 })
+    #   # => true
+    #
+    def any(scheme = nil, expected_type: ::Hash, allow_empty: false, &block)
       unless block_given?
-        return validations.default = scheme
+        if scheme.is_a?(Scheme)
+          return rules.default = scheme
+        end
+
+        return rules.default = Attribute.new(scheme)
       end
 
-      validations.default = Scheme.new(allow_empty: allow_empty, force: force, &block)
+      rules.default = Scheme.new(allow_empty: allow_empty, expected_type: expected_type, &block)
     end
 
     ##
@@ -224,7 +220,7 @@ module MediaTypes
     # @param [Scheme] scheme the scheme to merge into this
     #
     def merge(scheme, &block)
-      self.validations = validations.merge(scheme.send(:validations).clone)
+      self.rules = rules.merge(scheme.send(:rules))
       instance_exec(&block) if block_given?
     end
 
@@ -250,7 +246,7 @@ module MediaTypes
     #   # => true
     #
     def not_strict
-      validations.default = NotStrict.new
+      rules.default = NotStrict.new
     end
 
     ##
@@ -260,7 +256,7 @@ module MediaTypes
     # @param [Symbol] key key of the collection (same as #attribute)
     # @param [NilClass, Scheme, Class] scheme scheme to use if no +&block+ is given, or type of each item in collection
     # @param [TrueClass, FalseClass] allow_empty if true accepts 0 items in an enumerable
-    # @param [Class] force forces the value of this collection to be this type, defaults to Array.
+    # @param [Class] expected_type forces the value of this collection to be this type, defaults to Array.
     #
     # @see Scheme
     #
@@ -293,20 +289,24 @@ module MediaTypes
     #   MyMedia.valid?({ foo: [{ required: 'test', number: 42 }, { required: 'other', number: 0 }] })
     #   # => true
     #
-    def collection(key, scheme = nil, allow_empty: false, force: Array, &block)
+    def collection(key, scheme = nil, allow_empty: false, expected_type: ::Array, optional: false, &block)
       unless block_given?
         if scheme.is_a?(Scheme)
-          return validations[String(key)] = scheme
+          return rules.add(key, scheme, optional: optional)
         end
 
-        return validations[String(key)] = EnumerationOfType.new(
-          scheme,
-          enumeration_type: force,
-          allow_empty: allow_empty
+        return rules.add(
+          key,
+          EnumerationOfType.new(
+            scheme,
+            enumeration_type: expected_type,
+            allow_empty: allow_empty
+          ),
+          optional: optional
         )
       end
 
-      validations[String(key)] = Scheme.new(allow_empty: allow_empty, force: force, &block)
+      rules.add(key, Scheme.new(allow_empty: allow_empty, expected_type: expected_type, &block), optional: optional)
     end
 
     ##
@@ -344,91 +344,19 @@ module MediaTypes
     #   # => true
     #
     def link(*args, **opts, &block)
-      validations.fetch('_links') do
+      rules.fetch(:_links) do
         Links.new.tap do |links|
-          validations['_links'] = links
+          rules.add(:_links, links)
         end
       end.link(*args, **opts, &block)
     end
 
-    private
-
-    attr_accessor :validations, :allow_empty, :force
-
-    ##
-    # Checks if the output is nil or empty
-    #
-    # @private
-    #
-    def empty_guard!(output, options)
-      return unless MediaTypes::Object.new(output).empty?
-      throw(:end, true) if allow_empty
-      raise_empty!(backtrace: options.backtrace)
-    end
-
-    ##
-    # Mimics Enumerable#all? with mandatory +&block+
-    #
-    def all?(enumerable, options, &block)
-      context = EnumerationContext.new(validations: validations)
-
-      if force && !(force === enumerable) # rubocop:disable Style/CaseEquality
-        raise_forced_type_error!(type: enumerable.class, backtrace: options.backtrace)
-      end
-
-      if enumerable.is_a?(Hash) || enumerable.respond_to?(:key)
-        return enumerable.all? do |key, value|
-          yield String(key), value, options: options, context: context.enumerate(key)
-        end
-      end
-
-      without_forcing_type do
-        enumerable.each_with_index.all? do |array_like_element, i|
-          all?(array_like_element, options.trace(i), &block)
-        end
-      end
-    end
-
-    def raise_forced_type_error!(type:, backtrace:)
-      raise CollectionTypeError, format(
-        'Expected a %<expected>s, got a %<actual>s at %<backtrace>s',
-        expected: force,
-        actual: type,
-        backtrace: backtrace.join('->')
-      )
-    end
-
-    def raise_empty!(backtrace:)
-      raise EmptyOutputError, format('Expected output, got empty at %<backtrace>s', backtrace: backtrace.join('->'))
-    end
-
-    def raise_exhausted!(backtrace:, missing_keys:)
-      raise ExhaustedOutputError, format(
-        'Missing keys in output: %<missing_keys>s at [%<backtrace>s]',
-        missing_keys: missing_keys,
-        backtrace: backtrace.join('->')
-      )
+    def inspect
+      "[Scheme]#{rules}[/Scheme]"
     end
 
-    def exhaustive_guard!(keys, options)
-      unless options.exhaustive
-        return yield(->(_) {})
-      end
-
-      exhaustive_keys = keys.clone.map(&:to_s)
-      # noinspection RubyScope
-      result = yield ->(key) { exhaustive_keys.delete(String(key)) }
-      return result if exhaustive_keys.empty?
-
-      raise_exhausted!(missing_keys: exhaustive_keys, backtrace: options.backtrace)
-    end
+    private
 
-    def without_forcing_type
-      before_force = force
-      self.force = nil
-      result = yield
-      self.force = before_force
-      result
-    end
+    attr_accessor :rules
   end
 end

data/lib/media_types/scheme/allow_nil.rb

@@ -4,22 +4,14 @@ require 'delegate'
 
 module MediaTypes
   class Scheme
-    class CaseEqualityWithNil < SimpleDelegator
-
-      # Same as the wrapped {Object#===}, but also allows for NilCLass
-      def ===(other)
-        other.nil? || super
-      end
-    end
-
     # noinspection RubyInstanceMethodNamingConvention
     ##
     # Allows the wrapped +klazz+ to be nil
     #
     # @param [Class] klazz the class that +it+ must be the if +it+ is not NilClass
-    # @return [CaseEqualityWithNil]
+    # @return [CaseEqualityWithList]
     def AllowNil(klazz) # rubocop:disable Naming/MethodName
-      CaseEqualityWithNil.new(klazz)
+      AnyOf(NilClass, klazz)
     end
   end
 end