tuile 0.16.0 → 0.17.0

data/lib/tuile/component/has_content.rb

@@ -14,8 +14,9 @@ module Tuile
     # populatable regions gives each one a {Slot} rather than including this
     # twice.
     #
-    # The includer initializes `@content` to nil and provides a protected
-    # `layout(content)` positioning the child; the mixin owns the swap:
+    # The includer initializes `@content` to nil and positions the child from
+    # its own {Component#relayout}; the mixin owns the swap, and the swap marks,
+    # so nothing here places anything itself:
     #
     #   class Slot < Component
     #     include Component::HasContent
@@ -24,7 +25,7 @@ module Tuile
     #
     #     protected
     #
-    #     def layout(content) = content.rect = rect
+    #     def relayout = content&.rect = local_rect
     #   end
     #
     # **A child that is private machinery stays out**, because {#content=} ships
@@ -61,26 +62,18 @@ module Tuile
         end
 
         old = self.content
+        @content = content
         # Detached without notifying, and notified at the very end: the focus
         # repair in handle_child_removed cascades into whatever occupies the slot
         # *now*, so it has to see the new content (window_spec pins it).
         detach_child(old) unless old.nil?
-        @content = content
         unless content.nil?
           add_child(content, at: 0) # content paints beneath a Window's footer
           content.invalidate
-          layout(content)
         end
         handle_child_removed(old) unless old.nil?
       end
 
-      # @param rect [Rect]
-      # @return [void]
-      def rect=(rect)
-        super
-        layout(content) unless content.nil?
-      end
-
       # @return [void]
       def handle_focus
         super

data/lib/tuile/component/has_validation.rb

@@ -7,7 +7,7 @@ module Tuile
     # {Theme#error_active_bg_color} while focused.
     #
     #   login = Component::Button.new(caption: "Log in")
-    #   login.on_click = lambda do
+    #   login.on_click do
     #     username.error_message = username.empty? ? "Required" : nil
     #     password.error_message = password.empty? ? "Required" : nil
     #     next if [username, password].any?(&:error_message)
@@ -17,8 +17,8 @@ module Tuile
     #
     # The field turns red on its own; the *message* needs cells the field
     # doesn't own, so whoever has them — a `FormLayout`, or an app's own
-    # {Label} — subscribes to {#on_error_message_change} and paints the text in
-    # {Theme#error_color}.
+    # {Label} — subscribes to {#on_error_message_change} and paints
+    # {#shown_message} in {Theme#error_color}.
     #
     # Included by {HasValue}, so every field has it. Include it directly in a
     # component that can be invalid without being a field (a form section
@@ -33,7 +33,7 @@ module Tuile
     # still has to look focused (`design/decisions.md` `D_has_validation`).
     #
     # The well reaches the whole widget with nothing forwarding it: a composed
-    # field's inner face is marked {Component::BG_INHERIT} and a group's {List}
+    # field's inner face is marked {ComponentBackground::INHERIT} and a group's {List}
     # declares no background, so both walk up the ordinary background chain and
     # land on the composer's answer.
     #
@@ -52,15 +52,29 @@ module Tuile
     # a non-nil message. Assign `""` for a verdict with nothing to say.
     #
     # Unlike `bad_input?`, this fact is *discrete* — asserted at a click or a
-    # binder pass, not recomputed per keystroke — which is why it carries a
-    # change notice where `bad_input?` deliberately doesn't (`design/decisions.md`
-    # `D_bad_input`, `D_has_validation`).
+    # binder pass, not recomputed per keystroke — so its notice fires straight
+    # off the write, where {HasBadInput#on_bad_input_change} has a continuous
+    # fact to settle first (`design/decisions.md` `D_bad_input`,
+    # `D_has_validation`).
     module HasValidation
-      # @return [Proc, Method, nil] one-arg callable fired with the new message
-      #   (or `nil`) whenever {#error_message} actually changes — never on a
-      #   no-op set. Claimed by the container that paints the message; an app
-      #   painting its own takes it instead.
-      attr_accessor :on_error_message_change
+      extend Listeners::Declare
+
+      # What {#on_error_message_change} fires.
+      #
+      # @!attribute [r] source
+      #   @return [Component] the field whose verdict changed.
+      # @!attribute [r] error_message
+      #   @return [StyledString, nil] the new message, `nil` when the field just
+      #     became valid.
+      ErrorMessageChangeEvent = Data.define(:source, :error_message) { include Tuile::Event }
+
+      # @!method on_error_message_change
+      #   Fired with an {ErrorMessageChangeEvent} whenever {#error_message}
+      #   actually changes — never on a no-op set. The container that paints the
+      #   message registers here, and so may an app painting its own: the list
+      #   takes both, which a single slot could not.
+      #   @return [Listeners]
+      listener :on_error_message_change
 
       # @return [StyledString, nil] why the field is invalid, or `nil` when it
       #   is not; `nil` until something sets it.
@@ -80,9 +94,21 @@ module Tuile
 
         @error_message = new_message
         invalidate
-        on_error_message_change&.call(new_message)
+        on_error_message_change.fire(ErrorMessageChangeEvent.new(source: self, error_message: new_message))
       end
 
+      # The message a consumer with cells of its own paints beside the field:
+      # the verdict here, and {HasBadInput} widens it to prefer the field's own
+      # report, which outranks a verdict computed a pass ago.
+      #
+      #   field.on_error_message_change { message_label.caption = field.shown_message.to_s }
+      #   field.on_bad_input_change     { message_label.caption = field.shown_message.to_s }
+      #
+      # Register on both: two channels with two writers, either of which moves it.
+      # @return [StyledString, String, nil] `nil` when there is nothing to show;
+      #   a plain `String` when it is the field's own bad-input report.
+      def shown_message = error_message
+
       protected
 
       # The invalid well, picked up by everything this component paints —

data/lib/tuile/component/has_value.rb

@@ -8,42 +8,95 @@ module Tuile
     # not caring that a {TextField}'s value is a `String` while another field's
     # is a domain object.
     #
-    #   field.on_value_change = ->(v) { puts "now: #{v.inspect}" }
-    #   field.value = "hello"   # fires the listener
+    #   field.on_value_change { |e| puts "now: #{e.value.inspect}" }
+    #   field.value = "hello"   # fires the listener, e.from_user? false
     #   field.clear             # value = empty_value, fires again
     #
-    # The default {#value=}/{#value} keep the value in `@value` and are enough
-    # for a component with nothing more natural — you get a repaint and the
-    # listener for free. An includer whose value lives elsewhere overrides both
-    # ({AbstractStringField} backs them with its text buffer). Override {#empty_value}
-    # when the empty sentinel isn't `nil` (a text field's is `""`).
+    # == Who made the change
+    # Every event tells typing from a programmatic write, so a listener keeps
+    # no guard flag of its own:
+    #
+    #   field.on_value_change { |e| open_palette if e.from_user? }
+    #   field.value = "x"                        # e.from_user? is false
+    #   field.set_value("x", from_user: true)    # an app writing for the user
+    #
+    # The default {#set_value}/{#value} keep the value in `@value` and are
+    # enough for a component with nothing more natural — you get a repaint and
+    # the listener for free. An includer whose value lives elsewhere overrides
+    # both ({AbstractStringField} backs them with its text buffer); **the
+    # override point is {#set_value}, never {#value=}**, which is only its
+    # `from_user: false` spelling. Override {#empty_value} when the empty
+    # sentinel isn't `nil` (a text field's is `""`).
     #
     # {HasValidation} comes with it, so every field carries the
     # `error_message` a validator writes and paints its own error ink.
     #
     # == Implementation details
     # Deliberately smaller than Vaadin's `HasValue`: read-only,
-    # required-indicator, the from-client/old-value event payload, and
-    # converters all belong to the not-yet-built form layer, not here.
+    # required-indicator and converters belong to the not-yet-built form layer,
+    # not here. Of Vaadin's event payload, `isFromClient` is carried (as
+    # {ValueChangeEvent#from_user?}) and `getOldValue` is not, until something
+    # reads it (`D_from_user`).
     module HasValue
       include HasValidation
+      extend Listeners::Declare
+
+      # What {#on_value_change} fires.
+      #
+      # @!attribute [r] source
+      #   @return [Component] the field whose value changed.
+      # @!attribute [r] value
+      #   @return [Object] the new value.
+      # @!attribute [r] from_user
+      #   @return [Boolean] what the writer declared; read it as {#from_user?}.
+      ValueChangeEvent = Data.define(:source, :value, :from_user) do
+        include Tuile::Event
 
-      # @return [Proc, Method, nil] one-arg callable fired with the new value
-      #   whenever {#value} actually changes — never on a no-op set.
-      attr_accessor :on_value_change
+        # @return [Boolean] whether the change came from the user — typing, a
+        #   paste, a click, a key — or from an app writing on the user's
+        #   behalf through {HasValue#set_value}; `false` for every {HasValue#value=}.
+        def from_user? = from_user
+      end
+
+      # @!method on_value_change
+      #   Fired with a {ValueChangeEvent} whenever {#value} actually changes —
+      #   never on a no-op set.
+      #   @return [Listeners]
+      listener :on_value_change
 
       # @return [Object] the current value; `nil` until first set.
       def value = @value
 
-      # No-op (no repaint, no listener) when equal to the current value.
+      # A programmatic write: {#set_value} with `from_user: false`. Defined
+      # here once and never overridden — override {#set_value} instead, since a
+      # setter has no call syntax for the keyword.
       # @param new_value [Object]
       # @return [void]
       def value=(new_value)
+        set_value(new_value, from_user: false)
+      end
+
+      # Writes the value and fires {#on_value_change} carrying `from_user`.
+      # No-op (no repaint, no listener) when equal to the current value.
+      #
+      #   field.set_value(Date.today, from_user: true)   # a "Today" button's click
+      #
+      # The flag is the writer's claim, never derived from key dispatch and
+      # never checked: pass `true` when the write *is* a user's gesture — the
+      # gem's own key and mouse handlers do, as does {Testing.set_value} — and
+      # `false` for what the app decides alone. A wrong flag is silent, and
+      # `false` is the side that fails safe (`D_from_user`).
+      #
+      # The override point for an includer: call `super` with `from_user:`.
+      # @param new_value [Object]
+      # @param from_user [Boolean]
+      # @return [void]
+      def set_value(new_value, from_user:)
         return if value == new_value
 
         @value = new_value
         invalidate
-        on_value_change&.call(new_value)
+        on_value_change.fire(ValueChangeEvent.new(source: self, value: new_value, from_user:))
       end
 
       # Empty of *value*: a field whose parse is partial reports `true` while the
@@ -56,8 +109,9 @@ module Tuile
       #
       # An includer whose input can outrun its value ({HasBadInput}) must clear
       # the *input*: a field holding bad input already reads `empty_value`, so
-      # inheriting this default — over a {#value=} that returns early on a no-op
-      # set — is a `clear` that leaves the garbage on screen.
+      # inheriting this default — over a {#set_value} that returns early on a
+      # no-op set — is a `clear` that leaves the garbage on screen. A `clear` is
+      # programmatic: its event says `from_user? == false`.
       # @return [void]
       def clear = (self.value = empty_value)
 

data/lib/tuile/component/integer_field.rb

@@ -10,7 +10,7 @@ module Tuile
     # An empty or otherwise un-parseable buffer reads back as `nil`:
     #
     #   field = Component::IntegerField.new
-    #   field.on_value_change = ->(n) { puts n.inspect }  # Integer or nil, per change
+    #   field.on_value_change { |e| puts e.value.inspect }  # Integer or nil, per change
     #   field.value = 42                                   # field shows "42"
     #   field.value                                        # => 42
     #   field.clear                                        # empties it; value => nil
@@ -67,8 +67,8 @@ module Tuile
       def initialize
         super(Field.new)
         # Not the general on_key interceptor: that slot stays free for the app.
-        editor.on_key_up = -> { step(1) }
-        editor.on_key_down = -> { step(-1) }
+        editor.on_key_up { step(1) }
+        editor.on_key_down { step(-1) }
       end
 
       # @return [Integer, nil] the parsed buffer; `nil` when empty or not a
@@ -82,9 +82,10 @@ module Tuile
       # Writes `new_value` into the buffer and parks the caret at its end; fires
       # {#on_value_change} only if the value actually changed.
       # @param new_value [Integer, nil] `nil` empties the field.
+      # @param from_user [Boolean] see {HasValue#set_value}.
       # @return [void]
-      def value=(new_value)
-        editor.text = new_value.nil? ? "" : new_value.to_s
+      def set_value(new_value, from_user:)
+        editor.set_value(new_value.nil? ? "" : new_value.to_s, from_user:)
         editor.caret = editor.text.length
       end
 
@@ -102,7 +103,7 @@ module Tuile
       # Nudges {#value} by `delta`, treating an empty/un-parseable field as `0`.
       # @param delta [Integer]
       # @return [void]
-      def step(delta) = (self.value = (value || 0) + delta)
+      def step(delta) = set_value((value || 0) + delta, from_user: true)
     end
   end
 end

data/lib/tuile/component/label.rb

@@ -44,23 +44,26 @@ module Tuile
       # Skips the {Component#repaint} default's auto-clear: every row is
       # painted explicitly (with pre-padded blanks past the last line), so
       # the "fully draw over your rect" contract is met without an upfront
-      # wipe. Rows go through {Component#draw_text}, so the text, the trailing
+      # wipe. Rows go through {Canvas#set_text}, so the text, the trailing
       # padding and the blank rows all take {Component#bg_color}, and a span
       # that carries its own background keeps it.
+      # @param canvas [Canvas] see {Component#repaint}.
       # @return [void]
-      def repaint
+      def repaint(canvas)
         return if rect.empty?
 
         (0...rect.height).each do |row|
           line = @rows[row] || @blank_row
-          draw_text(rect.left, rect.top + row, line)
+          canvas.set_text(0, row, line)
         end
       end
 
       protected
 
+      # Re-pads the rows to the new width; a height change costs a cheap
+      # redundant pass, which beats keying the cache.
       # @return [void]
-      def handle_width_changed
+      def relayout
         super
         update_rows
       end
@@ -75,17 +78,7 @@ module Tuile
       def update_rows
         width = rect.width.clamp(0, nil)
         @blank_row = StyledString.plain(" " * width)
-        @rows = @text.lines.map { |line| pad_to(line.ellipsize(width), width) }
-      end
-
-      # @param line [StyledString]
-      # @param width [Integer]
-      # @return [StyledString]
-      def pad_to(line, width)
-        diff = width - line.display_width
-        return line if diff <= 0
-
-        line + StyledString.plain(" " * diff)
+        @rows = @text.lines.map { |line| line.ellipsize(width).ljust(width) }
       end
     end
   end

data/lib/tuile/component/layout/absolute.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    class Layout
+      # Places each child at the {Rect} it was added with, in this layout's own
+      # coordinates, and does no arithmetic of its own:
+      #
+      #   layout = Component::Layout::Absolute.new
+      #   layout.add(title, Rect.new(0, 0, 40, 1))
+      #   layout.add(body, Rect.new(0, 2, 40, 10))
+      #   layout.constrain(body, Rect.new(0, 2, 40, 20))   # moves it on the next settle
+      #
+      # The rect is where the child wants to be, and this layout's
+      # {Component#relayout} is what assigns it, so moving a child means
+      # {#constrain}ing it rather than writing its `rect`. A rect that sticks out
+      # of this layout is clipped at paint time, and this layout's own size
+      # doesn't matter: a detached `Absolute` with no rect still places its
+      # children, which is how a spec measures a tree that has no screen.
+      #
+      # When the rects depend on this layout's size, subclass {Layout} and write
+      # the `relayout` instead.
+      class Absolute < Layout
+        def initialize
+          super
+          # Identity-keyed: two == children are still two distinct slots.
+          @rects = {}.compare_by_identity
+        end
+
+        # @param child [Component, Enumerable<Component>] one child, or several
+        #   sharing the rect.
+        # @param rect [Rect, nil] where the child sits, in this layout's
+        #   coordinates; `nil` keeps the rect the child already has, which for a
+        #   new component is empty.
+        # @raise [TypeError] if `child` is not a {Component} or `rect` not a {Rect}.
+        # @return [void]
+        def add(child, rect = nil)
+          return child.each { add(_1, rect) } if child.is_a?(Enumerable)
+
+          rect ||= child.rect if child.is_a?(Component)
+          validate_rect(rect)
+          add_child(child)
+          @rects[child] = rect
+        end
+
+        # Moves a child already in the layout; it takes the new rect on the next
+        # settle.
+        # @param child [Component] a child of this layout.
+        # @param rect [Rect]
+        # @raise [ArgumentError] if `child` is not a child of this layout.
+        # @raise [TypeError] if `rect` is not a {Rect}.
+        # @return [void]
+        def constrain(child, rect)
+          raise ArgumentError, "#{child} is not a child of #{self}" unless children.any? { _1.equal?(child) }
+
+          validate_rect(rect)
+          return if @rects[child] == rect
+
+          @rects[child] = rect
+          invalidate_layout
+        end
+
+        # @param child [Component]
+        # @return [void]
+        def remove(child)
+          super
+          @rects.delete(child)
+        end
+
+        private
+
+        # @return [void]
+        def relayout
+          children.each { _1.rect = @rects.fetch(_1) }
+        end
+
+        # @param rect [Object]
+        # @raise [TypeError] unless `rect` is a {Rect}.
+        # @return [void]
+        def validate_rect(rect)
+          raise TypeError, "expected Rect, got #{rect.inspect}" unless rect.is_a?(Rect)
+        end
+      end
+    end
+  end
+end

data/lib/tuile/component/layout/box.rb

@@ -37,15 +37,15 @@ module Tuile
       #
       # Every child-list mutation re-runs the whole pass, because in a box the
       # children move: removing one shifts everything after it, and adding one
-      # shrinks every {Expand} share. ({Absolute} can skip this — there, siblings
-      # are independent.)
+      # shrinks every {Expand} share.
       #
       # Main-axis resolution order, against
       # `available = extent - padding - spacing * (children - 1)`:
       #
-      # 1. {Fixed} takes its cells, clamped to what is still unassigned.
-      # 2. {Percent} takes its share *of `available`*, likewise clamped.
-      # 3. {Expand} children split the residue by weight; the integer remainder
+      # 1. In declaration order, each {Fixed}, {Percent} or {Clamp} takes the
+      #    cells it resolves to — a {Percent} its share *of `available`*, a
+      #    {Clamp} that share bounded — clamped to what is still unassigned.
+      # 2. {Expand} children split the residue by weight; the integer remainder
       #    goes to the earliest of them, one cell each.
       #
       # So over-subscription starves in declaration order rather than raising:
@@ -86,7 +86,7 @@ module Tuile
           return if @spacing == cells
 
           @spacing = cells
-          relayout
+          invalidate_layout
         end
 
         # @param insets [Insets, Integer] an Integer becomes a uniform inset.
@@ -97,7 +97,7 @@ module Tuile
           return if @padding == insets
 
           @padding = insets
-          relayout
+          invalidate_layout
         end
 
         # Adds a child — or every element of an Enumerable, all with the same
@@ -108,8 +108,8 @@ module Tuile
         #   add(sidebar, Expand[1], at: 0)   # back where it was, after a #remove
         #
         # @param child [Component, Enumerable<Component>]
-        # @param main [Fixed, Percent, Expand] extent along the main axis.
-        # @param cross [Fixed, Percent] extent across it.
+        # @param main [Constraint] extent along the main axis.
+        # @param cross [Constraint] extent across it; not an {Expand}.
         # @param align [Symbol] one of {ALIGNMENTS} — where a child narrower than
         #   the cross extent sits. {Vertical} / {Horizontal} say which edge
         #   `:start` is.
@@ -131,7 +131,7 @@ module Tuile
           validate_align(align)
           add_child(child, at:)
           @placements[child] = { main:, cross:, align: }
-          relayout
+          invalidate_layout
         end
 
         # Re-constrains a child already in the layout and re-runs the pass. A
@@ -143,8 +143,8 @@ module Tuile
         # hiding, and the class doc for what is.
         #
         # @param child [Component] a child of this layout.
-        # @param main [Fixed, Percent, Expand, nil] extent along the main axis.
-        # @param cross [Fixed, Percent, nil] extent across it.
+        # @param main [Constraint, nil] extent along the main axis.
+        # @param cross [Constraint, nil] extent across it; not an {Expand}.
         # @param align [Symbol, nil] one of {ALIGNMENTS}.
         # @raise [ArgumentError] if `child` is not a child of this layout, or on
         #   an unknown constraint or alignment.
@@ -162,7 +162,7 @@ module Tuile
           return if current == updated
 
           @placements[child] = updated
-          relayout
+          invalidate_layout
         end
 
         # Removes the child, forgets its constraints, and closes the gap it left
@@ -172,56 +172,38 @@ module Tuile
         def remove(child)
           super
           @placements.delete(child)
-          relayout
-        end
-
-        # @param new_rect [Rect]
-        # @return [void]
-        def rect=(new_rect)
-          super
-          relayout
-        end
-
-        protected
-
-        # Re-divides the space: a child that went hidden gives its slot *and*
-        # the {#spacing} around it to its siblings, and one that came back takes
-        # them again with the constraints it was added with — which is what
-        # {Component#visible=} buys over `remove` plus `add(…, at:)`.
-        # @param _child [Component]
-        # @return [void]
-        def handle_child_visibility_changed(_child)
-          super
-          relayout
+          invalidate_layout
         end
 
         private
 
-        # Recomputes and assigns every child's rect, giving each an empty one
-        # when this layout's own rect — or {#inner_rect} — is empty.
+        # Re-divides the space, giving each child an empty rect when this
+        # layout's own — or {#inner_rect} — is empty. A child that went hidden
+        # gives its slot *and* the {#spacing} around it to its siblings, and one
+        # that came back takes them again with the constraints it was added
+        # with; that is what {Component#visible=} buys over `remove` plus
+        # `add(…, at:)`.
         #
         # Deliberately *no* `return if rect.empty?` guard: that strands the
         # children at the coordinates they last had, and the next full repaint
-        # paints them there (`D_empty_ancestor`). Construction is silent without
-        # one anyway — {#add} runs before a parent assigns a rect, so the
-        # children are already empty and `invalidate` no-ops while detached.
+        # paints them there (`D_empty_ancestor`).
         # @return [void]
         def relayout
           inner = inner_rect
-          collapsed = Rect.new(rect.left, rect.top, 0, 0)
+          collapsed = Rect.new(0, 0, 0, 0)
           if rect.empty? || inner.empty?
             children.each { _1.rect = collapsed }
           else
             children.each { _1.rect = collapsed unless _1.visible? }
             place_children(inner)
           end
-          invalidate
         end
 
-        # @return [Rect] {#rect} with {#padding} taken off each edge; may be
-        #   {Rect#empty? empty}.
+        # @return [Rect] {Component#local_rect} with {#padding} taken off each
+        #   edge — this layout's own coordinates, which are its children's too;
+        #   may be {Rect#empty? empty}.
         def inner_rect
-          Rect.new(rect.left + padding.left, rect.top + padding.top,
+          Rect.new(padding.left, padding.top,
                    rect.width - padding.horizontal, rect.height - padding.vertical)
         end
 
@@ -260,10 +242,11 @@ module Tuile
           unassigned = available
 
           kids.each_with_index do |child, i|
-            case (constraint = placement(child)[:main])
-            when Expand then expanding << i
-            when Fixed then unassigned -= (sizes[i] = constraint.cells.clamp(0, unassigned))
-            else unassigned -= (sizes[i] = percent_of(available, constraint).clamp(0, unassigned))
+            cells = placement(child)[:main].resolve(available)
+            if cells.nil?
+              expanding << i
+            else
+              unassigned -= (sizes[i] = cells.clamp(0, unassigned))
             end
           end
 
@@ -295,10 +278,7 @@ module Tuile
         #   extent, along the cross axis.
         def cross_placement(child, available)
           spec = placement(child)
-          size = case (constraint = spec[:cross])
-                 when Fixed then constraint.cells.clamp(0, available)
-                 else percent_of(available, constraint).clamp(0, available)
-                 end
+          size = spec[:cross].resolve(available).clamp(0, available)
           [align_offset(spec[:align], available - size), size]
         end
 
@@ -313,11 +293,6 @@ module Tuile
           end
         end
 
-        # @param extent [Integer]
-        # @param constraint [Percent]
-        # @return [Integer]
-        def percent_of(extent, constraint) = (extent * constraint.percent / 100.0).round
-
         # @param child [Component]
         # @return [Hash{Symbol => Object}] the child's `main`/`cross`/`align`.
         def placement(child) = @placements[child] || DEFAULT_PLACEMENT
@@ -352,25 +327,25 @@ module Tuile
         end
 
         # @param constraint [Object]
-        # @raise [ArgumentError] unless it is a {Fixed}, {Percent} or {Expand}.
+        # @raise [ArgumentError] unless it is a {Constraint}.
         # @return [void]
         def validate_main(constraint)
-          return if [Fixed, Percent, Expand].any? { constraint.is_a?(_1) }
+          return if constraint.is_a?(Constraint)
 
-          raise ArgumentError, "expected Fixed, Percent or Expand, got #{constraint.inspect}"
+          raise ArgumentError, "expected Fixed, Percent, Expand or Clamp, got #{constraint.inspect}"
         end
 
         # @param constraint [Object]
-        # @raise [ArgumentError] unless it is a {Fixed} or {Percent}.
+        # @raise [ArgumentError] unless it is a {Constraint} other than {Expand}.
         # @return [void]
         def validate_cross(constraint)
           if constraint.is_a? Expand
             raise ArgumentError, "Expand is main-axis only — a child has no siblings competing " \
                                  "across the axis; use Fixed or Percent for cross:"
           end
-          return if constraint.is_a?(Fixed) || constraint.is_a?(Percent)
+          return if constraint.is_a?(Constraint)
 
-          raise ArgumentError, "expected Fixed or Percent for cross:, got #{constraint.inspect}"
+          raise ArgumentError, "expected Fixed, Percent or Clamp for cross:, got #{constraint.inspect}"
         end
 
         # @param align [Object]