charming 0.1.2 → 0.1.3

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

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

@@ -1,94 +1,92 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module UI
-      # ANSISlicer extracts a visible substring from a string that may contain ANSI
-      # escape sequences, preserving the styling that is active at the start of
-      # the slice and emitting a trailing reset if any styled content was copied.
-      class ANSISlicer
-        def self.slice(line, start_column, width)
-          return "" unless width.positive?
-
-          slice_range(line.to_s, start_column, start_column + width)
-        end
+  module UI
+    # ANSISlicer extracts a visible substring from a string that may contain ANSI
+    # escape sequences, preserving the styling that is active at the start of
+    # the slice and emitting a trailing reset if any styled content was copied.
+    class ANSISlicer
+      def self.slice(line, start_column, width)
+        return "" unless width.positive?
+
+        slice_range(line.to_s, start_column, start_column + width)
+      end
 
-        def self.slice_range(line, start_column, end_column)
-          state = {column: 0, output: +"", active: [], started: false, styled: false}
+      def self.slice_range(line, start_column, end_column)
+        state = {column: 0, output: +"", active: [], started: false, styled: false}
 
-          each_ansi_or_char(line) do |token, ansi|
-            if ansi
-              slice_ansi_token(token, state, start_column, end_column)
-            else
-              slice_char(token, state, start_column, end_column)
-            end
+        each_ansi_or_char(line) do |token, ansi|
+          if ansi
+            slice_ansi_token(token, state, start_column, end_column)
+          else
+            slice_char(token, state, start_column, end_column)
           end
-
-          terminate_slice(state)
         end
 
-        def self.each_ansi_or_char(line)
-          index = 0
-          while index < line.length
-            match = line.match(Width::ANSI_PATTERN, index)
-            if match&.begin(0) == index
-              yield match[0], true
-              index = match.end(0)
-            else
-              yield line[index], false
-              index += 1
-            end
+        terminate_slice(state)
+      end
+
+      def self.each_ansi_or_char(line)
+        index = 0
+        while index < line.length
+          match = line.match(Width::ANSI_PATTERN, index)
+          if match&.begin(0) == index
+            yield match[0], true
+            index = match.end(0)
+          else
+            yield line[index], false
+            index += 1
           end
         end
+      end
 
-        def self.slice_ansi_token(token, state, start_column, end_column)
-          started = state[:started]
-          update_active_styles(state[:active], token)
-          return unless state[:column].between?(start_column, end_column - 1)
+      def self.slice_ansi_token(token, state, start_column, end_column)
+        started = state[:started]
+        update_active_styles(state[:active], token)
+        return unless state[:column].between?(start_column, end_column - 1)
 
-          start_slice(state)
-          if started
-            state[:output] << token
-            state[:styled] = !token.include?("[0m")
-          end
+        start_slice(state)
+        if started
+          state[:output] << token
+          state[:styled] = !token.include?("[0m")
         end
+      end
 
-        def self.slice_char(char, state, start_column, end_column)
-          char_width = Width.measure(char)
-          char_start = state[:column]
-          char_end = char_start + char_width
-          state[:column] = char_end
-          return unless char_end > start_column && char_start < end_column
+      def self.slice_char(char, state, start_column, end_column)
+        char_width = Width.measure(char)
+        char_start = state[:column]
+        char_end = char_start + char_width
+        state[:column] = char_end
+        return unless char_end > start_column && char_start < end_column
 
-          start_slice(state)
-          state[:output] << char
-        end
+        start_slice(state)
+        state[:output] << char
+      end
 
-        def self.start_slice(state)
-          return if state[:started]
+      def self.start_slice(state)
+        return if state[:started]
 
-          state[:output] << state[:active].join
-          state[:styled] = true unless state[:active].empty?
-          state[:started] = true
-        end
+        state[:output] << state[:active].join
+        state[:styled] = true unless state[:active].empty?
+        state[:started] = true
+      end
 
-        def self.terminate_slice(state)
-          return state[:output] if !state[:styled] || state[:output].empty?
+      def self.terminate_slice(state)
+        return state[:output] if !state[:styled] || state[:output].empty?
 
-          "#{state[:output]}\e[0m"
-        end
+        "#{state[:output]}\e[0m"
+      end
 
-        def self.update_active_styles(active, token)
-          if token.include?("[0m")
-            active.clear
-          else
-            active << token
-          end
+      def self.update_active_styles(active, token)
+        if token.include?("[0m")
+          active.clear
+        else
+          active << token
         end
-
-        private_class_method :each_ansi_or_char, :slice_ansi_token, :slice_char,
-          :start_slice, :terminate_slice, :update_active_styles
       end
+
+      private_class_method :each_ansi_or_char, :slice_ansi_token, :slice_char,
+        :start_slice, :terminate_slice, :update_active_styles
     end
   end
 end

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

@@ -1,35 +1,33 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module UI
-      class Border
-        attr_reader :top_left, :top_right, :bottom_left, :bottom_right, :horizontal, :vertical
+  module UI
+    class Border
+      attr_reader :top_left, :top_right, :bottom_left, :bottom_right, :horizontal, :vertical
 
-        def initialize(corners:, edges:)
-          @top_left, @top_right, @bottom_left, @bottom_right = corners
-          @horizontal, @vertical = edges
-        end
-
-        def self.fetch(name)
-          STYLES.fetch(name.to_sym)
-        end
+      def initialize(corners:, edges:)
+        @top_left, @top_right, @bottom_left, @bottom_right = corners
+        @horizontal, @vertical = edges
       end
 
-      Border::STYLES = {
-        normal: Border.new(
-          corners: ["+", "+", "+", "+"], edges: ["-", "|"]
-        ),
-        rounded: Border.new(
-          corners: ["╭", "╮", "╰", "╯"], edges: ["─", "│"]
-        ),
-        thick: Border.new(
-          corners: ["┏", "┓", "┗", "┛"], edges: ["━", "┃"]
-        ),
-        double: Border.new(
-          corners: ["╔", "╗", "╚", "╝"], edges: ["═", "║"]
-        )
-      }.freeze
+      def self.fetch(name)
+        STYLES.fetch(name.to_sym)
+      end
     end
+
+    Border::STYLES = {
+      normal: Border.new(
+        corners: ["+", "+", "+", "+"], edges: ["-", "|"]
+      ),
+      rounded: Border.new(
+        corners: ["╭", "╮", "╰", "╯"], edges: ["─", "│"]
+      ),
+      thick: Border.new(
+        corners: ["┏", "┓", "┗", "┛"], edges: ["━", "┃"]
+      ),
+      double: Border.new(
+        corners: ["╔", "╗", "╚", "╝"], edges: ["═", "║"]
+      )
+    }.freeze
   end
 end

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

@@ -1,57 +1,55 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module UI
-      class BorderPainter
-        DEFAULT_SIDES = %i[top right bottom left].freeze
-
-        def initialize(border:, sides: nil, foreground: nil, background: nil)
-          @border = border
-          @sides = Array(sides || DEFAULT_SIDES).map(&:to_sym)
-          @foreground = foreground
-          @background = background
-        end
+  module UI
+    class BorderPainter
+      DEFAULT_SIDES = %i[top right bottom left].freeze
+
+      def initialize(border:, sides: nil, foreground: nil, background: nil)
+        @border = border
+        @sides = Array(sides || DEFAULT_SIDES).map(&:to_sym)
+        @foreground = foreground
+        @background = background
+      end
 
-        def paint(lines, inner_width)
-          horizontal = @border.horizontal * inner_width
-          body = lines.map { |line| border_line(line, inner_width) }
+      def paint(lines, inner_width)
+        horizontal = @border.horizontal * inner_width
+        body = lines.map { |line| border_line(line, inner_width) }
 
-          [top_border(horizontal), *body, bottom_border(horizontal)].compact
-        end
+        [top_border(horizontal), *body, bottom_border(horizontal)].compact
+      end
 
-        private
+      private
 
-        def border_line(line, width)
-          left = @sides.include?(:left) ? render_border(@border.vertical) : ""
-          right = @sides.include?(:right) ? render_border(@border.vertical) : ""
+      def border_line(line, width)
+        left = @sides.include?(:left) ? render_border(@border.vertical) : ""
+        right = @sides.include?(:right) ? render_border(@border.vertical) : ""
 
-          "#{left}#{line}#{" " * (width - Width.measure(line))}#{right}"
-        end
+        "#{left}#{line}#{" " * (width - Width.measure(line))}#{right}"
+      end
 
-        def top_border(horizontal)
-          return unless @sides.include?(:top)
-          return render_border(horizontal) unless full_horizontal?
+      def top_border(horizontal)
+        return unless @sides.include?(:top)
+        return render_border(horizontal) unless full_horizontal?
 
-          render_border("#{@border.top_left}#{horizontal}#{@border.top_right}")
-        end
+        render_border("#{@border.top_left}#{horizontal}#{@border.top_right}")
+      end
 
-        def bottom_border(horizontal)
-          return unless @sides.include?(:bottom)
-          return render_border(horizontal) unless full_horizontal?
+      def bottom_border(horizontal)
+        return unless @sides.include?(:bottom)
+        return render_border(horizontal) unless full_horizontal?
 
-          render_border("#{@border.bottom_left}#{horizontal}#{@border.bottom_right}")
-        end
+        render_border("#{@border.bottom_left}#{horizontal}#{@border.bottom_right}")
+      end
 
-        def full_horizontal?
-          @sides.include?(:left) && @sides.include?(:right)
-        end
+      def full_horizontal?
+        @sides.include?(:left) && @sides.include?(:right)
+      end
 
-        def render_border(value)
-          return value unless @foreground
+      def render_border(value)
+        return value unless @foreground
 
-          Style.new(foreground: @foreground, background: @background).render(value)
-        end
+        Style.new(foreground: @foreground, background: @background).render(value)
       end
     end
   end