dry-interface 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35ad221861d5f292e3b7161879eee7b19ce7153dbda2db6f99623881978e1779
-  data.tar.gz: 5d7e84b70f23f0b898292ebc9fcecb825f3c602644e393e58cb3a4f12e618c27
+  metadata.gz: 24db806ee3d1f2da11074d2478d9de936a992f5ca834855c3d98cfdefbaab771
+  data.tar.gz: 7d84cd10027df4ecc162eda1728da6048a6d2fb78638cbc909806bbef814eac8
 SHA512:
-  metadata.gz: ca69ef2474fc1c3aaa39f0e52183dc938dcfc3f2f7b4154a58e5e25972c807d32cd4f1b7ef69708ea7a5f6b40e7b73a9b3badbc026de9912d73e9606edc5e2fb
-  data.tar.gz: 205d5ad822c71d32561ed6875a0aeee5045278af6e8cc6cda33fe063a4712e0f3df6e4146f5c5e78d58a0cbae52317cb6240e10afdf837a2d33576ae70494896
+  metadata.gz: 31158c8bd2ad52614c2c278f04279ee08ae22d9b73600f9b2aa272736919f24a65677d9cc20f06eac97190b4bdfbc1771ec9dc725a7d816ddbf4094ef4035938
+  data.tar.gz: e017702e3900a9113fa681d17eb4b210aedecf1b4a498881403f989f64c5380b04fca6fad4dade6be26dbc5c8b7008784bddbcd03766e04507ae1f44303f2615

data/lib/dry/interface/extensions/default.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Extensions
+      module Default
+        refine Proc do
+          # @example A string type with a proc default value
+          #  Dry::Types['string'].default { 'default' }
+          #
+          # @return [#call(Dry::Types::Type)]
+          def to_default
+            ->(type) { type[call] }.freeze
+          end
+        end
+
+        refine Object do
+          # @example String type with default value
+          #   Dry::Types['string'].default('foo')
+          #
+          # @return [#call(Dry::Types::Type)]
+          def to_default
+            ->(type = Dry::Types["any"]) { type[self] }.to_default
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/interface/extensions/type.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "dry/struct"
+require "dry/types"
+
+module Dry
+  class Interface
+    module Extensions
+      module Type
+        module Types
+          include Dry::Types()
+        end
+
+        refine String do
+          # Converts type references into types
+          #
+          # @example A strict string into a type
+          #   type = "strict.string".to_type
+          #
+          #   type.valid?("string") # => true
+          #   type.valid?(:symbol)  # => false
+          #
+          # @example A (strict) symbol into a type
+          #   type = "symbol".to_type
+          #
+          #   type.valid?(:symbol)  # => true
+          #   type.valid?("string") # => false
+          #
+          # @return [Dry::Types::Type]
+          # @raise [ArgumentError] if the type is not a valid type
+          def to_type
+            Dry::Types[self]
+          rescue Dry::Container::Error
+            raise ArgumentError, "Type reference [#{inspect}] not found in Dry::Types"
+          end
+        end
+
+        refine Object do
+          def to_type
+            raise ArgumentError, <<~ERROR
+              Cannot convert [#{inspect}] (#{self.class}) into a type using [#{inspect}#to_type]
+              Expected value of type Dry::Struct, Dry::Types or native Ruby module or class
+
+              ProTip: Replace [#{inspect}] with [Value(#{inspect})] to allow for [#{inspect}]
+
+              General examples:
+              Dry::Types:
+              Dry::Types["coercible.string"]
+              "strict.string"
+              "string"
+              Fixed values:
+              Value('undefined')
+              Value(:id)
+              Instance of class:
+              Hash
+              Array
+              String
+              [String]
+              [String, Symbol]
+              [[String, Symbol]]
+              { Symbol => Hash }
+              { Symbol => [Pathname] }
+              Constructors:
+              Struct.new(:value)
+              OpenStruct
+              Modules:
+              Enumerable
+              Comparable
+            ERROR
+          end
+        end
+
+        refine Dry::Types::Type do
+          # Dry::Types::Type is already a type in itself
+          # Used to streamline the API for all objects
+          #
+          # @example Dry type to dry type
+          #   type = Dry::Types['string'].to_type
+          #
+          #   type.valid?("string") # => true
+          #   type.valid?(:string)  # => false
+          #
+          # @return [Dry::Types::Type]
+          alias_method :to_type, :itself
+        end
+
+        refine Module do
+          # Ensures passed value includes module
+          #
+          # @example Check for enumerable values
+          #   type = Enumerable.to_type
+          #
+          #   type.valid?([])  # => true
+          #   type.valid?({})  # => true
+          #   type.valid?(nil) # => false
+          #
+          # @return [Dry::Types::Constrained]
+          def to_type
+            Types::Any.constrained(type: self)
+          end
+        end
+
+        refine Class do
+          # Wrapps class in a type constructor using ::new as initializer
+          #
+          # @example With a custom class
+          #   type = Struct.new(:value).to_type
+          #
+          #   type.valid?('value')            # => true
+          #   type.valid?                     # => false
+          #
+          # @example With a native Ruby class
+          #   type = String.to_type
+          #
+          #   type.valid?('value')            # => true
+          #   type.valid?(:symbol)            # => false
+          #
+          # @example With an instance of the class
+          #   Person = Struct.new(:name)
+          #
+          #   type = Person.to_type
+          #
+          #   type.valid?('value')             # => true
+          #   type.valid?(Person.new('John'))  # => true
+          #   type.valid?                      # => false
+          #
+          # @example With a class without constructor args
+          #   type = Mutex.to_type
+          #
+          #   type.valid?                      # => true
+          #   type.valid?('value')             # => false
+          #
+          # @return [Dry::Types::Constructor]
+          def to_type
+            Types.const_get(name).then do |maybe_type|
+              maybe_type == self ? to_constructor : maybe_type
+            end
+          rescue NameError, TypeError
+            to_constructor
+          end
+
+          private
+
+          def to_constructor
+            Types.Instance(self) | Types.Constructor(self, method(:new))
+          end
+        end
+
+        refine Hash do
+          # Recursively creates a hash type from {keys} & {values}
+          #
+          # @example With dynamic key and static value
+          #   type = { String => 'value' }
+          #
+          #   type.valid?('string' => 'value') # => true
+          #   type.valid?(symbol: 'value')     # => false
+          #   type.valid?('string' => 'other') # => false
+          #
+          # @example With dynamic key and value
+          #   type = { String => Enumerable }.to_type
+          #
+          #   type.valid?('string' => [])      # => true
+          #   type.valid?(symbol: [])          # => false
+          #   type.valid?('string' => :symbol) # => false
+          #
+          # @return [Dry::Types::Constrained, Dry::Types::Map]
+          def to_type
+            return Types::Hash if empty?
+
+            map { |k, v| Types::Hash.map(k.to_type, v.to_type) }.reduce(:|)
+          end
+        end
+
+        refine Array do
+          # Recursively creates an array type from {self}
+          #
+          # @example With member type
+          #   type = [String].to_type
+          #
+          #   type.valid?(['string'])            # => true
+          #   type.valid?([:symbol])             # => false
+          #
+          # @example Without member type
+          #   type = [].to_type
+          #
+          #   type.valid?(['anything'])          # => true
+          #   type.valid?('not-an-array')        # => false
+          #
+          # @example With nested members
+          #   type = [[String]].to_type
+          #
+          #   type.valid?([['string']])          # => true
+          #   type.valid?([[:symbol]])           # => false
+          #   type.valid?(['string'])            # => false
+          #
+          # @example With combined types
+          #   type = [String, Symbol].to_type
+          #
+          #   type.valid?(['string', :symbol])   # => true
+          #   type.valid?(['string'])            # => true
+          #   type.valid?([:symbol])             # => true
+          #   type.valid?([])                    # => true
+          #   type.valid?(:symbol)               # => false
+          #
+          # @return [Dry::Types::Constrained]
+          def to_type
+            return Types::Array if empty?
+
+            Types.Array(map(&:to_type).reduce(:|))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/interface/extensions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Extensions
+      autoload :Default, "dry/interface/extensions/default"
+      autoload :Type, "dry/interface/extensions/type"
+    end
+  end
+end

data/lib/dry/interface/types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Types
+      include Dry.Types(:strict, :nominal, :coercible)
+    end
+  end
+end

data/lib/dry/interface.rb

@@ -12,13 +12,35 @@ require "dry/types"
 module Dry
   class Interface < Dry::Struct
     autoload :Interfaces, "dry/interface/interfaces"
-    autoload :VERSION, "dry/interface/version"
+    autoload :Extensions, "dry/interface/extensions"
+    autoload :Types, "dry/interface/types"
 
     extend ActiveSupport::DescendantsTracker
     extend ActiveSupport::Inflector
 
+    using Extensions::Default
+    using Extensions::Type
+
     schema schema.strict(true)
 
+    delegate(*%i[
+               Constructor
+               Interface
+               Instance
+               Constant
+               Nominal
+               Value
+               Array
+               Hash
+               Any
+             ], to: Types)
+
+    Types.constants.each do |constant|
+      raise "#{const_get(constant)} is already defined"
+    rescue NameError
+      const_set(constant, Types.const_get(constant))
+    end
+
     concerning :New, prepend: true do
       prepended do
         class << self
@@ -44,6 +66,8 @@ module Dry
     end
 
     def self.new(...)
+      return super unless type
+
       type.call(...)
     end
 
@@ -57,6 +81,47 @@ module Dry
       end
     end
 
+    # Adds attribute {name} to the struct
+    #
+    # @example Add a new attribute
+    #   class User < Dry::Struct
+    #     attribute :name, String
+    #   end
+    #
+    # @example Add a new attribute with a default value
+    #   class User < Dry::Struct
+    #     attribute :name, String, default: "John"
+    #   end
+    #
+    # @example Add a new attribute with constraints
+    #   class User < Dry::Struct
+    #     attribute :name, String, size: 3..20
+    #   end
+    #
+    # @example Add a new attribute with array type
+    #   class User < Dry::Struct
+    #     attribute :name, [String]
+    #   end
+    #
+    # @param name [Symbol]
+    # @param constrains [Array<#to_type>]
+    # @option default [#call, Any]
+    # @return [void]
+    def self.attribute(field, *constrains, **options, &block)
+      alias_fields(field, **options) do |inner_options|
+        super(field, build_type_from(*constrains, **inner_options), &block)
+      end
+    end
+
+    # Optional version of {#attribute}
+    #
+    # @see #attribute
+    def self.attribute?(field, *constrains, **options, &block)
+      alias_fields(field, **options) do |inner_options|
+        super(field, build_type_from(*constrains, **inner_options), &block)
+      end
+    end
+
     def self.const_missing(name)
       case name
       when :Abstract
@@ -75,5 +140,36 @@ module Dry
 
       super
     end
+
+    def self.alias_fields(_field, aliases: [], **options, &block)
+      if options.key?(:alias)
+        aliases << options.delete(:alias)
+      end
+
+      block[options]
+
+      aliases.each do |alias_name|
+        alias_method alias_name, name
+      end
+    end
+
+    # @api private
+    def self.build_type_from(*constrains, **options)
+      unless (type = constrains.map(&:to_type).reduce(:|))
+        return build_type_from(Dry::Types["any"], **options)
+      end
+
+      if options.key?(:default)
+        options.delete(:default).to_default.then do |default_proc|
+          return build_type_from(type.default(&default_proc), **options)
+        end
+      end
+
+      if options.empty?
+        return type
+      end
+
+      build_type_from(type.constrained(**options))
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dry-interface
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Linus Oleander
@@ -60,11 +60,15 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/dry/interface.rb
+- lib/dry/interface/extensions.rb
+- lib/dry/interface/extensions/default.rb
+- lib/dry/interface/extensions/type.rb
 - lib/dry/interface/interfaces.rb
 - lib/dry/interface/interfaces/abstract.rb
 - lib/dry/interface/interfaces/common.rb
 - lib/dry/interface/interfaces/concrete.rb
 - lib/dry/interface/interfaces/value.rb
+- lib/dry/interface/types.rb
 homepage: https://github.com/oleander/dry-interface
 licenses:
 - MIT