ohhighmark 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f310c11edeb0bc2c0b7ce0871e3fce1bac23bc79d8bc06b6ae2a5612628afc9e
+  data.tar.gz: 1221b0fc060bc43e0a5c771e3dc51008ff41a6b883b977c926d59e34b3c49f21
+SHA512:
+  metadata.gz: 6da2f05b511406d14d93c64052b392220cf3ccb31cffef58b28a35daf940cf7275e09dbfe1a3dfcf863f92bba6f37a75d58d79d4726e3d9d700c7f3cb45a002b
+  data.tar.gz: a0a97b44f53f5f52ee45eeea9ae8bb90a9cfc453c6a4d0ef60740a7380a04313fb1390e944ae0c1fa38f02f76e9c9c53991f945853c661870147eb8d2d05b72e

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Knight
+
+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,346 @@
+# OhHighMark :wave:
+
+**A Ruby library for syntax highlighting markdown code with beautiful, customizable output.**
+
+OhHighMark provides colorful and readable markdown syntax visualization by tokenizing and rendering markdown with appropriate CSS classes. It displays each line in a table row with line numbers, ensuring perfect alignment and preserving all whitespace.
+
+## Overview
+
+### Key Features
+
+- **Table-based layout** - Each line in its own table row with separate cells for line numbers and code
+- **Perfect alignment** - Line numbers stay aligned with code content, even with long lines
+- **Whitespace preservation** - Uses `white-space: pre` to maintain exact spacing and indentation
+- **Non-selectable line numbers** - Prevents copy/paste issues
+- **Comprehensive markdown support** - Headings, text formatting, code, links, lists, tables, quotes, and more
+- **Inline markdown in lists** - Bold, italic, links, and other inline syntax work within list items
+- **Customizable styling** - Pre-built CSS with CSS variables for easy theming
+- **Semantic HTML** - Clean, semantic markup with `data-line-number` on rows
+- **Flexible rules** - Customizable tokenization rules via DSL
+
+### Supported Markdown Syntax
+
+OhHighMark supports all standard markdown elements:
+
+**Text Formatting:**
+- **Bold**: `**text**`
+- _Italic_: `_text_`
+- ***Bold-Italic***: `***text***`
+- ~~Strikethrough~~: `~~text~~`
+
+**Headings:** `# H1` through `###### H6`
+
+**Code:**
+- Inline: `` `code` ``
+- Fenced blocks: ` ``` ` ... ` ``` `
+
+**Links:**
+- Standard: `[text](url)`
+- Auto-links: `<http://url>`
+
+**Lists:**
+- Unordered: `- item`, `* item`, `+ item`
+- Nested: `  - nested item`
+- **With inline markdown**: `- **bold** with [link](url)`
+
+**Tables:**
+```markdown
+| Column 1 | Column 2 |
+| -------- | -------- |
+| Value 1  | Value 2  |
+```
+
+**Other:**
+- Horizontal rules: `---`
+- Block quotes: `> quote`
+- Escaped characters: `\*`, `\[`, `\]`, `\\`
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'ohhighmark'
+```
+
+Then run:
+
+```bash
+$ bundle install
+```
+
+Or install directly:
+
+```bash
+$ gem install ohhighmark
+```
+
+## Usage
+
+### Basic Usage
+
+```ruby
+require 'ohhighmark'
+
+# Use the helper in your views (Rails, Middleman, etc.)
+include OhHighMark::Helper
+
+# In your ERB view:
+<%= highlight_markdown do %>
+  # Your Markdown Here
+  
+  This is **bold** and this is _italic_.
+  
+  - List item with [link](https://example.com)
+  - Item with `inline code`
+<% end %>
+```
+
+### Direct API Usage
+
+```ruby
+require 'ohhighmark'
+
+markdown = <<~MD
+  # Welcome
+  
+  This is **bold** and ~~strikethrough~~.
+MD
+
+# Create highlighter and process
+highlighter = OhHighMark::Highlighter.new
+html_output = highlighter.process_lines_with_linenums(markdown)
+```
+
+### Advanced: Custom Rules
+
+```ruby
+# Define custom markdown rules
+ruleset = OhHighMark::RuleSet.new
+OhHighMark::MarkdownRules.apply(ruleset)
+
+# Add custom rules if needed
+ruleset.add(:custom_pattern, /your_regex/, :inline)
+
+# Create tokenizer and renderer
+tokenizer = OhHighMark::Tokenizer.new(ruleset.rules)
+tokens = tokenizer.tokenize(markdown_text)
+
+renderer = OhHighMark::Renderer.new
+html = renderer.render(tokens)
+```
+
+## Styling
+
+OhHighMark includes a pre-built CSS stylesheet with CSS custom properties (CSS variables) for easy customization.
+
+### Including the Stylesheet
+
+**Rails (Asset Pipeline / Sprockets):**
+
+In `application.css`:
+```css
+/*
+ *= require ohhighmark/ohhighmark
+ */
+```
+
+Or in `application.scss`:
+```scss
+@import 'ohhighmark/ohhighmark';
+```
+
+**Rails (Propshaft / Importmap):**
+
+Copy the stylesheet:
+```bash
+$ cp $(bundle show ohhighmark)/app/assets/stylesheets/ohhighmark/ohhighmark.css app/assets/stylesheets/
+```
+
+Link in your layout:
+```erb
+<%= stylesheet_link_tag "ohhighmark" %>
+```
+
+**Middleman:**
+
+Copy the stylesheet:
+```bash
+$ cp $(bundle show ohhighmark)/app/assets/stylesheets/ohhighmark/ohhighmark.css source/stylesheets/
+```
+
+Then import it in your main stylesheet.
+
+**Standalone / Other Frameworks:**
+
+Find the stylesheet in the gem:
+```bash
+$ bundle show ohhighmark
+# Copy app/assets/stylesheets/ohhighmark/ohhighmark.css to your project
+```
+
+### Customizing Colors
+
+Override CSS variables **after** including the OhHighMark stylesheet:
+
+```css
+:root {
+  /* Text and background */
+  --ohm-text-color: #ffffff;
+  --ohm-background-color: #1a1a1a;
+  --ohm-linenos-color: #666666;
+  --ohm-linenos-bg-color: #1a1a1a;
+  
+  /* Syntax colors */
+  --ohm-yellow: #ffff00;        /* H1 headings */
+  --ohm-orange: #ff8000;        /* H2 headings */
+  --ohm-purple: #ff00ff;        /* H3 headings */
+  --ohm-cyan: #00ffff;          /* H4-H6 headings */
+  --ohm-blue: #0080ff;          /* Links */
+  --ohm-intense-blue: #0040ff;  /* Link hover */
+  --ohm-green: #00ff00;         /* Quotes, lists */
+  --ohm-gray: #808080;          /* Horizontal rules */
+  --ohm-grayish: #999999;       /* Table borders */
+  
+  /* Table highlighting */
+  --ohm-table-bg: rgba(255, 248, 197, 0.2);
+  
+  /* Font */
+  --ohm-monospace-font: "Courier New", monospace;
+}
+```
+
+**Dark Theme Example:**
+```css
+:root {
+  --ohm-text-color: #e0e0e0;
+  --ohm-background-color: #0d1117;
+  --ohm-linenos-bg-color: #0d1117;
+  --ohm-linenos-color: #6e7681;
+  --ohm-blue: #4a9eff;
+  --ohm-green: #7cfc00;
+  --ohm-yellow: #ffd700;
+  --ohm-orange: #ff6b35;
+}
+```
+
+**Light Theme Example:**
+```css
+:root {
+  --ohm-text-color: #333333;
+  --ohm-background-color: #ffffff;
+  --ohm-linenos-bg-color: #f6f8fa;
+  --ohm-linenos-color: #57606a;
+  --ohm-blue: #0969da;
+  --ohm-green: #1a7f37;
+  --ohm-yellow: #b8860b;
+  --ohm-orange: #d2691e;
+}
+```
+
+### HTML Structure
+
+OhHighMark generates semantic HTML with clean structure:
+
+```html
+<div class="ohhighmark">
+  <table class="highlight">
+    <tbody>
+      <!-- Regular content row -->
+      <tr data-line-number="1">
+        <td class="blob-num">1</td>
+        <td class="blob-code"><span class="md-h1"># Heading</span></td>
+      </tr>
+      
+      <!-- Row with text -->
+      <tr data-line-number="2">
+        <td class="blob-num">2</td>
+        <td class="blob-code">Some text with <span class="md-bold">**bold**</span></td>
+      </tr>
+      
+      <!-- Table row (has table-line class) -->
+      <tr class="table-line" data-line-number="3">
+        <td class="blob-num">3</td>
+        <td class="blob-code"><span class="md-table-pipe">|</span> Col 1 <span class="md-table-pipe">|</span> Col 2 <span class="md-table-pipe">|</span></td>
+      </tr>
+    </tbody>
+  </table>
+</div>
+```
+
+**Key Structure Points:**
+- `data-line-number` attribute on `<tr>` for easy row targeting
+- `.blob-num` cell contains line number
+- `.blob-code` cell contains formatted content
+- `.table-line` class added to rows that are part of markdown tables
+- Markdown syntax wrapped in `<span>` elements with `.md-*` classes
+
+### CSS Classes Reference
+
+**Container & Layout:**
+- `.ohhighmark` - Main container div
+- `table.highlight` - Table element containing all lines
+- `.blob-num` - Line number cell (`user-select: none` prevents copying)
+- `.blob-code` - Code content cell (uses `white-space: pre`)
+- `.table-line` - Added to `<tr>` for markdown table rows
+
+**Markdown Syntax Classes:**
+- `.md-h1` through `.md-h6` - Heading levels 1-6
+- `.md-bold` - Bold text (`**text**`)
+- `.md-italic` - Italic text (`_text_`)
+- `.md-em` - Bold-italic emphasis (`***text***`)
+- `.md-strikethrough` - Strikethrough (`~~text~~`)
+- `.md-code` - Inline code (`` `code` ``)
+- `.md-link` - Standard links (`[text](url)`)
+- `.md-autolink` - Auto-linked URLs (`<http://url>`)
+- `.md-li` - List item markers
+- `.md-hr` - Horizontal rules (`---`)
+- `.md-fence` - Fenced code block delimiters
+- `.md-codeblock` - Content within fenced code blocks
+- `.md-table-pipe` - Table pipe characters (`|`)
+- `.md-table-dash` - Table separator rows (`---`)
+- `.md-quote` - Block quotes (`> text`)
+
+### Critical CSS Requirements
+
+**The `.blob-code` cell MUST have `white-space: pre`** to preserve whitespace and prevent wrapping:
+
+```css
+.ohhighmark td.blob-code {
+  white-space: pre;  /* REQUIRED - preserves all whitespace */
+  font-family: ui-monospace, monospace;
+  line-height: 20px;
+}
+```
+
+### Frontend JavaScript Integration
+
+Target rows by line number:
+
+```javascript
+// Select a specific line
+const row = document.querySelector('[data-line-number="5"]');
+
+// Highlight a line
+row.style.backgroundColor = 'rgba(255, 255, 0, 0.2)';
+
+// Get all table rows
+const tableRows = document.querySelectorAll('tr[data-line-number]');
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome!
+
+### Development Setup
+
+```bash
+$ git clone https://github.com/viacoffee/ohhighmark.git
+$ cd ohhighmark
+$ bundle install
+$ rspec  # Run tests
+```
+
+## License
+
+This gem is available as open source under the terms of the [MIT License](LICENSE).

data/app/assets/stylesheets/ohhighmark/ohhighmark.css

@@ -0,0 +1,171 @@
+/**
+ * OhHighMark Stylesheet
+ * 
+ * CSS custom properties for easy customization.
+ * Override these variables to customize the color scheme.
+ */
+
+:root {
+  /* Colors used by OhHighMark */
+  --ohm-text-color: #d8dee9;           /* Main text color */
+  --ohm-background-color: #2B303B;      /* Background color */
+  --ohm-linenos-color: #3b414d;         /* Line numbers color */
+  --ohm-linenos-bg-color: #2B303B;      /* Line numbers background */
+  --ohm-gray: #4c566a;                  /* Gray for HR */
+  --ohm-green: #a3be8c;                 /* Green for quotes and lists */
+  --ohm-grayish: #667084;               /* Light gray for tables */
+  --ohm-blue: #81a1c1;                  /* Blue for links */
+  --ohm-intense-blue: #5e81ac;          /* Darker blue for link hover */
+  --ohm-yellow: #ebcb8b;                /* Yellow for h1 */
+  --ohm-orange: #d08770;                /* Orange for h2 */
+  --ohm-purple: #b48ead;                /* Purple for h3 */
+  --ohm-cyan: #8fbcbb;                  /* Cyan for h4-h6 */
+  --ohm-table-bg: rgba(255, 248, 197, 0.2); /* Table row highlight */
+  
+  /* Font family for monospace content */
+  --ohm-monospace-font: ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, "Liberation Mono", monospace;
+}
+
+.ohhighmark {
+  color: var(--ohm-text-color);
+  background-color: var(--ohm-background-color);
+  padding: 10px;
+  margin: 0;
+}
+
+/* Table structure */
+.ohhighmark table.highlight {
+  border-collapse: collapse;
+  width: 100%;
+  font-family: var(--ohm-monospace-font);
+  font-size: 12px;
+  line-height: 20px;
+}
+
+.ohhighmark table.highlight tr {
+  background: transparent;
+}
+
+/* Line number cell */
+.ohhighmark td.blob-num {
+  padding: 0 10px;
+  width: 1%;
+  min-width: 30px;
+  font-family: var(--ohm-monospace-font);
+  font-size: 12px;
+  line-height: 18px;
+  color: var(--ohm-linenos-color);
+  text-align: right;
+  white-space: nowrap;
+  vertical-align: top;
+  user-select: none;
+  background-color: var(--ohm-linenos-bg-color);
+}
+
+/* Code content cell - CRITICAL: white-space: pre preserves spaces and line breaks */
+.ohhighmark td.blob-code {
+  padding: 0 10px;
+  color: var(--ohm-text-color);
+  vertical-align: top;
+  overflow: visible;
+  white-space: pre-wrap;           /* IMPORTANT: Preserves whitespace */
+  font-family: var(--ohm-monospace-font);
+  font-size: 12px;
+  line-height: 18px;
+}
+
+/* Table row highlighting */
+.ohhighmark tr.table-line {
+  background: var(--ohm-table-bg);
+}
+
+/* Headings */
+.ohhighmark .md-h1 {
+  color: var(--ohm-yellow);
+  font-weight: bold;
+}
+
+.ohhighmark .md-h2 {
+  color: var(--ohm-orange);
+  font-weight: bold;
+}
+
+.ohhighmark .md-h3 {
+  color: var(--ohm-purple);
+  font-weight: bold;
+}
+
+.ohhighmark .md-h4,
+.ohhighmark .md-h5,
+.ohhighmark .md-h6 {
+  color: var(--ohm-cyan);
+  font-weight: bold;
+}
+
+/* Text styles */
+.ohhighmark .md-bold {
+  font-weight: 700;
+}
+
+.ohhighmark .md-italic {
+  font-style: italic;
+}
+
+.ohhighmark .md-em {
+  font-weight: 700;
+  font-style: italic;
+}
+
+.ohhighmark .md-strikethrough {
+  text-decoration: line-through;
+}
+
+.ohhighmark .md-quote {
+  font-style: italic;
+  color: var(--ohm-green);
+}
+
+/* Horizontal rule */
+.ohhighmark .md-hr {
+  color: var(--ohm-gray);
+}
+
+/* Lists */
+.ohhighmark .md-li {
+  color: var(--ohm-green);
+}
+
+/* Links */
+.ohhighmark .md-link,
+.ohhighmark .md-autolink {
+  color: var(--ohm-blue);
+  text-decoration: underline;
+  text-underline-offset: 2px;
+}
+
+.ohhighmark .md-link:link,
+.ohhighmark .md-link:visited,
+.ohhighmark .md-autolink:link,
+.ohhighmark .md-autolink:visited {
+  color: var(--ohm-blue);
+}
+
+.ohhighmark .md-link:hover,
+.ohhighmark .md-link:focus,
+.ohhighmark .md-autolink:hover,
+.ohhighmark .md-autolink:focus {
+  color: var(--ohm-intense-blue);
+}
+
+/* Tables */
+.ohhighmark .md-table-pipe,
+.ohhighmark .md-table-dash {
+  color: var(--ohm-grayish);
+}
+
+/* Code blocks and fences */
+.ohhighmark .md-fence,
+.ohhighmark .md-codeblock,
+.ohhighmark .md-code {
+  font-family: var(--ohm-monospace-font);
+}

data/lib/ohhighmark/dsl.rb

@@ -0,0 +1,14 @@
+module OhHighMark
+  module DSL
+    private
+
+    # DSL methods for defining rules
+    def define_inline(name, regex, **options)
+      add(name, regex, kind: :inline, **options)
+    end
+
+    def define_block(name, regex, **options)
+      add(name, regex, kind: :block, **options)
+    end
+  end
+end

data/lib/ohhighmark/helper.rb

@@ -0,0 +1,23 @@
+module OhHighMark
+  module Helper
+    def highlight_markdown(&block)
+      raise ArgumentError, "block required" unless block
+
+      content =
+        if respond_to?(:capture)
+          capture(&block)
+        else
+          block.call.to_s
+        end
+
+      highlighter = Highlighter.new
+      html = highlighter.process_lines_with_linenums(content)
+
+      if respond_to?(:concat)
+        concat(html)
+      else
+        respond_to?(:raw) ? raw(html) : html
+      end
+    end
+  end
+end

data/lib/ohhighmark/highlighter.rb

@@ -0,0 +1,76 @@
+module OhHighMark
+  class Highlighter
+    def initialize
+      @ruleset   = RuleSet.new
+      MarkdownRules.apply(@ruleset)
+      @tokenizer = Tokenizer.new(@ruleset.rules)
+      @renderer  = Renderer.new
+      @in_fence  = false
+    end
+
+    # Output table with one row per line
+    def process_lines_with_linenums(content)
+      lines = content.each_line.to_a
+      current_line_num = 1
+      rows = []
+
+      lines.each do |line|
+        # Process the line
+        processed_html = process_line(line)
+        
+        # Check if this is a table line
+        is_table_line = line_is_table?(line)
+
+        # create table row
+        rows << create_table_row(current_line_num, processed_html, is_table_line)
+        current_line_num += 1
+      end
+      
+      %(<div class="ohhighmark"><table class="highlight"><tbody>#{rows.join}</tbody></table></div>)
+    end
+
+    def process_line(line)
+      if fence_rule&.regex&.match?(line)
+        @in_fence = !@in_fence
+        return wrap("md-fence", line)
+      end
+
+      return wrap("md-codeblock", line) if @in_fence
+
+      tokens = @tokenizer.tokenize(line) # block and inline tokens
+      @renderer.render(tokens)
+    end
+
+    private
+
+    def fence_rule
+      @ruleset.block.find { |r| r.name == :fence }
+    end
+
+    def wrap(klass, text)
+      %(<span class="#{klass}">#{CGI.escapeHTML(text)}</span>)
+    end
+    
+    # Checks if a line is part of a markdown table
+    def line_is_table?(line)
+      # Check against table rules
+      table_dash_rule = @ruleset.inline.find { |r| r.name == :table_dash }
+      table_syntax_rule = @ruleset.inline.find { |r| r.name == :table_syntax }
+      
+      (table_dash_rule&.regex&.match?(line) || table_syntax_rule&.regex&.match?(line))
+    end
+    
+    # Creates a single table row with line number and code cells
+    def create_table_row(line_num, code_html, is_table_line = false)
+      line_num_display = line_num.to_s
+
+      # Only include data-line-number attribute if there's an actual line number
+      data_attr = line_num_display.empty? ? '' : %( data-line-number="#{line_num}")
+      
+      # Add table-line class if this is a table row
+      tr_class = is_table_line ? ' class="table-line"' : ''
+      
+      %(<tr#{tr_class}#{data_attr}><td class="blob-num">#{line_num_display}</td><td class="blob-code">#{code_html}</td></tr>)
+    end
+  end
+end

data/lib/ohhighmark/markdown_rules.rb

@@ -0,0 +1,39 @@
+module OhHighMark
+  module MarkdownRules
+    def self.apply(ruleset)
+      ruleset.extend(DSL)
+
+      ruleset.instance_eval do
+        # Block rules
+        define_block :fence,   /^```/
+        # Heading rules for levels 1-6
+        (1..6).each do |level|
+          define_block "h#{level}".to_sym,
+            /^#{'#' * level}\s+.+$/ ,
+            class: "md-h#{level}"
+        end
+        # HR
+        define_block :hr, /^---$/
+        # Lists
+        define_block :list_item, /^(\s*)([-*+])(\s+.+)$/
+
+        # Inline rules - order matters! More specific patterns first
+        define_inline :code,       /`([^`]+)`/
+        # Emphasis (must be checked before bold to handle ***text***)
+        define_inline :em,         /\*\*\*(.+?)\*\*\*/
+        define_inline :bold,       /\*\*(.+?)\*\*/
+        define_inline :italic,     /\_(.+?)\_/
+        define_inline :strikethrough, /~~(.+?)~~/
+        define_inline :autolink,   /<(https?:\/\/[^\s>]+)>/
+        # Escaped characters - before other patterns that might match them
+        define_inline :escape,     /\\([\*\[\]\\])/
+        define_inline :quote,      /\"(.+?)\"/
+        define_inline :link,       /\[(.+?)\]\((.+?)\)/
+        # Table separator line (eg: | ---- | ------ |)
+        define_inline :table_dash, /^\|(?:\s*-+\s*\|)+\s*$/
+        # Table Column/header content: | something |
+        define_inline :table_syntax, /^\|.*?\|.*$/
+      end
+    end
+  end
+end

data/lib/ohhighmark/renderer.rb

@@ -0,0 +1,79 @@
+require "cgi"
+
+module OhHighMark
+  class Renderer
+    def render(tokens)
+      tokens.map { |t| render_token(t) }.join
+    end
+
+    private
+
+    def render_token(token)
+      case token.type
+      when :text
+        escape(token.raw)
+      when :escape
+        # For escaped characters, just render the character without the backslash
+        token.raw[1..-1]
+      when :autolink
+        wrap_autolink(token)
+      when :link, :list_item, :table_syntax, :table_dash
+        send("wrap_#{token.type}", token)
+      else
+        wrap("md-#{token.type}", token.raw)
+      end
+    end
+
+    def escape(text)
+      CGI.escapeHTML(text)
+    end
+
+    def wrap(klass, text)
+      %(<span class="#{klass}">#{escape(text)}</span>)
+    end
+
+    def wrap_table_syntax(token)
+      token.raw.gsub(/\|/) do |pipe|
+        wrap("md-table-pipe", pipe)
+      end
+    end
+
+    def wrap_table_dash(token)
+      wrap("md-table-dash", token.raw)
+    end
+
+    def wrap_list_item(token)
+      indent, flag = [
+        token.meta[:indent],
+        token.meta[:flag]
+      ].map(&method(:escape))
+      
+      # Render inline tokens in the rest content
+      rest_html = if token.meta[:rest_tokens] && !token.meta[:rest_tokens].empty?
+        token.meta[:rest_tokens].map { |t| render_token(t) }.join
+      else
+        escape(token.meta[:rest])
+      end
+
+      %(#{indent}<span class="md-li">#{flag}</span>#{rest_html})
+    end
+
+    def wrap_link(token)
+      raw, url = [
+        token.raw,
+        token.url
+      ].map(&method(:escape))
+
+      %(<a href="#{url}" target="_blank" class="md-link">#{raw}</a>)
+    end
+    
+    def wrap_autolink(token)
+      raw, url = [
+        token.raw,
+        token.url
+      ].map(&method(:escape))
+
+      %(<a href="#{url}" target="_blank" class="md-autolink">#{raw}</a>)
+    end
+  end
+end

data/lib/ohhighmark/rule.rb

@@ -0,0 +1,3 @@
+module OhHighMark
+  Rule = Struct.new(:name, :regex, :kind, :options, keyword_init: true)
+end

data/lib/ohhighmark/ruleset.rb

@@ -0,0 +1,23 @@
+module OhHighMark
+  class RuleSet
+    attr_reader :rules
+  
+    def initialize
+      @rules = []
+    end
+  
+    # Public readers for consumers
+    def inline
+      @rules.select { |r| r.kind == :inline }
+    end
+  
+    def block
+      @rules.select { |r| r.kind == :block }
+    end
+  
+    # Internal method used by DSL
+    def add(name, regex, kind:, **options)
+      @rules << Rule.new(name: name, regex: regex, kind: kind, options: options)
+    end
+  end
+end

data/lib/ohhighmark/token.rb

@@ -0,0 +1,20 @@
+module OhHighMark
+  Token = Struct.new(:type, :raw, :meta, keyword_init: true) do
+    # Convenience accessors
+    def url
+      meta && meta[:url]
+    end
+
+    def flag
+      meta && meta[:flag]
+    end
+
+    def rest
+      meta && meta[:rest]
+    end
+
+    def indent
+      meta && meta[:indent]
+    end
+  end
+end

data/lib/ohhighmark/tokenizer.rb

@@ -0,0 +1,129 @@
+module OhHighMark
+  class Tokenizer
+    def initialize(rules)
+      @block_rules  = rules.select { |r| r.kind == :block }
+      @inline_rules = rules.select { |r| r.kind == :inline }
+    end
+
+    def tokenize_line(line)
+      tokens = []
+      rest = line.dup
+
+      #block rules first
+      @block_rules.each do |rule|
+        if (m = rule.regex.match(line))
+          tokens << build_token(rule, m)
+          return tokens # whole line consumed by block
+        end
+      end
+
+      # process inline rules
+      rest = line.dup
+      until rest.empty?
+        matched = false
+
+        @inline_rules.each do |rule|
+          if (m = rule.regex.match(rest))
+            # emit text before match
+            if m.begin(0) > 0
+              tokens << Token.new(type: :text, raw: rest[0...m.begin(0)])
+            end
+
+            # emit matched token
+            tokens << build_token(rule, m)
+
+            # slice matched portion
+            rest = rest[m.end(0)..] || ""
+            matched = true
+            break
+          end
+        end
+
+        unless matched
+          tokens << Token.new(type: :text, raw: rest)
+          break
+        end
+      end
+
+      tokens
+    end
+
+    def tokenize(content)
+      content.each_line.flat_map { |line| tokenize_line(line.chomp) }
+    end
+
+    private
+
+    def build_token(rule, match)
+      case rule.name
+      when :link
+        Token.new(
+          type: :link,
+          raw: match[0], # "[text](url)"
+          meta: { url: match[2] }
+        )
+      when :autolink
+        Token.new(
+          type: :autolink,
+          raw: match[0], # "<http://url>"
+          meta: { url: match[1] }
+        )
+      when :escape
+        Token.new(
+          type: :escape,
+          raw: match[0]
+        )
+      when :list_item
+        Token.new(
+          type: rule.name,
+          raw: match[0],
+          meta: {
+            indent: match[1],
+            flag: match[2],
+            rest: match[3],
+            rest_tokens: tokenize_inline(match[3]) # Process inline tokens in rest
+          }
+        )
+      else
+        Token.new(
+          type: rule.name,
+          raw: match[0]
+        )
+      end
+    end
+
+    # Process inline rules on a text fragment
+    def tokenize_inline(text)
+      tokens = []
+      rest = text.dup
+
+      until rest.empty?
+        matched = false
+
+        @inline_rules.each do |rule|
+          if (m = rule.regex.match(rest))
+            # emit text before match
+            if m.begin(0) > 0
+              tokens << Token.new(type: :text, raw: rest[0...m.begin(0)])
+            end
+
+            # emit matched token
+            tokens << build_token(rule, m)
+
+            # slice matched portion
+            rest = rest[m.end(0)..] || ""
+            matched = true
+            break
+          end
+        end
+
+        unless matched
+          tokens << Token.new(type: :text, raw: rest)
+          break
+        end
+      end
+
+      tokens
+    end
+  end
+end

data/lib/ohhighmark/version.rb

@@ -0,0 +1,3 @@
+module OhHighMark
+  VERSION = "0.1.0"
+end

data/lib/ohhighmark.rb

@@ -0,0 +1,13 @@
+require_relative "ohhighmark/version"
+require_relative "ohhighmark/rule"
+require_relative "ohhighmark/ruleset"
+require_relative "ohhighmark/dsl"
+require_relative "ohhighmark/token"
+require_relative "ohhighmark/tokenizer"
+require_relative "ohhighmark/renderer"
+require_relative "ohhighmark/markdown_rules"
+require_relative "ohhighmark/highlighter"
+require_relative "ohhighmark/helper"
+
+module OhHighMark
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: ohhighmark
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Knight
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: OhHighMark is a Ruby library for syntax highlighting of markdown code,
+  providing colorful and readable markdown syntax visualization.
+email:
+- david+github@knight.sh
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- app/assets/stylesheets/ohhighmark/ohhighmark.css
+- lib/ohhighmark.rb
+- lib/ohhighmark/dsl.rb
+- lib/ohhighmark/helper.rb
+- lib/ohhighmark/highlighter.rb
+- lib/ohhighmark/markdown_rules.rb
+- lib/ohhighmark/renderer.rb
+- lib/ohhighmark/rule.rb
+- lib/ohhighmark/ruleset.rb
+- lib/ohhighmark/token.rb
+- lib/ohhighmark/tokenizer.rb
+- lib/ohhighmark/version.rb
+homepage: https://github.com/viacoffee/ohhighmark
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/viacoffee/ohhighmark
+  source_code_uri: https://github.com/viacoffee/ohhighmark
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A markdown syntax highlighter
+test_files: []