dry-struct 1.0.0 → 1.6.0

data/lib/dry/struct/class_interface.rb

@@ -1,32 +1,22 @@
-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"
 
 module Dry
   class Struct
     # Class-level interface of {Struct} and {Value}
-    module ClassInterface
+    module ClassInterface # rubocop:disable Metrics/ModuleLength
       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
 
@@ -52,8 +42,12 @@ module Dry
       #     end
       #   end
       #
-      #   Language.schema
-      #   # => #<Dry::Types[Constructor<Schema<keys={name: Nominal<String> details: Language::Details}> fn=Kernel.Hash>]>
+      #   Language.schema # new lines for readability
+      #   # => #<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'
@@ -70,11 +64,13 @@ module Dry
       #     end
       #   end
       #
-      #   Language.schema
+      #   Language.schema # new lines for readability
       #   => #<Dry::Types[Constructor<Schema<keys={
-      #         name: Nominal<String>
-      #         versions: Array<Nominal<String>>
-      #         celebrities: Array<Language::Celebrity>
+      #         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(
@@ -96,19 +92,54 @@ 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::Type, nil] type or superclass of nested type
@@ -116,17 +147,17 @@ module Dry
       #
       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',
-            tag: :'dry-struct'
+          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))
+          attribute(:"#{name}?", build_type(*args, &block))
         end
       end
 
@@ -145,29 +176,22 @@ module Dry
       #
       #   Book.schema
       #   # => #<Dry::Types[Constructor<Schema<keys={
-      #   #      title: Nominal<String>
-      #   #      author: Nominal<String>
+      #   #      title: Constrained<Nominal<String> rule=[type?(String)]>
+      #   #      author: Constrained<Nominal<String> rule=[type?(String)]>
       #   #    }> fn=Kernel.Hash>]>
       def attributes(new_schema)
-        keys = new_schema.keys.map { |k| k.to_s.chomp('?').to_sym }
+        keys = new_schema.keys.map { |k| k.to_s.chomp("?").to_sym }
         check_schema_duplication(keys)
 
         schema schema.schema(new_schema)
 
-        keys.each 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
 
         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) }
+          inherited_attrs = new_schema.reject { |k, _| d.has_attribute?(k.to_s.chomp("?").to_sym) }
           d.attributes(inherited_attrs)
         end
 
@@ -182,7 +206,7 @@ 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.key(:title).meta # => { struct: :Book }
@@ -199,7 +223,7 @@ 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")
@@ -208,7 +232,7 @@ module Dry
         schema schema.with_key_transform(proc || block)
       end
 
-      # @param [Hash{Symbol => Dry::Types::Type, 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_keys)
@@ -222,16 +246,25 @@ module Dry
 
       # @param [Hash{Symbol => Object},Dry::Struct] attributes
       # @raise [Struct::Error] if the given attributes don't conform {#schema}
-      def new(attributes = default_attributes, safe = false)
-        if equal?(attributes.class)
-          attributes
+      def new(attributes = default_attributes, safe = false, &block) # rubocop:disable Style/OptionalBooleanParameter
+        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
           load(schema.call_unsafe(attributes))
         end
-      rescue Types::CoercionError => error
-        raise Struct::Error, "[#{self}.new] #{error}"
+      rescue Types::CoercionError => e
+        raise Error, "[#{self}.new] #{e}", e.backtrace
       end
 
       # @api private
@@ -255,27 +288,26 @@ module Dry
       # @api private
       def load(attributes)
         struct = allocate
-        struct.send(:initialize, attributes)
+        struct.__send__(:initialize, attributes)
         struct
       end
 
       # @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
       # @yieldparam [Dry::Types::Result::Failure] failure
-      # @yieldreturn [Dry::Types::ResultResult]
+      # @yieldreturn [Dry::Types::Result]
       # @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)
+        block_given? ? yield(failure_result) : failure_result
       end
 
       # @param [Hash{Symbol => Object},Dry::Struct] input
@@ -298,7 +330,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
@@ -312,7 +344,7 @@ module Dry
         false
       end
 
-      # @param [Object, Dry::Struct] value
+      # @param [Object, Dry::Struct] other
       # @return [Boolean]
       def ===(other)
         other.is_a?(self)
@@ -336,7 +368,7 @@ module Dry
 
       # @return [Proc]
       def to_proc
-        proc { |input| call(input) }
+        @to_proc ||= proc { |input| call(input) }
       end
 
       # Checks if this {Struct} has the given attribute
@@ -357,10 +389,12 @@ module Dry
       # @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
@@ -369,13 +403,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
@@ -399,21 +448,21 @@ module Dry
       # @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
@@ -426,6 +475,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, __FILE__, __LINE__ + 1)
+            def #{key}                      # def email
+              @attributes[#{key.inspect}]   #   @attributes[:email]
+            end                             # end
+          RUBY
+        end
+      end
+      private :define_accessors
     end
   end
 end

data/lib/dry/struct/compiler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+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 column_name.to_s
+            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

data/lib/dry/struct/printer.rb

@@ -1,10 +1,13 @@
-require 'dry/types/printer'
+# frozen_string_literal: true
+
+require "dry/types/printer"
 
 module Dry
   module Types
     # @api private
     class Printer
       MAPPING[Struct::Sum] = :visit_struct_sum
+      MAPPING[Struct::Constructor] = :visit_struct_constructor
 
       def visit_struct_sum(sum)
         visit_sum_constructors(sum) do |constructors|
@@ -13,6 +16,8 @@ module Dry
           end
         end
       end
+
+      alias_method :visit_struct_constructor, :visit_constructor
     end
   end
 end