typed_params 0.2.0

data/lib/typed_params/transforms/nilify_blanks.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'typed_params/transforms/transform'
+
+module TypedParams
+  module Transforms
+    class NilifyBlanks < Transform
+      def call(key, value)
+        return [key, value] if
+          value.is_a?(Array) || value.is_a?(Hash)
+
+        [key, value.blank? ? nil : value]
+      end
+    end
+  end
+end

data/lib/typed_params/transforms/noop.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'typed_params/transforms/transform'
+
+module TypedParams
+  module Transforms
+    class Noop < Transform
+      def call(*) = []
+    end
+  end
+end

data/lib/typed_params/transforms/transform.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Transforms
+    class Transform
+      def call(key, value) = raise NotImplementedError
+
+      def self.wrap(fn) = fn
+    end
+  end
+end

data/lib/typed_params/types/array.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:array,
+      accepts_block: true,
+      scalar: false,
+      coerce: -> v { v.is_a?(String) ? v.split(',') : Array(v) },
+      match: -> v { v.is_a?(Array) },
+    )
+  end
+end

data/lib/typed_params/types/boolean.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    module Boolean
+      COERCIBLE_TYPES = [String, Numeric].freeze
+      TRUTHY_VALUES   = [
+        1,
+        '1',
+        'true',
+        'TRUE',
+        't',
+        'T',
+        'yes',
+        'YES',
+        'y',
+        'Y',
+      ].freeze
+    end
+
+    register(:boolean,
+      coerce: -> v {
+        return nil unless
+          Boolean::COERCIBLE_TYPES.any? { v.is_a?(_1) }
+
+        v.in?(Boolean::TRUTHY_VALUES)
+      },
+      match: -> v {
+        v.is_a?(TrueClass) || v.is_a?(FalseClass)
+      },
+    )
+  end
+end

data/lib/typed_params/types/date.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:date,
+      coerce: -> v { v.blank? ? nil : v.to_date },
+      match: -> v { v.is_a?(Date) },
+    )
+  end
+end

data/lib/typed_params/types/decimal.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:decimal,
+      coerce: -> v { v.blank? ? nil : v.to_d },
+      match: -> v { v.is_a?(BigDecimal) },
+    )
+  end
+end

data/lib/typed_params/types/float.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:float,
+      coerce: -> v { v.blank? ? nil : v.to_f },
+      match: -> v { v.is_a?(Float) },
+    )
+  end
+end

data/lib/typed_params/types/hash.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:hash,
+      name: :object,
+      accepts_block: true,
+      scalar: false,
+      coerce: -> v { v.respond_to?(:to_h) ? v.to_h : {} },
+      match: -> v { v.is_a?(Hash) },
+    )
+  end
+end

data/lib/typed_params/types/integer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:integer,
+      coerce: -> v { v.blank? ? nil : v.to_i },
+      match: -> v { v.is_a?(Integer) },
+    )
+  end
+end

data/lib/typed_params/types/nil.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:nil,
+      name: :null,
+      coerce: -> v { nil },
+      match: -> v { v.nil? },
+    )
+  end
+end

data/lib/typed_params/types/number.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:number,
+      match: -> v { v.is_a?(Numeric) },
+      abstract: true,
+    )
+  end
+end

data/lib/typed_params/types/string.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:string,
+      coerce: -> v { v.to_s },
+      match: -> v { v.is_a?(String) },
+    )
+  end
+end

data/lib/typed_params/types/symbol.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:symbol,
+      coerce: -> v { v.to_sym },
+      match: -> v { v.is_a?(Symbol) },
+    )
+  end
+end

data/lib/typed_params/types/time.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    register(:time,
+      match: -> v { v.is_a?(Time) },
+      coerce: -> v {
+        return nil if
+          v.blank?
+
+        case
+        when v.to_s.match?(/\A\d+\z/)
+          Time.at(v.to_i)
+        else
+          v.to_time
+        end
+      },
+    )
+  end
+end

data/lib/typed_params/types/type.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Types
+    class Type
+      attr_reader :type,
+                  :name
+
+      def initialize(type:, name:, match:, coerce:, scalar:, abstract:, archetype:, accepts_block:)
+        raise ArgumentError, ':abstract not allowed with :archetype' if
+          abstract && archetype.present?
+
+        raise ArgumentError, ':abstract not allowed with :coerce' if
+          abstract && coerce.present?
+
+        raise ArgumentError, ':coerce must be callable' unless
+          coerce.nil? || coerce.respond_to?(:call)
+
+        raise ArgumentError, ':match must be callable' unless
+          match.respond_to?(:call)
+
+        @name          = name || type
+        @type          = type
+        @match         = match
+        @coerce        = coerce
+        @abstract      = abstract
+        @archetype     = archetype
+        @scalar        = scalar
+        @accepts_block = accepts_block
+      end
+
+      def archetype
+        return unless @archetype.present?
+
+        return @archetype if
+          @archetype.is_a?(Type)
+
+        Types[@archetype]
+      end
+
+      def accepts_block? = !!@accepts_block
+      def coercable?     = !!@coerce
+      def scalar?        = !!@scalar
+      def abstract?      = !!@abstract
+      def subtype?       = !!@archetype
+
+      # NOTE(ezekg) Using yoda-style self#== because value may be a Type, and
+      #             we're overriding Type#coerce, which is a Ruby core method
+      #             expected to return an [x, y] tuple, so v == self breaks.
+      def match?(v)    = self == v || !!@match.call(v)
+      def mismatch?(v) = !match?(v)
+
+      def humanize
+        if subtype?
+          "#{@name} #{archetype.humanize}"
+        else
+          @name.to_s
+        end
+      end
+
+      def to_sym = type.to_sym
+      def to_s   = type.to_s
+
+      def inspect
+        "#<#{self.class.name} type=#{@type.inspect} name=#{@name.inspect} abstract=#{@abstract.inspect} archetype=#{@archetype.inspect}>"
+      end
+
+      def coerce(value)
+        raise CoercionError, 'type is not coercable' unless
+          coercable?
+
+        @coerce.call(value)
+      rescue
+        raise CoercionError, "failed to coerce #{Types.for(value).name} to #{@name}"
+      end
+    end
+  end
+end

data/lib/typed_params/types.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'typed_params/types/type'
+
+module TypedParams
+  module Types
+    cattr_reader :registry,  default: []
+    cattr_reader :abstracts, default: {}
+    cattr_reader :subtypes,  default: {}
+    cattr_reader :types,     default: {}
+
+    def self.register(type, match:, name: nil, coerce: nil, archetype: nil, abstract: false, scalar: true, accepts_block: false)
+      raise ArgumentError, "type is already registered: #{type.inspect}" if
+        registry.include?(type)
+
+      registry << type
+
+      t = Type.new(type:, name:, match:, coerce:, archetype:, abstract:, scalar:, accepts_block:)
+      case
+      when abstract
+        abstracts[type] = t
+      when archetype
+        subtypes[type] = t
+      else
+        types[type] = t
+      end
+    end
+
+    def self.unregister(type)
+      return unless
+        registry.include?(type)
+
+      t = abstracts.delete(type) || subtypes.delete(type) || types.delete(type)
+
+      registry.delete(type) if
+        t.present?
+
+      t
+    end
+
+    def self.coerce(value, to:) = (subtypes[to] || types[to]).coerce(value)
+
+    def self.array?(value)  = types[:array].match?(value)
+    def self.hash?(value)   = types[:hash].match?(value)
+    def self.nil?(value)    = types[:nil].match?(value)
+    def self.scalar?(value) = self.for(value).scalar?
+
+    def self.[](key)
+      type = abstracts[key] ||
+             subtypes[key] ||
+             types[key]
+
+      raise ArgumentError, "invalid type: #{key.inspect}" if
+        type.nil?
+
+      type
+    end
+
+    def self.for(value, try: nil)
+      _, type = subtypes.slice(*try).find { |_, t| t.match?(value) } ||
+                types.find { |_, t| t.match?(value) }
+
+      raise ArgumentError, "cannot find type for value: #{value.inspect}" if
+        type.nil?
+
+      type
+    end
+  end
+end

data/lib/typed_params/validations/exclusion.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'typed_params/validations/validation'
+
+module TypedParams
+  module Validations
+    class Exclusion < Validation
+      def call(value)
+        raise ValidationError, 'is invalid' if
+          case options
+          in in: Range | Array => e
+            e.include?(value)
+          end
+      end
+    end
+  end
+end

data/lib/typed_params/validations/format.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'typed_params/validations/validation'
+
+module TypedParams
+  module Validations
+    class Format < Validation
+      def call(value)
+        raise ValidationError, 'format is invalid' unless
+          case options
+          in without: Regexp => rx
+            !rx.match?(value)
+          in with: Regexp => rx
+            rx.match?(value)
+          end
+      end
+    end
+  end
+end

data/lib/typed_params/validations/inclusion.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'typed_params/validations/validation'
+
+module TypedParams
+  module Validations
+    class Inclusion < Validation
+      def call(value)
+        raise ValidationError, 'is invalid' unless
+          case options
+          in in: Range | Array => e
+            e.include?(value)
+          end
+      end
+    end
+  end
+end

data/lib/typed_params/validations/length.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'typed_params/validations/validation'
+
+module TypedParams
+  module Validations
+    class Length < Validation
+      def call(value)
+        case options
+        in minimum: Numeric => n
+          raise ValidationError, "length must be greater than or equal to #{n}" unless
+            value.length >= n
+        in maximum: Numeric => n
+          raise ValidationError, "length must be less than or equal to #{n}" unless
+            value.length <= n
+        in within: Range | Array => e
+          raise ValidationError, "length must be between #{e.first} and #{e.last}" unless
+            e.include?(value.length)
+        in in: Range | Array => e
+          raise ValidationError, "length must be between #{e.first} and #{e.last}" unless
+            e.include?(value.length)
+        in is: Numeric => n
+          raise ValidationError, "length must be equal to #{n}" unless
+            value.length == n
+        end
+      end
+    end
+  end
+end

data/lib/typed_params/validations/validation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module TypedParams
+  module Validations
+    class Validation
+      def initialize(options) = @options = options
+      def call(value)         = raise NotImplementedError
+
+      def self.wrap(fn)
+        -> v { raise ValidationError, 'is invalid' unless fn.call(v) }
+      end
+
+      private
+
+      attr_reader :options
+    end
+  end
+end

data/lib/typed_params/validator.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'typed_params/mapper'
+
+module TypedParams
+  class Validator < Mapper
+    def call(params)
+      raise InvalidParameterError.new('is missing', path: schema.path, source: schema.source) if
+        params.nil? && schema.required? && !schema.allow_nil?
+
+      depth_first_map(params) do |param|
+        schema = param.schema
+        type   = Types.for(param.value,
+          try: schema.type.subtype? ? schema.type.to_sym : nil,
+        )
+
+        raise InvalidParameterError.new("type mismatch (received unknown expected #{schema.type.humanize})", path: param.path, source: schema.source) if
+          type.nil?
+
+        # Handle nils early on
+        if Types.nil?(type)
+          raise InvalidParameterError.new('cannot be null', path: param.path, source: schema.source) unless
+            schema.optional? && TypedParams.config.ignore_nil_optionals ||
+            schema.allow_nil?
+
+          next
+        end
+
+        # Assert type
+        raise InvalidParameterError.new("type mismatch (received #{type.humanize} expected #{schema.type.humanize})", path: param.path, source: schema.source) unless
+          type == schema.type || type.subtype? && type.archetype == schema.type
+
+        # Assertions for params without children
+        if schema.children.nil?
+          # Assert non-scalars only contain scalars (unless allowed)
+          case
+          when schema.hash?
+            param.value.each do |key, value|
+              next if
+                Types.scalar?(value)
+
+              raise InvalidParameterError.new('unpermitted type (expected object of scalar types)', path: Path.new(*param.path.keys, key), source: schema.source) unless
+                schema.allow_non_scalars?
+            end
+          when schema.array?
+            param.value.each_with_index do |value, index|
+              next if
+                Types.scalar?(value)
+
+              raise InvalidParameterError.new('unpermitted type (expected array of scalar types)', path: Path.new(*param.path.keys, index), source: schema.source) unless
+                schema.allow_non_scalars?
+            end
+          end
+
+          # Handle blanks (and false-positive "blank" values)
+          if param.value.blank?
+            unless param.value == false
+              raise InvalidParameterError.new('cannot be blank', path: param.path, source: schema.source) unless
+                schema.allow_blank?
+
+              next
+            end
+          end
+        end
+
+        # Assert validations
+        schema.validations.each do |validation|
+          validation.call(param.value)
+        rescue ValidationError => e
+          raise InvalidParameterError.new(e.message, path: param.path, source: schema.source)
+        end
+      end
+    end
+  end
+end

data/lib/typed_params/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TypedParams
+  VERSION = '0.2.0'
+end

data/lib/typed_params.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'typed_params/bouncer'
+require 'typed_params/coercer'
+require 'typed_params/configuration'
+require 'typed_params/controller'
+require 'typed_params/formatters'
+require 'typed_params/formatters/formatter'
+require 'typed_params/formatters/jsonapi'
+require 'typed_params/formatters/rails'
+require 'typed_params/handler_set'
+require 'typed_params/handler'
+require 'typed_params/mapper'
+require 'typed_params/namespaced_set'
+require 'typed_params/parameter'
+require 'typed_params/parameterizer'
+require 'typed_params/path'
+require 'typed_params/pipeline'
+require 'typed_params/processor'
+require 'typed_params/schema_set'
+require 'typed_params/schema'
+require 'typed_params/transforms/key_alias'
+require 'typed_params/transforms/key_casing'
+require 'typed_params/transforms/nilify_blanks'
+require 'typed_params/transforms/noop'
+require 'typed_params/transforms/transform'
+require 'typed_params/transformer'
+require 'typed_params/types'
+require 'typed_params/types/array'
+require 'typed_params/types/boolean'
+require 'typed_params/types/date'
+require 'typed_params/types/decimal'
+require 'typed_params/types/float'
+require 'typed_params/types/hash'
+require 'typed_params/types/integer'
+require 'typed_params/types/nil'
+require 'typed_params/types/number'
+require 'typed_params/types/string'
+require 'typed_params/types/symbol'
+require 'typed_params/types/time'
+require 'typed_params/types/type'
+require 'typed_params/validations/exclusion'
+require 'typed_params/validations/format'
+require 'typed_params/validations/inclusion'
+require 'typed_params/validations/length'
+require 'typed_params/validations/validation'
+require 'typed_params/validator'
+
+module TypedParams
+  # Sentinel value for determining if something should be automatic.
+  # For example, automatically detecting a param's format via its
+  # schema vs using an explicitly provided format.
+  AUTO = Object.new
+
+  # Sentinel value for determining if something is the root. For
+  # example, determining if a schema is the root node.
+  ROOT = Object.new
+
+  class UndefinedActionError < StandardError; end
+  class InvalidMethodError < StandardError; end
+  class ValidationError < StandardError; end
+  class CoercionError < StandardError; end
+
+  class InvalidParameterError < StandardError
+    attr_reader :source,
+                :path
+
+    def initialize(message, source:, path:)
+      @source = source
+      @path   = path
+
+      super(message)
+    end
+
+    def inspect
+      "#<#{self.class.name} message=#{message.inspect} source=#{source.inspect} path=#{path.inspect}>"
+    end
+  end
+
+  class UnpermittedParameterError < InvalidParameterError; end
+
+  def self.formats = Formatters
+  def self.types   = Types
+
+  def self.config = @config ||= Configuration.new
+  def self.configure
+    yield config
+  end
+end