charming 0.1.2 → 0.1.4

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

@@ -3,76 +3,75 @@
 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, style: nil)
+        @theme = theme || UI::Theme.default
+        @style = style
+      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, :style
 
-        # 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
+  # Commonmarker; `Renderer` renders the AST, and 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

data/lib/charming/presentation/templates.rb

@@ -1,67 +1,65 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    # Templates resolves and renders view templates by name. Template handlers are registered
-    # for file extensions (e.g., `.tui.erb`) and the resolver searches `app/views/<name><ext>`
-    # under the application root, falling back through registered extensions when the first
-    # match is not found.
-    module Templates
-      # A resolved template: an on-disk *path* paired with the *handler* responsible for rendering it.
-      ResolvedTemplate = Data.define(:path, :handler) do
-        # Renders the template against *view* by delegating to the registered handler.
-        def render(view)
-          handler.render(path, view)
-        end
+  # Templates resolves and renders view templates by name. Template handlers are registered
+  # for file extensions (e.g., `.tui.erb`) and the resolver searches `app/views/<name><ext>`
+  # under the application root, falling back through registered extensions when the first
+  # match is not found.
+  module Templates
+    # A resolved template: an on-disk *path* paired with the *handler* responsible for rendering it.
+    ResolvedTemplate = Data.define(:path, :handler) do
+      # Renders the template against *view* by delegating to the registered handler.
+      def render(view)
+        handler.render(path, view)
       end
+    end
 
-      # Raised when no template file matches the given name under the application root.
-      MissingTemplateError = Class.new(Error)
-
-      class << self
-        # Registers a template *handler* for a file *extension* (e.g., ".tui.erb" => ErbHandler).
-        # The handler responds to `.render(path, view)`.
-        def register(extension, handler)
-          handlers[extension] = handler
-        end
+    # Raised when no template file matches the given name under the application root.
+    MissingTemplateError = Class.new(Error)
 
-        # Resolves a template by *name* under `app/views` of *root* (defaults to the current
-        # working directory). Raises MissingTemplateError when no matching file exists.
-        def resolve(name, root: nil)
-          views_root = File.join(root || Dir.pwd, "app", "views")
-          searched_paths = candidate_paths(views_root, name.to_s)
+    class << self
+      # Registers a template *handler* for a file *extension* (e.g., ".tui.erb" => ErbHandler).
+      # The handler responds to `.render(path, view)`.
+      def register(extension, handler)
+        handlers[extension] = handler
+      end
 
-          searched_paths.each do |path|
-            next unless File.file?(path)
+      # Resolves a template by *name* under `app/views` of *root* (defaults to the current
+      # working directory). Raises MissingTemplateError when no matching file exists.
+      def resolve(name, root: nil)
+        views_root = File.join(root || Dir.pwd, "app", "views")
+        searched_paths = candidate_paths(views_root, name.to_s)
 
-            return ResolvedTemplate.new(path: path, handler: handler_for(path))
-          end
+        searched_paths.each do |path|
+          next unless File.file?(path)
 
-          raise MissingTemplateError, "Missing template #{name.inspect}. Searched: #{searched_paths.join(", ")}"
+          return ResolvedTemplate.new(path: path, handler: handler_for(path))
         end
 
-        # Hash of registered handlers keyed by extension. Populated by `register`.
-        def handlers
-          @handlers ||= {}
-        end
+        raise MissingTemplateError, "Missing template #{name.inspect}. Searched: #{searched_paths.join(", ")}"
+      end
 
-        private
+      # Hash of registered handlers keyed by extension. Populated by `register`.
+      def handlers
+        @handlers ||= {}
+      end
 
-        # Returns candidate paths under *views_root* for *name*. When the bare path has a known
-        # extension, returns it directly; otherwise returns the path with each registered extension
-        # appended (in registration order).
-        def candidate_paths(views_root, name)
-          path = File.expand_path(name, views_root)
-          return [path] if handler_for(path)
+      private
 
-          handlers.keys.map { |extension| "#{path}#{extension}" }
-        end
+      # Returns candidate paths under *views_root* for *name*. When the bare path has a known
+      # extension, returns it directly; otherwise returns the path with each registered extension
+      # appended (in registration order).
+      def candidate_paths(views_root, name)
+        path = File.expand_path(name, views_root)
+        return [path] if handler_for(path)
 
-        # Looks up the handler whose registered extension matches the end of *path*. Returns nil
-        # when no handler matches.
-        def handler_for(path)
-          handlers.find { |extension, _handler| path.end_with?(extension) }&.last
-        end
+        handlers.keys.map { |extension| "#{path}#{extension}" }
+      end
+
+      # Looks up the handler whose registered extension matches the end of *path*. Returns nil
+      # when no handler matches.
+      def handler_for(path)
+        handlers.find { |extension, _handler| path.end_with?(extension) }&.last
       end
     end
   end

data/lib/charming/presentation/ui/ansi_codes.rb

@@ -1,88 +1,86 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module UI
-      class ANSICodes
-        ATTRIBUTES = {
-          bold: 1,
-          faint: 2,
-          italic: 3,
-          underline: 4,
-          reverse: 7,
-          strikethrough: 9
-        }.freeze
+  module UI
+    class ANSICodes
+      ATTRIBUTES = {
+        bold: 1,
+        faint: 2,
+        italic: 3,
+        underline: 4,
+        reverse: 7,
+        strikethrough: 9
+      }.freeze
 
-        COLORS = {
-          black: 30,
-          red: 31,
-          green: 32,
-          yellow: 33,
-          blue: 34,
-          magenta: 35,
-          cyan: 36,
-          white: 37,
-          bright_black: 90,
-          bright_red: 91,
-          bright_green: 92,
-          bright_yellow: 93,
-          bright_blue: 94,
-          bright_magenta: 95,
-          bright_cyan: 96,
-          bright_white: 97
-        }.freeze
+      COLORS = {
+        black: 30,
+        red: 31,
+        green: 32,
+        yellow: 33,
+        blue: 34,
+        magenta: 35,
+        cyan: 36,
+        white: 37,
+        bright_black: 90,
+        bright_red: 91,
+        bright_green: 92,
+        bright_yellow: 93,
+        bright_blue: 94,
+        bright_magenta: 95,
+        bright_cyan: 96,
+        bright_white: 97
+      }.freeze
 
-        def initialize(attributes:, foreground:, background:)
-          @attributes = attributes
-          @foreground = foreground
-          @background = background
-        end
+      def initialize(attributes:, foreground:, background:)
+        @attributes = attributes
+        @foreground = foreground
+        @background = background
+      end
 
-        def codes
-          @codes ||= attribute_codes +
-            color_codes(@foreground, foreground: true) +
-            color_codes(@background, foreground: false)
-        end
+      def codes
+        @codes ||= attribute_codes +
+          color_codes(@foreground, foreground: true) +
+          color_codes(@background, foreground: false)
+      end
 
-        def apply(value)
-          return value if codes.empty?
+      def apply(value)
+        return value if codes.empty?
 
-          start = "\e[#{codes.join(";")}m"
-          value.split("\n", -1).map { |line| "#{start}#{line.gsub("\e[0m", "\e[0m#{start}")}\e[0m" }.join("\n")
-        end
+        start = "\e[#{codes.join(";")}m"
+        value.split("\n", -1).map { |line| "#{start}#{line.gsub("\e[0m", "\e[0m#{start}")}\e[0m" }.join("\n")
+      end
 
-        private
+      private
 
-        def attribute_codes
-          @attributes.map { |attribute| ATTRIBUTES.fetch(attribute) }
-        end
+      def attribute_codes
+        @attributes.map { |attribute| ATTRIBUTES.fetch(attribute) }
+      end
 
-        def color_codes(color, foreground:)
-          return [] unless color
-          return indexed_color_code(color, foreground: foreground) if color.is_a?(Integer)
-          return named_color_code(color, foreground: foreground) if COLORS.key?(color.to_sym)
-          return truecolor_codes(color, foreground: foreground) if color.to_s.start_with?("#")
+      def color_codes(color, foreground:)
+        return [] unless color
+        return indexed_color_code(color, foreground: foreground) if color.is_a?(Integer)
+        return named_color_code(color, foreground: foreground) if COLORS.key?(color.to_sym)
+        return truecolor_codes(color, foreground: foreground) if color.to_s.start_with?("#")
 
-          raise ArgumentError, "unknown color: #{color.inspect}"
-        end
+        raise ArgumentError, "unknown color: #{color.inspect}"
+      end
 
-        def named_color_code(color, foreground:)
-          code = COLORS.fetch(color.to_sym)
-          [foreground ? code : code + 10]
-        end
+      def named_color_code(color, foreground:)
+        code = COLORS.fetch(color.to_sym)
+        [foreground ? code : code + 10]
+      end
 
-        def indexed_color_code(color, foreground:)
-          raise ArgumentError, "indexed color must be between 0 and 255" unless color.between?(0, 255)
+      def indexed_color_code(color, foreground:)
+        raise ArgumentError, "indexed color must be between 0 and 255" unless color.between?(0, 255)
 
-          [foreground ? 38 : 48, 5, color]
-        end
+        [foreground ? 38 : 48, 5, color]
+      end
 
-        def truecolor_codes(color, foreground:)
-          hex = color.to_s.delete_prefix("#")
-          raise ArgumentError, "truecolor must be #rrggbb" unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
+      def truecolor_codes(color, foreground:)
+        hex = color.to_s.delete_prefix("#")
+        raise ArgumentError, "truecolor must be #rrggbb" unless hex.match?(/\A[0-9a-fA-F]{6}\z/)
 
-          [foreground ? 38 : 48, 2, hex[0..1].to_i(16), hex[2..3].to_i(16), hex[4..5].to_i(16)]
-        end
+        [foreground ? 38 : 48, 2, hex[0..1].to_i(16), hex[2..3].to_i(16), hex[4..5].to_i(16)]
       end
     end
   end