charming 0.1.0 → 0.1.1

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+
+module Charming
+  module Presentation
+    module Components
+      class Viewport < Component
+        include KeyboardHandler
+
+        ANSI_PATTERN = /\e\[[0-9;]*m/
+        KEY_ACTIONS = {
+          up: :scroll_up,
+          down: :scroll_down,
+          page_up: :page_up,
+          page_down: :page_down,
+          home: :scroll_home,
+          end: :scroll_end,
+          left: :scroll_left,
+          right: :scroll_right
+        }.freeze
+
+        attr_reader :offset, :column
+
+        def initialize(content:, width: nil, height: nil, offset: 0, column: 0, wrap: false, keymap: :vim)
+          super()
+          @content = content
+          @width = width
+          @height = height
+          @offset = offset
+          @column = column
+          @wrap = wrap
+          @keymap = keymap
+          clamp_position
+        end
+
+        def render
+          visible_lines.map { |line| render_line(line) }.join("\n")
+        end
+
+        def handle_mouse(event)
+          return nil unless height
+
+          if event.scroll?
+            scroll_delta = (event.button_name == :scroll_up) ? -1 : 1
+            @offset += scroll_delta
+            clamp_position
+            return :handled
+          end
+
+          return nil unless event.click?
+
+          clicked_row = event.y
+          return nil if clicked_row < offset || clicked_row >= offset + viewport_height
+
+          @offset = clicked_row
+          clamp_position
+          :handled
+        end
+
+        private
+
+        attr_reader :content, :width, :height
+
+        def scroll_up
+          @offset -= 1
+          clamp_position
+        end
+
+        def scroll_down
+          @offset += 1
+          clamp_position
+        end
+
+        def page_up
+          @offset -= page_size
+          clamp_position
+        end
+
+        def page_down
+          @offset += page_size
+          clamp_position
+        end
+
+        def scroll_home
+          @offset = 0
+          @column = 0
+        end
+
+        def scroll_end
+          @offset = max_offset
+          @column = max_column
+        end
+
+        def scroll_left
+          @column -= 1
+          clamp_position
+        end
+
+        def scroll_right
+          @column += 1
+          clamp_position
+        end
+
+        def clamp_position
+          @offset = offset.clamp(0, max_offset)
+          @column = column.clamp(0, max_column)
+        end
+
+        def visible_lines
+          lines = content_lines.slice(offset, viewport_height) || []
+          return lines unless height
+
+          lines + Array.new([height - lines.length, 0].max, "")
+        end
+
+        def render_line(line)
+          return line unless width
+          return pad_line(line, width) if wrap?
+
+          pad_line(clip_line(line), width)
+        end
+
+        def clip_line(line)
+          clipped = clip_tokens(line.to_s)
+          needs_reset?(clipped) ? "#{clipped}\e[0m" : clipped
+        end
+
+        def clip_tokens(line)
+          state = {cursor: 0, output: +""}
+          line.scan(/#{ANSI_PATTERN}|./mo) do |token|
+            ansi?(token) ? append_ansi(state, token) : append_character(state, token)
+          end
+          state.fetch(:output)
+        end
+
+        def append_ansi(state, token)
+          state.fetch(:output) << token
+        end
+
+        def append_character(state, char)
+          char_width = Unicode::DisplayWidth.of(char)
+          cursor = state.fetch(:cursor)
+          state.fetch(:output) << char if visible?(cursor, char_width)
+          state[:cursor] = cursor + char_width
+        end
+
+        def visible?(cursor, char_width)
+          cursor >= column && cursor + char_width <= column + width
+        end
+
+        def needs_reset?(value)
+          value.match?(ANSI_PATTERN) && !value.end_with?("\e[0m")
+        end
+
+        def pad_line(line, target_width)
+          line + (" " * [target_width - UI::Width.measure(line), 0].max)
+        end
+
+        def content_lines
+          return wrapped_content_lines if wrap?
+
+          rendered_content.lines(chomp: true)
+        end
+
+        def wrapped_content_lines
+          rendered_content.lines(chomp: true).flat_map { |line| wrap_line(line) }
+        end
+
+        def wrap_line(line)
+          line_width = UI::Width.measure(line)
+          return [""] if line_width.zero?
+
+          start_column = 0
+          out = []
+          while start_column < line_width
+            out << UI.visible_slice(line, start_column, width)
+            start_column += width
+          end
+          out
+        end
+
+        def rendered_content
+          content.respond_to?(:render) ? content.render.to_s : content.to_s
+        end
+
+        def viewport_height
+          height || content_lines.length
+        end
+
+        def page_size
+          [viewport_height, 1].max
+        end
+
+        def max_offset
+          [content_lines.length - viewport_height, 0].max
+        end
+
+        def max_column
+          return 0 if wrap?
+          return 0 unless width
+
+          [content_width - width, 0].max
+        end
+
+        def content_width
+          content_lines.map { |line| UI::Width.measure(line) }.max || 0
+        end
+
+        def ansi?(token)
+          token.match?(ANSI_PATTERN)
+        end
+
+        def wrap?
+          @wrap && width&.positive?
+        end
+      end
+    end
+  end
+end

data/lib/charming/presentation/layout.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    # Layout contains generic screen-size math and composition helpers. It is
+    # intentionally unaware of application shells such as sidebars or nav panes.
+    module Layout
+      module_function
+
+      def clamp_size(value, min: nil, max: nil)
+        size = value.to_i
+        size = [size, min].max if min
+        size = [size, max].min if max
+        size
+      end
+
+      def available_width(screen, reserved: 0, min: nil, max: nil)
+        clamp_size(screen.width - reserved, min: min, max: max)
+      end
+
+      def available_height(screen, reserved: 0, min: nil, max: nil)
+        clamp_size(screen.height - reserved, min: min, max: max)
+      end
+
+      def stack_or_row(*blocks, narrow:, gap: 0)
+        if narrow
+          UI.join_vertical(*blocks, gap: gap)
+        else
+          UI.join_horizontal(*blocks, gap: gap)
+        end
+      end
+
+      def selected_window_start(selected_index:, item_count:, window_size:)
+        count = item_count.to_i
+        size = [window_size.to_i, 1].max
+        selected = selected_index.to_i.clamp(0, [count - 1, 0].max)
+        max_start = [count - size, 0].max
+
+        (selected - size + 1).clamp(0, max_start)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require "kramdown"
+
+module Charming
+  module Presentation
+    module Markdown
+      class Renderer
+        DEFAULT_RULE_WIDTH = 40
+
+        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
+
+        def render
+          document = Kramdown::Document.new(content.to_s)
+          render_blocks(document.root.children)
+        end
+
+        private
+
+        attr_reader :content, :width, :theme
+
+        def render_blocks(elements, list_depth: 0, width: @width)
+          elements.filter_map do |element|
+            rendered = render_block(element, list_depth: list_depth, width: width)
+            rendered unless rendered.to_s.empty?
+          end.join("\n\n")
+        end
+
+        def render_block(element, list_depth: 0, width: @width)
+          case element.type
+          when :p
+            wrap(render_inlines(element.children), width: width)
+          when :header
+            render_header(element, width: width)
+          when :blockquote
+            render_blockquote(element, list_depth: list_depth, width: width)
+          when :ul
+            render_list(element, ordered: false, list_depth: list_depth, width: width)
+          when :ol
+            render_list(element, ordered: true, list_depth: list_depth, width: width)
+          when :li
+            render_blocks(element.children, list_depth: list_depth, width: width)
+          when :codeblock
+            render_codeblock(element)
+          when :hr
+            render_rule(width: width)
+          when :blank
+            nil
+          else
+            render_unknown(element, list_depth: list_depth, width: width)
+          end
+        end
+
+        def render_unknown(element, list_depth:, width:)
+          return wrap(element.value.to_s, width: width) if element.children.empty?
+
+          render_blocks(element.children, list_depth: list_depth, width: width)
+        end
+
+        def render_header(element, width:)
+          rendered = wrap(render_inlines(element.children), width: width)
+          style = if element.options[:level].to_i == 1
+            style_for(:markdown_heading, fallback: theme_style(:title))
+          else
+            style_for(:markdown_subheading, fallback: theme_style(:title))
+          end
+          style.render(rendered)
+        end
+
+        def render_blockquote(element, list_depth:, width:)
+          quote_width = width ? [width - 2, 1].max : nil
+          rendered = render_blocks(element.children, list_depth: list_depth, width: quote_width)
+          border = style_for(:markdown_quote_border, fallback: theme_style(:border)).render("|")
+          quote_style = style_for(:markdown_quote, fallback: theme_style(:muted))
+
+          rendered.lines(chomp: true).map do |line|
+            "#{border} #{quote_style.render(line)}"
+          end.join("\n")
+        end
+
+        def render_list(element, ordered:, list_depth:, width:)
+          element.children.each_with_index.map do |item, index|
+            marker = ordered ? "#{ordered_start(element) + index}." : "-"
+            render_list_item(item, marker: marker, list_depth: list_depth, width: width)
+          end.join("\n")
+        end
+
+        def render_list_item(element, marker:, list_depth:, width:)
+          indent = "  " * list_depth
+          first_prefix = "#{indent}#{marker} "
+          rest_prefix = "#{indent}#{" " * (marker.length + 1)}"
+          item_width = width ? [width - UI::Width.measure(first_prefix), 1].max : nil
+          body = render_blocks(element.children, list_depth: list_depth + 1, width: item_width)
+
+          body.lines(chomp: true).each_with_index.map do |line, index|
+            "#{index.zero? ? first_prefix : rest_prefix}#{line}"
+          end.join("\n")
+        end
+
+        def ordered_start(element)
+          element.options.fetch(:start, 1).to_i
+        end
+
+        def render_codeblock(element)
+          code = element.value.to_s
+          rendered = if @syntax_highlighting
+            SyntaxHighlighter.new(theme: theme).render(code, language: code_language(element))
+          else
+            style_for(:markdown_code, fallback: theme_style(:warn)).render(code)
+          end
+
+          rendered.lines(chomp: true).map { |line| "  #{line}" }.join("\n")
+        end
+
+        def render_rule(width:)
+          style_for(:markdown_rule, fallback: theme_style(:border)).render("-" * (width || DEFAULT_RULE_WIDTH))
+        end
+
+        def render_inlines(elements)
+          elements.map { |element| render_inline(element) }.join
+        end
+
+        def render_inline(element)
+          case element.type
+          when :text
+            element.value.to_s
+          when :strong
+            style_for(:markdown_strong, fallback: theme_style(:text).bold).render(render_inlines(element.children))
+          when :em
+            style_for(:markdown_emphasis, fallback: theme_style(:text).italic).render(render_inlines(element.children))
+          when :codespan
+            style_for(:markdown_inline_code, fallback: theme_style(:warn)).render(element.value.to_s)
+          when :a
+            render_link(element)
+          when :br
+            "\n"
+          when :entity
+            element.value.respond_to?(:char) ? element.value.char : element.value.to_s
+          else
+            element.children.empty? ? element.value.to_s : render_inlines(element.children)
+          end
+        end
+
+        def render_link(element)
+          label = render_inlines(element.children)
+          href = element.attr["href"].to_s
+          rendered = href.empty? ? label : "#{label} <#{href}>"
+          style_for(:markdown_link, fallback: theme_style(:info).underline).render(rendered)
+        end
+
+        def code_language(element)
+          return element.options[:lang] if element.options[:lang]
+
+          element.attr["class"].to_s[/language-([^\s]+)/, 1]
+        end
+
+        def wrap(value, width:)
+          return value unless width
+
+          value.to_s.lines(chomp: true).map { |line| wrap_line(line, width) }.join("\n")
+        end
+
+        def wrap_line(line, width)
+          return line if UI::Width.measure(line) <= width
+
+          lines = []
+          current = +""
+
+          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
+          end
+
+          lines << current.rstrip unless current.empty?
+          lines.join("\n")
+        end
+
+        def style_for(name, fallback:)
+          return theme.public_send(name) if theme.respond_to?(name)
+
+          fallback
+        end
+
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "rouge"
+
+module Charming
+  module Presentation
+    module Markdown
+      class SyntaxHighlighter
+        def initialize(theme: UI::Theme.default)
+          @theme = theme || UI::Theme.default
+        end
+
+        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
+
+        attr_reader :theme
+
+        def lexer_for(language, code)
+          Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText
+        end
+
+        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
+        end
+
+        def token_name(token)
+          return token.qualname if token.respond_to?(:qualname)
+
+          token.to_s
+        end
+
+        def theme_style(name, fallback: nil)
+          return theme.public_send(name) if theme.respond_to?(name)
+
+          fallback || UI.style
+        end
+      end
+    end
+  end
+end

data/lib/charming/presentation/markdown.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    module Markdown
+    end
+  end
+end

data/lib/charming/presentation/template_view.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    class TemplateView < View
+      def initialize(template:, namespace: nil, **assigns)
+        super(**assigns)
+        @template = template
+        @namespace = namespace
+      end
+
+      def render
+        template.render(self).to_s
+      end
+
+      def template_binding
+        return binding unless namespace
+
+        namespace.module_eval("->(view) { view.instance_eval { binding } }", __FILE__, __LINE__).call(self)
+      end
+
+      private
+
+      attr_reader :template, :namespace
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+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
+      end
+    end
+  end
+end

data/lib/charming/presentation/templates.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Charming
+  module Presentation
+    module Templates
+      ResolvedTemplate = Data.define(:path, :handler) do
+        def render(view)
+          handler.render(path, view)
+        end
+      end
+
+      MissingTemplateError = Class.new(Error)
+
+      class << self
+        def register(extension, handler)
+          handlers[extension] = handler
+        end
+
+        def resolve(name, root: nil)
+          views_root = File.join(root || Dir.pwd, "app", "views")
+          searched_paths = candidate_paths(views_root, name.to_s)
+
+          searched_paths.each do |path|
+            next unless File.file?(path)
+
+            return ResolvedTemplate.new(path: path, handler: handler_for(path))
+          end
+
+          raise MissingTemplateError, "Missing template #{name.inspect}. Searched: #{searched_paths.join(", ")}"
+        end
+
+        def handlers
+          @handlers ||= {}
+        end
+
+        private
+
+        def candidate_paths(views_root, name)
+          path = File.expand_path(name, views_root)
+          return [path] if handler_for(path)
+
+          handlers.keys.map { |extension| "#{path}#{extension}" }
+        end
+
+        def handler_for(path)
+          handlers.find { |extension, _handler| path.end_with?(extension) }&.last
+        end
+      end
+    end
+  end
+end

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

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