tuile 0.9.0 → 0.10.0

data/lib/tuile/component/checkbox.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A boolean input on one row. Space or a left click toggles it:
+    #
+    #   [x] Enable syslog forwarding
+    #   [ ] Enable syslog forwarding
+    #
+    #   cb = Component::Checkbox.new("Enable syslog forwarding", value: true)
+    #   cb.on_value_change = ->(on) { config.syslog = on }
+    #   cb.toggle       # unchecks it, firing the listener with false
+    #   cb.checked?     # => false
+    #
+    # {#value} is the canonical seam ({HasValue}), always `true`/`false` and
+    # never `nil`; {#checked?} / {#checked=} / {#toggle} are the domain-word face
+    # over it — one piece of state, four names. Unchecked is the
+    # {#empty_value}, so a fresh checkbox is {HasValue#empty? empty} and
+    # {HasValue#clear} unchecks.
+    #
+    # Space toggles. Enter is unhandled — unlike {Button} — simply because a
+    # checkbox has no default action to confirm, so it bubbles to an ancestor;
+    # treat that as this widget declining a key, not as a guarantee the framework
+    # makes (a {TextArea} claims Enter for newline, and a checkable row in a
+    # {Component::List} toggles on it).
+    #
+    # A tab stop, so Tab lands on it, and the widget highlights while on the focus
+    # chain. Assign a {#rect} (typically from the surrounding {Layout}) at least
+    # `caption.display_width + 4` wide; a narrower one ellipsizes the caption, a
+    # wider one leaves a dead tail — see {#extent}.
+    #
+    # == Implementation details
+    # The glyphs are a house convention rather than constants: three columns plus
+    # a trailing space (`[x] `, `[ ] `), ASCII because `☑`/`☐` are absent from
+    # most monospace fonts and the fallback glyph bleeds over its cell. A widget
+    # painting checkbox-like rows without instantiating a Checkbox — checkable
+    # rows in a {Component::List} — repeats those literals to match.
+    class Checkbox < Component
+      include Component::HasValue
+      include Component::HasCaption
+
+      # @param caption [String, StyledString, nil] the label, coerced as
+      #   {HasCaption#caption=} coerces it.
+      # @param value [Boolean] initial state. Assigned through {#value=}, which
+      #   also seeds the backing ivar — an unseeded checkbox would read `nil` and
+      #   so report itself non-{HasValue#empty? empty} while fresh.
+      def initialize(caption = nil, value: false)
+        super()
+        self.caption = caption
+        self.value = value
+      end
+
+      def tab_stop? = true
+
+      # @return [Boolean] `false` — {HasValue#empty?} means unchecked.
+      def empty_value = false
+
+      # Coerces to `true`/`false` before storing, so the two-state invariant holds
+      # whatever a caller assigns — and `cb.value = nil` on a fresh checkbox is
+      # the no-op it looks like rather than a spurious change event.
+      # @param new_value [Object] anything; truthiness decides.
+      # @return [void]
+      def value=(new_value)
+        super(new_value ? true : false)
+      end
+
+      # @return [Boolean] {#value} under its domain word — `license.checked?`
+      #   reads better than `license.value`. Not a second piece of state.
+      def checked? = value
+
+      # {#value=} under its domain word. A delegator rather than an `alias`, so it
+      # keeps routing through the one write path even if a subclass overrides
+      # {#value=} (an `alias` would freeze this onto the body defined here).
+      # @param new_value [Object] anything; truthiness decides.
+      # @return [void]
+      def checked=(new_value)
+        self.value = new_value
+      end
+
+      # Flips {#value}.
+      # @return [void]
+      def toggle = (self.value = !value)
+
+      # The cells the widget actually paints: one row, `caption.display_width + 4`
+      # columns, clipped to {#rect}. A form column routinely hands a checkbox a
+      # 40-column rect for a 22-column `[ ] Enable syslog forwarding` — the extent
+      # is those 22 columns.
+      #
+      # Both the focus highlight and the click hit test use it, so a click on the
+      # blank tail — or on a lower row, when the rect is taller than one — does
+      # not toggle. It still *focuses*: {Component#handle_mouse}'s click-to-focus
+      # is ungated by geometry, and the tail is the field's own row.
+      #
+      # The extent ignores {Component#bg_color}: an inherited tint paints the dead
+      # tail, but a hit test that silently widened with a background would be a
+      # mode switch invisible in the code and untestable by inspection.
+      # @return [Rect]
+      def extent = Rect.new(rect.left, rect.top, [caption.display_width + 4, rect.width].min, 1)
+
+      # Toggles on Space. Every other key — Enter included — is left unhandled so
+      # it bubbles to an ancestor.
+      # @param key [String]
+      # @return [Boolean]
+      def handle_key(key)
+        return false unless key == " "
+
+        toggle
+        true
+      end
+
+      # Toggles on a left click within {#extent}; `super` runs first, so a click
+      # anywhere in {#rect} still focuses.
+      # @param event [MouseEvent]
+      # @return [void]
+      def handle_mouse(event)
+        super
+        return unless event.button == :left && extent.contains?(event.point)
+
+        toggle
+      end
+
+      # @return [void]
+      def repaint
+        super
+        return if rect.empty?
+
+        label = (StyledString.plain(value ? "[x] " : "[ ] ") + caption).ellipsize(rect.width)
+        label = label.with_bg(screen.theme.active_bg_color) if active?
+        draw_line(rect.left, rect.top, label)
+      end
+    end
+  end
+end

data/lib/tuile/component/checkbox_group.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # Multi-select from a set of typed items, one checkable row each. Arrows move
+    # a cursor; Space, Enter or a left click toggles the row under it:
+    #
+    #    [x] Errors
+    #    [ ] Warnings     <- cursor row, highlighted across the full width
+    #    [x] Info
+    #   ^ the composed {List}'s one-column gutter
+    #
+    #   cg = Component::CheckboxGroup.new(items: %w[Errors Warnings Info])
+    #   cg.value = %w[Errors Info]                    # any Enumerable, stored as a Set
+    #   cg.on_value_change = ->(set) { filter(set) }   # once per toggle
+    #   cg.value                                       # => #<Set: {"Errors", "Info"}>
+    #   cg.item_label = ->(level) { level.name }       # default :to_s
+    #
+    # {#value} is a **frozen `Set` of the selected items themselves** — of
+    # whatever type {#items} holds, never their labels. Frozen so `cg.value <<
+    # item` fails loudly rather than mutating the selection behind
+    # {HasValue#on_value_change}'s back; assign a new set or an `Array` instead.
+    # Treat it as *unordered*: it iterates in toggle order, so use
+    # `cg.items & cg.value.to_a` when you need {#items} order.
+    #
+    # Composes rather than subclasses, like {ComboBox}: a {List} is its single
+    # {HasContent} child, which is where the cursor, scrolling, the scrollbar and
+    # per-row mouse hit-testing come from. `content` is that list, so an app can
+    # tune it (`scrollbar_visibility`, `show_cursor_when_inactive`, …). Rows
+    # beyond {#rect}'s height scroll; the inner list is the tab stop, not the
+    # group.
+    #
+    # == +items+ is chrome; +value+ is authoritative
+    # {#items=} changes only what is *presented*. It never touches {#value} and
+    # never fires {HasValue#on_value_change}, and a selected item absent from
+    # {#items} renders no checked row while surviving intact — so a form saved
+    # without the user editing anything changes nothing silently. Keeping the two
+    # in sync is the app's job: `cg.value &= cg.items.to_set` reconciles them.
+    # Same contract as {ComboBox#value}, one item at a time.
+    #
+    # There is no select-all — neither a key nor a header row. An app that wants
+    # one writes `cg.value = cg.items` behind its own affordance.
+    #
+    # == Implementation details
+    # Items need stable `#hash`/`#eql?`, since the selection is a `Set`: an item
+    # mutated after being selected becomes unfindable. Two `==`-equal items also
+    # share one selection — their rows check and uncheck together — whereas two
+    # *distinct* items that merely render the same label toggle independently,
+    # because a row resolves to an item by index.
+    #
+    # Rows repeat {Checkbox}'s `[x] `/`[ ] ` glyph convention rather than
+    # importing a constant from it.
+    #
+    # UI-thread-confined, like every component (see {Screen}).
+    class CheckboxGroup < Component
+      include HasContent
+      include HasValue
+
+      # @return [Set]
+      EMPTY_SELECTION = Set.new.freeze
+      private_constant :EMPTY_SELECTION
+
+      # @param items [Array] the items to present, one row each; also settable
+      #   via {#items=}.
+      # @param value [Enumerable, nil] the initial selection. Seeds the backing
+      #   ivar directly, so no listener fires and assignment order doesn't
+      #   matter to a form helper.
+      def initialize(items: [], value: nil)
+        super()
+        @items = items.to_a
+        @item_label = :to_s.to_proc
+        @value = coerce(value)
+        @on_value_change = nil
+
+        list = List.new
+        # A List has no cursor at all by default (Cursor::None, position -1).
+        list.cursor = List::Cursor.new
+        list.on_item_chosen = ->(index, _line) { toggle_at(index) }
+        self.content = list
+        rebuild_rows
+      end
+
+      # @return [Array] the presented items.
+      attr_reader :items
+
+      # @return [Proc, Method] item -> row label (a `String`, {StyledString}, or
+      #   anything with `#to_s`); `:to_s` by default.
+      attr_reader :item_label
+
+      # Replaces the presented rows, leaving {#value} untouched.
+      # @param new_items [Array]
+      # @raise [TypeError] unless `new_items` is an `Array`.
+      # @return [void]
+      def items=(new_items)
+        raise TypeError, "expected Array, got #{new_items.inspect}" unless new_items.is_a?(Array)
+
+        @items = new_items
+        rebuild_rows
+      end
+
+      # @param proc [Proc, Method] item -> row label.
+      # @return [void]
+      def item_label=(proc)
+        @item_label = proc
+        rebuild_rows
+      end
+
+      # @return [Set] the frozen empty set — {HasValue#empty?} means nothing is
+      #   selected.
+      def empty_value = EMPTY_SELECTION
+
+      # Replaces the selection, firing {HasValue#on_value_change} when it really
+      # changed. Stores a frozen `Set` *copy*, so a set the caller goes on
+      # mutating can't reach in.
+      # @param new_value [Enumerable, nil] `nil` selects nothing.
+      # @raise [TypeError] unless `new_value` is an `Enumerable` or `nil`.
+      # @return [void]
+      def value=(new_value)
+        selected = coerce(new_value)
+        # HasValue#value= no-ops on an unchanged value; this guard is what also
+        # skips the row rebuild.
+        return if value == selected
+
+        super(selected)
+        rebuild_rows
+      end
+
+      # Toggles the cursor row on Space. Nothing else is claimed: the composed
+      # {List} — being the focused component — has already had its chance at the
+      # key (its arrows, Home/End, PgUp/PgDn, ^U/^D and Enter), and whatever
+      # neither of us wants bubbles on to an ancestor.
+      # @param key [String]
+      # @return [Boolean]
+      def handle_key(key)
+        return false unless key == " "
+
+        toggle_at(content.cursor.position)
+        true
+      end
+
+      protected
+
+      # Places the composed list across the whole rect ({HasContent} hook).
+      # @param list [Component]
+      # @return [void]
+      def layout(list) = (list.rect = rect)
+
+      private
+
+      # Flips membership of the item on row `index`; an index outside {#items} is
+      # ignored.
+      # @param index [Integer]
+      # @return [void]
+      def toggle_at(index)
+        return unless index.between?(0, @items.size - 1)
+
+        item = @items[index]
+        self.value = value.include?(item) ? value - [item] : value + [item]
+      end
+
+      # Re-renders every row from the current items, labels and selection.
+      # @return [void]
+      def rebuild_rows
+        content.lines = @items.map do |item|
+          StyledString.plain(value.include?(item) ? "[x] " : "[ ] ") + label_for(item)
+        end
+      end
+
+      # @param new_value [Enumerable, nil]
+      # @return [Set] a frozen copy; `nil` becomes {#empty_value}.
+      # @raise [TypeError] on anything else.
+      def coerce(new_value)
+        return empty_value if new_value.nil?
+        raise TypeError, "expected Enumerable, got #{new_value.inspect}" unless new_value.is_a?(Enumerable)
+
+        Set.new(new_value).freeze
+      end
+
+      # @param item [Object]
+      # @return [StyledString, String] whichever {StyledString#+} accepts on the
+      #   right — so a styled label keeps its spans and a plain one is parsed.
+      def label_for(item)
+        label = @item_label.call(item)
+        label.is_a?(StyledString) ? label : label.to_s
+      end
+    end
+  end
+end

data/lib/tuile/component/combo_box.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A text field with a filtering dropdown: type to narrow the candidates,
+    # arrow to move the highlight, Enter (or click) to accept. Its {#value} is
+    # the *selected item* — of whatever type the items are — not the display
+    # string, so a combo over domain objects hands back the object:
+    #
+    #   combo = Component::ComboBox.new
+    #   combo.items = User.all                       # Array of any type
+    #   combo.item_label = ->(u) { u.full_name }     # item -> shown text; default :to_s
+    #   combo.on_value_change = ->(u) { open(u) }    # fires on commit, with the item
+    #   combo.value = some_user                       # selects it; field shows its label
+    #
+    # It's the assembly you'd otherwise wire by hand — a {TextField} plus a
+    # non-modal {Popup} over a {List} — promoted to one component. Give it a
+    # single-row {#rect}; it paints the field across that row with a `▾` in the
+    # last column and floats the dropdown above or below.
+    #
+    # == The two values
+    # {#value} (the committed selection) and the field's typed text (a transient
+    # *query*) are deliberately distinct. Keystrokes move the query and refilter
+    # the list; only Enter/click commits, and only a commit changes {#value} and
+    # fires {#on_value_change}. An uncommitted query reverts to the current
+    # value's label when the dropdown is dismissed (ESC) or the combo loses
+    # focus. Selecting by list index (not by matching the label back) is what
+    # lets two items share a label and still resolve to the right object.
+    #
+    # The dropdown is a {ListDropdown}, tinted to read as a floating panel; see
+    # it for the theming knob.
+    #
+    # UI-thread-confined, like every component (see {Screen}).
+    class ComboBox < Component
+      include HasContent
+      include HasValue
+
+      # @param items [Array] the candidate items (any type); also settable via
+      #   {#items=}.
+      def initialize(items: [])
+        super()
+        @value = nil
+        @on_value_change = nil
+        @items = items.to_a
+        @item_label = :to_s.to_proc
+        @filtered = []
+        @suppressing_filter = false
+
+        field = TextField.new
+        field.on_change = ->(_text) { refill unless @suppressing_filter }
+        field.on_key = method(:field_key)
+        self.content = field
+
+        @overlay = ListDropdown.new
+        @overlay.on_item_chosen = ->(index, _line) { commit(index) }
+      end
+
+      # @return [Array] the candidate items.
+      attr_reader :items
+
+      # @return [Proc, Method] item -> shown label (a `String` or
+      #   {StyledString}); the field shows its `#to_s`, the list its styled form.
+      attr_reader :item_label
+
+      # @param new_items [Array]
+      # @return [void]
+      def items=(new_items)
+        raise TypeError, "expected Array, got #{new_items.inspect}" unless new_items.is_a?(Array)
+
+        @items = new_items
+        refill if @overlay.open?
+        invalidate
+      end
+
+      # @param proc [Proc, Method] item -> shown label.
+      # @return [void]
+      def item_label=(proc)
+        @item_label = proc
+        sync_field(display_for(value)) # re-render the current selection
+        invalidate
+      end
+
+      # Selects `new_value` programmatically: updates the field to its label
+      # *without* opening the dropdown, then fires {#on_value_change}. `nil`
+      # clears the selection (blank field). The value need not be in {#items}.
+      # @param new_value [Object]
+      # @return [void]
+      def value=(new_value)
+        return if value == new_value
+
+        sync_field(display_for(new_value))
+        super
+      end
+
+      # @return [Point, nil] the field's caret position (the combo delegates the
+      #   hardware cursor to its field).
+      def cursor_position = content.cursor_position
+
+      # @return [String]
+      def keyboard_hint = "↑↓ #{screen.theme.hint("select")}  ⏎ #{screen.theme.hint("accept")}"
+
+      # Re-anchors the (open) dropdown after {HasContent#rect=} has resized the
+      # field via {#layout}.
+      # @param new_rect [Rect]
+      # @return [void]
+      def rect=(new_rect)
+        super
+        anchor if @overlay.open?
+      end
+
+      # Closes the dropdown and reverts an uncommitted query when the combo
+      # leaves the focus chain — so tabbing away doesn't strand an open menu or
+      # a half-typed filter. Safe against re-entrancy: focus never sits inside
+      # the (non-focusable) {ListDropdown}, so closing the overlay repairs no
+      # focus.
+      # @param flag [Boolean]
+      # @return [void]
+      def active=(flag)
+        was = active?
+        super
+        return unless was && !active?
+
+        close_menu
+        revert_query
+      end
+
+      # @param event [MouseEvent]
+      # @return [void]
+      def handle_mouse(event)
+        if content.rect.contains?(event.point)
+          content.handle_mouse(event)
+        elsif event.button == :left && rect.contains?(event.point) # the ▾ cell
+          content.focus
+          @overlay.open? ? close_menu : open_menu
+        end
+      end
+
+      # @return [void]
+      def repaint
+        super
+        return if rect.empty?
+
+        well = active? ? screen.theme.active_bg_color : screen.theme.input_bg_color
+        draw_char(rect.left + rect.width - 1, rect.top, "▾", StyledString::Style::DEFAULT.with(bg: well))
+      end
+
+      protected
+
+      # Field spans the row bar the last column, which the `▾` occupies
+      # ({HasContent} layout hook).
+      # @param field [Component]
+      # @return [void]
+      def layout(field)
+        field.rect = Rect.new(rect.left, rect.top, [rect.width - 1, 0].max, 1)
+      end
+
+      private
+
+      # The field's key interceptor: while the dropdown is open forwards movement
+      # to it ({ListDropdown#move}), commits on Enter ({ListDropdown#choose}),
+      # and dismisses on ESC (reverting the query); opens it on Down or Enter
+      # when closed. Everything else (printable keys, editing) falls through to
+      # the field, whose {TextField#on_change} refilters.
+      # @param key [String]
+      # @return [Boolean] true if consumed.
+      def field_key(key)
+        if @overlay.open?
+          if @overlay.move(key)
+            true
+          elsif key == Keys::ENTER
+            @overlay.choose
+            true
+          elsif key == Keys::ESC
+            close_menu
+            revert_query
+            true
+          else
+            false
+          end
+        elsif [Keys::DOWN_ARROW, Keys::ENTER].include?(key)
+          open_menu
+          true
+        else
+          false
+        end
+      end
+
+      # Recomputes the matches for the current query, opening the dropdown when
+      # there are any (and preselecting the current value's row) or closing it
+      # when there are none.
+      # @return [void]
+      def refill
+        @filtered = matching(content.text)
+        if @filtered.empty?
+          close_menu
+        else
+          @overlay.lines = @filtered.map { |item| @item_label.call(item) }
+          @overlay.cursor = List::Cursor.new(position: @filtered.index(value) || 0)
+          @overlay.open unless @overlay.open?
+          anchor
+        end
+      end
+
+      # Items whose label contains `query` (case-insensitive). A query still
+      # equal to the current value's label — the resting state, or a fresh
+      # open — is treated as "show everything", so Down opens the full list.
+      # @param query [String]
+      # @return [Array]
+      def matching(query)
+        return @items if query.empty? || query == display_for(value)
+
+        needle = query.downcase
+        @items.select { |item| @item_label.call(item).to_s.downcase.include?(needle) }
+      end
+
+      # Commits the item at the menu's `index`: closes the dropdown and adopts
+      # it as {#value} (which repaints the field with its label).
+      # @param index [Integer]
+      # @return [void]
+      def commit(index)
+        item = @filtered[index]
+        close_menu
+        self.value = item
+      end
+
+      # @return [void]
+      def open_menu = refill
+
+      # @return [void]
+      def close_menu = (@overlay.close if @overlay.open?)
+
+      # @return [void]
+      def revert_query = sync_field(display_for(value))
+
+      # Sets the field's text without triggering a refilter — for programmatic
+      # value changes and query reverts, which must not spring the dropdown.
+      # Parks the caret at the end: `text=` only *clamps* the caret, so a
+      # shorter query replaced by a longer label would otherwise strand it
+      # mid-word (commit "Go", then pick "Kotlin" → caret after "Ko").
+      # @param text [String]
+      # @return [void]
+      def sync_field(text)
+        @suppressing_filter = true
+        content.text = text
+        content.caret = content.text.length
+      ensure
+        @suppressing_filter = false
+      end
+
+      # @param item [Object]
+      # @return [String] the plain-text label for `item`, or "" for nil.
+      def display_for(item) = item.nil? ? "" : @item_label.call(item).to_s
+
+      # Sizes and positions the dropdown against the field: full combo width,
+      # `min(matches, 10)` rows, below the field — flipped above when it won't
+      # fit beneath, clamped (with the list scrolling) when it fits neither.
+      # @return [void]
+      def anchor
+        desired = [@filtered.size, MAX_VISIBLE_ROWS].min
+        below = screen.size.height - (rect.top + 1)
+        above = rect.top
+        if desired <= below
+          top = rect.top + 1
+          height = desired
+        elsif above >= below
+          height = [desired, above].min
+          top = rect.top - height
+        else
+          height = below
+          top = rect.top + 1
+        end
+        @overlay.size = Size.new(rect.width, height)
+        @overlay.rect = Rect.new(rect.left, top, rect.width, height)
+      end
+
+      # Most matches shown before the dropdown scrolls.
+      # @return [Integer]
+      MAX_VISIBLE_ROWS = 10
+    end
+  end
+end

data/lib/tuile/component/has_caption.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # The chrome text a component *wears* — a {Window}'s border title, a
+    # {Button}'s label — as opposed to the value it *holds*.
+    #
+    #   button.caption = "Submit"
+    #   window.caption = StyledString.styled("Settings", fg: Color::RED)
+    #
+    # Tuile's naming split, which decides what a new component gets:
+    # **caption** is chrome, authored by the app; **text** is the value the
+    # user edits (aliased to {HasValue#value} on {AbstractStringField}). A
+    # component may carry both, hence two mixins.
+    #
+    # Includers own the *rendering* — clipping, width arithmetic, decoration
+    # such as {Window}'s `[key]-` shortcut prefix; this holds only the text.
+    #
+    # == Implementation details
+    # Being a mixin is what lets tree-walking code find "the {Button} captioned
+    # Submit" via `is_a?(HasCaption)` plus a caption compare, rather than a
+    # hardcoded list of classes that happen to respond to `caption`. Don't
+    # collapse it back into per-class accessors.
+    module HasCaption
+      # Read through *this* method, never `@caption` — the ivar stays nil until
+      # the first non-empty set ({#caption=} short-circuits when unchanged).
+      # @return [StyledString] the caption; empty when never set.
+      def caption = @caption || StyledString::EMPTY
+
+      # Sets the caption and invalidates the component. No-op when unchanged. A
+      # `String` is parsed via {StyledString.parse} (embedded ANSI is honored);
+      # a {StyledString} is used as-is; `nil` clears it.
+      # @param new_caption [String, StyledString, nil]
+      # @return [void]
+      def caption=(new_caption)
+        new_caption = StyledString.parse(new_caption)
+        return if caption == new_caption
+
+        @caption = new_caption
+        invalidate
+      end
+    end
+  end
+end

data/lib/tuile/component/has_content.rb

@@ -15,9 +15,6 @@ module Tuile
         content.handle_mouse(event) if !content.nil? && content.rect.contains?(event.point)
       end
 
-      # @return [Array<Component>]
-      def children = content.nil? ? [] : [content]
-
       # Sets the new content of this component. Updates `@content` itself;
       # including classes may still override to add behaviour (e.g. a
       # special-cased Array input) but should call `super` to perform the
@@ -34,10 +31,13 @@ module Tuile
         end
 
         old = self.content
-        old&.parent = nil
+        # Detached without notifying, and notified at the very end: the focus
+        # repair in on_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?
-          content.parent = self
+          add_child(content, at: 0) # content paints beneath a Window's footer
           content.invalidate
           layout(content)
         end