dry-interface 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24db806ee3d1f2da11074d2478d9de936a992f5ca834855c3d98cfdefbaab771
-  data.tar.gz: 7d84cd10027df4ecc162eda1728da6048a6d2fb78638cbc909806bbef814eac8
+  metadata.gz: b05534847a5f500b3095bc1e1f752006395f4de8b9f3da99e6a6535a26ada354
+  data.tar.gz: d8bf8f9f0d1fcf5eeaf10bfcaa29d83630c0ffbbd9bcc4274436e90bfe7a935f
 SHA512:
-  metadata.gz: 31158c8bd2ad52614c2c278f04279ee08ae22d9b73600f9b2aa272736919f24a65677d9cc20f06eac97190b4bdfbc1771ec9dc725a7d816ddbf4094ef4035938
-  data.tar.gz: e017702e3900a9113fa681d17eb4b210aedecf1b4a498881403f989f64c5380b04fca6fad4dade6be26dbc5c8b7008784bddbcd03766e04507ae1f44303f2615
+  metadata.gz: 8a31c77b1aefa20e3ea3f763d1bbde2630f9599134ddbce053c9da574f65e77c84c4b8bf1b56812de401ab94fdd36695f3c36c9bd97d74c6ce830217f49ef8a2
+  data.tar.gz: 2d7f3a2ad607d2ac0628840eaf0a6ac6dcffd244c2736a18cfa8ac166170a06defb08b5e0a77cc9fdb8622fe06cf2fe8a29f3843fb85169bbb1ec2c8d21193c6

data/lib/dry/{interface → concrete}/extensions/default.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dry
-  class Interface
+  class Concrete
     module Extensions
       module Default
         refine Proc do

data/lib/dry/{interface → concrete}/extensions/type.rb

@@ -4,7 +4,7 @@ require "dry/struct"
 require "dry/types"
 
 module Dry
-  class Interface
+  class Concrete
     module Extensions
       module Type
         module Types
@@ -84,6 +84,20 @@ module Dry
           alias_method :to_type, :itself
         end
 
+        refine Dry::Concrete.singleton_class 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
           #

data/lib/dry/concrete/extensions.rb

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

data/lib/dry/concrete/value.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Dry
+  class Concrete
+    class Value < self
+      def self.new(value, *other, &block)
+        case value
+        in Hash => attributes then super(attributes, *other, &block)
+        in Dry::Struct => instance then instance
+        else
+          case attribute_names
+          in [] then raise ArgumentError, "[#{self}] has no attributes, one is required"
+          in [key] then super({ key => value }, *other, &block)
+          else
+            raise ArgumentError, "[#{self}] has more than one attribute: #{attribute_names.join(', ')}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/concrete.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/concerning"
+require "active_support/core_ext/module/delegation"
+require "active_support/descendants_tracker"
+require "active_support/configurable"
+require "active_support/inflector"
+require "active_support/concern"
+require "dry/struct"
+require "dry/types"
+
+module Dry
+  autoload :Interface, "dry/interface"
+
+  class Concrete < Dry::Struct
+    autoload :Extensions, "dry/concrete/extensions"
+    autoload :Value, "dry/concrete/value"
+    autoload :Types, "dry/interface/types"
+
+    schema schema.strict(true)
+
+    include Dry.Types(:strict, :nominal, :coercible)
+
+    extend ActiveSupport::DescendantsTracker
+    include ActiveSupport::Configurable
+    extend ActiveSupport::Inflector
+
+    using Extensions::Default
+    using Extensions::Type
+
+    config.order = Hash.new(-1)
+
+    delegate(*%i[
+               Constructor
+               Interface
+               Instance
+               Constant
+               Nominal
+               Value
+               Array
+               Hash
+               Any
+             ], to: :Types)
+
+    def self.initializer(owner, &block)
+      owner.schema owner.schema.constructor(&block)
+    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.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, field
+      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

data/lib/dry/interface/interfaces/abstract.rb

@@ -1,19 +1,28 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module/introspection"
+require "active_support/core_ext/module/attribute_accessors"
+
 module Dry
   class Interface
     module Interfaces
       module Abstract
         extend ActiveSupport::Concern
-        include Common
 
         class_methods do
-          def type
-            direct_descendants.map(&:type).reduce(&:|) or raise "No types defined for [#{self}]"
+          # Class name without parent module
+          #
+          # @return [String]
+          def name
+            demodulize(super)
           end
 
-          def named
-            format "%<name>s<[%<names>s]>", { name: name, names: direct_descendants.map(&:named).join(" | ") }
+          def new(input, safe = false, &block)
+            if safe
+              call_safe(input, &block)
+            else
+              call_unsafe(input)
+            end
           end
         end
       end

data/lib/dry/interface/interfaces/concrete.rb

@@ -1,25 +1,45 @@
 # frozen_string_literal: true
 
+# module C
+#   def structs
+#     [self]
+#   end
+
+#   def named
+#     to_s
+#   end
+
+#   def type
+#     self
+#   end
+# end
+
 module Dry
   class Interface
     module Interfaces
       module Concrete
         extend ActiveSupport::Concern
-        include Common
 
-        included do
+        prepended do
           class << self
+            alias_method :call_safe, :_call_safe
+            alias_method :call_unsafe, :_call_unsafe
             alias_method :new, :_new
+            alias_method :call, :_call
           end
         end
+        # included do
+        #   class << self
+        #     alias_method :call, :_call
+        #   end
+        # end
 
         class_methods do
-          def type
-            direct_descendants.first or self
-          end
-
-          def named
-            direct_descendants.first&.name or name
+          # Class name without parent module
+          #
+          # @return [String]
+          def to_s
+            demodulize(name)
           end
         end
       end

data/lib/dry/interface/interfaces/unit.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Interfaces
+      module Unit
+        extend ActiveSupport::Concern
+
+        prepended do
+          class << self
+            alias_method :call, :_call
+            alias_method :call_unsafe, :_call_unsafe
+            alias_method :call_safe, :_call_safe
+          end
+        end
+
+        class_methods do
+          # Class name without parent module
+          #
+          # @return [String]
+          def to_s
+            demodulize(name)
+          end
+
+          # Allows a struct to be called without a hash
+          #
+          # @param value [Dry::Struct, Hash, Any]
+          # @param block [Proc]
+          #
+          # @return [Dry::Struct]
+
+          def new(value, *other, &block)
+            case value
+            in Hash => attributes then _new(attributes, *other, &block)
+            in Dry::Struct => instance then instance
+            else
+              case attribute_names
+              in [] then raise ArgumentError, "[#{self}] has no attributes, one is required"
+              in [key] then _new({ key => value }, *other, &block)
+              else
+                raise ArgumentError, "[#{self}] has more than one attribute: #{attribute_names.join(', ')}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dry/interface/interfaces.rb

@@ -3,8 +3,7 @@
 module Dry
   class Interface
     module Interfaces
-      autoload :Value, "dry/interface/interfaces/value"
-      autoload :Common, "dry/interface/interfaces/common"
+      autoload :Unit, "dry/interface/interfaces/unit"
       autoload :Abstract, "dry/interface/interfaces/abstract"
       autoload :Concrete, "dry/interface/interfaces/concrete"
     end

data/lib/dry/interface/patch.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Dry
+  class Interface
+    module Patch
+      autoload :Value, "dry/interface/patch/value"
+      autoload :Abstract, "dry/interface/patch/abstract"
+      autoload :Concrete, "dry/interface/patch/concrete"
+    end
+  end
+end

data/lib/dry/interface.rb

@@ -6,170 +6,118 @@ require "active_support/descendants_tracker"
 require "active_support/configurable"
 require "active_support/inflector"
 require "active_support/concern"
-require "dry/struct"
 require "dry/types"
 
 module Dry
-  class Interface < Dry::Struct
+  autoload :Concrete, "dry/concrete"
+
+  class Interface < Concrete
     autoload :Interfaces, "dry/interface/interfaces"
-    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
-          alias_method :_new, :new
-        end
-      end
-    end
+    include ActiveSupport::Configurable
 
-    module Types
-      include Dry.Types()
-    end
+    config.order = Hash.new(-1)
 
-    def self.Value(...)
-      Types.Value(...)
-    end
-
-    def self.type
-      direct_descendants.map(&:type).reduce(&:|)
-    end
+    class << self
+      alias _new new
+      alias _call call
+      alias _call_safe call_safe
+      alias _call_unsafe call_unsafe
 
-    def self.named
-      format "%<name>s<[%<names>s]>", { name: name, names: direct_descendants.map(&:named).join(" | ") }
+      delegate :call, to: :subtype
+      delegate :call_safe, to: :subtype
+      delegate :call_unsafe, to: :subtype
     end
 
-    def self.new(...)
-      return super unless type
-
-      type.call(...)
-    end
+    # Allow types structs to be ordered
+    #
+    # @param names [Array<Symbol>]
+    def self.order(*names)
+      result = names.each_with_index.reduce(EMPTY_HASH) do |acc, (name, index)|
+        acc.merge(name.to_s => index)
+      end
 
-    def self.initializer(owner, &block)
-      owner.schema owner.schema.constructor(&block)
+      config.order = result
     end
 
-    def self.otherwise(&block)
-      initializer(self) do |input, type, &error|
-        type[input] { block[input, type, &error] }
-      end
+    # @return [String]
+    def self.to_s
+      format("%<name>s<[%<types>s]>", name: name, types: subtypes.map(&:to_s).join(" | "))
     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)
+    def self.reduce(input, subtype)
+      case input
+      in { result: }
+        input
+      in { value: }
+        { result: subtype.call(value) }
       end
+    rescue Dry::Struct::Error => e
+      em = Dry::Types::ConstraintError.new(e.message, input.fetch(:value))
+      input.merge(errors: input.fetch(:errors, []) + [em])
+    rescue Dry::Types::CoercionError => e
+      input.merge(errors: input.fetch(:errors, []) + [e])
     end
 
-    # Optional version of {#attribute}
+    # Internal type represented by {self}
     #
-    # @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
-        return Class.new(self) do
-          include Interfaces::Abstract
+    # @return [Dry::Struct::Sum, Dry::Struct::Class]
+    def self.subtype
+      Constructor(self) do |value, _type, &error|
+        error ||= lambda do |error|
+          raise error
         end
-      when :Concrete
-        return Class.new(self) do
-          include Interfaces::Concrete
+
+        if subtypes.empty?
+          raise NotImplementedError, "No subtypes defined for #{name}"
         end
-      when :Value
-        return Class.new(self) do
-          include Interfaces::Value
+
+        output = subtypes.reduce({ value: value }, &method(:reduce))
+
+        case output
+        in { result: }
+          result
+        in { errors: }
+          error[Dry::Types::MultipleError.new(errors)]
+        in Dry::Struct
+          output
         end
       end
-
-      super
     end
 
-    def self.alias_fields(_field, aliases: [], **options, &block)
-      if options.key?(:alias)
-        aliases << options.delete(:alias)
-      end
+    # Internal types represented by {self}
+    #
+    # @return [Dry::Struct::Class]
+    def self.subtypes
+      types = subclasses.flat_map(&:subclasses)
 
-      block[options]
+      return types if config.order.empty?
 
-      aliases.each do |alias_name|
-        alias_method alias_name, name
+      types.sort_by do |type|
+        config.order.fetch(demodulize(type.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)
+    # @param name [Symbol]
+    #
+    # @return [Abstract::Class]
+    def self.const_missing(name)
+      case name
+      in :Concrete
+        Class.new(self) do
+          prepend Interfaces::Concrete
         end
+      in :Abstract
+        Class.new(self) do
+          prepend Interfaces::Abstract
+        end
+      in :Unit
+        Class.new(self) do
+          prepend Interfaces::Unit
+        end
+      else
+        super
       end
-
-      if options.empty?
-        return type
-      end
-
-      build_type_from(type.constrained(**options))
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dry-interface
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Linus Oleander
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-21 00:00:00.000000000 Z
+date: 2021-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -59,15 +59,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/dry/concrete.rb
+- lib/dry/concrete/extensions.rb
+- lib/dry/concrete/extensions/default.rb
+- lib/dry/concrete/extensions/type.rb
+- lib/dry/concrete/value.rb
 - 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/interfaces/unit.rb
+- lib/dry/interface/patch.rb
 - lib/dry/interface/types.rb
 homepage: https://github.com/oleander/dry-interface
 licenses:

data/lib/dry/interface/extensions.rb

@@ -1,10 +0,0 @@
-# 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/interfaces/common.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  class Interface
-    module Interfaces
-      module Common
-        extend ActiveSupport::Concern
-
-        class_methods do
-          def name
-            demodulize(super)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dry/interface/interfaces/value.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Dry
-  class Interface
-    module Interfaces
-      module Value
-        extend ActiveSupport::Concern
-        include Concrete
-
-        included do |child|
-          otherwise do |value, type, &error|
-            names = child.type.attribute_names
-
-            unless names.one?
-              raise ArgumentError, "Value classes must have exactly one attribute, got [#{names.join(', ')}] (#{names.count}) for [#{child}]"
-            end
-
-            type[names.first => value, &error]
-          end
-        end
-      end
-    end
-  end
-end