charming 0.1.2 → 0.1.4

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

@@ -1,30 +1,28 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # Markdown renders Markdown source as ANSI-styled terminal text. Parsing is delegated to
-      # `Presentation::Markdown::Renderer`; set *syntax_highlighting* to false to disable
-      # Rouge-backed code block highlighting.
-      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)
-          super(theme: theme)
-          @content = content
-          @width = width
-          @syntax_highlighting = syntax_highlighting
-        end
+  module Components
+    # Markdown renders CommonMark/GFM source as ANSI-styled terminal text.
+    class Markdown < Component
+      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.
-        def render
-          Charming::Presentation::Markdown::Renderer.new(
-            content: @content,
-            width: @width,
-            theme: theme,
-            syntax_highlighting: @syntax_highlighting
-          ).render
-        end
+      # Renders the Markdown body to a styled, terminal-safe string.
+      def render
+        Charming::Markdown::Renderer.new(
+          content: @content,
+          width: @width,
+          theme: theme,
+          syntax_highlighting: @syntax_highlighting,
+          style: @style,
+          base_url: @base_url
+        ).render
       end
     end
   end

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

@@ -1,63 +1,61 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # Modal is a centered, boxed overlay with an optional title, help line, and body content.
-      # The body may be a string, View, or Component; when it responds to `render`, its output
-      # is used. The result is wrapped in a UI::Style border with padding.
-      class Modal < Component
-        # *content* is the modal body. *title* (optional) is rendered centered at the top.
-        # *help* (optional) is rendered as a muted footer line. *width* is the modal's total width.
-        # *style* overrides the default `theme.modal` style.
-        def initialize(content:, title: nil, help: nil, width: 52, style: nil, theme: nil)
-          super(theme: theme)
-          @content = content
-          @title = title
-          @help = help
-          @width = width
-          @style = style
-        end
+  module Components
+    # Modal is a centered, boxed overlay with an optional title, help line, and body content.
+    # The body may be a string, View, or Component; when it responds to `render`, its output
+    # is used. The result is wrapped in a UI::Style border with padding.
+    class Modal < Component
+      # *content* is the modal body. *title* (optional) is rendered centered at the top.
+      # *help* (optional) is rendered as a muted footer line. *width* is the modal's total width.
+      # *style* overrides the default `theme.modal` style.
+      def initialize(content:, title: nil, help: nil, width: 52, style: nil, theme: nil)
+        super(theme: theme)
+        @content = content
+        @title = title
+        @help = help
+        @width = width
+        @style = style
+      end
 
-        # Renders the modal as a bordered, padded string with the title and help lines stacked
-        # above the content.
-        def render
-          box(column(*lines, gap: 1), style: modal_style)
-        end
+      # Renders the modal as a bordered, padded string with the title and help lines stacked
+      # above the content.
+      def render
+        box(column(*lines, gap: 1), style: modal_style)
+      end
 
-        private
+      private
 
-        attr_reader :content, :title, :help, :width
+      attr_reader :content, :title, :help, :width
 
-        # Returns the array of non-nil lines: title, help, content.
-        def lines
-          [title_line, help_line, render_content].compact
-        end
+      # Returns the array of non-nil lines: title, help, content.
+      def lines
+        [title_line, help_line, render_content].compact
+      end
 
-        # Returns the centered title line styled with the theme's title style, when a title was given.
-        def title_line
-          text(title, style: theme.title.align(:center).width(title_width)) if title
-        end
+      # Returns the centered title line styled with the theme's title style, when a title was given.
+      def title_line
+        text(title, style: theme.title.align(:center).width(title_width)) if title
+      end
 
-        # Returns the help line styled with the theme's muted style, when help was given.
-        def help_line
-          text(help, style: theme.muted) if help
-        end
+      # Returns the help line styled with the theme's muted style, when help was given.
+      def help_line
+        text(help, style: theme.muted) if help
+      end
 
-        # Returns the rendered content string, calling `render` on the body when applicable.
-        def render_content
-          content.respond_to?(:render) ? render_component(content) : content.to_s
-        end
+      # Returns the rendered content string, calling `render` on the body when applicable.
+      def render_content
+        content.respond_to?(:render) ? render_component(content) : content.to_s
+      end
 
-        # Returns the modal's outer style: the user-provided style or `theme.modal` at the given width.
-        def modal_style
-          @style || theme.modal.width(width)
-        end
+      # Returns the modal's outer style: the user-provided style or `theme.modal` at the given width.
+      def modal_style
+        @style || theme.modal.width(width)
+      end
 
-        # Returns the title's display width, accounting for the modal's horizontal padding/border.
-        def title_width
-          [width - 8, 0].max
-        end
+      # Returns the title's display width, accounting for the modal's horizontal padding/border.
+      def title_width
+        [width - 8, 0].max
       end
     end
   end

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

@@ -1,69 +1,67 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # Progressbar renders a fixed-width ASCII progress bar. The bar is sized to the configured
-      # *total* (in arbitrary units) and fills proportionally to the current value. Optionally
-      # appends a label after the bar.
-      class Progressbar < Component
-        # Public accessors: total units, current value, label text, completed and remaining
-        # characters, and the bar format symbol.
-        attr_accessor :total, :current, :label, :complete, :incomplete, :bar_format
+  module Components
+    # Progressbar renders a fixed-width ASCII progress bar. The bar is sized to the configured
+    # *total* (in arbitrary units) and fills proportionally to the current value. Optionally
+    # appends a label after the bar.
+    class Progressbar < Component
+      # Public accessors: total units, current value, label text, completed and remaining
+      # characters, and the bar format symbol.
+      attr_accessor :total, :current, :label, :complete, :incomplete, :bar_format
 
-        # *total* is the maximum unit count. *complete* and *incomplete* are the characters used
-        # for filled and unfilled positions (default "=" and " "). *bar_format* is reserved for
-        # future format variants. *label* is an optional suffix shown after the bar.
-        def initialize(total:, complete: "=", incomplete: " ", bar_format: :classic, label: nil)
-          super()
-          @total = [total.to_i, 0].max
-          @complete = complete.to_s
-          @incomplete = incomplete.to_s
-          @bar_format = bar_format.to_sym
-          @label = label
-          @current = 0
-        end
+      # *total* is the maximum unit count. *complete* and *incomplete* are the characters used
+      # for filled and unfilled positions (default "=" and " "). *bar_format* is reserved for
+      # future format variants. *label* is an optional suffix shown after the bar.
+      def initialize(total:, complete: "=", incomplete: " ", bar_format: :classic, label: nil)
+        super()
+        @total = [total.to_i, 0].max
+        @complete = complete.to_s
+        @incomplete = incomplete.to_s
+        @bar_format = bar_format.to_sym
+        @label = label
+        @current = 0
+      end
 
-        # Advances the current value by *count* (default 1), clamping to `[0, total]`. Returns self.
-        def tick(count = 1)
-          update(@current + count)
-          self
-        end
+      # Advances the current value by *count* (default 1), clamping to `[0, total]`. Returns self.
+      def tick(count = 1)
+        update(@current + count)
+        self
+      end
 
-        # Sets the current value, clamping to `[0, total]`. Returns self.
-        def update(value)
-          @current = value.to_i.clamp(0, @total)
-          self
-        end
+      # Sets the current value, clamping to `[0, total]`. Returns self.
+      def update(value)
+        @current = value.to_i.clamp(0, @total)
+        self
+      end
 
-        # Jumps the bar directly to 100% completion. Returns self.
-        def complete!
-          @current = @total
-          self
-        end
+      # Jumps the bar directly to 100% completion. Returns self.
+      def complete!
+        @current = @total
+        self
+      end
 
-        # Renders the bar as `[====  ]` (with the *label* appended when present).
-        def render
-          width = [@total, 1].max
-          completed = completed_width(width)
-          incomplete = width - completed
-          incomplete -= 1 if @current.zero?
-          bar = (@complete * completed) + (@incomplete * incomplete)
-          result = "[" + bar + "]"
+      # Renders the bar as `[====  ]` (with the *label* appended when present).
+      def render
+        width = [@total, 1].max
+        completed = completed_width(width)
+        incomplete = width - completed
+        incomplete -= 1 if @current.zero?
+        bar = (@complete * completed) + (@incomplete * incomplete)
+        result = "[" + bar + "]"
 
-          return result unless @label
+        return result unless @label
 
-          "#{result} #{@label}"
-        end
+        "#{result} #{@label}"
+      end
 
-        private
+      private
 
-        # Returns the number of `complete` characters to draw, rounded to the nearest integer.
-        def completed_width(width)
-          return 0 unless @total.positive?
+      # Returns the number of `complete` characters to draw, rounded to the nearest integer.
+      def completed_width(width)
+        return 0 unless @total.positive?
 
-          ((width * @current) / @total.to_f).round
-        end
+        ((width * @current) / @total.to_f).round
       end
     end
   end

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

@@ -1,48 +1,46 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Components
-      # Spinner is a simple rotating-frame indicator. The component cycles through a list of
-      # frames on each `tick`; pair it with a controller timer to drive animation. An optional
-      # *label* is appended after the current frame on each render.
-      class Spinner < Component
-        # The default frame set: a 4-frame ASCII spinner.
-        DEFAULT_FRAMES = ["-", "\\", "|", "/"].freeze
-
-        # The current frame list, frame index, and optional label string.
-        attr_reader :frames, :index, :label
-
-        # *frames* defaults to DEFAULT_FRAMES but may be replaced with any array of frame strings.
-        # *index* is the starting frame index. *label* is an optional suffix shown after the frame.
-        def initialize(frames: DEFAULT_FRAMES, index: 0, label: nil)
-          super()
-          raise ArgumentError, "frames cannot be empty" if frames.empty?
-
-          @frames = frames
-          @index = index
-          @label = label
-        end
-
-        # Advances the frame index by one position, wrapping around. Returns self for chaining.
-        def tick
-          @index = (index + 1) % frames.length
-          self
-        end
-
-        # Renders the current frame, optionally followed by the label and a space.
-        def render
-          return frame unless label
-
-          "#{frame} #{label}"
-        end
-
-        private
-
-        # Returns the current frame string (with index modulo frame count to be safe).
-        def frame
-          frames.fetch(index % frames.length)
-        end
+  module Components
+    # Spinner is a simple rotating-frame indicator. The component cycles through a list of
+    # frames on each `tick`; pair it with a controller timer to drive animation. An optional
+    # *label* is appended after the current frame on each render.
+    class Spinner < Component
+      # The default frame set: a 4-frame ASCII spinner.
+      DEFAULT_FRAMES = ["-", "\\", "|", "/"].freeze
+
+      # The current frame list, frame index, and optional label string.
+      attr_reader :frames, :index, :label
+
+      # *frames* defaults to DEFAULT_FRAMES but may be replaced with any array of frame strings.
+      # *index* is the starting frame index. *label* is an optional suffix shown after the frame.
+      def initialize(frames: DEFAULT_FRAMES, index: 0, label: nil)
+        super()
+        raise ArgumentError, "frames cannot be empty" if frames.empty?
+
+        @frames = frames
+        @index = index
+        @label = label
+      end
+
+      # Advances the frame index by one position, wrapping around. Returns self for chaining.
+      def tick
+        @index = (index + 1) % frames.length
+        self
+      end
+
+      # Renders the current frame, optionally followed by the label and a space.
+      def render
+        return frame unless label
+
+        "#{frame} #{label}"
+      end
+
+      private
+
+      # Returns the current frame string (with index modulo frame count to be safe).
+      def frame
+        frames.fetch(index % frames.length)
       end
     end
   end

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

@@ -3,140 +3,138 @@
 require "tty-table"
 
 module Charming
-  module Presentation
-    module Components
-      # Table renders tabular data with a header row, a selected row highlight, and keyboard
-      # navigation. Mouse clicks within the body area also select rows. The table is rendered
-      # via tty-table and the selected row is overlaid with reverse-video ANSI styling.
-      class Table < Component
-        include KeyboardHandler
-
-        # Maps navigation keys to the instance methods that move the selection. Shared with
-        # List and Viewport via KeyboardHandler.
-        KEY_ACTIONS = {
-          up: :move_up,
-          down: :move_down,
-          home: :move_home,
-          end: :move_end
-        }.freeze
-
-        # Number of terminal rows occupied by the table's top border and header line. Used by
-        # the mouse handler to translate absolute row coordinates to body rows.
-        HEADER_HEIGHT = 2
-
-        # The header row, the body rows, and the currently selected row index, respectively.
-        attr_reader :header, :rows, :selected_index
-
-        # *header* is an array of column labels. *rows* is the array of body rows (each either a
-        # String, an Array, or a Hash of column-value pairs). *selected_index* defaults to 0.
-        # *keymap* selects the keybinding style (`:vim` enables h/j/k/l → left/down/up/right).
-        def initialize(header:, rows: [], selected_index: 0, keymap: :vim)
-          super()
-          @header = Array(header).map(&:to_s)
-          @rows = Array(rows)
-          @selected_index = clamp_index(selected_index)
-          @keymap = keymap
-        end
+  module Components
+    # Table renders tabular data with a header row, a selected row highlight, and keyboard
+    # navigation. Mouse clicks within the body area also select rows. The table is rendered
+    # via tty-table and the selected row is overlaid with reverse-video ANSI styling.
+    class Table < Component
+      include KeyboardHandler
+
+      # Maps navigation keys to the instance methods that move the selection. Shared with
+      # List and Viewport via KeyboardHandler.
+      KEY_ACTIONS = {
+        up: :move_up,
+        down: :move_down,
+        home: :move_home,
+        end: :move_end
+      }.freeze
+
+      # Number of terminal rows occupied by the table's top border and header line. Used by
+      # the mouse handler to translate absolute row coordinates to body rows.
+      HEADER_HEIGHT = 2
+
+      # The header row, the body rows, and the currently selected row index, respectively.
+      attr_reader :header, :rows, :selected_index
+
+      # *header* is an array of column labels. *rows* is the array of body rows (each either a
+      # String, an Array, or a Hash of column-value pairs). *selected_index* defaults to 0.
+      # *keymap* selects the keybinding style (`:vim` enables h/j/k/l → left/down/up/right).
+      def initialize(header:, rows: [], selected_index: 0, keymap: :vim)
+        super()
+        @header = Array(header).map(&:to_s)
+        @rows = Array(rows)
+        @selected_index = clamp_index(selected_index)
+        @keymap = keymap
+      end
 
-        # Handles key events. Returns `[:selected, row]` on Enter; otherwise delegates to the
-        # KeyboardHandler for navigation keys.
-        def handle_key(event)
-          return nil if rows.empty?
+      # Handles key events. Returns `[:selected, row]` on Enter; otherwise delegates to the
+      # KeyboardHandler for navigation keys.
+      def handle_key(event)
+        return nil if rows.empty?
 
-          case Charming.key_of(event)
-          when :enter then [:selected, selected_row]
-          else super
-          end
+        case Charming.key_of(event)
+        when :enter then [:selected, selected_row]
+        else super
         end
+      end
 
-        # Handles mouse events: a click within the body area selects the clicked row.
-        # Returns :handled on a successful click.
-        def handle_mouse(event)
-          return nil if rows.empty?
-          return nil unless event.respond_to?(:click?) && event.click?
+      # Handles mouse events: a click within the body area selects the clicked row.
+      # Returns :handled on a successful click.
+      def handle_mouse(event)
+        return nil if rows.empty?
+        return nil unless event.respond_to?(:click?) && event.click?
 
-          clicked = event.y - HEADER_HEIGHT
-          return nil if clicked.negative? || clicked >= rows.length
+        clicked = event.y - HEADER_HEIGHT
+        return nil if clicked.negative? || clicked >= rows.length
 
-          @selected_index = clicked
-          :handled
-        end
+        @selected_index = clicked
+        :handled
+      end
 
-        # Returns the currently selected row, or nil when the table is empty.
-        def selected_row
-          rows[selected_index]
-        end
+      # Returns the currently selected row, or nil when the table is empty.
+      def selected_row
+        rows[selected_index]
+      end
 
-        # Renders the table to a string. Returns a placeholder when both header and rows are empty.
-        def render
-          return "(empty table)" if header.empty? && rows.empty?
+      # Renders the table to a string. Returns a placeholder when both header and rows are empty.
+      def render
+        return "(empty table)" if header.empty? && rows.empty?
 
-          normalized = rows.map { |row| normalize_row(row) }
-          lines = TTY::Table.new(header: header, rows: normalized)
-            .render(:unicode)
-            .lines(chomp: true)
+        normalized = rows.map { |row| normalize_row(row) }
+        lines = TTY::Table.new(header: header, rows: normalized)
+          .render(:unicode)
+          .lines(chomp: true)
 
-          compact_layout(lines)
-        end
+        compact_layout(lines)
+      end
 
-        private
-
-        # Coerces a *row* (Hash / String / Array) into a flat cell array matching the header.
-        # Excess cells are merged into the last column with a space separator.
-        def normalize_row(row)
-          cells = case row
-          when Hash then row.values
-          when String then [row]
-          else Array(row)
-          end
-          return cells if header.length <= 1 || cells.length <= header.length
-
-          kept = cells.first(header.length - 1)
-          merged = cells[(header.length - 1)..].join(" ")
-          kept + [merged]
+      private
+
+      # Coerces a *row* (Hash / String / Array) into a flat cell array matching the header.
+      # Excess cells are merged into the last column with a space separator.
+      def normalize_row(row)
+        cells = case row
+        when Hash then row.values
+        when String then [row]
+        else Array(row)
         end
+        return cells if header.length <= 1 || cells.length <= header.length
 
-        # Applies the selected-row highlight and trims unused body rows below the actual row count.
-        def compact_layout(lines)
-          return lines.join("\n") if lines.length < 4
+        kept = cells.first(header.length - 1)
+        merged = cells[(header.length - 1)..].join(" ")
+        kept + [merged]
+      end
 
-          top, header_line, _separator, *rest = lines
-          body = rest.first(rows.length)
-          bottom = rest[rows.length]
+      # Applies the selected-row highlight and trims unused body rows below the actual row count.
+      def compact_layout(lines)
+        return lines.join("\n") if lines.length < 4
 
-          highlighted = body.each_with_index.map do |line, index|
-            (index == selected_index) ? "\e[7m#{line}\e[m" : line
-          end
+        top, header_line, _separator, *rest = lines
+        body = rest.first(rows.length)
+        bottom = rest[rows.length]
 
-          [top, header_line, *highlighted, bottom].compact.join("\n")
+        highlighted = body.each_with_index.map do |line, index|
+          (index == selected_index) ? "\e[7m#{line}\e[m" : line
         end
 
-        # Moves the selection up one row.
-        def move_up
-          @selected_index -= 1 if selected_index.positive?
-        end
+        [top, header_line, *highlighted, bottom].compact.join("\n")
+      end
 
-        # Moves the selection down one row.
-        def move_down
-          @selected_index += 1 if selected_index < rows.length - 1
-        end
+      # Moves the selection up one row.
+      def move_up
+        @selected_index -= 1 if selected_index.positive?
+      end
 
-        # Moves the selection to the first row.
-        def move_home
-          @selected_index = 0
-        end
+      # Moves the selection down one row.
+      def move_down
+        @selected_index += 1 if selected_index < rows.length - 1
+      end
 
-        # Moves the selection to the last row.
-        def move_end
-          @selected_index = rows.length - 1
-        end
+      # Moves the selection to the first row.
+      def move_home
+        @selected_index = 0
+      end
 
-        # Clamps *value* to the valid row range, defaulting to 0 when the table is empty.
-        def clamp_index(value)
-          return 0 if rows.empty?
+      # Moves the selection to the last row.
+      def move_end
+        @selected_index = rows.length - 1
+      end
 
-          value.to_i.clamp(0, rows.length - 1)
-        end
+      # Clamps *value* to the valid row range, defaulting to 0 when the table is empty.
+      def clamp_index(value)
+        return 0 if rows.empty?
+
+        value.to_i.clamp(0, rows.length - 1)
       end
     end
   end