plumb 0.0.18 → 0.2.0.beta.2

data/lib/plumb/attribute_value_match.rb

@@ -7,6 +7,10 @@ module Plumb
     attr_reader :type, :attr_name, :value
 
     def initialize(type, attr_name, value)
+      unless attr_name.is_a?(::Symbol) || attr_name.is_a?(::String)
+        raise ArgumentError, "attribute name must be a Symbol or String, got #{attr_name.inspect}"
+      end
+
       @type = type
       @attr_name = attr_name
       @value = value
@@ -15,12 +19,48 @@ module Plumb
       freeze
     end
 
+    # Two attribute constraints are equal when they constrain the same attribute
+    # of the same base type to the same value. (The default Composable#== only
+    # compares #children, which an AttributeValueMatch doesn't expose, so it
+    # would treat every constraint as equal.)
+    def ==(other)
+      other.is_a?(self.class) &&
+        attr_name == other.attr_name &&
+        value == other.value &&
+        type == other.type
+    end
+
     def metadata = type.metadata
 
+    # An attribute-value constraint narrows by value, so it accepts any input
+    # (opts out of #>> composition type-checks).
+    def input_type = Types::Any
+
+    # It checks an attribute and returns the value unchanged — a pure refinement.
+    def value_preserving? = true
+
+    # Subtyping for an attribute constraint. Against another constraint on the
+    # SAME attribute, the base types must be compatible and this constraint's
+    # value must be a subtype of the other's — eg. `size: 10` <= `size: 8..100`,
+    # but `size: 10..15` </= `size: 11..14`. Against any other type, an
+    # attribute-constrained type is simply a subtype of its base type (eg.
+    # `Array.where(size: 10) <= Array`).
+    def subtype_of?(other)
+      if other.is_a?(AttributeValueMatch)
+        attr_name == other.attr_name &&
+          Plumb::Subtyping.subtype?(type, other.type) &&
+          Plumb::Subtyping.value_subtype?(value, other.value)
+      else
+        Plumb::Subtyping.subtype?(type, other)
+      end
+    end
+
     def call(result)
+      # Missing attributes fail the constraint instead of raising.
+      return result.invalid!(errors: @error) unless result.value.respond_to?(attr_name)
       return result if value === result.value.public_send(attr_name)
 
-      result.invalid(errors: @error)
+      result.invalid!(errors: @error)
     end
 
     private def _inspect = @inspect_line

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
       #
@@ -230,14 +249,21 @@ module Plumb
 
       MUST_BE_HASH = ['Must be a Hash of attributes'].freeze
 
-      # The Plumb::Step interface
-      # @param result [Plumb::Result::Valid]
-      # @return [Plumb::Result::Valid, Plumb::Result::Invalid]
+      # 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_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
 
@@ -254,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)
@@ -277,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
@@ -317,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)