dry-types 0.13.2 → 1.5.1

data/lib/dry/types/meta.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Dry
+  module Types
+    # Storage for meta-data
+    #
+    # @api public
+    module Meta
+      def initialize(*args, meta: EMPTY_HASH, **options)
+        super(*args, **options)
+        @meta = meta.freeze
+      end
+
+      # @param options [Hash] new_options
+      #
+      # @return [Type]
+      #
+      # @api public
+      def with(**options)
+        super(meta: @meta, **options)
+      end
+
+      # @overload meta
+      #   @return [Hash] metadata associated with type
+      #
+      # @overload meta(data)
+      #   @param [Hash] new metadata to merge into existing metadata
+      #   @return [Type] new type with added metadata
+      #
+      # @api public
+      def meta(data = Undefined)
+        if Undefined.equal?(data)
+          @meta
+        elsif data.empty?
+          self
+        else
+          with(meta: @meta.merge(data))
+        end
+      end
+
+      # Resets meta
+      #
+      # @return [Dry::Types::Type]
+      #
+      # @api public
+      def pristine
+        with(meta: EMPTY_HASH)
+      end
+    end
+  end
+end

data/lib/dry/types/module.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "dry/core/deprecations"
+require "dry/types/builder_methods"
+
+module Dry
+  module Types
+    # Export types registered in a container as module constants.
+    # @example
+    #   module Types
+    #     include Dry::Types(:strict, :coercible, :nominal, default: :strict)
+    #   end
+    #
+    #   Types.constants
+    #   # => [:Class, :Strict, :Symbol, :Integer, :Float, :String, :Array, :Hash,
+    #   #     :Decimal, :Nil, :True, :False, :Bool, :Date, :Nominal, :DateTime, :Range,
+    #   #     :Coercible, :Time]
+    #
+    # @api public
+    class Module < ::Module
+      def initialize(registry, *args, **kwargs)
+        @registry = registry
+        check_parameters(*args, **kwargs)
+        constants = type_constants(*args, **kwargs)
+        define_constants(constants)
+        extend(BuilderMethods)
+
+        if constants.key?(:Nominal)
+          singleton_class.send(:define_method, :included) do |base|
+            super(base)
+            base.instance_exec(const_get(:Nominal, false)) do |nominal|
+              extend Dry::Core::Deprecations[:'dry-types']
+              const_set(:Definition, nominal)
+              deprecate_constant(:Definition, message: "Nominal")
+            end
+          end
+        end
+      end
+
+      # @api private
+      def type_constants(*namespaces, default: Undefined, **aliases)
+        if namespaces.empty? && aliases.empty? && Undefined.equal?(default)
+          default_ns = :Strict
+        elsif Undefined.equal?(default)
+          default_ns = Undefined
+        else
+          default_ns = Inflector.camelize(default).to_sym
+        end
+
+        tree = registry_tree
+
+        if namespaces.empty? && aliases.empty?
+          modules = tree.select { |_, v| v.is_a?(::Hash) }.map(&:first)
+        else
+          modules = (namespaces + aliases.keys).map { |n| Inflector.camelize(n).to_sym }
+        end
+
+        tree.each_with_object({}) do |(key, value), constants|
+          if modules.include?(key)
+            name = aliases.fetch(Inflector.underscore(key).to_sym, key)
+            constants[name] = value
+          end
+
+          constants.update(value) if key == default_ns
+        end
+      end
+
+      # @api private
+      def registry_tree
+        @registry_tree ||= @registry.keys.each_with_object({}) { |key, tree|
+          type = @registry[key]
+          *modules, const_name = key.split(".").map { |part|
+            Inflector.camelize(part).to_sym
+          }
+          next if modules.empty?
+
+          modules.reduce(tree) { |br, name| br[name] ||= {} }[const_name] = type
+        }.freeze
+      end
+
+      private
+
+      # @api private
+      def check_parameters(*namespaces, default: Undefined, **aliases)
+        referenced = namespaces.dup
+        referenced << default unless false.equal?(default) || Undefined.equal?(default)
+        referenced.concat(aliases.keys)
+
+        known = @registry.keys.map { |k|
+          ns, *path = k.split(".")
+          ns.to_sym unless path.empty?
+        }.compact.uniq
+
+        (referenced.uniq - known).each do |name|
+          raise ArgumentError,
+                "#{name.inspect} is not a known type namespace. "\
+                "Supported options are #{known.map(&:inspect).join(", ")}"
+        end
+      end
+
+      # @api private
+      def define_constants(constants, mod = self)
+        constants.each do |name, value|
+          case value
+          when ::Hash
+            if mod.const_defined?(name, false)
+              define_constants(value, mod.const_get(name, false))
+            else
+              m = ::Module.new
+              mod.const_set(name, m)
+              define_constants(value, m)
+            end
+          else
+            mod.const_set(name, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/types/nominal.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require "dry/core/deprecations"
+require "dry/core/equalizer"
+require "dry/types/builder"
+require "dry/types/result"
+require "dry/types/options"
+require "dry/types/meta"
+
+module Dry
+  module Types
+    # Nominal types define a primitive class and do not apply any constructors or constraints
+    #
+    # Use these types for annotations and the base for building more complex types on top of them.
+    #
+    # @api public
+    class Nominal
+      include Type
+      include Options
+      include Meta
+      include Builder
+      include Printable
+      include Dry::Equalizer(:primitive, :options, :meta, inspect: false, immutable: true)
+
+      # @return [Class]
+      attr_reader :primitive
+
+      # @param [Class] primitive
+      #
+      # @return [Type]
+      #
+      # @api private
+      def self.[](primitive)
+        if primitive == ::Array
+          Types::Array
+        elsif primitive == ::Hash
+          Types::Hash
+        else
+          self
+        end
+      end
+
+      ALWAYS = proc { true }
+
+      # @param [Type,Class] primitive
+      # @param [Hash] options
+      #
+      # @api private
+      def initialize(primitive, **options)
+        super
+        @primitive = primitive
+        freeze
+      end
+
+      # @return [String]
+      #
+      # @api public
+      def name
+        primitive.name
+      end
+
+      # @return [false]
+      #
+      # @api public
+      def default?
+        false
+      end
+
+      # @return [false]
+      #
+      # @api public
+      def constrained?
+        false
+      end
+
+      # @return [false]
+      #
+      # @api public
+      def optional?
+        false
+      end
+
+      # @param [BasicObject] input
+      #
+      # @return [BasicObject]
+      #
+      # @api private
+      def call_unsafe(input)
+        input
+      end
+
+      # @param [BasicObject] input
+      #
+      # @return [BasicObject]
+      #
+      # @api private
+      def call_safe(input)
+        input
+      end
+
+      # @param [Object] input
+      #
+      # @yieldparam [Failure] failure
+      # @yieldreturn [Result]
+      #
+      # @return [Result,Logic::Result] when a block is not provided
+      # @return [nil] otherwise
+      #
+      # @api public
+      def try(input)
+        success(input)
+      end
+
+      # @param (see Dry::Types::Success#initialize)
+      #
+      # @return [Result::Success]
+      #
+      # @api public
+      def success(input)
+        Result::Success.new(input)
+      end
+
+      # @param (see Failure#initialize)
+      #
+      # @return [Result::Failure]
+      #
+      # @api public
+      def failure(input, error)
+        raise ArgumentError, "error must be a CoercionError" unless error.is_a?(CoercionError)
+
+        Result::Failure.new(input, error)
+      end
+
+      # Checks whether value is of a #primitive class
+      #
+      # @param [Object] value
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def primitive?(value)
+        value.is_a?(primitive)
+      end
+
+      # @api private
+      def coerce(input, &_block)
+        if primitive?(input)
+          input
+        elsif block_given?
+          yield
+        else
+          raise CoercionError, "#{input.inspect} must be an instance of #{primitive}"
+        end
+      end
+
+      # @api private
+      def try_coerce(input)
+        result = success(input)
+
+        coerce(input) do
+          result = failure(
+            input,
+            CoercionError.new("#{input.inspect} must be an instance of #{primitive}")
+          )
+        end
+
+        if block_given?
+          yield(result)
+        else
+          result
+        end
+      end
+
+      # Return AST representation of a type nominal
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:nominal, [primitive, meta ? self.meta : EMPTY_HASH]]
+      end
+
+      # Return self. Nominal types are lax by definition
+      #
+      # @return [Nominal]
+      #
+      # @api public
+      def lax
+        self
+      end
+
+      # Wrap the type with a proc
+      #
+      # @return [Proc]
+      #
+      # @api public
+      def to_proc
+        ALWAYS
+      end
+    end
+
+    extend Dry::Core::Deprecations[:'dry-types']
+    Definition = Nominal
+    deprecate_constant(:Definition, message: "Nominal")
+  end
+end
+
+require "dry/types/array"
+require "dry/types/hash"
+require "dry/types/map"

data/lib/dry/types/options.rb

@@ -1,42 +1,29 @@
+# frozen_string_literal: true
+
 module Dry
   module Types
+    # Common API for types with options
+    #
+    # @api private
     module Options
       # @return [Hash]
       attr_reader :options
 
-      # @see Definition#initialize
-      def initialize(*args, meta: EMPTY_HASH, **options)
+      # @see Nominal#initialize
+      #
+      # @api private
+      def initialize(*args, **options)
         @__args__ = args.freeze
         @options = options.freeze
-        @meta = meta.freeze
       end
 
       # @param [Hash] new_options
+      #
       # @return [Type]
-      def with(new_options)
-        self.class.new(*@__args__, **options, meta: @meta, **new_options)
-      end
-
-      # @overload meta
-      #   @return [Hash] metadata associated with type
       #
-      # @overload meta(data)
-      #   @param [Hash] new metadata to merge into existing metadata
-      #   @return [Type] new type with added metadata
-      def meta(data = nil)
-        if !data
-          @meta
-        elsif data.empty?
-          self
-        else
-          with(meta: @meta.merge(data))
-        end
-      end
-
-      # Resets meta
-      # @return [Dry::Types::Type]
-      def pristine
-        with(meta: EMPTY_HASH)
+      # @api private
+      def with(**new_options)
+        self.class.new(*@__args__, **options, **new_options)
       end
     end
   end

data/lib/dry/types/params.rb

@@ -1,53 +1,67 @@
-require 'dry/types/coercions/params'
+# frozen_string_literal: true
+
+require "dry/types/coercions/params"
 
 module Dry
   module Types
-    register('params.nil') do
-      self['nil'].constructor(Coercions::Params.method(:to_nil))
+    register("params.nil") do
+      self["nominal.nil"].constructor(Coercions::Params.method(:to_nil))
+    end
+
+    register("params.date") do
+      self["nominal.date"].constructor(Coercions::Params.method(:to_date))
     end
 
-    register('params.date') do
-      self['date'].constructor(Coercions::Params.method(:to_date))
+    register("params.date_time") do
+      self["nominal.date_time"].constructor(Coercions::Params.method(:to_date_time))
     end
 
-    register('params.date_time') do
-      self['date_time'].constructor(Coercions::Params.method(:to_date_time))
+    register("params.time") do
+      self["nominal.time"].constructor(Coercions::Params.method(:to_time))
     end
 
-    register('params.time') do
-      self['time'].constructor(Coercions::Params.method(:to_time))
+    register("params.true") do
+      self["nominal.true"].constructor(Coercions::Params.method(:to_true))
     end
 
-    register('params.true') do
-      self['true'].constructor(Coercions::Params.method(:to_true))
+    register("params.false") do
+      self["nominal.false"].constructor(Coercions::Params.method(:to_false))
     end
 
-    register('params.false') do
-      self['false'].constructor(Coercions::Params.method(:to_false))
+    register("params.bool") do
+      self["params.true"] | self["params.false"]
     end
 
-    register('params.bool') do
-      (self['params.true'] | self['params.false']).safe
+    register("params.integer") do
+      self["nominal.integer"].constructor(Coercions::Params.method(:to_int))
     end
 
-    register('params.integer') do
-      self['integer'].constructor(Coercions::Params.method(:to_int))
+    register("params.float") do
+      self["nominal.float"].constructor(Coercions::Params.method(:to_float))
     end
 
-    register('params.float') do
-      self['float'].constructor(Coercions::Params.method(:to_float))
+    register("params.decimal") do
+      self["nominal.decimal"].constructor(Coercions::Params.method(:to_decimal))
     end
 
-    register('params.decimal') do
-      self['decimal'].constructor(Coercions::Params.method(:to_decimal))
+    register("params.array") do
+      self["nominal.array"].constructor(Coercions::Params.method(:to_ary))
     end
 
-    register('params.array') do
-      self['array'].constructor(Coercions::Params.method(:to_ary)).safe
+    register("params.hash") do
+      self["nominal.hash"].constructor(Coercions::Params.method(:to_hash))
     end
 
-    register('params.hash') do
-      self['hash'].constructor(Coercions::Params.method(:to_hash)).safe
+    register("params.symbol") do
+      self["nominal.symbol"].constructor(Coercions::Params.method(:to_symbol))
+    end
+
+    register("params.string", self["string"])
+
+    COERCIBLE.each_key do |name|
+      next if name.equal?(:string)
+
+      register("optional.params.#{name}", self["params.nil"] | self["params.#{name}"])
     end
   end
 end