charming 0.1.3 → 0.2.0

data/lib/charming/generators/view_generator.rb

@@ -40,7 +40,7 @@ module Charming
 
       # CamelCase rendering of the action name (e.g., "user_settings" → "UserSettings").
       def action_class_name
-        action.split("_").map(&:capitalize).join
+        ActiveSupport::Inflector.camelize(action)
       end
     end
   end

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

@@ -111,7 +111,7 @@ module Charming
 
         # Converts a snake_case symbol/string to a humanized "Capitalized" string.
         def humanize(value)
-          value.to_s.tr("_", " ").capitalize
+          ActiveSupport::Inflector.humanize(value)
         end
       end
     end

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

@@ -2,17 +2,15 @@
 
 module Charming
   module Components
-    # Markdown renders Markdown source as ANSI-styled terminal text. Parsing is delegated to
-    # `Charming::Markdown::Renderer`; set *syntax_highlighting* to false to disable
-    # Rouge-backed code block highlighting.
+    # Markdown renders CommonMark/GFM source as ANSI-styled terminal text.
     class Markdown < Component
-      # *content* is the Markdown source string. *width* optionally sets the wrap width.
-      # *syntax_highlighting* enables Rouge for code blocks (defaults to true).
-      def initialize(content:, width: nil, theme: nil, syntax_highlighting: true)
+      def initialize(content:, width: nil, theme: nil, syntax_highlighting: true, style: :dark, base_url: nil)
         super(theme: theme)
         @content = content
         @width = width
         @syntax_highlighting = syntax_highlighting
+        @style = style
+        @base_url = base_url
       end
 
       # Renders the Markdown body to a styled, terminal-safe string.
@@ -21,7 +19,9 @@ module Charming
           content: @content,
           width: @width,
           theme: theme,
-          syntax_highlighting: @syntax_highlighting
+          syntax_highlighting: @syntax_highlighting,
+          style: @style,
+          base_url: @base_url
         ).render
       end
     end

data/lib/charming/presentation/layout/builder.rb

@@ -36,9 +36,15 @@ module Charming
       end
 
       # Adds a Pane leaf node to the current scope. *name* (optional) is the focus slot name;
-      # *content* (or a *block*) is the body. *options* are forwarded to Pane.
+      # *content* (or a *block*) is the body. *options* are split into PaneGeometry,
+      # PaneStyle, and PaneBehavior keyword args.
       def pane(name = nil, content = nil, **options, &block)
-        node = Pane.new(name: name, content: content, block: block, view: view, **options)
+        node = Pane.new(
+          name: name, content: content, block: block, view: view,
+          geometry: PaneGeometry.build(**options.slice(:width, :height, :grow, :border, :padding)),
+          style: PaneStyle.build(**options.slice(:style, :focused_style)),
+          behavior: PaneBehavior.build(**options.slice(:focus, :scroll, :clip, :wrap))
+        )
         append(node)
         node
       end

data/lib/charming/presentation/layout/pane.rb

@@ -4,34 +4,20 @@ module Charming
   module Layout
     # Pane is a leaf layout node: a single rectangle with optional border, padding, and
     # styling, containing a piece of content (a string, a View, or a block evaluated in the
-    # view's context). Panes with a `name` and `focus: true` are registered as focusable
-    # slots in the controller's focus ring.
+    # view's context). Panes with a `name` and `behavior.focus: true` are registered as
+    # focusable slots in the controller's focus ring.
     class Pane
-      # The pane's focus slot name, fixed width, fixed height, and grow weight.
-      attr_reader :name, :width, :height, :grow
-
-      # *name* is the focus slot identifier (optional). *content* or *block* provides the body.
-      # *width*/*height*/*grow* control sizing. *border* may be `true` (normal border) or a
-      # border name symbol. *padding* may be 1, 2, or 4 values (CSS-style shorthand).
-      # *style* sets the base style; *focused_style* overrides it when the pane is focused.
-      # *focus: true* marks the pane as focusable. *scroll*/*clip*/*wrap* control how
-      # overflow content is rendered (via the embedded Viewport).
-      def initialize(name: nil, content: nil, block: nil, view: nil, width: nil, height: nil, grow: nil, border: nil, padding: nil, style: nil, focused_style: nil, focus: false, scroll: false, clip: true, wrap: false)
-        @name = name
-        @content = content
-        @block = block
-        @view = view
-        @width = width
-        @height = height
-        @grow = grow
-        @border = border
-        @padding = padding
-        @style = style
-        @focused_style = focused_style
-        @focus = focus
-        @scroll = scroll
-        @clip = clip
-        @wrap = wrap
+      attr_reader :name
+      delegate :width, :height, :grow, to: :geometry
+
+      # *name* is the focus slot identifier. *content* (or a *block*) is the body; *view*
+      # is the view used for instance_exec when the block is given. *geometry*, *style*, and
+      # *behavior* are value objects that own sizing, styling, and render-time flags.
+      def initialize(name: nil, content: nil, block: nil, view: nil,
+        geometry: PaneGeometry.new, style: PaneStyle.new,
+        behavior: PaneBehavior.new)
+        @name, @content, @block, @view = name, content, block, view
+        @geometry, @style, @behavior = geometry, style, behavior
       end
 
       # Raises ArgumentError — panes are leaves and cannot contain layout children.
@@ -39,110 +25,56 @@ module Charming
         raise ArgumentError, "pane cannot contain layout children"
       end
 
-      # Returns [name] when the pane is marked focusable and has a name, otherwise [].
+      # Returns [name] when the pane is focusable and named, otherwise [].
       def focusable_names
-        (focus && name) ? [name] : []
+        (@behavior.focus && name) ? [name] : []
+      end
+
+      # Returns the mouse target represented by this pane, if it has a name.
+      def mouse_targets(rect)
+        return [] unless name
+
+        [{name: name, rect: rect, inner_rect: @geometry.inset(rect)}]
       end
 
       # Renders the pane into *rect*, applying the configured style, border, and padding
       # around the evaluated content.
       def render(rect)
-        outer_style(rect).render(rendered_content(rect))
+        inner = @geometry.inset(rect)
+        outer_style(inner).render(rendered_content(inner))
       end
 
       private
 
-      # The raw content, the body block, the view used for instance_exec, and styling options.
-      attr_reader :content, :block, :view, :border, :padding, :style, :focused_style, :focus, :scroll, :clip, :wrap
-
-      # Returns the content string for *rect*, optionally clipped/scrolled by an embedded Viewport.
-      def rendered_content(rect)
-        content_rect = inner_rect(rect)
-        value = evaluate_content(content_rect)
-        return value unless clip || scroll
-
-        Components::Viewport.new(content: value, width: content_rect.width, height: content_rect.height, wrap: wrap).render
-      end
+      attr_reader :content, :block, :view, :geometry, :style, :behavior
 
-      # Evaluates the configured content (block or constant) and renders it to a string.
-      # Pane blocks may accept the inner content Rect when they need exact available dimensions.
-      def evaluate_content(content_rect)
+      # Returns the content string for *content_rect*, optionally clipped/scrolled by an
+      # embedded Viewport when *behavior.should_viewport?* is true.
+      def rendered_content(content_rect)
         value = if block
           block.arity.zero? ? view.instance_exec(&block) : view.instance_exec(content_rect, &block)
         else
           content
         end
-        value.respond_to?(:render) ? value.render.to_s : value.to_s
+        return value.to_s unless value.respond_to?(:render)
+        return value.render.to_s unless @behavior.should_viewport?
+
+        Components::Viewport.new(content: value.render, width: content_rect.width,
+          height: content_rect.height, wrap: @behavior.wrap).render.to_s
       end
 
       # Builds the outer style object with optional border and padding, sized to the
       # inner rect of the pane.
-      def outer_style(rect)
-        styled = current_style
-        styled = styled.border(border_style) if border
-        styled = styled.padding(*padding_values) if padding
-        styled.width(inner_rect(rect).width).height(inner_rect(rect).height)
-      end
-
-      # Returns the active style: the focused variant when the pane is focused, otherwise
-      # the configured style or a default UI::Style.
-      def current_style
-        return focused_pane_style if focused?
-
-        style || UI.style
-      end
-
-      # Returns the focused-pane style: the focused_style override, or the theme's title style.
-      def focused_pane_style
-        focused_style || view.__send__(:theme).title
+      def outer_style(inner)
+        styled = @style.resolve(view, focused: focused?)
+        styled = styled.border(@geometry.border_style) if @geometry.border
+        styled = styled.padding(*@geometry.padding_values) if @geometry.padding
+        styled.width(inner.width).height(inner.height)
       end
 
-      # True when the pane is configured for focus and the view reports it as currently focused.
+      # True when the pane is configured for focus and the view reports it as focused.
       def focused?
-        focus && name && view.focused?(name)
-      end
-
-      # Returns the inner Rect after border and padding insets are applied.
-      def inner_rect(rect)
-        rect.inset(
-          top: border_top + padding_top,
-          right: border_right + padding_right,
-          bottom: border_bottom + padding_bottom,
-          left: border_left + padding_left
-        )
-      end
-
-      # Resolves the border style symbol: :normal when border is `true`, otherwise the configured value.
-      def border_style
-        (border == true) ? :normal : border
-      end
-
-      # Border thickness on each side (1 when a border is configured, 0 otherwise).
-      def border_top = border ? 1 : 0
-      def border_right = border ? 1 : 0
-      def border_bottom = border ? 1 : 0
-      def border_left = border ? 1 : 0
-
-      # The padding values normalized to [top, right, bottom, left] form.
-      def padding_values
-        @padding_values ||= expand_padding(Array(padding))
-      end
-
-      # Per-side padding values (0 when no padding is configured).
-      def padding_top = padding ? padding_values[0] : 0
-      def padding_right = padding ? padding_values[1] : 0
-      def padding_bottom = padding ? padding_values[2] : 0
-      def padding_left = padding ? padding_values[3] : 0
-
-      # Normalizes 1/2/4 padding arguments to [top, right, bottom, left].
-      def expand_padding(values)
-        case values.length
-        when 1 then [values[0], values[0], values[0], values[0]]
-        when 2 then [values[0], values[1], values[0], values[1]]
-        when 4 then values
-        else
-          raise ArgumentError, "padding expects 1, 2, or 4 values"
-        end
+        @behavior.focus && name && view.focused?(name)
       end
     end
   end

data/lib/charming/presentation/layout/pane_behavior.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Charming
+  module Layout
+    # PaneBehavior holds the render-time options that control a Pane's
+    # interaction with the focus ring and the embedded Viewport.
+    class PaneBehavior
+      attr_reader :focus, :scroll, :clip, :wrap
+
+      def self.build(focus: false, scroll: false, clip: true, wrap: false)
+        new(focus: focus, scroll: scroll, clip: clip, wrap: wrap)
+      end
+
+      def initialize(focus:, scroll:, clip:, wrap:)
+        @focus, @scroll, @clip, @wrap = focus, scroll, clip, wrap
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(PaneBehavior) &&
+          focus == other.focus && scroll == other.scroll &&
+          clip == other.clip && wrap == other.wrap
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [focus, scroll, clip, wrap].hash
+      end
+
+      def focusable?
+        focus
+      end
+
+      def should_viewport?
+        clip || scroll
+      end
+    end
+  end
+end

data/lib/charming/presentation/layout/pane_geometry.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Charming
+  module Layout
+    # PaneGeometry holds a Pane's sizing (width, height, grow) and inset
+    # configuration (border + padding). It knows how to inset a Rect for the
+    # content area and how to expand CSS-style 1/2/4-value padding.
+    class PaneGeometry
+      attr_reader :width, :height, :grow, :border, :padding
+
+      def self.build(width: nil, height: nil, grow: nil, border: nil, padding: nil)
+        new(width: width, height: height, grow: grow,
+          border: (border == true) ? :normal : border, padding: padding)
+      end
+
+      def initialize(width:, height:, grow:, border:, padding:)
+        @width, @height, @grow, @border, @padding = width, height, grow, border, padding
+        @padding_values = padding ? expand_padding(Array(padding)) : [0, 0, 0, 0]
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(PaneGeometry) &&
+          width == other.width && height == other.height && grow == other.grow &&
+          border == other.border && padding == other.padding
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [width, height, grow, border, padding].hash
+      end
+
+      def border_top = border ? 1 : 0
+      def border_right = border ? 1 : 0
+      def border_bottom = border ? 1 : 0
+      def border_left = border ? 1 : 0
+
+      attr_reader :padding_values
+
+      def padding_top = padding ? @padding_values[0] : 0
+      def padding_right = padding ? @padding_values[1] : 0
+      def padding_bottom = padding ? @padding_values[2] : 0
+      def padding_left = padding ? @padding_values[3] : 0
+
+      def inset(rect)
+        rect.inset(
+          top: border_top + padding_top,
+          right: border_right + padding_right,
+          bottom: border_bottom + padding_bottom,
+          left: border_left + padding_left
+        )
+      end
+
+      def border_style
+        (border == true) ? :normal : border
+      end
+
+      private
+
+      def expand_padding(values)
+        case values.length
+        when 1 then [values[0], values[0], values[0], values[0]]
+        when 2 then [values[0], values[1], values[0], values[1]]
+        when 4 then values
+        else
+          raise ArgumentError, "padding expects 1, 2, or 4 values"
+        end
+      end
+    end
+  end
+end

data/lib/charming/presentation/layout/pane_style.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Charming
+  module Layout
+    # PaneStyle holds a Pane's base style and the focused-state override.
+    # It resolves which style to use at render time given the pane's current
+    # focus state and the view's theme.
+    class PaneStyle
+      attr_reader :style, :focused_style
+
+      def self.build(style: nil, focused_style: nil)
+        new(style: style, focused_style: focused_style)
+      end
+
+      def initialize(style:, focused_style:)
+        @style, @focused_style = style, focused_style
+        freeze
+      end
+
+      def ==(other)
+        other.is_a?(PaneStyle) &&
+          style == other.style && focused_style == other.focused_style
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [style, focused_style].hash
+      end
+
+      # Returns the active style for *focused*: the focused override when the
+      # pane is focused, otherwise the configured *style* or a default UI::Style.
+      def resolve(view, focused:)
+        return focused_style || view.__send__(:theme).title if focused
+
+        style || UI.style
+      end
+    end
+  end
+end

data/lib/charming/presentation/layout/rect.rb

@@ -6,6 +6,11 @@ module Charming
     # (width, height). Layout operations produce new Rect instances rather than mutating
     # existing ones.
     Rect = Data.define(:x, :y, :width, :height) do
+      # Returns true when the zero-based cell coordinate falls within this rectangle.
+      def cover?(point_x, point_y)
+        point_x >= x && point_x < x + width && point_y >= y && point_y < y + height
+      end
+
       # Returns a new Rect inset by *top*/*right*/*bottom*/*left* cells. The result is
       # clamped to a minimum width/height of 0.
       def inset(top: 0, right: 0, bottom: 0, left: 0)

data/lib/charming/presentation/layout/screen_layout.rb

@@ -32,6 +32,13 @@ module Charming
         child ? child.focusable_names : []
       end
 
+      # Returns all named pane mouse targets for the full screen layout.
+      def mouse_targets
+        return [] unless child
+
+        child.mouse_targets(Rect.new(x: 0, y: 0, width: screen.width, height: screen.height))
+      end
+
       # Renders the child into the full-screen rect, then overlays each registered overlay
       # on top in order.
       def render

data/lib/charming/presentation/layout/split.rb

@@ -32,6 +32,13 @@ module Charming
         children.flat_map(&:focusable_names)
       end
 
+      # Returns all named pane mouse targets in this split, preserving declaration order.
+      def mouse_targets(rect)
+        child_rects(rect).zip(children).flat_map do |child_rect, child|
+          child.respond_to?(:mouse_targets) ? child.mouse_targets(child_rect) : []
+        end
+      end
+
       # Renders each child into its own sub-rect, then overlays them on a blank canvas
       # of the parent's dimensions.
       def render(rect)

data/lib/charming/presentation/markdown/render_context.rb

@@ -2,18 +2,36 @@
 
 module Charming
   module Markdown
-    # RenderContext carries the state needed to render nested Markdown blocks: the current
-    # list nesting depth (used for indentation) and the wrap width.
-    RenderContext = Data.define(:list_depth, :width) do
-      # Builds a new RenderContext with the given *width* and optional starting *list_depth*.
-      def self.from(width:, list_depth: 0)
-        new(list_depth: list_depth, width: width)
+    # RenderContext carries render-time state that needs to flow down the Markdown AST.
+    RenderContext = Data.define(:width, :list_depth, :style, :current_style, :base_url, :source_lines) do
+      def self.from(width:, style:, base_url: nil, source_lines: [], list_depth: 0, current_style: nil)
+        new(
+          width: width,
+          list_depth: list_depth,
+          style: style,
+          current_style: current_style || style[:document],
+          base_url: base_url,
+          source_lines: source_lines
+        )
       end
 
-      # Returns a derived context with the list depth incremented by *depth_increment*
-      # and the wrap width overridden to *width* (defaults to the current width).
-      def nested(depth_increment: 0, width: self.width)
-        self.class.new(list_depth: list_depth + depth_increment, width: width)
+      def with(width: self.width, list_depth: self.list_depth, current_style: self.current_style)
+        self.class.new(
+          width: width,
+          list_depth: list_depth,
+          style: style,
+          current_style: current_style,
+          base_url: base_url,
+          source_lines: source_lines
+        )
+      end
+
+      def nested_list(width: self.width)
+        with(width: width, list_depth: list_depth + 1)
+      end
+
+      def inherit(style_name)
+        current_style.inherit_visual(style[style_name])
       end
     end
   end