textbringer-rouge 0.99.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a83149141e91d7c108286ded2187d565fdaeacc7fa005cae1545b7f5751dd0a1
+  data.tar.gz: 297fad68a36842e58348ecd573c7add6f8af0aef27238dfda95bbd29df150c8e
+SHA512:
+  metadata.gz: 904d5ec8c63b8a4930e0a62cfb46edce29cf6a67d902dde342dd4c6522a77106f3b8a7457c028aba55a7f0283580b1123014cc3af3e86c3a5ffb33af280165e1
+  data.tar.gz: 9d849aa8beb0b3629a7b5199875bcaf9329b23bb1fa103b65a3cafdbe04402667455f05d8571ee2f696a4ee13bb417bb9b5f0c9e6428621747663ccdf3a44161

data/CLAUDE.md

@@ -0,0 +1,188 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## プロジェクト概要
+
+**textbringer-rouge** は、Textbringer エディタに Rouge シンタックスハイライトライブラリを統合し、200+ の言語に自動でシンタックスハイライトを提供する Ruby gem。
+
+### 背景と目的
+
+- 各言語ごとに正規表現ベースのシンタックスルールを手書きするのはメンテコストが高い
+- Rouge（デファクトスタンダードなシンタックスハイライター）を統合することで、上流のメンテに任せられる
+- 一つの gem で全言語をサポートする方が、言語ごとに個別の gem を作るよりも有用
+
+## 開発コマンド
+
+```bash
+# 依存関係のインストール
+bundle install
+
+# テスト実行
+bundle exec rake test
+
+# 単一テストファイルの実行
+bundle exec ruby -I lib:test test/textbringer/rouge_adapter_test.rb
+
+# gem のビルド
+bundle exec rake build
+
+# ローカルインストール
+bundle exec rake install
+```
+
+## アーキテクチャ
+
+### コア設計原則
+
+Textbringer のシンタックスハイライトは、**Window クラス**が Mode クラスの `syntax_table` を直接参照して処理する。Mode の `highlight` メソッドは呼ばれない。そのため、Rouge を使ったカスタムハイライトを実現するには、**Window クラスのモンキーパッチ**が必要。
+
+### Window モンキーパッチの仕組み
+
+```ruby
+# Window#highlight をオーバーライド
+class Window
+  alias_method :original_highlight, :highlight
+
+  def highlight
+    if @buffer.mode.respond_to?(:custom_highlight)
+      @buffer.mode.custom_highlight(self)  # Mode に委譲
+    else
+      original_highlight  # デフォルトの正規表現ベース
+    end
+  end
+end
+```
+
+Mode が `custom_highlight` メソッドを実装していれば、それを使う。そうでなければ従来の正規表現ベースのハイライトにフォールバック。
+
+### RougeAdapter モジュール
+
+Mode に include することで、Rouge を使ったハイライトを提供する:
+
+```ruby
+module RougeAdapter
+  # Window から呼ばれる
+  def custom_highlight(window)
+    lexer = self.class.rouge_lexer.new
+    text = @buffer.to_s
+
+    position = @buffer.point_min
+    lexer.lex(text).each do |token, value|
+      face_name = token_type_to_face(token)
+      # face_name に対応する Face の attributes を適用
+      position += value.bytesize
+    end
+  end
+
+  private
+
+  def token_type_to_face(token)
+    # Rouge のトークン階層を利用してマッピング
+    # Literal.String.Double → Literal.String → Literal
+    # 完全一致がなければ親トークンタイプへフォールバック
+  end
+end
+```
+
+### トークンマッピングの階層
+
+Rouge のトークンは階層構造を持つ（例: `Literal.String.Double` → `Literal.String` → `Literal`）。`token_type_to_face` メソッドは、完全一致がない場合に親トークンタイプへフォールバックすることで、すべてのトークンを適切にマッピングする。
+
+## 技術的な重要ポイント
+
+### 1. パフォーマンス考慮
+
+- Textbringer は `CONFIG[:highlight_buffer_size_limit]` でハイライトするバッファサイズを制限（デフォルト 1024 バイト）
+- Rouge のトークナイズは正規表現より遅い可能性があるため、パフォーマンステストが必要
+- 大きいファイルでは部分的にハイライト
+
+### 2. エラーハンドリング
+
+- Rouge が失敗した場合は、デフォルトの正規表現ベースにフォールバック
+- 不正な構文のファイルでもクラッシュしないようにする
+
+### 3. デフォルトトークンマッピング
+
+標準的な Rouge トークンを Textbringer のフェイスにマッピング:
+
+```ruby
+DEFAULT_TOKEN_MAP = {
+  'Literal.String' => :string,
+  'Literal.Number' => :number,
+  'Keyword' => :keyword,
+  'Comment' => :comment,
+  'Name.Function' => :function_name,
+  'Name.Class' => :type,
+}
+```
+
+### 4. デフォルトフェイス定義
+
+```ruby
+Face.define :string, foreground: "green"
+Face.define :number, foreground: "magenta"
+Face.define :keyword, foreground: "cyan", bold: true
+Face.define :comment, foreground: "brightblack"
+Face.define :function_name, foreground: "blue", bold: true
+Face.define :type, foreground: "yellow", bold: true
+```
+
+## PoC 実装の参照先
+
+完全動作版の PoC 実装は `/Users/yancya/.ghq/github.com/yancya/textbringer-json/` にある:
+
+- `lib/textbringer/rouge_adapter.rb` - RougeAdapter の完全実装
+- `test/rouge_adapter_test.rb` - テストコード（全部通過）
+- 実際に JSON ファイルでハイライトが動作確認済み（79 トークン処理、50 ハイライトエントリ適用）
+
+新しいコードを書く際は、この PoC 実装を参考にすること。
+
+## プロジェクト構造（予定）
+
+```
+textbringer-rouge/
+├── lib/
+│   ├── textbringer/
+│   │   ├── rouge_adapter.rb      # Window モンキーパッチ + RougeAdapter
+│   │   ├── rouge_mode_factory.rb # 動的 Mode 生成
+│   │   └── rouge_config.rb       # デフォルトトークンマッピング
+│   └── textbringer_plugin.rb     # プラグインエントリポイント
+├── test/
+├── README.md
+└── CLAUDE.md
+```
+
+## 自動言語検出の実装方針
+
+ファイル拡張子や shebang から適切な Rouge lexer を選択し、動的に Mode を生成:
+
+```ruby
+class RougeModeFactory
+  def self.create_mode_for_file(filename)
+    lexer = Rouge::Lexer.guess(filename: filename)
+    create_mode_for_lexer(lexer)
+  end
+
+  def self.create_mode_for_lexer(lexer_class)
+    mode_class = Class.new(Textbringer::Mode) do
+      include RougeAdapter
+      use_rouge lexer_class, default_token_map
+    end
+    mode_class
+  end
+end
+```
+
+## テストの方針
+
+- RougeAdapter 自体の単体テスト
+- 複数言語（Ruby, Python, JavaScript など）のハイライトテスト
+- パフォーマンステスト（大きいファイル、トークン数の多いファイル）
+- エラーハンドリングのテスト（不正な構文のファイル）
+
+## 参考リンク
+
+- [Rouge GitHub](https://github.com/rouge-ruby/rouge)
+- [Textbringer GitHub](https://github.com/shugo/textbringer)
+- [Rouge Lexers 一覧](https://github.com/rouge-ruby/rouge/wiki/List-of-supported-languages-and-lexers)

data/LICENSE.txt

@@ -0,0 +1,13 @@
+DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+Version 2, December 2004
+
+Copyright (C) 2026 Shinta Koyanagi <yancya@upec.jp>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. You just DO WHAT THE FUCK YOU WANT TO.

data/README.md

@@ -0,0 +1,110 @@
+# Textbringer Rouge
+
+Rouge syntax highlighting integration for Textbringer.
+
+This plugin integrates the [Rouge](https://github.com/rouge-ruby/rouge) syntax highlighter into [Textbringer](https://github.com/shugo/textbringer), automatically providing syntax highlighting for 200+ programming languages without needing to write regex patterns for each language.
+
+## Features
+
+- **200+ Languages**: Automatic syntax highlighting for all languages supported by Rouge
+- **Zero Configuration**: Works out of the box - just install and open any supported file
+- **Smart Detection**: Automatically detects the language from file extensions
+- **Fallback Support**: Falls back to regex-based highlighting if Rouge fails
+- **Customizable**: Override default token mappings and colors for any language
+
+## Installation
+
+Install the gem by executing:
+
+```bash
+gem install textbringer-rouge
+```
+
+Or add it to your Gemfile:
+
+```ruby
+gem 'textbringer-rouge'
+```
+
+## Usage
+
+The plugin is automatically loaded when you start Textbringer. Simply open any supported file and syntax highlighting will be applied automatically.
+
+### Supported Languages
+
+Rouge supports 200+ languages including:
+
+- **Web**: HTML, CSS, JavaScript, TypeScript, JSX, Vue, Svelte
+- **Programming**: Ruby, Python, Java, C, C++, C#, Go, Rust, Swift, Kotlin
+- **Scripting**: Bash, PowerShell, Perl, Lua, R
+- **Data**: JSON, YAML, TOML, XML, CSV
+- **Markup**: Markdown, reStructuredText, AsciiDoc
+- **Config**: Nginx, Apache, Dockerfile, .gitignore
+- **And many more...**
+
+See the [full list of supported languages](https://github.com/rouge-ruby/rouge/wiki/List-of-supported-languages-and-lexers).
+
+### Customization
+
+You can customize the colors by modifying Textbringer faces in your `~/.textbringer.rb`:
+
+```ruby
+# Change string color
+Textbringer::Face.define :string, foreground: "lightgreen"
+
+# Change keyword color
+Textbringer::Face.define :keyword, foreground: "lightblue", bold: true
+
+# Change comment color
+Textbringer::Face.define :comment, foreground: "gray", italic: true
+```
+
+### Debug Mode
+
+Enable debug logging to troubleshoot issues:
+
+```bash
+TEXTBRINGER_ROUGE_DEBUG=1 txtb your_file.rb
+```
+
+Debug logs will be written to `/tmp/rouge_adapter_debug.log`.
+
+## How It Works
+
+Textbringer Rouge uses a clever technique to integrate Rouge with Textbringer:
+
+1. **Window Monkey Patch**: Extends `Window#highlight` to support custom highlighting methods
+2. **RougeAdapter**: A mixin module that provides Rouge-based highlighting for any Mode
+3. **Token Mapping**: Maps Rouge's semantic tokens to Textbringer's Face system
+4. **Fallback**: Falls back to regex-based highlighting if Rouge encounters errors
+
+This approach maintains compatibility with existing Textbringer modes while adding powerful language support.
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+### Running Tests
+
+```bash
+# Run all tests
+bundle exec rake test
+
+# Run a specific test file
+bundle exec ruby -I lib:test test/textbringer/rouge_adapter_test.rb
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/yancya/textbringer-rouge.
+
+## License
+
+The gem is available as open source under the terms of the [WTFPL](http://www.wtfpl.net/).
+
+## Credits
+
+- [Textbringer](https://github.com/shugo/textbringer) - The Emacs-like text editor in Ruby
+- [Rouge](https://github.com/rouge-ruby/rouge) - The pure Ruby syntax highlighter

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/textbringer/rouge/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Rouge
+    VERSION = "0.99.0"
+  end
+end

data/lib/textbringer/rouge_adapter.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "rouge"
+
+module Textbringer
+  # Monkey patch Window to support custom highlight methods in modes
+  class Window
+    unless method_defined?(:original_highlight)
+      alias_method :original_highlight, :highlight
+
+      def highlight
+        # If the mode has a custom highlight method, use it
+        if @buffer.mode.respond_to?(:custom_highlight)
+          @buffer.mode.custom_highlight(self)
+        else
+          # Otherwise use the default regex-based highlighting
+          original_highlight
+        end
+      end
+    end
+  end
+
+  # Adapter module to use Rouge lexers for syntax highlighting in Textbringer.
+  #
+  # This allows modes to leverage Rouge's extensive language support (200+ languages)
+  # instead of manually writing regex patterns.
+  #
+  # Usage:
+  #   class MyMode < Mode
+  #     include RougeAdapter
+  #     use_rouge Rouge::Lexers::JSON, {
+  #       'Literal.String' => :string,
+  #       'Literal.Number' => :number,
+  #     }
+  #   end
+  module RougeAdapter
+    DEBUG = ENV["TEXTBRINGER_ROUGE_DEBUG"] == "1"
+
+    attr_accessor :rouge_lexer, :token_map
+
+    def custom_highlight(window)
+      window.instance_variable_set(:@highlight_on, {})
+      window.instance_variable_set(:@highlight_off, {})
+
+      if DEBUG
+        File.open("/tmp/rouge_adapter_debug.log", "a") do |f|
+          f.puts "[#{Time.now}] RougeAdapter#custom_highlight called"
+          f.puts "  has_colors: #{Window.class_variable_get(:@@has_colors)}"
+          f.puts "  syntax_highlight: #{CONFIG[:syntax_highlight]}"
+          f.puts "  binary: #{@buffer.binary?}"
+          f.puts "  buffer: #{@buffer.name}"
+        end
+      end
+
+      return if !Window.class_variable_get(:@@has_colors) || !CONFIG[:syntax_highlight] || @buffer.binary?
+
+      # Use instance-level lexer if available, otherwise use class-level
+      lexer_class = @rouge_lexer || self.class.rouge_lexer
+      lexer = lexer_class&.new
+
+      if DEBUG
+        File.open("/tmp/rouge_adapter_debug.log", "a") do |f|
+          f.puts "  lexer: #{lexer ? lexer.class : 'nil'}"
+        end
+      end
+
+      unless lexer
+        # Fallback to regex-based highlighting
+        window.send(:original_highlight)
+        return
+      end
+
+      # Get text to highlight (same logic as original)
+      if @buffer.bytesize < CONFIG[:highlight_buffer_size_limit]
+        base_pos = @buffer.point_min
+        text = @buffer.to_s
+      else
+        base_pos = @buffer.point
+        len = window.columns * (window.lines - 1) / 2 * 3
+        text = @buffer.substring(@buffer.point, @buffer.point + len).scrub("")
+      end
+
+      return unless text.valid_encoding?
+
+      # Tokenize using Rouge
+      highlight_on = {}
+      position = base_pos
+      token_count = 0
+      lexer.lex(text).each do |token, value|
+        token_count += 1
+        face_name = token_type_to_face(token)
+
+        # Apply highlight at token start position
+        if face_name && (attributes = Face[face_name]&.attributes)
+          # Skip if position is before buffer point (same logic as original)
+          token_end = position + value.bytesize
+          if position < @buffer.point && @buffer.point < token_end
+            position = @buffer.point
+          end
+
+          highlight_on[position] = attributes
+        end
+
+        position += value.bytesize
+      end
+
+      window.instance_variable_set(:@highlight_on, highlight_on)
+
+      if DEBUG
+        File.open("/tmp/rouge_adapter_debug.log", "a") do |f|
+          f.puts "  tokens processed: #{token_count}"
+          f.puts "  highlight_on entries: #{highlight_on.size}"
+        end
+      end
+    rescue ::Rouge::Guesser::Ambiguous, StandardError => e
+      # Fallback to regex-based highlighting if Rouge fails
+      if DEBUG
+        File.open("/tmp/rouge_adapter_debug.log", "a") do |f|
+          f.puts "  ERROR: #{e.class}: #{e.message}"
+          f.puts "  Falling back to regex-based highlighting"
+        end
+      end
+      window.send(:original_highlight)
+    end
+
+    private
+
+    def token_type_to_face(token)
+      # Convert Rouge token to face name using the configured mapping
+      # Use instance-level token_map if available, otherwise use class-level
+      token_map = @token_map || self.class.token_map || {}
+      token_qualname = token.qualname
+
+      # Try exact match first
+      return token_map[token_qualname] if token_map[token_qualname]
+
+      # Try parent token types (e.g., Literal.String.Double -> Literal.String -> Literal)
+      parent = token.token_chain.find { |t| token_map[t.qualname] }
+      token_map[parent&.qualname]
+    end
+
+    module ClassMethods
+      attr_accessor :rouge_lexer, :token_map
+
+      # Configure this mode to use a Rouge lexer for syntax highlighting.
+      #
+      # @param lexer_class [Class] Rouge lexer class (e.g., Rouge::Lexers::JSON)
+      # @param token_map [Hash] Mapping from Rouge token qualnames to Textbringer face names
+      #
+      # Example:
+      #   use_rouge Rouge::Lexers::JSON, {
+      #     'Literal.String' => :string,
+      #     'Literal.Number' => :number,
+      #     'Keyword.Constant' => :keyword,
+      #   }
+      def use_rouge(lexer_class, token_map = {})
+        include RougeAdapter unless included_modules.include?(RougeAdapter)
+        self.rouge_lexer = lexer_class
+        self.token_map = token_map
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/textbringer/rouge_config.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module RougeConfig
+    # Default mapping from Rouge token types to Textbringer faces
+    DEFAULT_TOKEN_MAP = {
+      # String literals
+      "Literal.String" => :string,
+      "Literal.String.Double" => :string,
+      "Literal.String.Single" => :string,
+      "Literal.String.Backtick" => :string,
+      "Literal.String.Heredoc" => :string,
+      "Literal.String.Regex" => :string,
+      "Literal.String.Symbol" => :string,
+
+      # Numeric literals
+      "Literal.Number" => :number,
+      "Literal.Number.Integer" => :number,
+      "Literal.Number.Float" => :number,
+      "Literal.Number.Hex" => :number,
+      "Literal.Number.Oct" => :number,
+      "Literal.Number.Bin" => :number,
+
+      # Keywords
+      "Keyword" => :keyword,
+      "Keyword.Constant" => :keyword,
+      "Keyword.Declaration" => :keyword,
+      "Keyword.Namespace" => :keyword,
+      "Keyword.Pseudo" => :keyword,
+      "Keyword.Reserved" => :keyword,
+      "Keyword.Type" => :keyword,
+
+      # Comments
+      "Comment" => :comment,
+      "Comment.Single" => :comment,
+      "Comment.Multiline" => :comment,
+      "Comment.Doc" => :comment,
+      "Comment.Preproc" => :comment,
+      "Comment.PreprocFile" => :comment,
+
+      # Names (functions, classes, variables)
+      "Name.Function" => :function_name,
+      "Name.Class" => :type,
+      "Name.Constant" => :constant,
+      "Name.Variable" => :variable,
+      "Name.Variable.Instance" => :variable,
+      "Name.Variable.Class" => :variable,
+      "Name.Variable.Global" => :variable,
+      "Name.Builtin" => :builtin,
+      "Name.Label" => :label,
+
+      # Operators and punctuation
+      "Operator" => :operator,
+      "Punctuation" => :punctuation,
+    }.freeze
+
+    # Define default faces for syntax highlighting
+    def self.define_default_faces
+      Face.define :string, foreground: "green"
+      Face.define :number, foreground: "magenta"
+      Face.define :keyword, foreground: "cyan", bold: true
+      Face.define :comment, foreground: "brightblack"
+      Face.define :function_name, foreground: "blue", bold: true
+      Face.define :type, foreground: "yellow", bold: true
+      Face.define :constant, foreground: "yellow"
+      Face.define :variable, foreground: "default"
+      Face.define :builtin, foreground: "cyan"
+      Face.define :label, foreground: "yellow", bold: true
+      Face.define :operator, foreground: "default"
+      Face.define :punctuation, foreground: "default"
+    end
+  end
+
+  # Define default faces when this module is loaded
+  RougeConfig.define_default_faces
+end

data/lib/textbringer/rouge_mode.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "rouge_adapter"
+require_relative "rouge_config"
+
+module Textbringer
+  # Universal Rouge mode that supports all languages
+  class RougeMode < Mode
+    include RougeAdapter
+
+    # Match common source file extensions
+    # This pattern will match before Fundamental mode but after specific modes like RubyMode
+    self.file_name_pattern = /\.(py|js|ts|jsx|tsx|json|yaml|yml|toml|xml|html|css|scss|sass|java|c|cpp|h|hpp|rs|go|php|rb|sh|bash|sql|md|txt)\z/i
+
+    def initialize(buffer)
+      super(buffer)
+
+      # Auto-detect lexer from filename
+      begin
+        lexer_class = ::Rouge::Lexer.guess(filename: buffer.name)
+        @rouge_lexer = lexer_class
+        @token_map = RougeConfig::DEFAULT_TOKEN_MAP
+      rescue ::Rouge::Guesser::Ambiguous => e
+        # If multiple lexers match, use the first one
+        @rouge_lexer = e.alternatives.first
+        @token_map = RougeConfig::DEFAULT_TOKEN_MAP
+      rescue
+        # No lexer found, don't set lexer (will fallback to default highlighting)
+        @rouge_lexer = nil
+      end
+
+      @buffer[:indent_tabs_mode] = false
+      @buffer[:tab_width] = 2
+    end
+  end
+end

data/lib/textbringer/rouge_mode_factory.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "rouge_adapter"
+require_relative "rouge_config"
+require_relative "rouge/version"
+
+module Textbringer
+  module RougeModeFactory
+    @mode_cache = {}
+
+    class << self
+      # Create a Mode class for a specific Rouge lexer
+      #
+      # @param lexer_class [Class] Rouge lexer class (e.g., ::Rouge::Lexers::JSON)
+      # @return [Class] A Mode subclass configured for that lexer
+      def create_mode_for_lexer(lexer_class)
+        # Cache modes to avoid recreating them
+        @mode_cache[lexer_class] ||= begin
+          # Create class name for the mode
+          mode_class_name = "Rouge#{lexer_class.tag.capitalize}Mode"
+
+          # Check if already defined
+          if Textbringer.const_defined?(mode_class_name)
+            return Textbringer.const_get(mode_class_name)
+          end
+
+          # Build file name pattern
+          file_pattern_code = if lexer_class.filenames && !lexer_class.filenames.empty?
+            patterns_code = lexer_class.filenames.map do |pattern|
+              if pattern.start_with?("*.")
+                ext = Regexp.escape(pattern[2..-1])
+                "/\\.#{ext}\\z/i"
+              elsif pattern.include?("*")
+                regex_pattern = Regexp.escape(pattern).gsub('\*', '.*')
+                "/#{regex_pattern}\\z/i"
+              else
+                "/#{Regexp.escape(pattern)}\\z/"
+              end
+            end.join(", ")
+            "self.file_name_pattern = Regexp.union(#{patterns_code})"
+          else
+            ""
+          end
+
+          # Define the mode class using class_eval with a named class
+          # This ensures Mode.inherited is called with a properly named class
+          Textbringer.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            class #{mode_class_name} < Mode
+              include RougeAdapter
+              use_rouge #{lexer_class.inspect}, RougeConfig::DEFAULT_TOKEN_MAP
+
+              #{file_pattern_code}
+
+              def initialize(buffer)
+                super(buffer)
+                @buffer[:indent_tabs_mode] = false
+                @buffer[:tab_width] = 2
+              end
+            end
+          RUBY
+
+          Textbringer.const_get(mode_class_name)
+        end
+      end
+
+      # Create a Mode for a file based on its filename
+      #
+      # @param filename [String] The filename to guess the lexer for
+      # @return [Class, nil] A Mode subclass, or nil if no lexer found
+      def create_mode_for_file(filename)
+        lexer_class = ::Rouge::Lexer.guess(filename: filename)
+        create_mode_for_lexer(lexer_class)
+      rescue ::Rouge::Guesser::Ambiguous => e
+        # If multiple lexers match, pick the first one
+        create_mode_for_lexer(e.alternatives.first)
+      rescue
+        # No lexer found
+        nil
+      end
+
+      # Register all Rouge lexers with Textbringer
+      #
+      # This should be called when the plugin is loaded
+      def register_all_lexers
+        ::Rouge::Lexer.all.each do |lexer_class|
+          # Skip lexers without file patterns
+          next if lexer_class.filenames.nil? || lexer_class.filenames.empty?
+
+          begin
+            create_mode_for_lexer(lexer_class)
+          rescue => e
+            # Skip lexers that fail to initialize
+            warn "Failed to register lexer #{lexer_class}: #{e.message}" if ENV["TEXTBRINGER_ROUGE_DEBUG"] == "1"
+          end
+        end
+      end
+    end
+  end
+
+  # Auto-register all lexers when the module is loaded
+  RougeModeFactory.register_all_lexers
+end

data/lib/textbringer_plugin.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "textbringer/rouge_adapter"
+require "textbringer/rouge_config"
+require "textbringer/rouge_mode"

data/test/test_helper.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+# Mock Textbringer for testing without the actual dependency
+module Textbringer
+  class Face
+    @faces = {}
+
+    def self.define(name, **options)
+      @faces[name] = new(name, options)
+    end
+
+    def self.[](name)
+      @faces[name]
+    end
+
+    attr_reader :name, :attributes
+
+    def initialize(name, attributes)
+      @name = name
+      @attributes = attributes
+    end
+  end
+
+  class Mode
+    attr_reader :buffer
+
+    def initialize(buffer)
+      @buffer = buffer
+    end
+
+    def self.define_syntax(face, pattern)
+      # Mock define_syntax
+    end
+
+    def self.file_name_pattern
+      @file_name_pattern
+    end
+
+    def self.file_name_pattern=(pattern)
+      @file_name_pattern = pattern
+    end
+  end
+
+  class Window
+    @@has_colors = true
+
+    def self.class_variable_get(name)
+      @@has_colors if name == :@@has_colors
+    end
+
+    attr_reader :buffer, :columns, :lines
+
+    def initialize(buffer, columns: 80, lines: 24)
+      @buffer = buffer
+      @columns = columns
+      @lines = lines
+    end
+
+    def highlight
+      # Mock highlight method (will be overridden by RougeAdapter)
+    end
+
+    def instance_variable_set(name, value)
+      super(name, value)
+    end
+
+    def instance_variable_get(name)
+      super(name)
+    end
+  end
+
+  class Buffer
+    attr_reader :name, :bytesize, :point_min, :point
+
+    def initialize(name:, content: "", bytesize: nil)
+      @name = name
+      @content = content
+      @bytesize = bytesize || content.bytesize
+      @point_min = 0
+      @point = 0
+      @vars = {}
+    end
+
+    def to_s
+      @content
+    end
+
+    def binary?
+      false
+    end
+
+    def substring(start_pos, end_pos)
+      @content[start_pos...end_pos]
+    end
+
+    def []=(key, value)
+      @vars[key] = value
+    end
+
+    def [](key)
+      @vars[key]
+    end
+  end
+
+  CONFIG = {
+    syntax_highlight: true,
+    highlight_buffer_size_limit: 1024 * 1024,
+  }
+end
+
+# Load Rouge before loading our code
+require "rouge"
+
+# Now load our code
+require "textbringer/rouge_adapter"
+require "textbringer/rouge_config"
+
+require "test/unit"

data/test/textbringer/rouge_adapter_test.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Textbringer
+  class RougeAdapterTest < Test::Unit::TestCase
+    test "VERSION is defined" do
+      assert do
+        ::Textbringer::Rouge.const_defined?(:VERSION)
+      end
+    end
+
+    test "RougeAdapter module exists" do
+      assert do
+        defined?(Textbringer::RougeAdapter)
+      end
+    end
+
+    test "RougeAdapter provides use_rouge class method" do
+      mode_class = Class.new(Mode) do
+        include RougeAdapter
+      end
+
+      assert_respond_to mode_class, :use_rouge
+    end
+
+    test "RougeAdapter::use_rouge configures lexer and token_map" do
+      mode_class = Class.new(Mode) do
+        include RougeAdapter
+        use_rouge ::Rouge::Lexers::Ruby, {
+          "Keyword" => :keyword,
+          "Literal.String" => :string,
+        }
+      end
+
+      assert_equal ::Rouge::Lexers::Ruby, mode_class.rouge_lexer
+      assert_equal({ "Keyword" => :keyword, "Literal.String" => :string }, mode_class.token_map)
+    end
+
+    test "RougeAdapter::custom_highlight tokenizes simple Ruby code" do
+      mode_class = Class.new(Mode) do
+        include RougeAdapter
+        use_rouge ::Rouge::Lexers::Ruby, {
+          "Keyword" => :keyword,
+          "Literal.String" => :string,
+        }
+      end
+
+      buffer = Buffer.new(name: "test.rb", content: 'puts "hello"')
+      mode = mode_class.new(buffer)
+      window = Window.new(buffer)
+
+      mode.custom_highlight(window)
+
+      highlight_on = window.instance_variable_get(:@highlight_on)
+      assert_not_nil highlight_on
+      assert_operator highlight_on.size, :>, 0
+    end
+
+    test "RougeAdapter::token_type_to_face maps tokens with parent fallback" do
+      mode_class = Class.new(Mode) do
+        include RougeAdapter
+        use_rouge ::Rouge::Lexers::Ruby, {
+          "Literal.String" => :string,
+          "Keyword" => :keyword,
+        }
+      end
+
+      buffer = Buffer.new(name: "test.rb")
+      mode = mode_class.new(buffer)
+
+      # Test exact match
+      token = ::Rouge::Token["Keyword"]
+      face = mode.send(:token_type_to_face, token)
+      assert_equal :keyword, face
+
+      # Test parent fallback (Literal.String.Double -> Literal.String)
+      token = ::Rouge::Token["Literal.String.Double"]
+      face = mode.send(:token_type_to_face, token)
+      assert_equal :string, face
+    end
+
+    test "RougeConfig::DEFAULT_TOKEN_MAP is defined" do
+      assert do
+        RougeConfig::DEFAULT_TOKEN_MAP.is_a?(Hash)
+      end
+    end
+
+    test "RougeConfig defines default faces" do
+      assert_not_nil Face[:string]
+      assert_not_nil Face[:number]
+      assert_not_nil Face[:keyword]
+      assert_not_nil Face[:comment]
+    end
+  end
+end

data/test/textbringer/rouge_mode_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "textbringer/rouge_mode"
+
+module Textbringer
+  class RougeModeTest < Test::Unit::TestCase
+    test "RougeMode class exists" do
+      assert do
+        defined?(Textbringer::RougeMode)
+      end
+    end
+
+    test "RougeMode has file_name_pattern" do
+      assert_not_nil RougeMode.file_name_pattern
+    end
+
+    test "RougeMode file_name_pattern matches Python files" do
+      assert_match RougeMode.file_name_pattern, "test.py"
+    end
+
+    test "RougeMode file_name_pattern matches JSON files" do
+      assert_match RougeMode.file_name_pattern, "test.json"
+    end
+
+    test "RougeMode file_name_pattern matches JavaScript files" do
+      assert_match RougeMode.file_name_pattern, "test.js"
+    end
+
+    test "RougeMode auto-detects Python lexer" do
+      buffer = Buffer.new(name: "test.py")
+      mode = RougeMode.new(buffer)
+
+      assert_equal ::Rouge::Lexers::Python, mode.rouge_lexer
+    end
+
+    test "RougeMode auto-detects JSON lexer" do
+      buffer = Buffer.new(name: "test.json")
+      mode = RougeMode.new(buffer)
+
+      assert_equal ::Rouge::Lexers::JSON, mode.rouge_lexer
+    end
+
+    test "RougeMode auto-detects Ruby lexer" do
+      buffer = Buffer.new(name: "test.rb")
+      mode = RougeMode.new(buffer)
+
+      assert_equal ::Rouge::Lexers::Ruby, mode.rouge_lexer
+    end
+
+    test "RougeMode has default token_map" do
+      buffer = Buffer.new(name: "test.py")
+      mode = RougeMode.new(buffer)
+
+      assert_not_nil mode.token_map
+      assert_kind_of Hash, mode.token_map
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: textbringer-rouge
+version: !ruby/object:Gem::Version
+  version: 0.99.0
+platform: ruby
+authors:
+- yancya
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: textbringer
+  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: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A Textbringer plugin that integrates Rouge syntax highlighter to provide
+  automatic syntax highlighting for 200+ languages.
+email:
+- yancya@upec.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CLAUDE.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/textbringer/rouge/version.rb
+- lib/textbringer/rouge_adapter.rb
+- lib/textbringer/rouge_config.rb
+- lib/textbringer/rouge_mode.rb
+- lib/textbringer/rouge_mode_factory.rb
+- lib/textbringer_plugin.rb
+- test/test_helper.rb
+- test/textbringer/rouge_adapter_test.rb
+- test/textbringer/rouge_mode_test.rb
+homepage: https://github.com/yancya/textbringer-rouge
+licenses:
+- WTFPL
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/yancya/textbringer-rouge
+  source_code_uri: https://github.com/yancya/textbringer-rouge
+post_install_message:
+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: 3.4.19
+signing_key:
+specification_version: 4
+summary: Rouge syntax highlighting integration for Textbringer
+test_files: []