dry-struct 1.2.0 → 1.3.0

data/lib/dry-struct.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require 'dry/struct'

data/lib/dry/struct.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require 'dry-types'
 require 'dry-equalizer'
 require 'dry/core/extensions'
 require 'dry/core/constants'
+require 'dry/core/deprecations'
 
 require 'dry/struct/version'
 require 'dry/struct/errors'
@@ -85,6 +88,12 @@ module Dry
     extend Core::Extensions
     include Core::Constants
     extend ClassInterface
+    extend Core::Deprecations[:'dry-struct']
+
+    class << self
+      # override `Dry::Types::Builder#prepend`
+      define_method(:prepend, ::Module.method(:prepend))
+    end
 
     autoload :Value, 'dry/struct/value'
 
@@ -95,7 +104,8 @@ module Dry
     defines :schema
     schema Types['coercible.hash'].schema(EMPTY_HASH)
 
-    @meta = EMPTY_HASH
+    defines :abstract_class
+    abstract
 
     # @!attribute [Hash{Symbol => Object}] attributes
     attr_reader :attributes
@@ -144,12 +154,13 @@ module Dry
     #   )
     #   rom_n_roda.to_hash
     #     #=> {title: 'Web Development with ROM and Roda', subtitle: nil}
-    def to_hash
+    def to_h
       self.class.schema.each_with_object({}) do |key, result|
         result[key.name] = Hashify[self[key.name]] if attributes.key?(key.name)
       end
     end
-    alias_method :to_h, :to_hash
+    alias_method :to_hash, :to_h
+    # deprecate :to_hash, :to_h, message: "Implicit convertion structs to hashes is deprecated. Use .to_h"
 
     # Create a copy of {Dry::Struct} with overriden attributes
     #

data/lib/dry/struct/class_interface.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'weakref'
 require 'dry/core/class_attributes'
 require 'dry/core/inflector'
 require 'dry/core/descendants_tracker'
@@ -19,14 +22,8 @@ module Dry
       def inherited(klass)
         super
 
-        base = self
-
-        klass.class_eval do
-          @meta = base.meta
-
-          unless name.eql?('Dry::Struct::Value')
-            extend Core::DescendantsTracker
-          end
+        unless klass.name.eql?('Dry::Struct::Value')
+          klass.extend(Core::DescendantsTracker)
         end
       end
 
@@ -96,10 +93,45 @@ 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
@@ -124,9 +156,9 @@ module Dry
 
           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
 
@@ -154,14 +186,7 @@ module Dry
 
         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
 
@@ -222,16 +247,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)
+        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 Error, "[#{self}.new] #{error}"
+        raise Error, "[#{self}.new] #{error}", error.backtrace
       end
 
       # @api private
@@ -260,10 +294,9 @@ module Dry
       end
 
       # @param [#call,nil] constructor
-      # @param [Hash] _options
       # @param [#call,nil] block
       # @return [Dry::Struct::Constructor]
-      def constructor(constructor = nil, **_options, &block)
+      def constructor(constructor = nil, **, &block)
         Constructor.new(self, fn: constructor || block)
       end
 
@@ -336,7 +369,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 +390,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?
+            schema schema.meta(meta) unless meta.empty?
           end
         end
       end
@@ -376,6 +411,21 @@ module Dry
         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
@@ -406,11 +456,11 @@ module Dry
       # 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)
             Types[type]
-          elsif block.nil? && type.nil?
+          elsif block.nil? && Undefined.equal?(type)
             raise(
               ::ArgumentError,
               'you must supply a type or a block to `Dry::Struct.attribute`'
@@ -427,11 +477,18 @@ module Dry
       end
       private :build_type
 
-      # @api private
-      # @return [Boolean]
-      def value?
-        false
+      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.rb

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

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

@@ -1,10 +1,12 @@
+# 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.group(1, "#<#{klass.name || klass.inspect}", '>') do
         pp.seplist(@attributes.keys, proc { pp.text ',' }) do |column_name|
           column_value = @attributes[column_name]
           pp.breakable ' '

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,7 +8,9 @@ module Dry
       # @param [#to_hash, #map, Object] value
       # @return [Hash, Array]
       def self.[](value)
-        if value.respond_to?(:to_hash)
+        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] }

data/lib/dry/struct/printer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'dry/types/printer'
 
 module Dry
@@ -5,6 +7,7 @@ module Dry
     # @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

data/lib/dry/struct/struct_builder.rb

@@ -1,9 +1,11 @@
-require 'dry/types/compiler'
+# frozen_string_literal: true
+
+require 'dry/struct/compiler'
 
 module Dry
   class Struct
     # @private
-    class StructBuilder < Types::Compiler
+    class StructBuilder < Compiler
       attr_reader :struct
 
       def initialize(struct)
@@ -12,13 +14,22 @@ module Dry
       end
 
       # @param [Symbol|String] attr_name the name of the nested type
-      # @param [Dry::Struct,Dry::Types::Type::Array] type the superclass of the nested struct
+      # @param [Dry::Struct,Dry::Types::Type::Array,Undefined] type the superclass of the nested struct
       # @yield the body of the nested struct
       def call(attr_name, type, &block)
         const_name = const_name(type, attr_name)
         check_name(const_name)
 
-        new_type = ::Class.new(parent(type), &block)
+        builder = self
+        parent = parent(type)
+
+        new_type = ::Class.new(Undefined.default(parent, struct.abstract_class)) do
+          if Undefined.equal?(parent)
+            schema builder.struct.schema.clear
+          end
+
+          class_exec(&block)
+        end
         struct.const_set(const_name, new_type)
 
         if array?(type)
@@ -38,14 +49,10 @@ module Dry
         if array?(type)
           visit(type.to_ast)
         else
-          type || default_superclass
+          type
         end
       end
 
-      def default_superclass
-        struct.value? ? Value : Struct
-      end
-
       def const_name(type, attr_name)
         snake_name =
           if array?(type)
@@ -71,11 +78,11 @@ module Dry
 
       def visit_array(node)
         member, * = node
-        member
+        visit(member)
       end
 
       def visit_nominal(*)
-        default_superclass
+        Undefined
       end
 
       def visit_constructor(node)