marvi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 81a8d64fd49b33e6d17b7d1b2bf898bca77b6abb347ec5d4f6844f6b2969b647
+  data.tar.gz: b8020fc1f24ab9806f1dc3d8b94baf4061e6ab329a0dc54598db747465e5c5d7
+SHA512:
+  metadata.gz: decbb5c0688e364d432aced0e156a9b0cdd1d33f3aeaa6c9bba5f7761f1bfd5182e740cc023b956926838261e1d66fa8a90f0666ded886d72dd397010c793ac7
+  data.tar.gz: 5f969855ab9c5d49801bc4675ecd19d4c815a8e49e7532559bc6f46ffc6d76f3ae6f735e6f73c495bee7406ccbfcd091305127f29c00e0d0c859179c3447543b

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-03-17
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"marvi" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["takkanm@gmail.com"](mailto:"takkanm@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Mitsutaka Mimura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,69 @@
+# Marvi
+
+Marvi is a terminal Markdown renderer. It parses Markdown and displays it with ANSI colors and styles directly in your terminal.
+
+## Installation
+
+```bash
+gem install marvi
+```
+
+Or add to your Gemfile:
+
+```bash
+bundle add marvi
+```
+
+## Usage
+
+### CLI
+
+Render a Markdown file:
+
+```bash
+marvi README.md
+```
+
+Read from stdin:
+
+```bash
+cat README.md | marvi
+echo "# Hello **world**" | marvi
+```
+
+### Ruby API
+
+```ruby
+require "marvi"
+
+markdown = File.read("README.md")
+puts Marvi::Renderer.new.render(markdown)
+```
+
+## Supported Markdown elements
+
+- Headings (`#`, `##`, `###`, ...)
+- Bold (`**text**`) and italic (`*text*`)
+- Inline code (`` `code` ``)
+- Code blocks (` ``` `)
+- Unordered and ordered lists
+- Blockquotes (`> text`)
+- Horizontal rules (`---`)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt.
+
+```bash
+bin/setup
+rake test
+bin/console
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/takkanm/marvi.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "standard/rake"
+
+task default: %i[test standard]

data/exe/marvi

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "../lib/marvi"
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: marvi [FILE]\n       cat FILE | marvi"
+  opts.on("-h", "--help", "Show help") do
+    puts opts
+    exit
+  end
+  opts.on("-v", "--version", "Show version") do
+    puts Marvi::VERSION
+    exit
+  end
+end.parse!
+
+markdown = if ARGV.empty?
+  $stdin.read
+else
+  File.read(ARGV[0])
+end
+
+if $stdout.tty?
+  Marvi::Renderer::Curses.new.render(markdown)
+else
+  print Marvi::Renderer::ANSI.new.render(markdown)
+end

data/lib/marvi/ansi.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Marvi
+  module ANSI
+    RESET   = "\e[0m"
+    BOLD    = "\e[1m"
+    ITALIC  = "\e[3m"
+    CYAN    = "\e[36m"
+    YELLOW  = "\e[33m"
+    GREEN   = "\e[32m"
+    MAGENTA = "\e[35m"
+    WHITE   = "\e[37m"
+    BG_DARK = "\e[48;5;236m"
+
+    HEADER_COLORS = [CYAN, GREEN, YELLOW, MAGENTA, WHITE, WHITE].freeze
+  end
+end

data/lib/marvi/ast_walker.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "kramdown"
+require "kramdown-parser-gfm"
+
+module Marvi
+  class ASTWalker
+    HEADER_COLORS = %i[cyan green yellow magenta white white].freeze
+
+    def walk(markdown)
+      doc = Kramdown::Document.new(markdown, input: "GFM")
+      lines = render_block(doc.root)
+      lines.pop while lines.last&.plain_text&.empty?
+      lines
+    end
+
+    private
+
+    def render_block(el, indent: 0, list_type: nil, list_index: nil)
+      case el.type
+      when :root
+        el.children.flat_map { |child| render_block(child) }
+      when :header
+        render_header(el)
+      when :p
+        [RichLine.new(render_inline_children(el)), RichLine.blank]
+      when :ul
+        el.children.flat_map { |child| render_block(child, indent: indent, list_type: :ul) } + [RichLine.blank]
+      when :ol
+        el.children.each_with_index.flat_map do |child, i|
+          render_block(child, indent: indent, list_type: :ol, list_index: i + 1)
+        end + [RichLine.blank]
+      when :li
+        render_li(el, indent: indent, list_type: list_type, list_index: list_index)
+      when :codeblock
+        render_codeblock(el)
+      when :blockquote
+        render_blockquote(el)
+      when :hr
+        [RichLine.new([Span.new(text: "─" * 60, color: :cyan)]), RichLine.blank]
+      when :table
+        render_table(el)
+      when :blank
+        [RichLine.blank]
+      else
+        el.children.flat_map { |child| render_block(child) }
+      end
+    end
+
+    def render_header(el)
+      level = el.options[:level]
+      color = HEADER_COLORS[level - 1]
+      prefix = Span.new(text: "#" * level + " ", bold: true, color: color)
+      content = render_inline_children(el).map do |s|
+        Span.new(text: s.text, bold: true, italic: s.italic, color: s.color || color, bg_color: s.bg_color)
+      end
+      [RichLine.new([prefix] + content), RichLine.blank]
+    end
+
+    def render_li(el, indent:, list_type:, list_index:)
+      bullet = list_type == :ol ? "#{list_index}." : "•"
+      prefix = Span.new(text: "#{"  " * indent}#{bullet} ", color: :cyan)
+      lines = []
+
+      el.children.each do |child|
+        case child.type
+        when :ul, :ol
+          nested = render_block(child, indent: indent + 1, list_type: child.type)
+          nested.pop while nested.last&.plain_text&.empty?
+          lines += nested
+        when :p
+          if lines.empty?
+            lines << RichLine.new([prefix] + render_inline_children(child))
+          else
+            lines += render_block(child)
+          end
+        else
+          if lines.empty?
+            lines << RichLine.new([prefix] + render_inline(child))
+          else
+            lines << RichLine.new(render_inline(child))
+          end
+        end
+      end
+      lines
+    end
+
+    def render_codeblock(el)
+      lang = el.options[:lang]
+      lines = []
+      lines << RichLine.new([Span.new(text: lang, color: :yellow)]) if lang
+      el.value.chomp.split("\n").each do |line|
+        lines << RichLine.new([Span.new(text: "  #{line}", color: :green, bg_color: :dark)])
+      end
+      lines << RichLine.blank
+      lines
+    end
+
+    def render_blockquote(el)
+      inner = el.children.flat_map { |child| render_block(child) }
+      prefix = Span.new(text: "│ ", color: :cyan)
+      inner.map { |line| RichLine.new([prefix] + line.spans) } + [RichLine.blank]
+    end
+
+    def render_table(el)
+      rows = el.children.flat_map(&:children)
+      header_row = el.children.find { |s| s.type == :thead }&.children&.first
+
+      cell_spans = rows.map { |row| row.children.map { |cell| render_inline_children(cell) } }
+      col_widths = cell_spans.map { |row| row.map { |spans| spans.sum { |s| s.text.length } } }
+        .transpose.map { |col| col.max }
+
+      lines = []
+      top = col_widths.map { |w| "─" * (w + 2) }.join("┬")
+      lines << RichLine.new([Span.new(text: "┌#{top}┐", color: :cyan)])
+
+      rows.each_with_index do |row, ri|
+        is_header = row == header_row
+        row_spans = []
+        row.children.each_with_index do |cell, ci|
+          content = cell_spans[ri][ci]
+          plain_len = content.sum { |s| s.text.length }
+          padding = col_widths[ci] - plain_len
+          styled = is_header ? content.map { |s| Span.new(text: s.text, bold: true, color: :cyan) } : content
+          row_spans += [Span.new(text: "│ ", color: :cyan)] + styled + [Span.new(text: " " * (padding + 1))]
+        end
+        row_spans << Span.new(text: "│", color: :cyan)
+        lines << RichLine.new(row_spans)
+
+        if is_header
+          sep = col_widths.map { |w| "─" * (w + 2) }.join("┼")
+          lines << RichLine.new([Span.new(text: "├#{sep}┤", color: :cyan)])
+        end
+      end
+
+      bottom = col_widths.map { |w| "─" * (w + 2) }.join("┴")
+      lines << RichLine.new([Span.new(text: "└#{bottom}┘", color: :cyan)])
+      lines << RichLine.blank
+      lines
+    end
+
+    def render_inline_children(el)
+      el.children.flat_map { |child| render_inline(child) }
+    end
+
+    def render_inline(el)
+      case el.type
+      when :text
+        [Span.new(text: el.value)]
+      when :strong
+        render_inline_children(el).map { |s| Span.new(text: s.text, bold: true, italic: s.italic, color: s.color, bg_color: s.bg_color) }
+      when :em
+        render_inline_children(el).map { |s| Span.new(text: s.text, bold: s.bold, italic: true, color: s.color, bg_color: s.bg_color) }
+      when :codespan
+        [Span.new(text: " #{el.value} ", color: :cyan, bg_color: :dark)]
+      when :br
+        [Span.new(text: "\n")]
+      when :smart_quote
+        char = {lsquo: "'", rsquo: "'", ldquo: "\u201C", rdquo: "\u201D"}.fetch(el.value, "'")
+        [Span.new(text: char)]
+      when :entity
+        [Span.new(text: el.options[:original] || el.value.char)]
+      else
+        render_inline_children(el)
+      end
+    end
+  end
+end

data/lib/marvi/document.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Marvi
+  class Span
+    attr_reader :text, :bold, :italic, :color, :bg_color
+
+    def initialize(text:, bold: false, italic: false, color: nil, bg_color: nil)
+      @text = text
+      @bold = bold
+      @italic = italic
+      @color = color
+      @bg_color = bg_color
+    end
+  end
+
+  class RichLine
+    attr_reader :spans
+
+    def initialize(spans = [])
+      @spans = spans
+    end
+
+    def plain_text
+      @spans.map(&:text).join
+    end
+
+    def self.blank
+      new([])
+    end
+  end
+end

data/lib/marvi/renderer/ansi.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Marvi
+  module Renderer
+    class ANSI
+      COLOR_MAP = {
+        cyan:    Marvi::ANSI::CYAN,
+        green:   Marvi::ANSI::GREEN,
+        yellow:  Marvi::ANSI::YELLOW,
+        magenta: Marvi::ANSI::MAGENTA,
+        white:   Marvi::ANSI::WHITE
+      }.freeze
+
+      def render(markdown)
+        lines = ASTWalker.new.walk(markdown)
+        lines.map { |line| render_line(line) }.join("\n") + "\n"
+      end
+
+      private
+
+      def render_line(line)
+        line.spans.map { |span| render_span(span) }.join
+      end
+
+      def render_span(span)
+        codes = []
+        codes << Marvi::ANSI::BOLD if span.bold
+        codes << Marvi::ANSI::ITALIC if span.italic
+        codes << COLOR_MAP[span.color] if span.color
+        codes << Marvi::ANSI::BG_DARK if span.bg_color == :dark
+        return span.text if codes.empty?
+        "#{codes.join}#{span.text}#{Marvi::ANSI::RESET}"
+      end
+    end
+  end
+end

data/lib/marvi/renderer/curses.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "curses"
+
+module Marvi
+  module Renderer
+    class Curses
+      COLOR_PAIRS = {
+        cyan:          1,
+        green:         2,
+        yellow:        3,
+        magenta:       4,
+        white:         5,
+        green_on_dark: 6,
+        cyan_on_dark:  7
+      }.freeze
+
+      ITALIC_ATTR = (defined?(::Curses::A_ITALIC) ? ::Curses::A_ITALIC : 0)
+
+      def render(markdown)
+        @lines = ASTWalker.new.walk(markdown)
+        @scroll = 0
+
+        ::Curses.init_screen
+        ::Curses.start_color
+        ::Curses.use_default_colors
+        ::Curses.noecho
+        ::Curses.cbreak
+        ::Curses.stdscr.keypad(true)
+        setup_colors
+        draw
+
+        catch(:quit) do
+          loop { handle_key(::Curses.getch) }
+        end
+      ensure
+        ::Curses.close_screen
+      end
+
+      private
+
+      def setup_colors
+        ::Curses.init_pair(COLOR_PAIRS[:cyan],          ::Curses::COLOR_CYAN,    -1)
+        ::Curses.init_pair(COLOR_PAIRS[:green],         ::Curses::COLOR_GREEN,   -1)
+        ::Curses.init_pair(COLOR_PAIRS[:yellow],        ::Curses::COLOR_YELLOW,  -1)
+        ::Curses.init_pair(COLOR_PAIRS[:magenta],       ::Curses::COLOR_MAGENTA, -1)
+        ::Curses.init_pair(COLOR_PAIRS[:white],         ::Curses::COLOR_WHITE,   -1)
+        ::Curses.init_pair(COLOR_PAIRS[:green_on_dark], ::Curses::COLOR_GREEN,   ::Curses::COLOR_BLACK)
+        ::Curses.init_pair(COLOR_PAIRS[:cyan_on_dark],  ::Curses::COLOR_CYAN,    ::Curses::COLOR_BLACK)
+      end
+
+      def handle_key(key)
+        case key
+        when "q", "Q", 27                  then throw :quit
+        when "j", ::Curses::Key::DOWN      then scroll_by(1)
+        when "k", ::Curses::Key::UP        then scroll_by(-1)
+        when "d"                           then scroll_by(page_size / 2)
+        when "u"                           then scroll_by(-page_size / 2)
+        when "f", " ", ::Curses::Key::NPAGE then scroll_by(page_size)
+        when "b", ::Curses::Key::PPAGE     then scroll_by(-page_size)
+        when "g"                           then @scroll = 0; draw
+        when "G"                           then @scroll = max_scroll; draw
+        end
+      end
+
+      def draw
+        ::Curses.clear
+        visible_lines.each_with_index do |line, row|
+          ::Curses.setpos(row, 0)
+          render_line(line)
+        end
+        draw_status_bar
+        ::Curses.refresh
+      end
+
+      def draw_status_bar
+        ::Curses.setpos(::Curses.lines - 1, 0)
+        ::Curses.attron(::Curses.color_pair(COLOR_PAIRS[:cyan])) do
+          top    = @scroll + 1
+          bottom = [@scroll + page_size, @lines.size].min
+          status = " #{top}-#{bottom}/#{@lines.size}  j/k scroll  g/G top/bottom  q quit"
+          ::Curses.addstr(status.ljust(::Curses.cols)[0, ::Curses.cols])
+        end
+      end
+
+      def render_line(line)
+        line.spans.each do |span|
+          render_span(span)
+        rescue ::Curses::Error
+          # ignore write errors at line edge
+        end
+      end
+
+      def render_span(span)
+        attr = build_attr(span)
+        if attr != 0
+          ::Curses.attron(attr) { ::Curses.addstr(span.text) }
+        else
+          ::Curses.addstr(span.text)
+        end
+      end
+
+      def build_attr(span)
+        attr = 0
+        attr |= ::Curses::A_BOLD if span.bold
+        attr |= ITALIC_ATTR      if span.italic
+
+        pair_key = if span.bg_color == :dark
+          span.color == :cyan ? :cyan_on_dark : :green_on_dark
+        elsif span.color
+          span.color
+        end
+
+        attr |= ::Curses.color_pair(COLOR_PAIRS[pair_key]) if pair_key
+        attr
+      end
+
+      def visible_lines
+        @lines[@scroll, page_size] || []
+      end
+
+      def page_size
+        [::Curses.lines - 1, 1].max
+      end
+
+      def max_scroll
+        [@lines.size - page_size, 0].max
+      end
+
+      def scroll_by(delta)
+        @scroll = [[@scroll + delta, 0].max, max_scroll].min
+        draw
+      end
+    end
+  end
+end

data/lib/marvi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Marvi
+  VERSION = "0.1.0"
+end

data/lib/marvi.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "marvi/version"
+require_relative "marvi/ansi"
+require_relative "marvi/document"
+require_relative "marvi/ast_walker"
+require_relative "marvi/renderer/ansi"
+require_relative "marvi/renderer/curses"
+
+module Marvi
+  class Error < StandardError; end
+end

data/sig/marvi.rbs

@@ -0,0 +1,4 @@
+module Marvi
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: marvi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mitsutaka Mimura
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: kramdown-parser-gfm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Renders Markdown with ANSI colors in pipes and an interactive curses
+  pager in TTY.
+email:
+- takkanm@gmail.com
+executables:
+- marvi
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/marvi
+- lib/marvi.rb
+- lib/marvi/ansi.rb
+- lib/marvi/ast_walker.rb
+- lib/marvi/document.rb
+- lib/marvi/renderer/ansi.rb
+- lib/marvi/renderer/curses.rb
+- lib/marvi/version.rb
+- sig/marvi.rbs
+homepage: https://github.com/takkanm/marvi
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/takkanm/marvi
+  source_code_uri: https://github.com/takkanm/marvi
+  changelog_uri: https://github.com/takkanm/marvi/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Terminal Markdown renderer
+test_files: []