mui 0.1.0 → 0.3.0

data/docs/plugins.md

@@ -0,0 +1,285 @@
+---
+title: Plugins
+layout: default
+nav_order: 5
+---
+
+# Plugins
+{: .no_toc }
+
+## Table of contents
+{: .no_toc .text-delta }
+
+1. TOC
+{:toc}
+
+---
+
+## Overview
+
+Mui's plugin system allows you to extend the editor's functionality using Ruby gems. Plugins can:
+
+- Add custom commands
+- Define key mappings
+- React to events (autocmd)
+- Integrate with external tools
+- Add syntax highlighting
+
+## Official Plugins
+
+| Plugin | Description | Install |
+|--------|-------------|---------|
+| [mui-lsp](https://github.com/S-H-GAMELINKS/mui-lsp) | LSP support | `gem install mui-lsp` |
+| [mui-git](https://github.com/S-H-GAMELINKS/mui-git) | Git integration | `gem install mui-git` |
+| [mui-fzf](https://github.com/S-H-GAMELINKS/mui-fzf) | fzf integration | `gem install mui-fzf` |
+
+## Using Plugins
+
+### Loading Plugins
+
+Add plugins to your `~/.muirc`:
+
+```ruby
+Mui.use "mui-lsp"
+Mui.use "mui-git"
+Mui.use "mui-fzf"
+```
+
+Plugins are automatically installed via `bundler/inline` on first startup.
+
+### LSP Configuration
+
+Configure LSP servers with `Mui.lsp`:
+
+```ruby
+Mui.use "mui-lsp"
+
+Mui.lsp do
+  # Use preset configuration
+  use :ruby
+
+  # Custom server configuration
+  server :typescript,
+    command: ["typescript-language-server", "--stdio"],
+    filetypes: ["typescript", "typescriptreact"]
+end
+```
+
+---
+
+## Creating Plugins
+
+### Class-based Plugin
+
+```ruby
+class MyPlugin < Mui::Plugin
+  name :my_plugin
+  version "1.0.0"
+  description "My awesome plugin"
+
+  # Optional: declare dependencies
+  depends_on :other_plugin
+
+  def setup
+    # Define commands, keymaps, autocmds here
+  end
+end
+```
+
+### DSL-based Plugin
+
+```ruby
+Mui.define_plugin(:my_plugin) do
+  # Define commands, keymaps, autocmds here
+end
+```
+
+---
+
+## Plugin API
+
+### Commands
+
+```ruby
+def setup
+  command :greet do |ctx|
+    ctx.set_message("Hello!")
+  end
+
+  command :greet_name do |ctx, name|
+    ctx.set_message("Hello, #{name}!")
+  end
+end
+```
+
+### Key Mappings
+
+```ruby
+def setup
+  # Normal mode mapping
+  keymap :normal, "<Leader>g" do |ctx|
+    ctx.editor.execute_command("greet")
+  end
+
+  # Insert mode mapping
+  keymap :insert, "<C-g>" do |ctx|
+    ctx.insert_text("Generated text")
+  end
+
+  # Multi-key sequence
+  keymap :normal, "<Leader>gg" do |ctx|
+    ctx.set_message("Leader g g pressed!")
+  end
+end
+```
+
+### Autocmd Events
+
+```ruby
+def setup
+  autocmd :BufEnter, pattern: "*.rb" do |ctx|
+    ctx.set_message("Opened Ruby file: #{ctx.buffer.file_path}")
+  end
+
+  autocmd :BufWritePre do |ctx|
+    # Run before every file save
+  end
+
+  autocmd :InsertLeave do |ctx|
+    # Run when leaving insert mode
+  end
+end
+```
+
+---
+
+## CommandContext API
+
+The `ctx` object passed to handlers provides access to editor internals:
+
+### Messages
+
+```ruby
+ctx.set_message("Info message")
+ctx.set_error("Error message")
+```
+
+### Editor Access
+
+```ruby
+ctx.editor                    # Editor instance
+ctx.buffer                    # Current buffer
+ctx.window                    # Current window
+ctx.mode                      # Current mode (:normal, :insert, etc.)
+```
+
+### Mode Control
+
+```ruby
+ctx.change_mode(:normal)
+ctx.change_mode(:insert)
+```
+
+### Text Manipulation
+
+```ruby
+ctx.insert_text("text")       # Insert at cursor
+ctx.buffer.lines              # Get all lines
+ctx.buffer.line(n)            # Get line n
+```
+
+### Cursor
+
+```ruby
+ctx.cursor_row                # Current row (0-indexed)
+ctx.cursor_col                # Current column (0-indexed)
+ctx.move_cursor(row, col)     # Move cursor
+```
+
+### File Operations
+
+```ruby
+ctx.buffer.file_path          # Current file path
+ctx.buffer.modified?          # Has unsaved changes?
+ctx.editor.execute_command("w")   # Save file
+ctx.editor.execute_command("e filename")  # Open file
+```
+
+### Scratch Buffers
+
+```ruby
+ctx.open_scratch_buffer("[Results]", "Content here")
+```
+
+### Jobs
+
+See [Jobs]({{ site.baseurl }}/jobs) for async job execution.
+
+### Interactive Commands
+
+```ruby
+if ctx.command_exists?("fzf")
+  result = ctx.run_interactive_command("fzf")
+  ctx.editor.execute_command("e #{result}") if result
+end
+```
+
+---
+
+## Publishing Plugins
+
+### Gem Structure
+
+```
+mui-myplugin/
+├── lib/
+│   └── mui_myplugin.rb
+├── mui-myplugin.gemspec
+└── README.md
+```
+
+### Gemspec
+
+```ruby
+Gem::Specification.new do |spec|
+  spec.name          = "mui-myplugin"
+  spec.version       = "1.0.0"
+  spec.summary       = "My Mui plugin"
+  spec.files         = Dir["lib/**/*.rb"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "mui", ">= 0.2.0"
+end
+```
+
+### Plugin File
+
+```ruby
+# lib/mui_myplugin.rb
+require "mui"
+
+class MuiMyplugin < Mui::Plugin
+  name :myplugin
+  version "1.0.0"
+
+  def setup
+    command :my_command do |ctx|
+      ctx.set_message("Hello from myplugin!")
+    end
+  end
+end
+```
+
+### Publishing
+
+```bash
+gem build mui-myplugin.gemspec
+gem push mui-myplugin-1.0.0.gem
+```
+
+Users can then install with:
+
+```ruby
+# ~/.muirc
+Mui.use "mui-myplugin"
+```

data/docs/syntax-highlighting.md

@@ -0,0 +1,149 @@
+---
+title: Syntax Highlighting
+layout: default
+nav_order: 7
+---
+
+# Syntax Highlighting
+{: .no_toc }
+
+## Table of contents
+{: .no_toc .text-delta }
+
+1. TOC
+{:toc}
+
+---
+
+## Overview
+
+Mui includes built-in syntax highlighting for 9 programming languages. Highlighting is automatic based on file extension.
+
+## Supported Languages
+
+| Language | Extensions |
+|----------|------------|
+| Ruby | `.rb`, `.rake`, `.gemspec` |
+| C | `.c`, `.h`, `.y` |
+| Go | `.go` |
+| Rust | `.rs` |
+| JavaScript | `.js`, `.mjs`, `.cjs`, `.jsx` |
+| TypeScript | `.ts`, `.tsx`, `.mts`, `.cts` |
+| Markdown | `.md`, `.markdown` |
+| HTML | `.html`, `.htm`, `.xhtml` |
+| CSS | `.css`, `.scss`, `.sass` |
+
+## Configuration
+
+### Enable/Disable
+
+```ruby
+# ~/.muirc
+Mui.set :syntax, true   # Enable (default)
+Mui.set :syntax, false  # Disable
+```
+
+## Language Features
+
+### Ruby
+
+- Keywords (`def`, `class`, `module`, `if`, `end`, etc.)
+- Strings (single, double, heredoc)
+- Comments (`#`, `=begin`/`=end`)
+- Numbers
+- Symbols (`:symbol`)
+- Constants (`CONSTANT`, `ClassName`)
+- Instance variables (`@foo`, `@@bar`)
+- Global variables (`$stdout`)
+- Method calls (`.to_s`, `.each`)
+
+### C
+
+- Keywords (`int`, `char`, `struct`, `if`, `for`, etc.)
+- Strings and character literals
+- Comments (`//`, `/* */`)
+- Numbers
+- Preprocessor directives (`#include`, `#define`)
+
+### Go
+
+- Keywords (`func`, `package`, `import`, `go`, `defer`, etc.)
+- Types (`int`, `string`, `bool`, etc.)
+- Constants (`true`, `false`, `nil`, `iota`)
+- Strings (regular and raw backtick strings)
+- Comments (`//`, `/* */`)
+
+### Rust
+
+- Keywords (`fn`, `let`, `mut`, `impl`, `trait`, etc.)
+- Macros (`println!`, `vec!`)
+- Lifetimes (`'a`, `'static`)
+- Attributes (`#[derive]`, `#[cfg]`)
+- Doc comments (`///`, `//!`)
+- Raw strings (`r#"..."#`)
+
+### JavaScript
+
+- ES6+ keywords (`const`, `let`, `async`, `await`, `class`)
+- Template literals (`` `template ${expr}` ``)
+- Regex literals (`/pattern/flags`)
+- BigInt (`123n`)
+- Strings and comments
+
+### TypeScript
+
+All JavaScript features plus:
+- Type keywords (`interface`, `type`, `enum`, `declare`, `abstract`)
+- Type annotations
+
+### Markdown
+
+- Headings (`#`, `##`, etc.)
+- Emphasis (`*italic*`, `**bold**`)
+- Code blocks (fenced and indented)
+- Links (`[text](url)`)
+- Lists (ordered and unordered)
+- Blockquotes (`>`)
+
+### HTML
+
+- Tags (`<div>`, `</div>`, `<br/>`)
+- Attributes (`class="..."`, `id="..."`)
+- Comments (`<!-- -->`)
+- DOCTYPE
+- Entities (`&amp;`, `&lt;`)
+
+### CSS
+
+- Selectors (`.class`, `#id`, `:pseudo`, `::pseudo-element`)
+- Properties and values
+- Hex colors (`#fff`, `#ffffff`)
+- At-rules (`@media`, `@import`, `@keyframes`)
+- Functions (`calc()`, `rgb()`, `var()`)
+
+## Theme Colors
+
+Syntax colors are defined per theme. All 8 built-in themes include syntax highlighting colors:
+
+- `mui` (default)
+- `solarized_dark`
+- `solarized_light`
+- `monokai`
+- `nord`
+- `gruvbox_dark`
+- `dracula`
+- `tokyo_night`
+
+Each theme defines colors for:
+
+| Element | Description |
+|---------|-------------|
+| `syntax_keyword` | Language keywords |
+| `syntax_string` | String literals |
+| `syntax_comment` | Comments |
+| `syntax_number` | Numeric literals |
+| `syntax_type` | Types and classes |
+| `syntax_function` | Function names |
+| `syntax_variable` | Variables |
+| `syntax_constant` | Constants |
+| `syntax_operator` | Operators |

data/exe/mui

@@ -3,5 +3,4 @@
 
 require "mui"
 
-puts "Mui v#{Mui::VERSION} - A Vim-like TUI editor written in Ruby"
-puts "Coming soon..."
+Mui::Editor.new(ARGV[0]).run

data/lib/mui/autocmd.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Mui
+  # Event-driven hook system for plugins
+  class Autocmd
+    EVENTS = %i[
+      BufEnter
+      BufLeave
+      BufWrite
+      BufWritePre
+      BufWritePost
+      ModeChanged
+      CursorMoved
+      TextChanged
+      InsertEnter
+      InsertLeave
+      InsertCompletion
+      JobStarted
+      JobCompleted
+      JobFailed
+      JobCancelled
+    ].freeze
+
+    def initialize
+      @handlers = {}
+      EVENTS.each { |e| @handlers[e] = [] }
+    end
+
+    def register(event, pattern: nil, &block)
+      event = event.to_sym
+      raise ArgumentError, "Unknown event: #{event}" unless EVENTS.include?(event)
+
+      @handlers[event] << { pattern:, handler: block }
+    end
+
+    def trigger(event, context = nil, **kwargs)
+      event = event.to_sym
+      return unless @handlers[event]
+
+      @handlers[event].each do |entry|
+        # Skip pattern matching for non-buffer events (like Job events)
+        next if context && entry[:pattern] && !match_pattern?(context, entry[:pattern])
+
+        # Pass context or kwargs depending on what's available
+        entry[:handler].call(context || kwargs)
+      end
+    end
+
+    private
+
+    def match_pattern?(context, pattern)
+      return true unless pattern
+
+      file_path = context.buffer.file_path
+
+      case pattern
+      when Regexp
+        file_path&.match?(pattern)
+      when String
+        File.fnmatch(pattern, file_path || "")
+      else
+        false
+      end
+    end
+  end
+end