charming 0.1.2 → 0.1.3

data/lib/charming/presentation/view.rb

@@ -1,135 +1,133 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    # View is the base class for all screen view implementations. It provides assign injection (via `initialize`),
-    # rendering hooks, layout composition helpers (`row`, `column`, `render_component`, `yield_content`),
-    # and access to controller theme, style, and focus state from within views.
-    class View
-      # Initializes the view with named assigns injected as instance-local accessor methods via
-      # `define_singleton_method`. Called when a controller instantiates a view for rendering.
-      def initialize(**assigns)
-        @assigns = assigns
-        define_assign_readers
-      end
+  # View is the base class for all screen view implementations. It provides assign injection (via `initialize`),
+  # rendering hooks, layout composition helpers (`row`, `column`, `render_component`, `yield_content`),
+  # and access to controller theme, style, and focus state from within views.
+  class View
+    # Initializes the view with named assigns injected as instance-local accessor methods via
+    # `define_singleton_method`. Called when a controller instantiates a view for rendering.
+    def initialize(**assigns)
+      @assigns = assigns
+      define_assign_readers
+    end
 
-      # Returns all view assigns as a hash, used by layouts to compose the full template (content + screen + controller).
-      def layout_assigns
-        assigns
-      end
+    # Returns all view assigns as a hash, used by layouts to compose the full template (content + screen + controller).
+    def layout_assigns
+      assigns
+    end
 
-      # Renders the view's body. Default is empty — subclasses override to return visible text.
-      def render
-        ""
-      end
+    # Renders the view's body. Default is empty — subclasses override to return visible text.
+    def render
+      ""
+    end
 
-      # Delegates focus checking to the controller in assigns, allowing views to determine which slot (sidebar, content) has focus.
-      def focused?(slot)
-        ctrl = assigns[:focus_controller] || assigns[:controller]
-        ctrl ? ctrl.focused?(slot) : false
-      end
+    # Delegates focus checking to the controller in assigns, allowing views to determine which slot (sidebar, content) has focus.
+    def focused?(slot)
+      ctrl = assigns[:focus_controller] || assigns[:controller]
+      ctrl ? ctrl.focused?(slot) : false
+    end
 
-      private
+    private
 
-      attr_reader :assigns
+    attr_reader :assigns
 
-      # Returns the shared UI style configuration used by components and views for visual rendering (colors, borders).
-      def style
-        UI.style
-      end
+    # Returns the shared UI style configuration used by components and views for visual rendering (colors, borders).
+    def style
+      UI.style
+    end
 
-      # Returns the active theme: uses `theme` from assigns or controller, falling back to `UI::Theme.default`.
-      def theme
-        assigns[:theme] || assigns[:controller]&.theme || UI::Theme.default
-      end
+    # Returns the active theme: uses `theme` from assigns or controller, falling back to `UI::Theme.default`.
+    def theme
+      assigns[:theme] || assigns[:controller]&.theme || UI::Theme.default
+    end
 
-      # Outputs styled text through the view's rendering pipeline. Accepts a named `style:` for inline formatting.
-      # Appends the rendered value to the output buffer and returns it.
-      def text(value, style: nil)
-        rendered = apply_style(value.to_s, style)
-        append_to_buffer(rendered)
-        rendered
-      end
+    # Outputs styled text through the view's rendering pipeline. Accepts a named `style:` for inline formatting.
+    # Appends the rendered value to the output buffer and returns it.
+    def text(value, style: nil)
+      rendered = apply_style(value.to_s, style)
+      append_to_buffer(rendered)
+      rendered
+    end
 
-      # Renders a box with optional styling. Accepts an inline block for complex content or a plain value.
-      # Used for bordered containers and field groups in views.
-      def box(value = nil, style: nil, &)
-        content = block_given? ? capture(&) : value.to_s
-        apply_style(content, style)
-      end
+    # Renders a box with optional styling. Accepts an inline block for complex content or a plain value.
+    # Used for bordered containers and field groups in views.
+    def box(value = nil, style: nil, &)
+      content = block_given? ? capture(&) : value.to_s
+      apply_style(content, style)
+    end
 
-      # Joins items horizontally (side-by-side) using the UI rendering engine. Supports a `gap:` parameter.
-      def row(*items, gap: 0)
-        UI.join_horizontal(*items, gap: gap)
-      end
+    # Joins items horizontally (side-by-side) using the UI rendering engine. Supports a `gap:` parameter.
+    def row(*items, gap: 0)
+      UI.join_horizontal(*items, gap: gap)
+    end
 
-      # Stacks items vertically using the UI rendering engine. Supports a `gap:` parameter for spacing.
-      def column(*items, gap: 0)
-        UI.join_vertical(*items, gap: gap)
-      end
+    # Stacks items vertically using the UI rendering engine. Supports a `gap:` parameter for spacing.
+    def column(*items, gap: 0)
+      UI.join_vertical(*items, gap: gap)
+    end
 
-      # Renders a component (e.g., a ProgressBar, Spinner, Modal) and returns its string output.
-      def render_component(component)
-        component.render.to_s
-      end
+    # Renders a component (e.g., a ProgressBar, Spinner, Modal) and returns its string output.
+    def render_component(component)
+      component.render.to_s
+    end
 
-      # Renders a partial view component. An alias for `render_component` used in layout templates.
-      def render_partial(partial)
-        render_component(partial)
-      end
+    # Renders a partial view component. An alias for `render_component` used in layout templates.
+    def render_partial(partial)
+      render_component(partial)
+    end
 
-      # Builds a declarative layout tree for the current terminal screen and renders it.
-      def screen_layout(background: nil, &)
-        layout = Layout::Builder.build(screen: layout_screen, view: self, background: background, &)
-        register_layout_focus(layout)
-        layout.render
-      end
+    # Builds a declarative layout tree for the current terminal screen and renders it.
+    def screen_layout(background: nil, &)
+      layout = Layout::Builder.build(screen: layout_screen, view: self, background: background, &)
+      register_layout_focus(layout)
+      layout.render
+    end
 
-      # Yields the layout's `content` slot — used by view templates to inject their body into a layout wrapper (e.g., sidebar).
-      def yield_content
-        assigns.fetch(:content, "")
-      end
+    # Yields the layout's `content` slot — used by view templates to inject their body into a layout wrapper (e.g., sidebar).
+    def yield_content
+      assigns.fetch(:content, "")
+    end
 
-      # Evaluates a block in the view's context with a clean output buffer. Captures text written via `text`/`box`
-      # and returns joined content. Resets buffer afterward for parent rendering.
-      def capture(&)
-        previous_buffer = @output_buffer
-        @output_buffer = []
-        result = instance_eval(&)
-        @output_buffer.empty? ? result.to_s : @output_buffer.join("\n")
-      ensure
-        @output_buffer = previous_buffer
-      end
+    # Evaluates a block in the view's context with a clean output buffer. Captures text written via `text`/`box`
+    # and returns joined content. Resets buffer afterward for parent rendering.
+    def capture(&)
+      previous_buffer = @output_buffer
+      @output_buffer = []
+      result = instance_eval(&)
+      @output_buffer.empty? ? result.to_s : @output_buffer.join("\n")
+    ensure
+      @output_buffer = previous_buffer
+    end
 
-      # Appends a value to the current output buffer (if one is active). Used by rendering helpers.
-      def append_to_buffer(value)
-        @output_buffer << value if @output_buffer
-      end
+    # Appends a value to the current output buffer (if one is active). Used by rendering helpers.
+    def append_to_buffer(value)
+      @output_buffer << value if @output_buffer
+    end
 
-      # Applies a style object's `render` method to a string, returning styled output or raw text when style is nil.
-      def apply_style(value, style_object)
-        style_object ? style_object.render(value) : value
-      end
+    # Applies a style object's `render` method to a string, returning styled output or raw text when style is nil.
+    def apply_style(value, style_object)
+      style_object ? style_object.render(value) : value
+    end
 
-      # Dynamically defines read-only accessor methods for each assign key as singleton methods on self.
-      # Skips keys where the view already responds (controller methods take precedence).
-      def define_assign_readers
-        assigns.each_key do |name|
-          next if respond_to?(name, true)
+    # Dynamically defines read-only accessor methods for each assign key as singleton methods on self.
+    # Skips keys where the view already responds (controller methods take precedence).
+    def define_assign_readers
+      assigns.each_key do |name|
+        next if respond_to?(name, true)
 
-          define_singleton_method(name) { assigns.fetch(name) }
-        end
+        define_singleton_method(name) { assigns.fetch(name) }
       end
+    end
 
-      def layout_screen
-        assigns[:screen] || assigns[:controller]&.screen || Charming::Screen.new(width: 80, height: 24)
-      end
+    def layout_screen
+      assigns[:screen] || assigns[:controller]&.screen || Charming::Screen.new(width: 80, height: 24)
+    end
 
-      def register_layout_focus(layout)
-        return unless assigns[:controller]
+    def register_layout_focus(layout)
+      return unless assigns[:controller]
 
-        assigns[:controller].focus.define_layout(layout.focusable_names)
-      end
+      assigns[:controller].focus.define_layout(layout.focusable_names)
     end
   end
 end

data/lib/charming/runtime.rb

@@ -26,19 +26,21 @@ module Charming
     # restores terminal state on exit.
     def run
       setup_terminal
-      render(resolve_response(dispatch(@route.action)))
-      loop do
-        event = next_task_event || next_timer_event || @backend.read_event(timeout: read_timeout)
-        next unless event
+      with_raw_input do
+        render(resolve_response(dispatch(@route.action)))
+        loop do
+          event = next_task_event || next_timer_event || @backend.read_event(timeout: read_timeout)
+          next unless event
 
-        response = dispatch_event(event)
-        next unless response
-        break if response.quit?
+          response = dispatch_event(event)
+          next unless response
+          break if response.quit?
 
-        response = resolve_response(response)
-        break if response.quit?
+          response = resolve_response(response)
+          break if response.quit?
 
-        render(response)
+          render(response)
+        end
       end
     ensure
       @task_executor&.shutdown(timeout: 0.0)
@@ -93,8 +95,12 @@ module Charming
     end
 
     # Dispatches a resize event: updates screen dimensions and re-renders the current action.
+    # The renderer's cached previous frame is invalidated and the backend is cleared so the
+    # new-dimension frame paints onto a clean alt-screen instead of overlaying stale rows.
     def dispatch_resize(event)
       @screen = Screen.new(width: event.width, height: event.height)
+      @renderer.invalidate if @renderer.respond_to?(:invalidate)
+      @backend.clear if @backend.respond_to?(:clear)
       dispatch(@route.action, event: event)
     end
 
@@ -183,6 +189,13 @@ module Charming
       @backend.install_resize_handler if @backend.respond_to?(:install_resize_handler)
     end
 
+    # Keeps input raw/no-echo across rendering and dispatch, not just during reads.
+    def with_raw_input(&block)
+      return yield unless @backend.respond_to?(:with_raw_input)
+
+      @backend.with_raw_input(&block)
+    end
+
     # Restores terminal state: reinstalls any previous resize handler, shows
     # the cursor, and leaves the alternative screen buffer.
     def restore_terminal

data/lib/charming/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Charming
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/lib/charming.rb

@@ -17,6 +17,7 @@ loader.inflector.inflect(
   "mouse_parser" => "MouseParser",
   "tty_backend" => "TTYBackend"
 )
+loader.collapse("#{__dir__}/charming/presentation")
 loader.setup
 
 module Charming
@@ -37,5 +38,5 @@ module Charming
   end
 end
 
-Charming::Presentation::Templates.register ".tui.erb", Charming::Presentation::Templates::ErbHandler
-Charming::Presentation::Templates.register ".txt.erb", Charming::Presentation::Templates::ErbHandler
+Charming::Templates.register ".tui.erb", Charming::Templates::ErbHandler
+Charming::Templates.register ".txt.erb", Charming::Templates::ErbHandler

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: charming
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - pando
@@ -277,6 +277,7 @@ files:
 - lib/charming/presentation/component.rb
 - lib/charming/presentation/components/activity_indicator.rb
 - lib/charming/presentation/components/command_palette.rb
+- lib/charming/presentation/components/command_palette_modal.rb
 - lib/charming/presentation/components/empty_state.rb
 - lib/charming/presentation/components/form.rb
 - lib/charming/presentation/components/form/builder.rb