charming 0.1.2 → 0.1.4

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

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

@@ -1,81 +1,79 @@
 # frozen_string_literal: true
 
 module Charming
-  module Presentation
-    module UI
-      # Canvas is a 2D character grid of fixed width and height that supports
-      # placing content at (row, column) coordinates and overlaying one block
-      # on top of another. Construct via .new(width, height) for a blank grid
-      # or .parse(string) to reconstruct from rendered output.
-      class Canvas
-        def initialize(width, height)
-          @width = width
-          @height = height
-          @grid = Array.new(height) { " " * width }
-        end
+  module UI
+    # Canvas is a 2D character grid of fixed width and height that supports
+    # placing content at (row, column) coordinates and overlaying one block
+    # on top of another. Construct via .new(width, height) for a blank grid
+    # or .parse(string) to reconstruct from rendered output.
+    class Canvas
+      def initialize(width, height)
+        @width = width
+        @height = height
+        @grid = Array.new(height) { " " * width }
+      end
 
-        def self.parse(string)
-          lines = string.to_s.lines(chomp: true)
-          width = UI.block_width(lines)
-          canvas = new(width, lines.length)
-          lines.each_with_index { |line, i| canvas.instance_variable_get(:@grid)[i] = line }
-          canvas
-        end
+      def self.parse(string)
+        lines = string.to_s.lines(chomp: true)
+        width = UI.block_width(lines)
+        canvas = new(width, lines.length)
+        lines.each_with_index { |line, i| canvas.instance_variable_get(:@grid)[i] = line }
+        canvas
+      end
 
-        def to_s
-          @grid.join("\n")
-        end
+      def to_s
+        @grid.join("\n")
+      end
 
-        def place(block, top: 0, left: 0, background: nil)
-          lines = block.to_s.lines(chomp: true)
-          row = Canvas.offset(top, @height, lines.length)
-          column = Canvas.offset(left, @width, UI.block_width(lines))
-          draw_lines(lines, row: row, column: column, onto: @grid)
-          rendered = to_s
-          background ? UI::Style.new.background(background).render(rendered) : rendered
-        end
+      def place(block, top: 0, left: 0, background: nil)
+        lines = block.to_s.lines(chomp: true)
+        row = Canvas.offset(top, @height, lines.length)
+        column = Canvas.offset(left, @width, UI.block_width(lines))
+        draw_lines(lines, row: row, column: column, onto: @grid)
+        rendered = to_s
+        background ? UI::Style.new.background(background).render(rendered) : rendered
+      end
 
-        def overlay(other, top: :center, left: :center)
-          overlay_lines = other.to_s.lines(chomp: true)
-          row = Canvas.offset(top, @grid.length, overlay_lines.length)
-          column = Canvas.offset(left, @width, UI.block_width(overlay_lines))
-          draw_lines(overlay_lines, row: row, column: column, onto: @grid)
-          self
-        end
+      def overlay(other, top: :center, left: :center)
+        overlay_lines = other.to_s.lines(chomp: true)
+        row = Canvas.offset(top, @grid.length, overlay_lines.length)
+        column = Canvas.offset(left, @width, UI.block_width(overlay_lines))
+        draw_lines(overlay_lines, row: row, column: column, onto: @grid)
+        self
+      end
 
-        def self.offset(value, available, size)
-          return [(available - size) / 2, 0].max if value == :center
+      def self.offset(value, available, size)
+        return [(available - size) / 2, 0].max if value == :center
 
-          value
-        end
+        value
+      end
 
-        private
+      private
 
-        def draw_lines(lines, row:, column:, onto:)
-          lines.each_with_index do |line, index|
-            line_index = row + index
-            next if line_index.negative? || line_index >= onto.length
+      def draw_lines(lines, row:, column:, onto:)
+        lines.each_with_index do |line, index|
+          line_index = row + index
+          next if line_index.negative? || line_index >= onto.length
 
-            onto[line_index] = compose_line(onto[line_index], line, column)
-          end
+          onto[line_index] = compose_line(onto[line_index], line, column)
         end
+      end
 
-        def compose_line(base_line, overlay_line, column)
-          return ANSISlicer.slice(base_line, 0, @width) if column >= @width
-          return ANSISlicer.slice(base_line, 0, @width) if column + Width.measure(overlay_line) <= 0
+      def compose_line(base_line, overlay_line, column)
+        return ANSISlicer.slice(base_line, 0, @width) if column >= @width
+        return ANSISlicer.slice(base_line, 0, @width) if column + Width.measure(overlay_line) <= 0
 
-          target_column = [column, 0].max
-          overlay_start = [0 - column, 0].max
-          overlay = ANSISlicer.slice(overlay_line, overlay_start, @width - target_column)
-          overlay_width = Width.measure(overlay)
-          return ANSISlicer.slice(base_line, 0, @width) if overlay_width.zero?
+        target_column = [column, 0].max
+        overlay_start = [0 - column, 0].max
+        overlay = ANSISlicer.slice(overlay_line, overlay_start, @width - target_column)
+        overlay_width = Width.measure(overlay)
+        return ANSISlicer.slice(base_line, 0, @width) if overlay_width.zero?
 
-          right_column = target_column + overlay_width
+        right_column = target_column + overlay_width
 
-          ANSISlicer.slice(base_line, 0, target_column) +
-            overlay +
-            ANSISlicer.slice(base_line, right_column, [@width - right_column, 0].max)
-        end
+        ANSISlicer.slice(base_line, 0, target_column) +
+          overlay +
+          ANSISlicer.slice(base_line, right_column, [@width - right_column, 0].max)
       end
     end
   end