charming 0.1.2 → 0.1.3

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

@@ -1,67 +1,65 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module Markdown
-      # InlineRenderer dispatches Kramdown inline-level elements (text, strong, em,
-      # codespan, link, line break, HTML entity) to their individual rendering handlers.
-      # Handlers are built once at construction as a frozen hash of element-type symbols
-      # to callables.
-      class InlineRenderer
-        # *renderer* is the parent Renderer (used to render nested inlines and look up styles).
-        def initialize(renderer:)
-          @renderer = renderer
-          build_handlers
-        end
+  module Markdown
+    # InlineRenderer dispatches Kramdown inline-level elements (text, strong, em,
+    # codespan, link, line break, HTML entity) to their individual rendering handlers.
+    # Handlers are built once at construction as a frozen hash of element-type symbols
+    # to callables.
+    class InlineRenderer
+      # *renderer* is the parent Renderer (used to render nested inlines and look up styles).
+      def initialize(renderer:)
+        @renderer = renderer
+        build_handlers
+      end
 
-        # Renders *element* using the handler registered for `element.type`. Unknown types
-        # fall through to `render_unknown`.
-        def render(element, context:)
-          handler = @handlers[element.type] || method(:render_unknown)
-          handler.call(element, context)
-        end
+      # Renders *element* using the handler registered for `element.type`. Unknown types
+      # fall through to `render_unknown`.
+      def render(element, context:)
+        handler = @handlers[element.type] || method(:render_unknown)
+        handler.call(element, context)
+      end
 
-        private
+      private
 
-        # The frozen hash of element-type → handler mapping.
-        attr_reader :handlers
+      # The frozen hash of element-type → handler mapping.
+      attr_reader :handlers
 
-        # Builds the handler hash for text, strong, em, codespan, link, br, and entity.
-        def build_handlers
-          r = @renderer
-          @handlers = {
-            text: ->(element, _context) { element.value.to_s },
-            strong: ->(element, context) { render_styled(element, context, :markdown_strong) { |s| s.bold } },
-            em: ->(element, context) { render_styled(element, context, :markdown_emphasis) { |s| s.italic } },
-            codespan: ->(element, _context) { r.style_for(:markdown_inline_code, fallback: r.theme_style(:warn)).render(element.value.to_s) },
-            a: ->(element, context) { send(:render_link, element, context) },
-            br: ->(_element, _context) { "\n" },
-            entity: ->(element, _context) { element.value.respond_to?(:char) ? element.value.char : element.value.to_s }
-          }.freeze
-        end
+      # Builds the handler hash for text, strong, em, codespan, link, br, and entity.
+      def build_handlers
+        r = @renderer
+        @handlers = {
+          text: ->(element, _context) { element.value.to_s },
+          strong: ->(element, context) { render_styled(element, context, :markdown_strong) { |s| s.bold } },
+          em: ->(element, context) { render_styled(element, context, :markdown_emphasis) { |s| s.italic } },
+          codespan: ->(element, _context) { r.style_for(:markdown_inline_code, fallback: r.theme_style(:warn)).render(element.value.to_s) },
+          a: ->(element, context) { send(:render_link, element, context) },
+          br: ->(_element, _context) { "\n" },
+          entity: ->(element, _context) { element.value.respond_to?(:char) ? element.value.char : element.value.to_s }
+        }.freeze
+      end
 
-        # Renders a styled inline (strong/em) by first rendering children, then applying
-        # the theme style and the block-form (e.g., `bold`/`italic`) decoration.
-        def render_styled(element, context, style_name)
-          rendered = @renderer.render_inlines(element.children, width: context.width)
-          style = @renderer.style_for(style_name, fallback: yield(@renderer.theme_style(:text)))
-          style.render(rendered)
-        end
+      # Renders a styled inline (strong/em) by first rendering children, then applying
+      # the theme style and the block-form (e.g., `bold`/`italic`) decoration.
+      def render_styled(element, context, style_name)
+        rendered = @renderer.render_inlines(element.children, width: context.width)
+        style = @renderer.style_for(style_name, fallback: yield(@renderer.theme_style(:text)))
+        style.render(rendered)
+      end
 
-        # Renders a Markdown link as "label <href>" (URL omitted when empty), styled with
-        # the markdown_link theme token or the info+underline fallback.
-        def render_link(element, context)
-          label = @renderer.render_inlines(element.children, width: context.width)
-          href = element.attr["href"].to_s
-          rendered = href.empty? ? label : "#{label} <#{href}>"
-          @renderer.style_for(:markdown_link, fallback: @renderer.theme_style(:info).underline).render(rendered)
-        end
+      # Renders a Markdown link as "label <href>" (URL omitted when empty), styled with
+      # the markdown_link theme token or the info+underline fallback.
+      def render_link(element, context)
+        label = @renderer.render_inlines(element.children, width: context.width)
+        href = element.attr["href"].to_s
+        rendered = href.empty? ? label : "#{label} <#{href}>"
+        @renderer.style_for(:markdown_link, fallback: @renderer.theme_style(:info).underline).render(rendered)
+      end
 
-        # Fallback for unknown inline types: returns the value when there are no children,
-        # otherwise recurses into the children.
-        def render_unknown(element, context)
-          element.children.empty? ? element.value.to_s : @renderer.render_inlines(element.children, width: context.width)
-        end
+      # Fallback for unknown inline types: returns the value when there are no children,
+      # otherwise recurses into the children.
+      def render_unknown(element, context)
+        element.children.empty? ? element.value.to_s : @renderer.render_inlines(element.children, width: context.width)
       end
     end
   end

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

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    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)
-        end
+  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)
+      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)
-        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)
       end
     end
   end

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

@@ -3,110 +3,108 @@
 require "kramdown"
 
 module Charming
-  module Presentation
-    module Markdown
-      # Renderer is the top-level Markdown-to-ANSI renderer. Parses the *content* with
-      # Kramdown, then walks the document's block and inline trees to produce styled
-      # terminal output. Code blocks are highlighted via Rouge when `syntax_highlighting`
-      # is enabled.
-      class Renderer
-        # Wrap width used by `render_rule` when no width is otherwise specified.
-        DEFAULT_RULE_WIDTH = 40
-
-        # The Markdown source, configured wrap width, theme, and syntax-highlighting flag.
-        attr_reader :content, :width, :theme, :syntax_highlighting
-
-        # *content* is the Markdown source string. *width* optionally wraps paragraphs to that
-        # many display columns. *theme* is the Charming theme used to style blocks/inlines.
-        # *syntax_highlighting* enables Rouge-backed code block highlighting (default true).
-        def initialize(content:, width: nil, theme: UI::Theme.default, syntax_highlighting: true)
-          @content = content
-          @width = width
-          @theme = theme || UI::Theme.default
-          @syntax_highlighting = syntax_highlighting
-        end
+  module Markdown
+    # Renderer is the top-level Markdown-to-ANSI renderer. Parses the *content* with
+    # Kramdown, then walks the document's block and inline trees to produce styled
+    # terminal output. Code blocks are highlighted via Rouge when `syntax_highlighting`
+    # is enabled.
+    class Renderer
+      # Wrap width used by `render_rule` when no width is otherwise specified.
+      DEFAULT_RULE_WIDTH = 40
+
+      # The Markdown source, configured wrap width, theme, and syntax-highlighting flag.
+      attr_reader :content, :width, :theme, :syntax_highlighting
+
+      # *content* is the Markdown source string. *width* optionally wraps paragraphs to that
+      # many display columns. *theme* is the Charming theme used to style blocks/inlines.
+      # *syntax_highlighting* enables Rouge-backed code block highlighting (default true).
+      def initialize(content:, width: nil, theme: UI::Theme.default, syntax_highlighting: true)
+        @content = content
+        @width = width
+        @theme = theme || UI::Theme.default
+        @syntax_highlighting = syntax_highlighting
+      end
 
-        # Parses the content and returns the fully-rendered Markdown as a single string.
-        def render
-          document = Kramdown::Document.new(content.to_s)
-          render_blocks(document.root.children)
-        end
+      # Parses the content and returns the fully-rendered Markdown as a single string.
+      def render
+        document = Kramdown::Document.new(content.to_s)
+        render_blocks(document.root.children)
+      end
 
-        # Renders a list of Kramdown block *elements* into a string, joined by blank lines.
-        # *list_depth* is forwarded to the render context for list indentation. *width*
-        # defaults to the renderer's configured width.
-        def render_blocks(elements, list_depth: 0, width: @width)
-          context = RenderContext.from(width: width, list_depth: list_depth)
-          elements.filter_map do |element|
-            rendered = block_renderer.render(element, context: context)
-            rendered unless rendered.to_s.empty?
-          end.join("\n\n")
-        end
+      # Renders a list of Kramdown block *elements* into a string, joined by blank lines.
+      # *list_depth* is forwarded to the render context for list indentation. *width*
+      # defaults to the renderer's configured width.
+      def render_blocks(elements, list_depth: 0, width: @width)
+        context = RenderContext.from(width: width, list_depth: list_depth)
+        elements.filter_map do |element|
+          rendered = block_renderer.render(element, context: context)
+          rendered unless rendered.to_s.empty?
+        end.join("\n\n")
+      end
 
-        # Renders a list of Kramdown inline *elements* into a single concatenated string.
-        # *width* defaults to the renderer's configured width.
-        def render_inlines(elements, width: @width)
-          context = RenderContext.from(width: width)
-          elements.map { |element| inline_renderer.render(element, context: context) }.join
-        end
+      # Renders a list of Kramdown inline *elements* into a single concatenated string.
+      # *width* defaults to the renderer's configured width.
+      def render_inlines(elements, width: @width)
+        context = RenderContext.from(width: width)
+        elements.map { |element| inline_renderer.render(element, context: context) }.join
+      end
 
-        # Word-wraps *value* to *width* display columns (when *width* is given), preserving
-        # any ANSI styling on each line. Returns *value* unchanged when *width* is nil.
-        def wrap(value, width:)
-          return value unless width
+      # Word-wraps *value* to *width* display columns (when *width* is given), preserving
+      # any ANSI styling on each line. Returns *value* unchanged when *width* is nil.
+      def wrap(value, width:)
+        return value unless width
 
-          value.to_s.lines(chomp: true).map { |line| wrap_line(line, width) }.join("\n")
-        end
+        value.to_s.lines(chomp: true).map { |line| wrap_line(line, width) }.join("\n")
+      end
 
-        # Returns the theme's style for *name* if the theme defines it, otherwise returns
-        # *fallback*. Lets views override markdown-specific theme tokens.
-        def style_for(name, fallback:)
-          return theme.public_send(name) if theme.respond_to?(name)
+      # Returns the theme's style for *name* if the theme defines it, otherwise returns
+      # *fallback*. Lets views override markdown-specific theme tokens.
+      def style_for(name, fallback:)
+        return theme.public_send(name) if theme.respond_to?(name)
 
-          fallback
-        end
+        fallback
+      end
 
-        # Returns the theme's style for *name*, building a one-token default theme when
-        # the active theme doesn't define it. Used as a final fallback for markdown styling.
-        def theme_style(name)
-          return theme.public_send(name) if theme.respond_to?(name)
+      # Returns the theme's style for *name*, building a one-token default theme when
+      # the active theme doesn't define it. Used as a final fallback for markdown styling.
+      def theme_style(name)
+        return theme.public_send(name) if theme.respond_to?(name)
 
-          UI::Theme::DEFAULT_TOKENS.fetch(name).then { |token| UI::Theme.new(name => token).public_send(name) }
-        end
+        UI::Theme::DEFAULT_TOKENS.fetch(name).then { |token| UI::Theme.new(name => token).public_send(name) }
+      end
 
-        private
+      private
 
-        # The BlockRenderer instance, lazily built.
-        def block_renderer
-          @block_renderer ||= BlockRenderer.new(renderer: self)
-        end
+      # The BlockRenderer instance, lazily built.
+      def block_renderer
+        @block_renderer ||= BlockRenderer.new(renderer: self)
+      end
 
-        # The InlineRenderer instance, lazily built.
-        def inline_renderer
-          @inline_renderer ||= InlineRenderer.new(renderer: self)
-        end
+      # The InlineRenderer instance, lazily built.
+      def inline_renderer
+        @inline_renderer ||= InlineRenderer.new(renderer: self)
+      end
 
-        # Word-wraps a single *line* to *width* display columns using greedy space-splitting.
-        def wrap_line(line, width)
-          return line if UI::Width.measure(line) <= width
+      # Word-wraps a single *line* to *width* display columns using greedy space-splitting.
+      def wrap_line(line, width)
+        return line if UI::Width.measure(line) <= width
 
-          lines = []
-          current = +""
+        lines = []
+        current = +""
 
-          line.split(/\s+/).each do |word|
-            candidate = current.empty? ? word : "#{current} #{word}"
+        line.split(/\s+/).each do |word|
+          candidate = current.empty? ? word : "#{current} #{word}"
 
-            if !current.empty? && UI::Width.measure(candidate) > width
-              lines << current.rstrip
-              current = word
-            else
-              current = candidate
-            end
+          if !current.empty? && UI::Width.measure(candidate) > width
+            lines << current.rstrip
+            current = word
+          else
+            current = candidate
           end
-
-          lines << current.rstrip unless current.empty?
-          lines.join("\n")
         end
+
+        lines << current.rstrip unless current.empty?
+        lines.join("\n")
       end
     end
   end

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

@@ -3,76 +3,74 @@
 require "rouge"
 
 module Charming
-  module Presentation
-    module Markdown
-      # SyntaxHighlighter turns a code block string into ANSI-styled terminal text using
-      # Rouge lexers. The theme provides markdown_code_* tokens for per-token styling;
-      # when a token is undefined in the theme, the highlighter falls back to a sensible
-      # base style (muted italic for comments, title for keywords, etc.).
-      class SyntaxHighlighter
-        # *theme* is the active Charming theme. Defaults to UI::Theme.default.
-        def initialize(theme: UI::Theme.default)
-          @theme = theme || UI::Theme.default
-        end
+  module Markdown
+    # SyntaxHighlighter turns a code block string into ANSI-styled terminal text using
+    # Rouge lexers. The theme provides markdown_code_* tokens for per-token styling;
+    # when a token is undefined in the theme, the highlighter falls back to a sensible
+    # base style (muted italic for comments, title for keywords, etc.).
+    class SyntaxHighlighter
+      # *theme* is the active Charming theme. Defaults to UI::Theme.default.
+      def initialize(theme: UI::Theme.default)
+        @theme = theme || UI::Theme.default
+      end
 
-        # Highlights *code* (using Rouge) for the given *language* (auto-detected when nil)
-        # and returns a styled multi-line string. Each Rouge token is rendered with the
-        # theme style matching its token type.
-        def render(code, language: nil)
-          lexer = lexer_for(language, code)
-          lexer.lex(code.to_s).map do |token, value|
-            style_for(token).render(value)
-          end.join
-        end
+      # Highlights *code* (using Rouge) for the given *language* (auto-detected when nil)
+      # and returns a styled multi-line string. Each Rouge token is rendered with the
+      # theme style matching its token type.
+      def render(code, language: nil)
+        lexer = lexer_for(language, code)
+        lexer.lex(code.to_s).map do |token, value|
+          style_for(token).render(value)
+        end.join
+      end
 
-        private
+      private
 
-        # The Charming theme used for token styling.
-        attr_reader :theme
+      # The Charming theme used for token styling.
+      attr_reader :theme
 
-        # Picks a Rouge lexer for *language* and *code*, falling back to plain text.
-        def lexer_for(language, code)
-          Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText
-        end
+      # Picks a Rouge lexer for *language* and *code*, falling back to plain text.
+      def lexer_for(language, code)
+        Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText
+      end
 
-        # Returns the Charming style for a given Rouge *token*, mapping token qualifiers
-        # to theme tokens and falling back to a sensible base style per category.
-        def style_for(token)
-          name = token_name(token)
+      # Returns the Charming style for a given Rouge *token*, mapping token qualifiers
+      # to theme tokens and falling back to a sensible base style per category.
+      def style_for(token)
+        name = token_name(token)
 
-          case name
-          when /Comment/
-            theme_style(:markdown_code_comment, fallback: theme_style(:muted).italic)
-          when /Keyword/
-            theme_style(:markdown_code_keyword, fallback: theme_style(:title))
-          when /String/
-            theme_style(:markdown_code_string, fallback: theme_style(:warn))
-          when /Number|Literal/
-            theme_style(:markdown_code_literal, fallback: theme_style(:info))
-          when /Name\.(Class|Constant|Function|Namespace)/
-            theme_style(:markdown_code_constant, fallback: theme_style(:info))
-          when /Error/
-            theme_style(:markdown_code_error, fallback: theme_style(:warn).bold)
-          else
-            theme_style(:markdown_code, fallback: theme_style(:text))
-          end
+        case name
+        when /Comment/
+          theme_style(:markdown_code_comment, fallback: theme_style(:muted).italic)
+        when /Keyword/
+          theme_style(:markdown_code_keyword, fallback: theme_style(:title))
+        when /String/
+          theme_style(:markdown_code_string, fallback: theme_style(:warn))
+        when /Number|Literal/
+          theme_style(:markdown_code_literal, fallback: theme_style(:info))
+        when /Name\.(Class|Constant|Function|Namespace)/
+          theme_style(:markdown_code_constant, fallback: theme_style(:info))
+        when /Error/
+          theme_style(:markdown_code_error, fallback: theme_style(:warn).bold)
+        else
+          theme_style(:markdown_code, fallback: theme_style(:text))
         end
+      end
 
-        # Returns the qualified token name when the token object supports it, otherwise
-        # the token's default `to_s`.
-        def token_name(token)
-          return token.qualname if token.respond_to?(:qualname)
+      # Returns the qualified token name when the token object supports it, otherwise
+      # the token's default `to_s`.
+      def token_name(token)
+        return token.qualname if token.respond_to?(:qualname)
 
-          token.to_s
-        end
+        token.to_s
+      end
 
-        # Returns the theme's style for *name*, falling back to *fallback* (or a default
-        # empty style) when the theme doesn't define it.
-        def theme_style(name, fallback: nil)
-          return theme.public_send(name) if theme.respond_to?(name)
+      # Returns the theme's style for *name*, falling back to *fallback* (or a default
+      # empty style) when the theme doesn't define it.
+      def theme_style(name, fallback: nil)
+        return theme.public_send(name) if theme.respond_to?(name)
 
-          fallback || UI.style
-        end
+        fallback || UI.style
       end
     end
   end

data/lib/charming/presentation/markdown.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    # Markdown is the namespace for the Markdown rendering pipeline. Parsing is delegated to
-    # Kramdown; per-block and per-inline element rendering is handled by `BlockRenderer`
-    # and `InlineRenderer`; code blocks are highlighted by `SyntaxHighlighter` (Rouge-backed).
-    module Markdown
-    end
+  # Markdown is the namespace for the Markdown rendering pipeline. Parsing is delegated to
+  # Kramdown; per-block and per-inline element rendering is handled by `BlockRenderer`
+  # and `InlineRenderer`; code blocks are highlighted by `SyntaxHighlighter` (Rouge-backed).
+  module Markdown
   end
 end

data/lib/charming/presentation/template_view.rb

@@ -1,34 +1,32 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    # TemplateView wraps a resolved ERB template and exposes it as a renderable View. The
-    # template is rendered with the view's helpers (`text`, `box`, `row`, `column`, `style`,
-    # `theme`, etc.) and the view's assigns available as reader methods inside the template.
-    class TemplateView < View
-      def initialize(template:, namespace: nil, **assigns)
-        super(**assigns)
-        @template = template
-        @namespace = namespace
-      end
+  # TemplateView wraps a resolved ERB template and exposes it as a renderable View. The
+  # template is rendered with the view's helpers (`text`, `box`, `row`, `column`, `style`,
+  # `theme`, etc.) and the view's assigns available as reader methods inside the template.
+  class TemplateView < View
+    def initialize(template:, namespace: nil, **assigns)
+      super(**assigns)
+      @template = template
+      @namespace = namespace
+    end
 
-      # Renders the wrapped template to a string, evaluated in the view's binding context.
-      def render
-        template.render(self).to_s
-      end
+    # Renders the wrapped template to a string, evaluated in the view's binding context.
+    def render
+      template.render(self).to_s
+    end
 
-      # Returns the binding used by ERB handlers to evaluate the template body. When *namespace*
-      # is set, the binding is created by a proc generated in the namespace's context so the
-      # template can resolve constants relative to the application.
-      def template_binding
-        return binding unless namespace
+    # Returns the binding used by ERB handlers to evaluate the template body. When *namespace*
+    # is set, the binding is created by a proc generated in the namespace's context so the
+    # template can resolve constants relative to the application.
+    def template_binding
+      return binding unless namespace
 
-        namespace.module_eval("->(view) { view.instance_eval { binding } }", __FILE__, __LINE__).call(self)
-      end
+      namespace.module_eval("->(view) { view.instance_eval { binding } }", __FILE__, __LINE__).call(self)
+    end
 
-      private
+    private
 
-      attr_reader :template, :namespace
-    end
+    attr_reader :template, :namespace
   end
 end

data/lib/charming/presentation/templates/erb_handler.rb

@@ -3,12 +3,10 @@
 require "erb"
 
 module Charming
-  module Presentation
-    module Templates
-      class ErbHandler
-        def self.render(path, view)
-          ERB.new(File.read(path), trim_mode: "-").result(view.template_binding)
-        end
+  module Templates
+    class ErbHandler
+      def self.render(path, view)
+        ERB.new(File.read(path), trim_mode: "-").result(view.template_binding)
       end
     end
   end