charming 0.1.2 → 0.1.3

data/lib/charming/presentation/components/command_palette.rb

@@ -1,118 +1,116 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # CommandPalette renders a fuzzy-searchable command picker UI. It wraps a TextInput for search
-      # input and a List for result display, dispatching key events between them. Users type to filter
-      # the registered commands by label match, navigate with up/down/home/end keys (delegated to List),
-      # confirm a selection with Enter (returns [:selected, command]), or cancel with Escape (returns :cancelled).
-      # State is serializable as a hash of value/cursor/selected_index for session persistence.
-      class CommandPalette < Component
-        Command = Data.define(:label, :value)
-
-        # A single command palette entry: a human-readable +label+ and a callable or
-        # method symbol +value+ that gets executed when the user selects it.
-        attr_reader :commands, :input
-
-        # Initializes the dropdown widget with a list of Command entries and search
-        # parameters for building the underlying TextInput (placeholder text, cursor
-        # position, value) and List (display height, initial selection). Returns void;
-        # the state is later serializable via +state+ for session persistence.
-        def initialize(commands:, placeholder: "Search commands", height: nil, value: "", cursor: nil, selected_index: 0, theme: nil)
-          super(theme: theme)
-          @commands = commands
-          @height = height
-          @input = TextInput.new(value: value, placeholder: placeholder, cursor: cursor)
-          @list = build_list(selected_index: selected_index)
-        end
+  module Components
+    # CommandPalette renders a fuzzy-searchable command picker UI. It wraps a TextInput for search
+    # input and a List for result display, dispatching key events between them. Users type to filter
+    # the registered commands by label match, navigate with up/down/home/end keys (delegated to List),
+    # confirm a selection with Enter (returns [:selected, command]), or cancel with Escape (returns :cancelled).
+    # State is serializable as a hash of value/cursor/selected_index for session persistence.
+    class CommandPalette < Component
+      Command = Data.define(:label, :value)
+
+      # A single command palette entry: a human-readable +label+ and a callable or
+      # method symbol +value+ that gets executed when the user selects it.
+      attr_reader :commands, :input
+
+      # Initializes the dropdown widget with a list of Command entries and search
+      # parameters for building the underlying TextInput (placeholder text, cursor
+      # position, value) and List (display height, initial selection). Returns void;
+      # the state is later serializable via +state+ for session persistence.
+      def initialize(commands:, placeholder: "Search commands", height: nil, value: "", cursor: nil, selected_index: 0, theme: nil)
+        super(theme: theme)
+        @commands = commands
+        @height = height
+        @input = TextInput.new(value: value, placeholder: placeholder, cursor: cursor)
+        @list = build_list(selected_index: selected_index)
+      end
 
-        # Returns the currently displayed Command entry in the List at the time of calling.
-        # Returns nil if no entry is highlighted (i.e., user has opened the palette but not
-        # moved the selection). Useful for retrieving the result after key handling.
-        def selected_command
-          list.selected_item
-        end
+      # Returns the currently displayed Command entry in the List at the time of calling.
+      # Returns nil if no entry is highlighted (i.e., user has opened the palette but not
+      # moved the selection). Useful for retrieving the result after key handling.
+      def selected_command
+        list.selected_item
+      end
 
-        # Collects the current state of the TextInput and List into a serializable hash
-        # suitable for round-trip storage in session. Returns {value:, cursor:, selected_index:}.
-        def state
-          {
-            value: input.value,
-            cursor: input.cursor,
-            selected_index: list.selected_index
-          }
-        end
+      # Collects the current state of the TextInput and List into a serializable hash
+      # suitable for round-trip storage in session. Returns {value:, cursor:, selected_index:}.
+      def state
+        {
+          value: input.value,
+          cursor: input.cursor,
+          selected_index: list.selected_index
+        }
+      end
 
-        # Handles key events by routing them to the appropriate sub-component: Escape kills the
-        # palette returning :cancelled; up/down/home/end keys go to the List selection handler
-        # via handle_list_key; all other keys (including typed characters) are passed to the TextInput
-        # which manages cursor position and input filtering. If a list key match fails, falls through
-        # to the TextInput handler. Returns nil/nil if no handler consumed the event, or :cancelled when
-        # Escape is pressed.
-        def handle_key(event)
-          key = Charming.key_of(event)
-          return :cancelled if key == :escape
+      # Handles key events by routing them to the appropriate sub-component: Escape kills the
+      # palette returning :cancelled; up/down/home/end keys go to the List selection handler
+      # via handle_list_key; all other keys (including typed characters) are passed to the TextInput
+      # which manages cursor position and input filtering. If a list key match fails, falls through
+      # to the TextInput handler. Returns nil/nil if no handler consumed the event, or :cancelled when
+      # Escape is pressed.
+      def handle_key(event)
+        key = Charming.key_of(event)
+        return :cancelled if key == :escape
 
-          return handle_list_key(event) if list_key?(key)
+        return handle_list_key(event) if list_key?(key)
 
-          handle_input_key(event)
-        end
+        handle_input_key(event)
+      end
 
-        # Renders the command palette as a vertically-stacked text representation: the search TextInput
-        # row on line 1, and then the filtered List results (or "No commands found") on subsequent lines.
-        # Returns a multiline string suitable for terminal rendering.
-        def render
-          [input.render, render_results].join("\n")
-        end
+      # Renders the command palette as a vertically-stacked text representation: the search TextInput
+      # row on line 1, and then the filtered List results (or "No commands found") on subsequent lines.
+      # Returns a multiline string suitable for terminal rendering.
+      def render
+        [input.render, render_results].join("\n")
+      end
 
-        private
+      private
 
-        attr_reader :height, :list
+      attr_reader :height, :list
 
-        # Delegates key handling entirely to the internal List widget, which manages up/down/home/end selection.
-        # Returns whatever the List's handle_key returns (typically nil or the symbol from the subclass).
-        def handle_list_key(event)
-          list.handle_key(event)
-        end
+      # Delegates key handling entirely to the internal List widget, which manages up/down/home/end selection.
+      # Returns whatever the List's handle_key returns (typically nil or the symbol from the subclass).
+      def handle_list_key(event)
+        list.handle_key(event)
+      end
 
-        # Passes the key event to the TextInput for cursor position and search text management.
-        # If the input returns :handled, rebuilds the List so that filtering is re-evaluated against
-        # the new input value. Returns nil/nil if no handler consumed the event.
-        def handle_input_key(event)
-          result = input.handle_key(event)
-          @list = build_list if result == :handled
-          result
-        end
+      # Passes the key event to the TextInput for cursor position and search text management.
+      # If the input returns :handled, rebuilds the List so that filtering is re-evaluated against
+      # the new input value. Returns nil/nil if no handler consumed the event.
+      def handle_input_key(event)
+        result = input.handle_key(event)
+        @list = build_list if result == :handled
+        result
+      end
 
-        # Checks whether the given key is a List-navigation key (up/down/home/end). Returns true for those keys
-        # so they can be dispatched via +handle_list_key+ rather than falling through to TextInput.
-        def list_key?(key)
-          %i[up down home end enter].include?(key)
-        end
+      # Checks whether the given key is a List-navigation key (up/down/home/end). Returns true for those keys
+      # so they can be dispatched via +handle_list_key+ rather than falling through to TextInput.
+      def list_key?(key)
+        %i[up down home end enter].include?(key)
+      end
 
-        # Renders the filtered results section below the search input. If no commands match the current filter text,
-        # returns "No commands found"; otherwise renders the List widget's styled display string. Returns a single-line string.
-        def render_results
-          return "No commands found" if filtered_commands.empty?
+      # Renders the filtered results section below the search input. If no commands match the current filter text,
+      # returns "No commands found"; otherwise renders the List widget's styled display string. Returns a single-line string.
+      def render_results
+        return "No commands found" if filtered_commands.empty?
 
-          list.render
-        end
+        list.render
+      end
 
-        # Builds a new List from the currently filtered commands at the given selected_index height and label extractor.
-        # The +selected_index+ parameter defaults to the last known value in +list+ to preserve scroll position across rebuilds.
-        def build_list(selected_index: list&.selected_index || 0)
-          List.new(items: filtered_commands, selected_index: selected_index, height: height, label: :label.to_proc, theme: theme)
-        end
+      # Builds a new List from the currently filtered commands at the given selected_index height and label extractor.
+      # The +selected_index+ parameter defaults to the last known value in +list+ to preserve scroll position across rebuilds.
+      def build_list(selected_index: list&.selected_index || 0)
+        List.new(items: filtered_commands, selected_index: selected_index, height: height, label: :label.to_proc, theme: theme)
+      end
 
-        # Returns the full commands array when input value is empty; otherwise a subset whose labels match case-insensitively
-        # against the current TextInput value. Used to drive the fuzzy search behavior. Returns an Array of Command entries.
-        def filtered_commands
-          return commands if input.value.empty?
+      # Returns the full commands array when input value is empty; otherwise a subset whose labels match case-insensitively
+      # against the current TextInput value. Used to drive the fuzzy search behavior. Returns an Array of Command entries.
+      def filtered_commands
+        return commands if input.value.empty?
 
-          commands.select do |command|
-            command.label.downcase.include?(input.value.downcase)
-          end
+        commands.select do |command|
+          command.label.downcase.include?(input.value.downcase)
         end
       end
     end

data/lib/charming/presentation/components/command_palette_modal.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Charming
+  module Components
+    # CommandPaletteModal wraps command palette content in the framework's standard modal chrome.
+    class CommandPaletteModal < Component
+      DEFAULT_TITLE = "Command palette"
+      DEFAULT_HELP = "Type to filter. Enter selects. Escape closes."
+      DEFAULT_WIDTH = 52
+
+      def initialize(content:, title: DEFAULT_TITLE, help: DEFAULT_HELP, width: DEFAULT_WIDTH, style: nil, theme: nil)
+        super(theme: theme)
+        @content = content
+        @title = title
+        @help = help
+        @width = width
+        @style = style
+      end
+
+      def render
+        render_component Modal.new(content: content, title: title, help: help, width: width, style: modal_style, theme: theme)
+      end
+
+      private
+
+      attr_reader :content, :title, :help, :width
+
+      def modal_style
+        @style
+      end
+    end
+  end
+end

data/lib/charming/presentation/components/empty_state.rb

@@ -1,55 +1,53 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # EmptyState is a placeholder component for screens with no content. Renders one of three
-      # states: a default "nothing to show" message, a "loading…" message, or an error message
-      # with optional help text.
-      class EmptyState < Component
-        # *message* is shown in the default state. *loading* switches to the loading message
-        # (overrides *message*). *loading_message* is the string rendered in the loading state.
-        # *error* and *error_message* switch to the error state (the string form takes precedence).
-        # *help* is an optional muted line shown below the error message.
-        def initialize(message: "Nothing to show.", loading: false, loading_message: "Loading...", error: nil, error_message: nil, help: nil, theme: nil)
-          super(theme: theme)
-          @message = message
-          @loading = loading
-          @loading_message = loading_message
-          @error = error
-          @error_message = error_message
-          @help = help
-        end
-
-        # Renders the appropriate state as styled text: loading → loading message, error →
-        # error message + help, otherwise the default message.
-        def render
-          return loading_state if @loading
-          return error_state if error?
-
-          text @message, style: theme.muted
-        end
-
-        private
-
-        # Renders the loading state as a muted line.
-        def loading_state
-          text @loading_message, style: theme.muted
-        end
-
-        # Renders the error state: the error message styled with the theme's warn style,
-        # optionally followed by a muted help line.
-        def error_state
-          lines = [text(@error_message || @error.to_s, style: theme.warn)]
-          lines << text(@help, style: theme.muted) if @help.to_s.strip != ""
-
-          column(*lines)
-        end
-
-        # True when either the *error* or *error_message* string is non-blank.
-        def error?
-          @error.to_s.strip != "" || @error_message.to_s.strip != ""
-        end
+  module Components
+    # EmptyState is a placeholder component for screens with no content. Renders one of three
+    # states: a default "nothing to show" message, a "loading…" message, or an error message
+    # with optional help text.
+    class EmptyState < Component
+      # *message* is shown in the default state. *loading* switches to the loading message
+      # (overrides *message*). *loading_message* is the string rendered in the loading state.
+      # *error* and *error_message* switch to the error state (the string form takes precedence).
+      # *help* is an optional muted line shown below the error message.
+      def initialize(message: "Nothing to show.", loading: false, loading_message: "Loading...", error: nil, error_message: nil, help: nil, theme: nil)
+        super(theme: theme)
+        @message = message
+        @loading = loading
+        @loading_message = loading_message
+        @error = error
+        @error_message = error_message
+        @help = help
+      end
+
+      # Renders the appropriate state as styled text: loading → loading message, error →
+      # error message + help, otherwise the default message.
+      def render
+        return loading_state if @loading
+        return error_state if error?
+
+        text @message, style: theme.muted
+      end
+
+      private
+
+      # Renders the loading state as a muted line.
+      def loading_state
+        text @loading_message, style: theme.muted
+      end
+
+      # Renders the error state: the error message styled with the theme's warn style,
+      # optionally followed by a muted help line.
+      def error_state
+        lines = [text(@error_message || @error.to_s, style: theme.warn)]
+        lines << text(@help, style: theme.muted) if @help.to_s.strip != ""
+
+        column(*lines)
+      end
+
+      # True when either the *error* or *error_message* string is non-blank.
+      def error?
+        @error.to_s.strip != "" || @error_message.to_s.strip != ""
       end
     end
   end

data/lib/charming/presentation/components/form/builder.rb

@@ -1,60 +1,58 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      class Form
-        # Builder collects form field declarations inside a `form(:name) { ... }` block and
-        # assembles them into a Form component when `build` is called. Each declaration method
-        # appends a Field subclass instance to the builder's *fields* list.
-        class Builder
-          # The accumulated field list and the theme applied to each declared field.
-          attr_reader :fields, :theme
-
-          # Initializes an empty builder. *theme* is forwarded to every declared field unless
-          # the field declaration explicitly overrides it.
-          def initialize(theme: nil)
-            @theme = theme
-            @fields = []
-          end
-
-          # Appends a single-line Input field. *options* are passed through to Input.
-          def input(name, **options)
-            fields << Input.new(name, **field_options(options))
-          end
-
-          # Appends a multi-line Textarea field.
-          def textarea(name, **options)
-            fields << Textarea.new(name, **field_options(options))
-          end
-
-          # Appends a Select field with the given *options* array.
-          def select(name, **options)
-            fields << Select.new(name, **field_options(options))
-          end
-
-          # Appends a Confirm (boolean) field.
-          def confirm(name, **options)
-            fields << Confirm.new(name, **field_options(options))
-          end
-
-          # Appends a static Note (non-focusable).
-          def note(text, **options)
-            fields << Note.new(text, **field_options(options))
-          end
-
-          # Assembles the collected fields into a Form component, bound to *state* and using
-          # the *theme* argument (falling back to the builder's theme).
-          def build(state:, theme: nil)
-            Components::Form.new(fields: fields, state: state, theme: theme || self.theme)
-          end
-
-          private
-
-          # Merges the builder's theme into the per-field *options* so each field receives it.
-          def field_options(options)
-            {theme: theme}.merge(options)
-          end
+  module Components
+    class Form
+      # Builder collects form field declarations inside a `form(:name) { ... }` block and
+      # assembles them into a Form component when `build` is called. Each declaration method
+      # appends a Field subclass instance to the builder's *fields* list.
+      class Builder
+        # The accumulated field list and the theme applied to each declared field.
+        attr_reader :fields, :theme
+
+        # Initializes an empty builder. *theme* is forwarded to every declared field unless
+        # the field declaration explicitly overrides it.
+        def initialize(theme: nil)
+          @theme = theme
+          @fields = []
+        end
+
+        # Appends a single-line Input field. *options* are passed through to Input.
+        def input(name, **options)
+          fields << Input.new(name, **field_options(options))
+        end
+
+        # Appends a multi-line Textarea field.
+        def textarea(name, **options)
+          fields << Textarea.new(name, **field_options(options))
+        end
+
+        # Appends a Select field with the given *options* array.
+        def select(name, **options)
+          fields << Select.new(name, **field_options(options))
+        end
+
+        # Appends a Confirm (boolean) field.
+        def confirm(name, **options)
+          fields << Confirm.new(name, **field_options(options))
+        end
+
+        # Appends a static Note (non-focusable).
+        def note(text, **options)
+          fields << Note.new(text, **field_options(options))
+        end
+
+        # Assembles the collected fields into a Form component, bound to *state* and using
+        # the *theme* argument (falling back to the builder's theme).
+        def build(state:, theme: nil)
+          Components::Form.new(fields: fields, state: state, theme: theme || self.theme)
+        end
+
+        private
+
+        # Merges the builder's theme into the per-field *options* so each field receives it.
+        def field_options(options)
+          {theme: theme}.merge(options)
         end
       end
     end

data/lib/charming/presentation/components/form/confirm.rb

@@ -1,67 +1,65 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      class Form
-        # Confirm is a boolean Form field that renders a checkbox-style control. Space toggles
-        # the value; y/Right sets it to true; n/Left sets it to false. Required confirms must
-        # be accepted (value == true) to pass validation.
-        class Confirm < Field
-          # *value* is the initial boolean state (default: false). All other options are
-          # forwarded to Field.
-          def initialize(name, value: false, **options)
-            super(name, **options)
-            @initial_value = value
-          end
+  module Components
+    class Form
+      # Confirm is a boolean Form field that renders a checkbox-style control. Space toggles
+      # the value; y/Right sets it to true; n/Left sets it to false. Required confirms must
+      # be accepted (value == true) to pass validation.
+      class Confirm < Field
+        # *value* is the initial boolean state (default: false). All other options are
+        # forwarded to Field.
+        def initialize(name, value: false, **options)
+          super(name, **options)
+          @initial_value = value
+        end
 
-          # Handles the standard confirm keys: space toggles, y/right sets to true, n/left
-          # sets to false, and a space character (when the event exposes `char`) also toggles.
-          def handle_key(event)
-            case Charming.key_of(event)
-            when :space
-              toggle
-            when :y, :right
-              state[:values][name] = true
-            when :n, :left
-              state[:values][name] = false
-            else
-              return nil unless event.respond_to?(:char) && event.char == " "
+        # Handles the standard confirm keys: space toggles, y/right sets to true, n/left
+        # sets to false, and a space character (when the event exposes `char`) also toggles.
+        def handle_key(event)
+          case Charming.key_of(event)
+          when :space
+            toggle
+          when :y, :right
+            state[:values][name] = true
+          when :n, :left
+            state[:values][name] = false
+          else
+            return nil unless event.respond_to?(:char) && event.char == " "
 
-              toggle
-            end
-            :handled
+            toggle
           end
+          :handled
+        end
 
-          # Returns ["must be accepted"] when required and the value is not true, otherwise
-          # the result of the base Field validation.
-          def validate
-            return ["must be accepted"] if required? && value != true
+        # Returns ["must be accepted"] when required and the value is not true, otherwise
+        # the result of the base Field validation.
+        def validate
+          return ["must be accepted"] if required? && value != true
 
-            super
-          end
+          super
+        end
 
-          private
+        private
 
-          # The default value for a freshly-bound field is the *value* passed at construction.
-          def default_value
-            @initial_value
-          end
+        # The default value for a freshly-bound field is the *value* passed at construction.
+        def default_value
+          @initial_value
+        end
 
-          # Renders "[x] Label" or "[ ] Label" depending on the current value.
-          def render_control
-            "#{checked_marker} #{label}"
-          end
+        # Renders "[x] Label" or "[ ] Label" depending on the current value.
+        def render_control
+          "#{checked_marker} #{label}"
+        end
 
-          # Returns the checkbox marker string.
-          def checked_marker
-            value ? "[x]" : "[ ]"
-          end
+        # Returns the checkbox marker string.
+        def checked_marker
+          value ? "[x]" : "[ ]"
+        end
 
-          # Flips the current value (true ↔ false).
-          def toggle
-            state[:values][name] = !value
-          end
+        # Flips the current value (true ↔ false).
+        def toggle
+          state[:values][name] = !value
         end
       end
     end