plumb 0.0.17 → 0.2.0.beta.1

data/lib/plumb/attributes.rb

@@ -113,6 +113,25 @@ module Plumb
       base.define_singleton_method(:__plumb_struct_class__) { base }
     end
 
+    # The struct class behind `node`, or nil. Structs appear in two shapes: a
+    # Plumb::Attributes class itself (Types::Data subclasses are Composable
+    # classes), or the Function that Composable.wrap builds around a plain
+    # `include Plumb::Attributes` class — the class is the wrapped callable, so
+    # it is reached via #fn (a Function's #children are its types). This is the
+    # one owner of that representation fact — used by #build_nested and Codec's
+    # rewriter.
+    #
+    # Keyed on Function#wraps_callable? rather than on the types the node declares:
+    # boundary absorption can move a neighbouring type into a wrapper's slot (see
+    # Function#absorb_input), and it wraps the same class either way.
+    def self.struct_class(node)
+      return node if node.is_a?(::Class) && node <= Attributes
+      return nil unless node.is_a?(Plumb::Function) && node.wraps_callable?
+
+      callable = node.fn
+      callable.is_a?(::Class) && callable <= Attributes ? callable : nil
+    end
+
     attr_reader :errors, :attributes
 
     def initialize(attrs = {})
@@ -186,7 +205,7 @@ module Plumb
       # Add a step to the processing pipeline that runs before attribute validation.
       # This allows you to transform or validate the input data before it's assigned to attributes.
       #
-      # @param st [Plumb::Step, nil] A step object to add to the pipeline
+      # @param st [Plumb::Composable, #call, nil] A step object to add to the pipeline
       # @param block [Proc, nil] A block to use as a step (if st is nil)
       # @return [Class] Returns self for method chaining
       #
@@ -228,14 +247,23 @@ module Plumb
         super
       end
 
-      # The Plumb::Step interface
-      # @param result [Plumb::Result::Valid]
-      # @return [Plumb::Result::Valid, Plumb::Result::Invalid]
+      MUST_BE_HASH = ['Must be a Hash of attributes'].freeze
+
+      # The Plumb::Callable interface
+      # @param result [Plumb::Result]
+      # @return [Plumb::Result]
       def call(result)
         return result if result.value.is_a?(self)
-        return result.invalid(errors: ['Must be a Hash of attributes']) unless result.value.respond_to?(:to_h)
+        return result.invalid(errors: MUST_BE_HASH) unless result.value.respond_to?(:to_h)
 
-        instance = new(result.value.to_h)
+        # Some #to_h implementations reject malformed contents; treat that as invalid input.
+        begin
+          attributes = result.value.to_h
+        rescue ::TypeError, ::ArgumentError
+          return result.invalid(errors: MUST_BE_HASH)
+        end
+
+        instance = new(attributes)
         instance.valid? ? result.valid(instance) : result.invalid(instance, errors: instance.errors.to_h)
       end
 
@@ -252,6 +280,22 @@ module Plumb
       # node name for visitors
       def node_name = :data
 
+      # A Data type joins Composable via `extend`, so it doesn't pick up the
+      # Equality hooks the subtype engine calls. Structural subtyping delegates
+      # to the underlying schema (a HashClass): a Data type is a subtype of
+      # `other` exactly when its schema is. `other` may be another Data type
+      # (compared schema-to-schema), a HashClass, or any Plumb type. Recurse via
+      # Plumb::Subtyping.subtype?, never #<= (which on a Class is Ruby's own
+      # class-hierarchy operator).
+      def subtype_of?(other)
+        other = other._schema if other.respond_to?(:node_name) && other.node_name == :data
+        Plumb::Subtyping.subtype?(_schema, other)
+      end
+
+      # Mirror hook (see Composable#supertype_of?). A Data type claims a subtype
+      # only where its schema does — which by default is nothing.
+      def supertype_of?(other) = _schema.supertype_of?(other)
+
       # attribute(:friend) { attribute(:name, String) }
       # attribute(:friend, MyStruct) { attribute(:name, String) }
       # attribute(:name, String)
@@ -275,9 +319,12 @@ module Plumb
               child = node.children.first
               child = __plumb_struct_class__ if child == Types::Any
               Types::Array[build_nested(name, child, &block)]
-            elsif node.is_a?(Plumb::Step)
-              build_nested(name, node, &block)
-            elsif node.is_a?(Class) && node <= Plumb::Attributes
+            # A wrapper function holds a caller-supplied callable — possibly a struct
+            # class, possibly not; #build_nested raises if it isn't. Deliberately NOT
+            # every Function: a #transform / #build / coercion wraps a lambda Plumb
+            # built, which a nested-attributes block has no business rewriting.
+            elsif (node.is_a?(Plumb::Function) && node.wraps_callable?) ||
+                  (node.is_a?(Class) && node <= Plumb::Attributes)
               build_nested(name, node, &block)
             else
               node
@@ -315,19 +362,14 @@ module Plumb
       end
 
       def build_nested(name, node, &block)
-        if node.is_a?(Class) && node <= Plumb::Attributes
-          sub = Class.new(node)
-          sub.instance_exec(&block)
-          __set_nested_class__(name, sub)
-          return Composable.wrap(sub)
+        klass = Plumb::Attributes.struct_class(node)
+        unless klass
+          raise ArgumentError,
+                "attribute #{name.inspect} was given a nested-attributes block, " \
+                "but its type #{node.inspect} is not a struct class"
         end
 
-        return node unless node.is_a?(Plumb::Step)
-
-        child = node.children.first
-        return node unless child <= Plumb::Attributes
-
-        sub = Class.new(child)
+        sub = Class.new(klass)
         sub.instance_exec(&block)
         __set_nested_class__(name, sub)
         Composable.wrap(sub)