dry-types 0.6.0

data/lib/dry-types.rb

@@ -0,0 +1 @@
+require 'dry/types'

data/lib/dry/types.rb

@@ -0,0 +1,115 @@
+require 'bigdecimal'
+require 'date'
+require 'set'
+
+require 'inflecto'
+require 'thread_safe'
+
+require 'dry-container'
+require 'dry-equalizer'
+
+require 'dry/types/version'
+require 'dry/types/container'
+require 'dry/types/definition'
+require 'dry/types/constructor'
+require 'dry/types/struct'
+require 'dry/types/value'
+
+module Dry
+  module Types
+    extend Dry::Configurable
+
+    setting :namespace, self
+
+    class SchemaError < TypeError
+      def initialize(key, value)
+        super("#{value.inspect} (#{value.class}) has invalid type for :#{key}")
+      end
+    end
+
+    class SchemaKeyError < KeyError
+      def initialize(key)
+        super(":#{key} is missing in Hash input")
+      end
+    end
+
+    StructError = Class.new(TypeError)
+    ConstraintError = Class.new(TypeError)
+
+    TYPE_SPEC_REGEX = %r[(.+)<(.+)>].freeze
+
+    def self.module
+      namespace = Module.new
+      define_constants(namespace, type_keys)
+      namespace
+    end
+
+    def self.finalize
+      warn 'Dry::Types.finalize and configuring namespace is deprecated. Just'\
+       ' do `include Dry::Types.module` in places where you want to have access'\
+       ' to built-in types'
+
+      define_constants(config.namespace, type_keys)
+    end
+
+    def self.container
+      @container ||= Container.new
+    end
+
+    def self.register(name, type = nil, &block)
+      container.register(name, type || block.call)
+    end
+
+    def self.register_class(klass, meth = :new)
+      type = Definition.new(klass).constructor(klass.method(meth))
+      container.register(identifier(klass), type)
+    end
+
+    def self.[](name)
+      type_map.fetch_or_store(name) do
+        case name
+        when String
+          result = name.match(TYPE_SPEC_REGEX)
+
+          if result
+            type_id, member_id = result[1..2]
+            container[type_id].member(self[member_id])
+          else
+            container[name]
+          end
+        when Class
+          self[identifier(name)]
+        end
+      end
+    end
+
+    def self.define_constants(namespace, identifiers)
+      names = identifiers.map do |id|
+        parts = id.split('.')
+        [Inflecto.camelize(parts.pop), parts.map(&Inflecto.method(:camelize))]
+      end
+
+      names.map do |(klass, parts)|
+        mod = parts.reduce(namespace) do |a, e|
+          a.constants.include?(e.to_sym) ? a.const_get(e) : a.const_set(e, Module.new)
+        end
+
+        mod.const_set(klass, self[identifier((parts + [klass]).join('::'))])
+      end
+    end
+
+    def self.identifier(klass)
+      Inflecto.underscore(klass).tr('/', '.')
+    end
+
+    def self.type_map
+      @type_map ||= ThreadSafe::Cache.new
+    end
+
+    def self.type_keys
+      container._container.keys
+    end
+  end
+end
+
+require 'dry/types/core' # load built-in types

data/lib/dry/types/builder.rb

@@ -0,0 +1,46 @@
+module Dry
+  module Types
+    module Builder
+      def |(other)
+        Sum.new(self, other)
+      end
+
+      def optional
+        Optional.new(Types['nil'] | self)
+      end
+
+      def constrained(options)
+        Constrained.new(self, rule: Types.Rule(options))
+      end
+
+      def default(input = nil, &block)
+        value = input ? input : block
+
+        if value.is_a?(Proc) || valid?(value)
+          Default[value].new(self, value: value)
+        else
+          raise ConstraintError, "default value #{value.inspect} violates constraints"
+        end
+      end
+
+      def enum(*values)
+        Enum.new(constrained(inclusion: values), values: values)
+      end
+
+      def safe
+        Safe.new(self)
+      end
+
+      def constructor(constructor, options = {})
+        Constructor.new(with(options), fn: constructor)
+      end
+    end
+  end
+end
+
+require 'dry/types/default'
+require 'dry/types/constrained'
+require 'dry/types/enum'
+require 'dry/types/optional'
+require 'dry/types/safe'
+require 'dry/types/sum'

data/lib/dry/types/coercions/form.rb

@@ -0,0 +1,91 @@
+require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Dry
+  module Types
+    module Coercions
+      module Form
+        TRUE_VALUES = %w[1 on  t true  y yes].freeze
+        FALSE_VALUES = %w[0 off f false n no].freeze
+        BOOLEAN_MAP = Hash[TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])].freeze
+
+        def self.to_nil(input)
+          if input.is_a?(String) && input == ''
+            nil
+          else
+            input
+          end
+        end
+
+        def self.to_date(input)
+          Date.parse(input)
+        rescue ArgumentError
+          input
+        end
+
+        def self.to_date_time(input)
+          DateTime.parse(input)
+        rescue ArgumentError
+          input
+        end
+
+        def self.to_time(input)
+          Time.parse(input)
+        rescue ArgumentError
+          input
+        end
+
+        def self.to_true(input)
+          BOOLEAN_MAP.fetch(input, input)
+        end
+
+        def self.to_false(input)
+          BOOLEAN_MAP.fetch(input, input)
+        end
+
+        def self.to_int(input)
+          if input == ''
+            nil
+          else
+            result = input.to_i
+
+            if result === 0 && input != '0'
+              input
+            else
+              result
+            end
+          end
+        end
+
+        def self.to_float(input)
+          if input == ''
+            nil
+          else
+            result = input.to_f
+
+            if result == 0.0 && (input != '0' || input != '0.0')
+              input
+            else
+              result
+            end
+          end
+        end
+
+        def self.to_decimal(input)
+          if input == ''
+            nil
+          else
+            result = to_float(input)
+
+            if result.is_a?(Float)
+              result.to_d
+            else
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/compiler.rb

@@ -0,0 +1,63 @@
+module Dry
+  module Types
+    class Compiler
+      attr_reader :registry
+
+      def initialize(registry)
+        @registry = registry
+      end
+
+      def call(ast)
+        visit(ast)
+      end
+
+      def visit(node, *args)
+        send(:"visit_#{node[0]}", node[1], *args)
+      end
+
+      def visit_type(node)
+        type, args = node
+        meth = :"visit_#{type.tr('.', '_')}"
+
+        if respond_to?(meth)
+          send(meth, args)
+        else
+          registry[type]
+        end
+      end
+
+      def visit_sum(node)
+        node.map { |type| visit(type) }.reduce(:|)
+      end
+
+      def visit_array(node)
+        registry['array'].member(call(node))
+      end
+
+      def visit_form_array(node)
+        registry['form.array'].member(call(node))
+      end
+
+      def visit_hash(node)
+        constructor, schema = node
+        merge_with('hash', constructor, schema)
+      end
+
+      def visit_form_hash(node)
+        constructor, schema = node
+        merge_with('form.hash', constructor, schema)
+      end
+
+      def visit_key(node)
+        name, types = node
+        { name => visit(types) }
+      end
+
+      def merge_with(hash_id, constructor, schema)
+        registry[hash_id].__send__(
+          constructor, schema.map { |key| visit(key) }.reduce(:merge)
+        )
+      end
+    end
+  end
+end

data/lib/dry/types/constrained.rb

@@ -0,0 +1,47 @@
+require 'dry/types/decorator'
+require 'dry/types/constraints'
+
+module Dry
+  module Types
+    class Constrained
+      include Decorator
+      include Builder
+
+      attr_reader :rule
+
+      def initialize(type, options)
+        super
+        @rule = options.fetch(:rule)
+      end
+
+      def call(input)
+        result = try(input)
+
+        if valid?(result)
+          result
+        else
+          raise ConstraintError, "#{input.inspect} violates constraints"
+        end
+      end
+      alias_method :[], :call
+
+      def try(input)
+        type[input]
+      end
+
+      def valid?(input)
+        rule.(input).success?
+      end
+
+      def constrained(options)
+        with(rule: rule & Types.Rule(options))
+      end
+
+      private
+
+      def decorate?(response)
+        super || response.kind_of?(Constructor)
+      end
+    end
+  end
+end

data/lib/dry/types/constraints.rb

@@ -0,0 +1,24 @@
+require 'dry/logic/rule_compiler'
+require 'dry/logic/predicates'
+
+module Dry
+  module Types
+    module Predicates
+      include Logic::Predicates
+
+      predicate(:type?) do |type, value|
+        value.kind_of?(type)
+      end
+    end
+
+    def self.Rule(options)
+      rule_compiler.(
+        options.map { |key, val| [:val, [:predicate, [:"#{key}?", [val]]]] }
+      ).reduce(:and)
+    end
+
+    def self.rule_compiler
+      @rule_compiler ||= Logic::RuleCompiler.new(Types::Predicates)
+    end
+  end
+end

data/lib/dry/types/constructor.rb

@@ -0,0 +1,59 @@
+require 'dry/types/decorator'
+
+module Dry
+  module Types
+    class Constructor < Definition
+      include Dry::Equalizer(:type)
+
+      undef_method :primitive
+
+      attr_reader :fn
+
+      attr_reader :type
+
+      def self.new(input, options = {})
+        type = input.is_a?(Definition) ? input : Definition.new(input)
+        super(type, options)
+      end
+
+      def initialize(type, options = {})
+        super
+        @type = type
+        @fn = options.fetch(:fn)
+      end
+
+      def primitive
+        type.primitive
+      end
+
+      def call(input)
+        fn[input]
+      end
+      alias_method :[], :call
+
+      def constructor(new_fn, options = {})
+        with(options.merge(fn: -> input { new_fn[fn[input]] }))
+      end
+
+      def respond_to_missing?(meth, include_private = false)
+        super || type.respond_to?(meth)
+      end
+
+      private
+
+      def method_missing(meth, *args, &block)
+        if type.respond_to?(meth)
+          response = type.__send__(meth, *args, &block)
+
+          if response.is_a?(Constructor)
+            constructor(response.fn, options.merge(response.options))
+          else
+            response
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end