mui 0.2.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/lib/mui/command_completer.rb

@@ -13,9 +13,18 @@ module Mui
     ].freeze
 
     def complete(prefix)
-      return COMMANDS.sort if prefix.empty?
+      all_commands = COMMANDS + plugin_command_names
 
-      COMMANDS.select { |cmd| cmd.start_with?(prefix) }.sort
+      return all_commands.uniq.sort if prefix.empty?
+
+      prefix_downcase = prefix.downcase
+      all_commands.select { |cmd| cmd.downcase.start_with?(prefix_downcase) }.uniq.sort
+    end
+
+    private
+
+    def plugin_command_names
+      Mui.config.commands.keys.map(&:to_s)
     end
   end
 end

data/lib/mui/command_history.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Mui
+  # Manages command history with file persistence
+  class CommandHistory
+    MAX_HISTORY = 100
+    HISTORY_FILE = File.expand_path("~/.mui_history")
+
+    attr_reader :history
+
+    def initialize(history_file: HISTORY_FILE)
+      @history_file = history_file
+      @history = []
+      @index = nil
+      @saved_input = nil
+      load_from_file
+    end
+
+    def add(command)
+      return if command.strip.empty?
+
+      @history.delete(command)
+      @history.push(command)
+      @history.shift if @history.size > MAX_HISTORY
+      save_to_file
+    end
+
+    def previous(current_input)
+      return nil if @history.empty?
+
+      if @index.nil?
+        @saved_input = current_input
+        @index = @history.size - 1
+      elsif @index.positive?
+        @index -= 1
+      else
+        return nil
+      end
+
+      @history[@index]
+    end
+
+    def next_entry
+      return nil if @index.nil?
+
+      if @index < @history.size - 1
+        @index += 1
+        @history[@index]
+      else
+        result = @saved_input
+        reset
+        result
+      end
+    end
+
+    def reset
+      @index = nil
+      @saved_input = nil
+    end
+
+    def browsing?
+      !@index.nil?
+    end
+
+    def size
+      @history.size
+    end
+
+    def empty?
+      @history.empty?
+    end
+
+    private
+
+    def load_from_file
+      return unless File.exist?(@history_file)
+
+      @history = File.readlines(@history_file, chomp: true).last(MAX_HISTORY)
+    rescue StandardError
+      @history = []
+    end
+
+    def save_to_file
+      File.write(@history_file, "#{@history.join("\n")}\n")
+    rescue StandardError
+      # Ignore write failures
+    end
+  end
+end

data/lib/mui/command_line.rb

@@ -5,11 +5,12 @@ module Mui
     # Commands that accept file path arguments
     FILE_COMMANDS = %w[e w sp split vs vsplit tabnew tabe tabedit].freeze
 
-    attr_reader :buffer, :cursor_pos
+    attr_reader :buffer, :cursor_pos, :history
 
-    def initialize
+    def initialize(history: CommandHistory.new)
       @buffer = ""
       @cursor_pos = 0
+      @history = history
     end
 
     def input(char)
@@ -27,6 +28,25 @@ module Mui
     def clear
       @buffer = ""
       @cursor_pos = 0
+      @history.reset
+    end
+
+    def history_previous
+      result = @history.previous(@buffer)
+      return false unless result
+
+      @buffer = result.dup
+      @cursor_pos = @buffer.length
+      true
+    end
+
+    def history_next
+      result = @history.next_entry
+      return false unless result
+
+      @buffer = result.dup
+      @cursor_pos = @buffer.length
+      true
     end
 
     def move_cursor_left
@@ -38,6 +58,9 @@ module Mui
     end
 
     def execute
+      command = @buffer.strip
+      @history.add(command) unless command.empty?
+      @history.reset
       result = parse(@buffer)
       @buffer = ""
       @cursor_pos = 0
@@ -127,6 +150,13 @@ module Mui
         { action: :tab_move, position: ::Regexp.last_match(1).to_i }
       when /^(\d+)tabn(?:ext)?/, /^tabn(?:ext)?\s+(\d+)/
         { action: :tab_go, index: ::Regexp.last_match(1).to_i - 1 }
+      when /^!(.*)$/
+        shell_cmd = ::Regexp.last_match(1).strip
+        if shell_cmd.empty?
+          { action: :shell_command_error, message: "E471: Argument required" }
+        else
+          { action: :shell_command, command: shell_cmd }
+        end
       when /^(\d+)$/
         { action: :goto_line, line_number: ::Regexp.last_match(1).to_i }
       else

data/lib/mui/command_registry.rb

@@ -12,14 +12,33 @@ module Mui
     end
 
     def execute(name, context, *)
-      command = @commands[name.to_sym]
+      command = find(name)
       raise UnknownCommandError, name unless command
 
       command.call(context, *)
     end
 
     def exists?(name)
-      @commands.key?(name.to_sym)
+      @commands.key?(name.to_sym) || plugin_command_exists?(name)
+    end
+
+    def find(name)
+      # Built-in commands take precedence
+      command = @commands[name.to_sym]
+      return command if command
+
+      # Fall back to plugin commands
+      plugin_commands[name.to_sym]
+    end
+
+    private
+
+    def plugin_command_exists?(name)
+      plugin_commands.key?(name.to_sym)
+    end
+
+    def plugin_commands
+      Mui.config.commands
     end
   end
 end

data/lib/mui/config.rb

@@ -11,7 +11,9 @@ module Mui
         shiftwidth: 2, # Indent width for > and < commands
         expandtab: true, # Use spaces instead of tabs
         tabstop: 8, # Tab display width
-        reselect_after_indent: false # Keep selection after > / < in visual mode
+        reselect_after_indent: false, # Keep selection after > / < in visual mode
+        leader: "\\", # Leader key for key mappings (default: backslash)
+        timeoutlen: 1000 # Timeout for multi-key sequences in milliseconds
       }
       @plugins = []
       @keymaps = {}