charming 0.1.2 → 0.1.3

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

@@ -1,84 +1,82 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      class Form
-        # Textarea is a multi-line Form field backed by a TextArea widget. The cursor offset,
-        # top-visible row, and preferred vertical column are all persisted in the form's
-        # per-field state so the field behaves consistently when refocused mid-edit.
-        class Textarea < Field
-          # *value* is the initial text. *placeholder* is shown when the value is empty.
-          # *width* and *height* constrain the rendered area. All other options are forwarded
-          # to Field (label, required, validate, help, theme).
-          def initialize(name, value: "", placeholder: "", width: nil, height: nil, **options)
-            super(name, **options)
-            @initial_value = value
-            @placeholder = placeholder
-            @width = width
-            @height = height
-          end
+  module Components
+    class Form
+      # Textarea is a multi-line Form field backed by a TextArea widget. The cursor offset,
+      # top-visible row, and preferred vertical column are all persisted in the form's
+      # per-field state so the field behaves consistently when refocused mid-edit.
+      class Textarea < Field
+        # *value* is the initial text. *placeholder* is shown when the value is empty.
+        # *width* and *height* constrain the rendered area. All other options are forwarded
+        # to Field (label, required, validate, help, theme).
+        def initialize(name, value: "", placeholder: "", width: nil, height: nil, **options)
+          super(name, **options)
+          @initial_value = value
+          @placeholder = placeholder
+          @width = width
+          @height = height
+        end
 
-          # Binds the field, seeds the initial value, and initializes the cursor/offset state.
-          def bind(state)
-            super
-            state[:values][name] = @initial_value if state[:values][name].nil?
-            field_state[:cursor] = state[:values][name].to_s.length unless field_state.key?(:cursor)
-            field_state[:offset] ||= 0
-          end
+        # Binds the field, seeds the initial value, and initializes the cursor/offset state.
+        def bind(state)
+          super
+          state[:values][name] = @initial_value if state[:values][name].nil?
+          field_state[:cursor] = state[:values][name].to_s.length unless field_state.key?(:cursor)
+          field_state[:offset] ||= 0
+        end
 
-          # Forwards key events to the underlying TextArea, syncing the value, cursor, offset,
-          # and preferred column back into the form state. Returns :handled when consumed.
-          def handle_key(event)
-            area = text_area
-            result = area.handle_key(event)
-            return nil unless result == :handled
+        # Forwards key events to the underlying TextArea, syncing the value, cursor, offset,
+        # and preferred column back into the form state. Returns :handled when consumed.
+        def handle_key(event)
+          area = text_area
+          result = area.handle_key(event)
+          return nil unless result == :handled
 
-            state[:values][name] = area.value
-            field_state[:cursor] = area.cursor
-            field_state[:offset] = area.offset
-            field_state[:preferred_column] = area.preferred_column
-            :handled
-          end
+          state[:values][name] = area.value
+          field_state[:cursor] = area.cursor
+          field_state[:offset] = area.offset
+          field_state[:preferred_column] = area.preferred_column
+          :handled
+        end
 
-          # Renders the field with its label on the first line, body lines indented, and
-          # optional help/error lines below.
-          def render(active: false)
-            label_line = "#{active ? ">" : " "} #{label}:"
-            label_line = theme.selected.render(label_line) if active
-            [label_line, *body_lines, help_line, *error_lines].compact.join("\n")
-          end
+        # Renders the field with its label on the first line, body lines indented, and
+        # optional help/error lines below.
+        def render(active: false)
+          label_line = "#{active ? ">" : " "} #{label}:"
+          label_line = theme.selected.render(label_line) if active
+          [label_line, *body_lines, help_line, *error_lines].compact.join("\n")
+        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 the multi-line body, indenting each line by two spaces.
-          def body_lines
-            text_area.render.lines(chomp: true).map { |line| "  #{line}" }
-          end
+        # Renders the multi-line body, indenting each line by two spaces.
+        def body_lines
+          text_area.render.lines(chomp: true).map { |line| "  #{line}" }
+        end
 
-          # Builds a fresh TextArea each render, seeded from the current form-state value and
-          # the persisted cursor/offset/preferred_column.
-          def text_area
-            TextArea.new(
-              value: value.to_s,
-              placeholder: @placeholder,
-              width: @width,
-              height: @height,
-              cursor: field_state[:cursor],
-              offset: field_state[:offset],
-              preferred_column: field_state[:preferred_column]
-            )
-          end
+        # Builds a fresh TextArea each render, seeded from the current form-state value and
+        # the persisted cursor/offset/preferred_column.
+        def text_area
+          TextArea.new(
+            value: value.to_s,
+            placeholder: @placeholder,
+            width: @width,
+            height: @height,
+            cursor: field_state[:cursor],
+            offset: field_state[:offset],
+            preferred_column: field_state[:preferred_column]
+          )
+        end
 
-          # Returns the per-field state hash for this field.
-          def field_state
-            state[:fields][name]
-          end
+        # Returns the per-field state hash for this field.
+        def field_state
+          state[:fields][name]
         end
       end
     end

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

@@ -1,155 +1,153 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # Form is a multi-field form component with built-in focus traversal, validation, and
-      # submit/cancel handling. Fields are produced by `Form::Builder` (see `controller.form`)
-      # and bound to a per-form mutable state hash. Tab/Shift+Tab cycles focus through
-      # focusable fields, Enter advances to the next field (or submits on the last), Escape
-      # cancels, and Ctrl+S submits from any field.
-      class Form < Component
-        # The list of field objects and the mutable state hash the form is bound to.
-        attr_reader :fields, :state
-
-        # *fields* is the array of form field objects. *state* is a hash for storing field
-        # values/errors and the current focus index; usually `session[:forms][form_name]`.
-        def initialize(fields:, state: nil, theme: nil)
-          super(theme: theme)
-          @fields = fields
-          @state = normalize_state(state || {})
-          bind_fields
-          clamp_focus
-        end
+  module Components
+    # Form is a multi-field form component with built-in focus traversal, validation, and
+    # submit/cancel handling. Fields are produced by `Form::Builder` (see `controller.form`)
+    # and bound to a per-form mutable state hash. Tab/Shift+Tab cycles focus through
+    # focusable fields, Enter advances to the next field (or submits on the last), Escape
+    # cancels, and Ctrl+S submits from any field.
+    class Form < Component
+      # The list of field objects and the mutable state hash the form is bound to.
+      attr_reader :fields, :state
+
+      # *fields* is the array of form field objects. *state* is a hash for storing field
+      # values/errors and the current focus index; usually `session[:forms][form_name]`.
+      def initialize(fields:, state: nil, theme: nil)
+        super(theme: theme)
+        @fields = fields
+        @state = normalize_state(state || {})
+        bind_fields
+        clamp_focus
+      end
 
-        # Handles key events: Escape cancels, Ctrl+S submits, Tab cycles focus, Enter advances
-        # or submits, and unhandled keys are passed to the focused field.
-        def handle_key(event)
-          key = Charming.key_of(event)
-          return :cancelled if key == :escape
-          return submit if submit_shortcut?(event)
-          return move_focus(tab_direction(event)) if key == :tab
+      # Handles key events: Escape cancels, Ctrl+S submits, Tab cycles focus, Enter advances
+      # or submits, and unhandled keys are passed to the focused field.
+      def handle_key(event)
+        key = Charming.key_of(event)
+        return :cancelled if key == :escape
+        return submit if submit_shortcut?(event)
+        return move_focus(tab_direction(event)) if key == :tab
 
-          result = handle_current_field(event)
-          return result if result
+        result = handle_current_field(event)
+        return result if result
 
-          advance_or_submit if key == :enter
-        end
+        advance_or_submit if key == :enter
+      end
 
-        # Returns a hash of `{field_name => value}` for the current field values.
-        def values
-          state[:values]
-        end
+      # Returns a hash of `{field_name => value}` for the current field values.
+      def values
+        state[:values]
+      end
 
-        # Renders each field on its own line, marking the active field with `active: true`.
-        def render
-          fields.each_with_index.map do |field, index|
-            field.render(active: index == state[:focus_index])
-          end.join("\n")
-        end
+      # Renders each field on its own line, marking the active field with `active: true`.
+      def render
+        fields.each_with_index.map do |field, index|
+          field.render(active: index == state[:focus_index])
+        end.join("\n")
+      end
 
-        private
+      private
 
-        # Ensures the state hash has all the required sub-keys: :values, :fields, :errors, and
-        # a sensible :focus_index default.
-        def normalize_state(value)
-          value[:values] ||= {}
-          value[:fields] ||= {}
-          value[:errors] ||= {}
-          value[:focus_index] ||= first_focusable_index || 0
-          value
-        end
+      # Ensures the state hash has all the required sub-keys: :values, :fields, :errors, and
+      # a sensible :focus_index default.
+      def normalize_state(value)
+        value[:values] ||= {}
+        value[:fields] ||= {}
+        value[:errors] ||= {}
+        value[:focus_index] ||= first_focusable_index || 0
+        value
+      end
 
-        # Binds each field to the state hash so field updates write back into `state[:values]`.
-        def bind_fields
-          fields.each { |field| field.bind(state) }
-        end
+      # Binds each field to the state hash so field updates write back into `state[:values]`.
+      def bind_fields
+        fields.each { |field| field.bind(state) }
+      end
 
-        # Forwards *event* to the currently focused field and returns its result.
-        def handle_current_field(event)
-          current_field&.handle_key(event)
-        end
+      # Forwards *event* to the currently focused field and returns its result.
+      def handle_current_field(event)
+        current_field&.handle_key(event)
+      end
 
-        # Returns -1 for Shift+Tab (backward), +1 for plain Tab (forward).
-        def tab_direction(event)
-          return -1 if event.respond_to?(:shift) && event.shift
+      # Returns -1 for Shift+Tab (backward), +1 for plain Tab (forward).
+      def tab_direction(event)
+        return -1 if event.respond_to?(:shift) && event.shift
 
-          +1
-        end
+        +1
+      end
 
-        # True when the event is the submit shortcut (Ctrl+S).
-        def submit_shortcut?(event)
-          Charming.key_of(event) == :s && event.respond_to?(:ctrl) && event.ctrl
-        end
+      # True when the event is the submit shortcut (Ctrl+S).
+      def submit_shortcut?(event)
+        Charming.key_of(event) == :s && event.respond_to?(:ctrl) && event.ctrl
+      end
 
-        # On Enter: submit when the last focusable field is active, otherwise advance focus.
-        def advance_or_submit
-          return submit if last_focusable?
+      # On Enter: submit when the last focusable field is active, otherwise advance focus.
+      def advance_or_submit
+        return submit if last_focusable?
 
-          move_focus(+1)
-        end
+        move_focus(+1)
+      end
 
-        # Validates all fields, focuses the first invalid one, and returns [:submitted, values]
-        # when there are no errors.
-        def submit
-          state[:errors] = validation_errors
-          focus_first_error unless state[:errors].empty?
-          return :handled unless state[:errors].empty?
+      # Validates all fields, focuses the first invalid one, and returns [:submitted, values]
+      # when there are no errors.
+      def submit
+        state[:errors] = validation_errors
+        focus_first_error unless state[:errors].empty?
+        return :handled unless state[:errors].empty?
 
-          [:submitted, values.dup]
-        end
+        [:submitted, values.dup]
+      end
 
-        # Runs each field's validator and collects per-field error messages.
-        def validation_errors
-          fields.each_with_object({}) do |field, errors|
-            messages = field.validate
-            errors[field.name] = messages unless messages.empty?
-          end
+      # Runs each field's validator and collects per-field error messages.
+      def validation_errors
+        fields.each_with_object({}) do |field, errors|
+          messages = field.validate
+          errors[field.name] = messages unless messages.empty?
         end
+      end
 
-        # Moves focus to the first focusable field with errors, when any.
-        def focus_first_error
-          invalid = fields.index { |field| field.focusable? && state[:errors].key?(field.name) }
-          state[:focus_index] = invalid if invalid
-        end
+      # Moves focus to the first focusable field with errors, when any.
+      def focus_first_error
+        invalid = fields.index { |field| field.focusable? && state[:errors].key?(field.name) }
+        state[:focus_index] = invalid if invalid
+      end
 
-        # Returns the field at the current focus index, or nil when out of range.
-        def current_field
-          fields[state[:focus_index]]
-        end
+      # Returns the field at the current focus index, or nil when out of range.
+      def current_field
+        fields[state[:focus_index]]
+      end
 
-        # Moves focus by *direction* (forward or backward) through the focusable fields.
-        def move_focus(direction)
-          indices = focusable_indices
-          return nil if indices.empty?
+      # Moves focus by *direction* (forward or backward) through the focusable fields.
+      def move_focus(direction)
+        indices = focusable_indices
+        return nil if indices.empty?
 
-          current = indices.index(state[:focus_index]) || 0
-          state[:focus_index] = indices[(current + direction) % indices.length]
-          :handled
-        end
+        current = indices.index(state[:focus_index]) || 0
+        state[:focus_index] = indices[(current + direction) % indices.length]
+        :handled
+      end
 
-        # True when the current focus index is the last focusable field.
-        def last_focusable?
-          focusable_indices.last == state[:focus_index]
-        end
+      # True when the current focus index is the last focusable field.
+      def last_focusable?
+        focusable_indices.last == state[:focus_index]
+      end
 
-        # Indices of focusable fields, memoized.
-        def focusable_indices
-          @focusable_indices ||= fields.each_index.select { |index| fields[index].focusable? }
-        end
+      # Indices of focusable fields, memoized.
+      def focusable_indices
+        @focusable_indices ||= fields.each_index.select { |index| fields[index].focusable? }
+      end
 
-        # The first index of a focusable field, or nil when no fields are focusable.
-        def first_focusable_index
-          fields.each_index.find { |index| fields[index].focusable? }
-        end
+      # The first index of a focusable field, or nil when no fields are focusable.
+      def first_focusable_index
+        fields.each_index.find { |index| fields[index].focusable? }
+      end
 
-        # On initialization, ensures :focus_index points at a focusable field.
-        def clamp_focus
-          return if focusable_indices.empty?
-          return if focusable_indices.include?(state[:focus_index])
+      # On initialization, ensures :focus_index points at a focusable field.
+      def clamp_focus
+        return if focusable_indices.empty?
+        return if focusable_indices.include?(state[:focus_index])
 
-          state[:focus_index] = focusable_indices.first
-        end
+        state[:focus_index] = focusable_indices.first
       end
     end
   end

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

@@ -1,56 +1,54 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # KeyboardHandler is a mixin module that provides keyboard event dispatch by mapping symbolic key names
-      # to private method calls. Implementors must define a constant +KEY_ACTIONS+ as a hash where each key is
-      # a symbol (e.g., :up, :down, :enter) and each value is the target method name (e.g., :move_up). Call
-      # +handle_key(event)+ with any event object; it uses Charming.key_of to resolve the raw event to a symbol,
-      # looks up the corresponding action in KEY_ACTIONS, sends that method on self, and returns :handled if an
-      # action was found. Returns nil (via :handled being truthy or not) when no matching key exists.
-      module KeyboardHandler
-        VIM_KEYMAP = {
-          up: :k,
-          down: :j,
-          left: :h,
-          right: :l
-        }.freeze
-
-        def handle_key(event)
-          key = Charming.key_of(event)
-          action = key_actions[key]
-          return unless action
-
-          send(action)
-          :handled
-        end
+  module Components
+    # KeyboardHandler is a mixin module that provides keyboard event dispatch by mapping symbolic key names
+    # to private method calls. Implementors must define a constant +KEY_ACTIONS+ as a hash where each key is
+    # a symbol (e.g., :up, :down, :enter) and each value is the target method name (e.g., :move_up). Call
+    # +handle_key(event)+ with any event object; it uses Charming.key_of to resolve the raw event to a symbol,
+    # looks up the corresponding action in KEY_ACTIONS, sends that method on self, and returns :handled if an
+    # action was found. Returns nil (via :handled being truthy or not) when no matching key exists.
+    module KeyboardHandler
+      VIM_KEYMAP = {
+        up: :k,
+        down: :j,
+        left: :h,
+        right: :l
+      }.freeze
+
+      def handle_key(event)
+        key = Charming.key_of(event)
+        action = key_actions[key]
+        return unless action
+
+        send(action)
+        :handled
+      end
 
-        private
+      private
 
-        def key_actions
-          base_key_actions.merge(normalized_keymap)
-        end
+      def key_actions
+        base_key_actions.merge(normalized_keymap)
+      end
 
-        def base_key_actions
-          self.class.const_get(:KEY_ACTIONS)
-        end
+      def base_key_actions
+        self.class.const_get(:KEY_ACTIONS)
+      end
 
-        def normalized_keymap
-          resolved_keymap.each_with_object({}) do |(action_key, keys), actions|
-            action = base_key_actions[action_key.to_sym]
-            next unless action
+      def normalized_keymap
+        resolved_keymap.each_with_object({}) do |(action_key, keys), actions|
+          action = base_key_actions[action_key.to_sym]
+          next unless action
 
-            Array(keys).each { |key| actions[key.to_sym] = action }
-          end
+          Array(keys).each { |key| actions[key.to_sym] = action }
         end
+      end
 
-        def resolved_keymap
-          case @keymap
-          when :vim then VIM_KEYMAP
-          when nil then {}
-          else @keymap
-          end
+      def resolved_keymap
+        case @keymap
+        when :vim then VIM_KEYMAP
+        when nil then {}
+        else @keymap
         end
       end
     end