dry-types 0.6.0

data/lib/dry/types/container.rb

@@ -0,0 +1,7 @@
+module Dry
+  module Types
+    class Container
+      include Dry::Container::Mixin
+    end
+  end
+end

data/lib/dry/types/core.rb

@@ -0,0 +1,57 @@
+module Dry
+  module Types
+    COERCIBLE = {
+      string: String,
+      int: Integer,
+      float: Float,
+      decimal: BigDecimal,
+      array: Array,
+      hash: Hash
+    }.freeze
+
+    NON_COERCIBLE = {
+      nil: NilClass,
+      symbol: Symbol,
+      class: Class,
+      true: TrueClass,
+      false: FalseClass,
+      date: Date,
+      date_time: DateTime,
+      time: Time
+    }.freeze
+
+    ALL_PRIMITIVES = COERCIBLE.merge(NON_COERCIBLE).freeze
+
+    # Register built-in types that are non-coercible through kernel methods
+    ALL_PRIMITIVES.each do |name, primitive|
+      register(name.to_s, Definition[primitive].new(primitive))
+    end
+
+    # Register strict built-in types that are non-coercible through kernel methods
+    ALL_PRIMITIVES.each do |name, primitive|
+      register("strict.#{name}", self[name.to_s].constrained(type: primitive))
+    end
+
+    # Register built-in primitive types with kernel coercion methods
+    COERCIBLE.each do |name, primitive|
+      register("coercible.#{name}", self[name.to_s].constructor(Kernel.method(primitive.name)))
+    end
+
+    # Register non-coercible maybe types
+    ALL_PRIMITIVES.each_key do |name|
+      next if name == :nil
+      register("maybe.strict.#{name}", self["strict.#{name}"].optional)
+    end
+
+    # Register coercible maybe types
+    COERCIBLE.each_key do |name|
+      register("maybe.coercible.#{name}", self["coercible.#{name}"].optional)
+    end
+
+    # Register :bool since it's common and not a built-in Ruby type :(
+    register("bool", self["true"] | self["false"])
+    register("strict.bool", self["strict.true"] | self["strict.false"])
+  end
+end
+
+require 'dry/types/form'

data/lib/dry/types/decorator.rb

@@ -0,0 +1,48 @@
+module Dry
+  module Types
+    module Decorator
+      attr_reader :type, :options
+
+      def initialize(type, options = {})
+        @type = type
+        @options = options
+      end
+
+      def constructor
+        type.constructor
+      end
+
+      def valid?(input)
+        type.valid?(input)
+      end
+
+      def respond_to_missing?(meth, include_private = false)
+        super || type.respond_to?(meth)
+      end
+
+      def with(new_options)
+        self.class.new(type, options.merge(new_options))
+      end
+
+      private
+
+      def decorate?(response)
+        response.kind_of?(type.class)
+      end
+
+      def method_missing(meth, *args, &block)
+        if type.respond_to?(meth)
+          response = type.__send__(meth, *args, &block)
+
+          if decorate?(response)
+            self.class.new(response, options)
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/default.rb

@@ -0,0 +1,43 @@
+require 'dry/types/decorator'
+
+module Dry
+  module Types
+    class Default
+      include Decorator
+      include Builder
+
+      class Callable < Default
+        def evaluate
+          value.call
+        end
+      end
+
+      attr_reader :value
+
+      alias_method :evaluate, :value
+
+      def self.[](value)
+        if value.respond_to?(:call)
+          Callable
+        else
+          self
+        end
+      end
+
+      def initialize(type, options)
+        super
+        @value = options.fetch(:value)
+      end
+
+      def call(input)
+        if input.nil?
+          evaluate
+        else
+          output = type[input]
+          output.nil? ? evaluate : output
+        end
+      end
+      alias_method :[], :call
+    end
+  end
+end

data/lib/dry/types/definition.rb

@@ -0,0 +1,53 @@
+require 'dry/types/builder'
+
+module Dry
+  module Types
+    class Definition
+      include Dry::Equalizer(:primitive, :options)
+      include Builder
+
+      attr_reader :options
+
+      attr_reader :primitive
+
+      def self.[](primitive)
+        if primitive == ::Array
+          Definition::Array
+        elsif primitive == ::Hash
+          Definition::Hash
+        else
+          self
+        end
+      end
+
+      def initialize(primitive, options = {})
+        @primitive = primitive
+        @options = options
+      end
+
+      def with(new_options)
+        self.class.new(primitive, options.merge(new_options))
+      end
+
+      def name
+        primitive.name
+      end
+
+      def call(input)
+        input
+      end
+      alias_method :[], :call
+
+      def try(input)
+        call(input)
+      end
+
+      def valid?(input)
+        input.is_a?(primitive)
+      end
+    end
+  end
+end
+
+require 'dry/types/definition/array'
+require 'dry/types/definition/hash'

data/lib/dry/types/definition/array.rb

@@ -0,0 +1,24 @@
+module Dry
+  module Types
+    class Definition
+      class Array < Definition
+        def self.constructor(member_constructor, array)
+          array.map { |value| member_constructor[value] }
+        end
+
+        def member(type)
+          member_constructor =
+            case type
+            when String, Class then Types[type]
+            else type
+            end
+
+          array_constructor = self.class
+            .method(:constructor).to_proc.curry.(member_constructor)
+
+          constructor(array_constructor, member: member_constructor)
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/definition/hash.rb

@@ -0,0 +1,68 @@
+module Dry
+  module Types
+    class Definition
+      class Hash < Definition
+        def self.safe_constructor(types, hash)
+          types.each_with_object({}) do |(key, type), result|
+            if hash.key?(key)
+              result[key] = type[hash[key]]
+            elsif type.is_a?(Default)
+              result[key] = type.evaluate
+            end
+          end
+        end
+
+        def self.symbolized_constructor(types, hash)
+          types.each_with_object({}) do |(key, type), result|
+            if hash.key?(key)
+              result[key] = type[hash[key]]
+            else
+              key_name = key.to_s
+
+              if hash.key?(key_name)
+                result[key] = type[hash[key_name]]
+              elsif type.is_a?(Default)
+                result[key] = type.evaluate
+              end
+            end
+          end
+        end
+
+        def self.strict_constructor(types, hash)
+          types.each_with_object({}) do |(key, type), result|
+            begin
+              value = hash.fetch(key)
+              result[key] = type[value]
+            rescue TypeError
+              raise SchemaError.new(key, value)
+            rescue KeyError
+              raise SchemaKeyError.new(key)
+            end
+          end
+        end
+
+        def strict(type_map)
+          schema(type_map, :strict_constructor)
+        end
+
+        def symbolized(type_map)
+          schema(type_map, :symbolized_constructor)
+        end
+
+        def schema(type_map, meth = :safe_constructor)
+          types = type_map.each_with_object({}) { |(name, type), result|
+            result[name] =
+              case type
+              when String, Class then Types[type]
+              else type
+              end
+          }
+
+          fn = self.class.method(meth).to_proc.curry.(types)
+
+          constructor(fn, schema: types)
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/enum.rb

@@ -0,0 +1,30 @@
+require 'dry/types/decorator'
+
+module Dry
+  module Types
+    class Enum
+      include Decorator
+
+      attr_reader :values, :mapping
+
+      def initialize(type, options)
+        super
+        @values = options.fetch(:values).freeze
+        @values.each(&:freeze)
+        @mapping = values.each_with_object({}) { |v, h| h[values.index(v)] = v }.freeze
+      end
+
+      def call(input)
+        value =
+          if values.include?(input)
+            input
+          elsif mapping.key?(input)
+            mapping[input]
+          end
+
+        type[value || input]
+      end
+      alias_method :[], :call
+    end
+  end
+end

data/lib/dry/types/form.rb

@@ -0,0 +1,53 @@
+require 'dry/types/coercions/form'
+
+module Dry
+  module Types
+    register('form.nil') do
+      self['nil'].constructor(Coercions::Form.method(:to_nil))
+    end
+
+    register('form.date') do
+      self['date'].constructor(Coercions::Form.method(:to_date))
+    end
+
+    register('form.date_time') do
+      self['date_time'].constructor(Coercions::Form.method(:to_date_time))
+    end
+
+    register('form.time') do
+      self['time'].constructor(Coercions::Form.method(:to_time))
+    end
+
+    register('form.true') do
+      self['true'].constructor(Coercions::Form.method(:to_true))
+    end
+
+    register('form.false') do
+      self['false'].constructor(Coercions::Form.method(:to_false))
+    end
+
+    register('form.bool') do
+      self['form.true'] | self['form.false']
+    end
+
+    register('form.int') do
+      self['int'].constructor(Coercions::Form.method(:to_int))
+    end
+
+    register('form.float') do
+      self['float'].constructor(Coercions::Form.method(:to_float))
+    end
+
+    register('form.decimal') do
+      self['decimal'].constructor(Coercions::Form.method(:to_decimal))
+    end
+
+    register('form.array') do
+      self['array'].safe
+    end
+
+    register('form.hash') do
+      self['hash'].safe
+    end
+  end
+end

data/lib/dry/types/optional.rb

@@ -0,0 +1,16 @@
+require 'kleisli/maybe'
+require 'dry/types/decorator'
+
+module Dry
+  module Types
+    class Optional
+      include Decorator
+      include Builder
+
+      def call(input)
+        input.is_a?(Kleisli::Maybe) ? input : Maybe(type[input])
+      end
+      alias_method :[], :call
+    end
+  end
+end

data/lib/dry/types/safe.rb

@@ -0,0 +1,25 @@
+require 'dry/types/decorator'
+
+module Dry
+  module Types
+    class Safe
+      include Decorator
+      include Builder
+
+      def call(input)
+        if input.is_a?(primitive)
+          type.call(input)
+        else
+          input
+        end
+      end
+      alias_method :[], :call
+
+      private
+
+      def decorate?(response)
+        super || response.kind_of?(Constructor)
+      end
+    end
+  end
+end

data/lib/dry/types/struct.rb

@@ -0,0 +1,64 @@
+module Dry
+  module Types
+    class Struct
+      class << self
+        attr_reader :constructor
+      end
+
+      def self.inherited(klass)
+        super
+        Types.register_class(klass) unless klass == Value
+      end
+
+      def self.attribute(name, type)
+        attributes(name => type)
+      end
+
+      def self.attributes(new_schema)
+        prev_schema = schema
+
+        @schema = prev_schema.merge(new_schema)
+        @constructor = Types['coercible.hash'].public_send(constructor_type, schema)
+
+        attr_reader(*(new_schema.keys - prev_schema.keys))
+
+        self
+      end
+
+      def self.constructor_type(type = :strict)
+        @constructor_type ||= type
+      end
+
+      def self.schema
+        super_schema = superclass.respond_to?(:schema) ? superclass.schema : {}
+        super_schema.merge(@schema || {})
+      end
+
+      def self.new(attributes = {})
+        if attributes.is_a?(self)
+          attributes
+        else
+          super(constructor[attributes])
+        end
+      rescue SchemaError, SchemaKeyError => e
+        raise StructError, "[#{self}.new] #{e.message}"
+      end
+
+      def initialize(attributes)
+        attributes.each { |key, value| instance_variable_set("@#{key}", value) }
+      end
+
+      def [](name)
+        public_send(name)
+      end
+
+      def to_hash
+        self.class.schema.keys.each_with_object({}) { |key, result|
+          value = self[key]
+          result[key] = value.respond_to?(:to_hash) ? value.to_hash : value
+        }
+      end
+      alias_method :to_h, :to_hash
+    end
+  end
+end