dry-struct 0.6.0 → 1.4.0

data/lib/dry/struct/class_interface.rb

@@ -1,10 +1,13 @@
-require 'dry/core/class_attributes'
-require 'dry/core/inflector'
-require 'dry/core/descendants_tracker'
+# frozen_string_literal: true
 
-require 'dry/struct/errors'
-require 'dry/struct/constructor'
-require 'dry/struct/sum'
+require "weakref"
+require "dry/core/class_attributes"
+require "dry/core/inflector"
+require "dry/core/descendants_tracker"
+
+require "dry/struct/errors"
+require "dry/struct/constructor"
+require "dry/struct/sum"
 
 module Dry
   class Struct
@@ -12,21 +15,15 @@ module Dry
     module ClassInterface
       include Core::ClassAttributes
 
-      include Dry::Types::Type
-      include Dry::Types::Builder
+      include Types::Type
+      include Types::Builder
 
       # @param [Class] klass
       def inherited(klass)
         super
 
-        base = self
-
-        klass.class_eval do
-          @meta = base.meta
-
-          unless equal?(Value)
-            extend Dry::Core::DescendantsTracker
-          end
+        unless klass.name.eql?("Dry::Struct::Value")
+          klass.extend(Core::DescendantsTracker)
         end
       end
 
@@ -34,7 +31,7 @@ module Dry
       # and modifies {.schema} accordingly.
       #
       # @param [Symbol] name name of the defined attribute
-      # @param [Dry::Types::Definition, nil] type or superclass of nested type
+      # @param [Dry::Types::Type, nil] type or superclass of nested type
       # @return [Dry::Struct]
       # @yield
       #   If a block is given, it will be evaluated in the context of
@@ -53,10 +50,7 @@ module Dry
       #   end
       #
       #   Language.schema
-      #     #=> {
-      #           :name=>#<Dry::Types::Definition primitive=String options={} meta={}>,
-      #           :details=>Language::Details
-      #         }
+      #   # => #<Dry::Types[Constructor<Schema<keys={name: Constrained<Nominal<String> rule=[type?(String)]> details: Language::Details}> fn=Kernel.Hash>]>
       #
       #   ruby = Language.new(name: 'Ruby', details: { type: 'OO' })
       #   ruby.name #=> 'Ruby'
@@ -66,19 +60,19 @@ module Dry
       # @example with a nested array of structs
       #   class Language < Dry::Struct
       #     attribute :name, Types::String
-      #     array :versions, Types::String
-      #     array :celebrities, Types::Array.of(Dry::Struct) do
+      #     attribute :versions, Types::Array.of(Types::String)
+      #     attribute :celebrities, Types::Array.of(Dry::Struct) do
       #       attribute :name, Types::String
       #       attribute :pseudonym, Types::String
       #     end
       #   end
       #
       #   Language.schema
-      #     #=> {
-      #           :name=>#<Dry::Types::Definition primitive=String options={} meta={}>,
-      #           :versions=>#<Dry::Types::Array::Member primitive=Array options={:member=>#<Dry::Types::Definition primitive=String options={} meta={}>} meta={}>,
-      #           :celebrities=>#<Dry::Types::Array::Member primitive=Array options={:member=>Language::Celebrity} meta={}>
-      #         }
+      #   => #<Dry::Types[Constructor<Schema<keys={
+      #         name: Constrained<Nominal<String> rule=[type?(String)]>
+      #         versions: Constrained<Array<Constrained<Nominal<String> rule=[type?(String)]>> rule=[type?(Array)]>
+      #         celebrities: Constrained<Array<Language::Celebrity> rule=[type?(Array)]>
+      #      }> fn=Kernel.Hash>]>
       #
       #   ruby = Language.new(
       #     name: 'Ruby',
@@ -99,41 +93,76 @@ module Dry
       #   ruby.celebrities[0].pseudonym #=> 'Matz'
       #   ruby.celebrities[1].name #=> 'Aaron Patterson'
       #   ruby.celebrities[1].pseudonym #=> 'tenderlove'
-      def attribute(name, type = nil, &block)
+      def attribute(name, type = Undefined, &block)
         attributes(name => build_type(name, type, &block))
       end
 
+      # Add atributes from another struct
+      #
+      # @example
+      #   class Address < Dry::Struct
+      #     attribute :city, Types::String
+      #     attribute :country, Types::String
+      #   end
+      #
+      #   class User < Dry::Struct
+      #     attribute :name, Types::String
+      #     attributes_from Address
+      #   end
+      #
+      #   User.new(name: 'Quispe', city: 'La Paz', country: 'Bolivia')
+      #
+      # @example with nested structs
+      #   class User < Dry::Struct
+      #     attribute :name, Types::String
+      #     attribute :address do
+      #       attributes_from Address
+      #     end
+      #   end
+      #
+      # @param struct [Dry::Struct]
+      def attributes_from(struct)
+        extracted_schema = struct.schema.keys.map { |key|
+          if key.required?
+            [key.name, key.type]
+          else
+            [:"#{key.name}?", key.type]
+          end
+        }.to_h
+        attributes(extracted_schema)
+      end
+
       # Adds an omittable (key is not required on initialization) attribute for this {Struct}
       #
       # @example
       #   class User < Dry::Struct
-      #     attribute  :name,  Types::Strict::String
-      #     attribute? :email, Types::Strict::String
+      #     attribute  :name,  Types::String
+      #     attribute? :email, Types::String
       #   end
       #
-      #   User.new(name: 'John') # => #<User name="John">
+      #   User.new(name: 'John') # => #<User name="John" email=nil>
       #
       # @param [Symbol] name name of the defined attribute
-      # @param [Dry::Types::Definition, nil] type or superclass of nested type
+      # @param [Dry::Types::Type, nil] type or superclass of nested type
       # @return [Dry::Struct]
       #
       def attribute?(*args, &block)
         if args.size == 1 && block.nil?
-          Dry::Core::Deprecations.warn(
-            'Dry::Struct.attribute? is deprecated for checking attribute presence, '\
-            'use has_attribute? instead',
+          Core::Deprecations.warn(
+            "Dry::Struct.attribute? is deprecated for checking attribute presence, "\
+            "use has_attribute? instead",
             tag: :'dry-struct'
           )
 
           has_attribute?(args[0])
         else
-          name, type = args
+          name, * = args
 
-          attribute(name, build_type(name, type, &block).meta(omittable: true))
+          attribute(:"#{name}?", build_type(*args, &block))
         end
       end
 
-      # @param [Hash{Symbol => Dry::Types::Definition}] new_schema
+      # @param [Hash{Symbol => Dry::Types::Type}] new_schema
       # @return [Dry::Struct]
       # @raise [RepeatedAttributeError] when trying to define attribute with the
       #   same name as previously defined one
@@ -147,27 +176,25 @@ module Dry
       #   end
       #
       #   Book.schema
-      #     #=> {title: #<Dry::Types::Definition primitive=String options={}>,
-      #     #    author: #<Dry::Types::Definition primitive=String options={}>}
+      #   # => #<Dry::Types[Constructor<Schema<keys={
+      #   #      title: Constrained<Nominal<String> rule=[type?(String)]>
+      #   #      author: Constrained<Nominal<String> rule=[type?(String)]>
+      #   #    }> fn=Kernel.Hash>]>
       def attributes(new_schema)
-        check_schema_duplication(new_schema)
+        keys = new_schema.keys.map { |k| k.to_s.chomp("?").to_sym }
+        check_schema_duplication(keys)
 
-        input input.schema(new_schema)
+        schema schema.schema(new_schema)
 
-        new_schema.each_key do |key|
-          next if instance_methods.include?(key)
-          class_eval(<<-RUBY)
-            def #{ key }
-              @attributes[#{ key.inspect }]
-            end
-          RUBY
-        end
+        define_accessors(keys)
 
         @attribute_names = nil
 
-        descendants.
-          select { |d| d.superclass == self }.
-          each { |d| d.attributes(new_schema.reject { |k, _| d.schema.key?(k) }) }
+        direct_descendants = descendants.select { |d| d.superclass == self }
+        direct_descendants.each do |d|
+          inherited_attrs = new_schema.reject { |k, _| d.has_attribute?(k.to_s.chomp("?").to_sym) }
+          d.attributes(inherited_attrs)
+        end
 
         self
       end
@@ -180,13 +207,13 @@ module Dry
       #   class Book < Dry::Struct
       #     transform_types { |t| t.meta(struct: :Book) }
       #
-      #     attribute :title, Types::Strict::String
+      #     attribute :title, Types::String
       #   end
       #
-      #   Book.schema[:title].meta # => { struct: :Book }
+      #   Book.schema.key(:title).meta # => { struct: :Book }
       #
       def transform_types(proc = nil, &block)
-        input input.with_type_transform(proc || block)
+        schema schema.with_type_transform(proc || block)
       end
 
       # Add an arbitrary transformation for input hash keys.
@@ -197,54 +224,80 @@ module Dry
       #   class Book < Dry::Struct
       #     transform_keys(&:to_sym)
       #
-      #     attribute :title, Types::Strict::String
+      #     attribute :title, Types::String
       #   end
       #
       #   Book.new('title' => "The Old Man and the Sea")
       #   # => #<Book title="The Old Man and the Sea">
       def transform_keys(proc = nil, &block)
-        input input.with_key_transform(proc || block)
+        schema schema.with_key_transform(proc || block)
       end
 
-      # @param [Hash{Symbol => Dry::Types::Definition, Dry::Struct}] new_schema
+      # @param [Hash{Symbol => Dry::Types::Type, Dry::Struct}] new_keys
       # @raise [RepeatedAttributeError] when trying to define attribute with the
       #   same name as previously defined one
-      def check_schema_duplication(new_schema)
-        shared_keys = new_schema.keys & (schema.keys - superclass.schema.keys)
+      def check_schema_duplication(new_keys)
+        overlapping_keys = new_keys & (attribute_names - superclass.attribute_names)
 
-        raise RepeatedAttributeError, shared_keys.first if shared_keys.any?
+        if overlapping_keys.any?
+          raise RepeatedAttributeError, overlapping_keys.first
+        end
       end
       private :check_schema_duplication
 
       # @param [Hash{Symbol => Object},Dry::Struct] attributes
       # @raise [Struct::Error] if the given attributes don't conform {#schema}
-      def new(attributes = default_attributes)
-        if attributes.instance_of?(self)
-          attributes
+      def new(attributes = default_attributes, safe = false, &block)
+        if attributes.is_a?(Struct)
+          if equal?(attributes.class)
+            attributes
+          else
+            # This implicit coercion is arguable but makes sense overall
+            # in cases there you pass child struct to the base struct constructor
+            # User.new(super_user)
+            #
+            # We may deprecate this behavior in future forcing people to be explicit
+            new(attributes.to_h, safe, &block)
+          end
+        elsif safe
+          load(schema.call_safe(attributes) { |output = attributes| return yield output })
         else
-          super(input[attributes])
+          load(schema.call_unsafe(attributes))
         end
-      rescue Types::SchemaError, Types::MissingKeyError, Types::UnknownKeysError => error
-        raise Struct::Error, "[#{self}.new] #{error}"
+      rescue Types::CoercionError => e
+        raise Error, "[#{self}.new] #{e}", e.backtrace
       end
 
-      # Calls type constructor. The behavior is identical to `.new` but returns
-      # the input back if it's a subclass of the struct.
-      #
-      # @param [Hash{Symbol => Object},Dry::Struct] attributes
-      # @return [Dry::Struct]
-      def call(attributes = default_attributes)
-        return attributes if attributes.is_a?(self)
-        new(attributes)
+      # @api private
+      def call_safe(input, &block)
+        if input.is_a?(self)
+          input
+        else
+          new(input, true, &block)
+        end
+      end
+
+      # @api private
+      def call_unsafe(input)
+        if input.is_a?(self)
+          input
+        else
+          new(input)
+        end
+      end
+
+      # @api private
+      def load(attributes)
+        struct = allocate
+        struct.__send__(:initialize, attributes)
+        struct
       end
-      alias_method :[], :call
 
       # @param [#call,nil] constructor
-      # @param [Hash] _options
       # @param [#call,nil] block
       # @return [Dry::Struct::Constructor]
-      def constructor(constructor = nil, **_options, &block)
-        Struct::Constructor.new(self, fn: constructor || block)
+      def constructor(constructor = nil, **, &block)
+        Constructor[self, fn: constructor || block]
       end
 
       # @param [Hash{Symbol => Object},Dry::Struct] input
@@ -252,10 +305,10 @@ module Dry
       # @yieldreturn [Dry::Types::ResultResult]
       # @return [Dry::Types::Result]
       def try(input)
-        Types::Result::Success.new(self[input])
-      rescue Struct::Error => e
-        failure = Types::Result::Failure.new(input, e.message)
-        block_given? ? yield(failure) : failure
+        success(self[input])
+      rescue Error => e
+        failure_result = failure(input, e.message)
+        block_given? ? yield(failure_result) : failure_result
       end
 
       # @param [Hash{Symbol => Object},Dry::Struct] input
@@ -263,7 +316,7 @@ module Dry
       # @private
       def try_struct(input)
         if input.is_a?(self)
-          Types::Result::Success.new(input)
+          input
         else
           yield
         end
@@ -278,7 +331,7 @@ module Dry
       # @param [({Symbol => Object})] args
       # @return [Dry::Types::Result::Failure]
       def failure(*args)
-        result(::Dry::Types::Result::Failure, *args)
+        result(Types::Result::Failure, *args)
       end
 
       # @param [Class] klass
@@ -292,11 +345,12 @@ module Dry
         false
       end
 
-      # @param [Object, Dry::Struct] value
+      # @param [Object, Dry::Struct] other
       # @return [Boolean]
-      def valid?(value)
-        self === value
+      def ===(other)
+        other.is_a?(self)
       end
+      alias_method :primitive?, :===
 
       # @return [true]
       def constrained?
@@ -313,6 +367,11 @@ module Dry
         false
       end
 
+      # @return [Proc]
+      def to_proc
+        @to_proc ||= proc { |input| call(input) }
+      end
+
       # Checks if this {Struct} has the given attribute
       #
       # @param [Symbol] key Attribute name
@@ -321,25 +380,22 @@ module Dry
         schema.key?(key)
       end
 
-      # @return [Hash{Symbol => Dry::Types::Definition, Dry::Struct}]
-      def schema
-        input.member_types
-      end
-
       # Gets the list of attribute names
       #
       # @return [Array<Symbol>]
       def attribute_names
-        @attribute_names ||= schema.keys
+        @attribute_names ||= schema.map(&:name)
       end
 
       # @return [{Symbol => Object}]
       def meta(meta = Undefined)
         if meta.equal?(Undefined)
-          @meta
+          schema.meta
+        elsif meta.empty?
+          self
         else
-          Class.new(self) do
-            @meta = @meta.merge(meta) unless meta.empty?
+          ::Class.new(self) do
+            schema schema.meta(meta) unless meta.empty?
           end
         end
       end
@@ -348,13 +404,28 @@ module Dry
       # @param [Dry::Types::Type] type
       # @return [Dry::Types::Sum]
       def |(type)
-        if type.is_a?(Class) && type <= Struct
-          Struct::Sum.new(self, type)
+        if type.is_a?(::Class) && type <= Struct
+          Sum.new(self, type)
         else
           super
         end
       end
 
+      # Make the struct abstract. This class will be used as a default
+      # parent class for nested structs
+      def abstract
+        abstract_class self
+      end
+
+      # Dump to the AST
+      #
+      # @return [Array]
+      #
+      # @api public
+      def to_ast(meta: true)
+        [:struct, [::WeakRef.new(self), schema.to_ast(meta: meta)]]
+      end
+
       # Stores an object for building nested struct classes
       # @return [StructBuilder]
       def struct_builder
@@ -367,32 +438,32 @@ module Dry
       #
       # @return [Hash{Symbol => Object}]
       def default_attributes(default_schema = schema)
-        default_schema.each_with_object({}) do |(name, type), result|
-          result[name] = default_attributes(type.schema) if struct?(type)
+        default_schema.each_with_object({}) do |key, result|
+          result[key.name] = default_attributes(key.schema) if struct?(key.type)
         end
       end
       private :default_attributes
 
       # Checks if the given type is a Dry::Struct
       #
-      # @param [Dry::Types::Definition, Dry::Struct] type
+      # @param [Dry::Types::Type] type
       # @return [Boolean]
       def struct?(type)
-        type.is_a?(Class) && type <= Struct
+        type.is_a?(::Class) && type <= Struct
       end
       private :struct?
 
       # Constructs a type
       #
       # @return [Dry::Types::Type, Dry::Struct]
-      def build_type(name, type, &block)
+      def build_type(name, type = Undefined, &block)
         type_object =
-          if type.is_a?(String)
-            Dry::Types[type]
-          elsif block.nil? && type.nil?
+          if type.is_a?(::String)
+            Types[type]
+          elsif block.nil? && Undefined.equal?(type)
             raise(
-              ArgumentError,
-              'you must supply a type or a block to `Dry::Struct.attribute`'
+              ::ArgumentError,
+              "you must supply a type or a block to `Dry::Struct.attribute`"
             )
           else
             type
@@ -405,6 +476,19 @@ module Dry
         end
       end
       private :build_type
+
+      def define_accessors(keys)
+        keys.each do |key|
+          next if instance_methods.include?(key)
+
+          class_eval(<<-RUBY)
+            def #{key}
+              @attributes[#{key.inspect}]
+            end
+          RUBY
+        end
+      end
+      private :define_accessors
     end
   end
 end

data/lib/dry/struct/compiler.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "weakref"
+require "dry/types/compiler"
+
+module Dry
+  class Struct
+    class Compiler < Types::Compiler
+      def visit_struct(node)
+        struct, _ = node
+
+        struct.__getobj__
+      rescue ::WeakRef::RefError
+        if struct.weakref_alive?
+          raise
+        else
+          raise RecycledStructError
+        end
+      end
+    end
+  end
+end

data/lib/dry/struct/constructor.rb

@@ -1,29 +1,9 @@
+# frozen_string_literal: true
+
 module Dry
   class Struct
-    class Constructor
-      include Dry::Equalizer(:type)
-      include Dry::Types::Type
-
-      # @return [#call]
-      attr_reader :fn
-
-      # @return [#call]
-      attr_reader :type
-
-      # @param [Struct] type
-      # @param [Hash] options
-      # @param [#call, nil] block
-      def initialize(type, options = {}, &block)
-        @type = type
-        @fn = options.fetch(:fn, block)
-      end
-
-      # @param [Object] input
-      # @return [Object]
-      def call(input)
-        type[fn[input]]
-      end
-      alias_method :[], :call
+    class Constructor < Types::Constructor
+      alias_method :primitive, :type
     end
   end
 end

data/lib/dry/struct/errors.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Dry
   class Struct
     # Raised when given input doesn't conform schema and constructor type
     Error = Class.new(TypeError)
 
     # Raised when defining duplicate attributes
-    class RepeatedAttributeError < ArgumentError
+    class RepeatedAttributeError < ::ArgumentError
       # @param [Symbol] key
       #   attribute name that is the same as previously defined one
       def initialize(key)
@@ -13,9 +15,17 @@ module Dry
     end
 
     # Raised when a struct doesn't have an attribute
-    class MissingAttributeError < KeyError
+    class MissingAttributeError < ::KeyError
       def initialize(key)
-        super("Missing attribute: #{ key.inspect }")
+        super("Missing attribute: #{key.inspect}")
+      end
+    end
+
+    # When struct class stored in ast was garbage collected because no alive objects exists
+    # This shouldn't happen in a working application
+    class RecycledStructError < ::RuntimeError
+      def initialize
+        super("Reference to struct class was garbage collected")
       end
     end
   end

data/lib/dry/struct/extensions/pretty_print.rb

@@ -1,16 +1,18 @@
-require 'pp'
+# frozen_string_literal: true
+
+require "pp"
 
 module Dry
   class Struct
     def pretty_print(pp)
       klass = self.class
-      pp.group(1, "#<#{ klass.name || klass.inspect }", '>') do
-        pp.seplist(@attributes.keys, proc { pp.text ',' }) do |column_name|
+      pp.group(1, "#<#{klass.name || klass.inspect}", ">") do
+        pp.seplist(@attributes.keys, proc { pp.text "," }) do |column_name|
           column_value = @attributes[column_name]
-          pp.breakable ' '
+          pp.breakable " "
           pp.group(1) do
             pp.text column_name
-            pp.text '='
+            pp.text "="
             pp.pp column_value
           end
         end

data/lib/dry/struct/extensions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Dry::Struct.register_extension(:pretty_print) do
-  require 'dry/struct/extensions/pretty_print'
+  require "dry/struct/extensions/pretty_print"
 end

data/lib/dry/struct/hashify.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dry
   class Struct
     # Helper for {Struct#to_hash} implementation
@@ -6,12 +8,10 @@ module Dry
       # @param [#to_hash, #map, Object] value
       # @return [Hash, Array]
       def self.[](value)
-        if value.respond_to?(:to_hash)
-          if RUBY_VERSION >= '2.4'
-            value.to_hash.transform_values { |v| self[v] }
-          else
-            value.to_hash.each_with_object({}) { |(k, v), h| h[k] = self[v] }
-          end
+        if value.is_a?(Struct)
+          value.to_h.transform_values { |current| self[current] }
+        elsif value.respond_to?(:to_hash)
+          value.to_hash.transform_values { |current| self[current] }
         elsif value.respond_to?(:to_ary)
           value.to_ary.map { |item| self[item] }
         else