mui 0.1.0 → 0.3.0

data/lib/mui/window_manager.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module Mui
+  class WindowManager
+    # Predicates for determining if a window is in a given direction from another
+    DIRECTION_PREDICATES = {
+      left: ->(w, active) { w.x + w.width <= active.x },
+      right: ->(w, active) { w.x >= active.x + active.width },
+      up: ->(w, active) { w.y + w.height <= active.y },
+      down: ->(w, active) { w.y >= active.y + active.height }
+    }.freeze
+
+    attr_reader :active_window, :layout_root
+
+    def initialize(screen, color_scheme: nil)
+      @screen = screen
+      @color_scheme = color_scheme
+      @active_window = nil
+      @layout_root = nil
+      @layout_calculator = Layout::Calculator.new
+    end
+
+    def add_window(buffer)
+      window = create_window(buffer)
+
+      @layout_root = Layout::LeafNode.new(window) if @layout_root.nil?
+
+      @active_window ||= window
+      update_layout
+      window
+    end
+
+    def remove_window(window)
+      return false if single_window?
+
+      node = @layout_root.find_window_node(window)
+      return false unless node
+
+      remove_node(node)
+
+      @active_window = windows.first if @active_window == window
+      update_layout
+      true
+    end
+
+    def split_horizontal(buffer = nil)
+      split(:horizontal, buffer)
+    end
+
+    def split_vertical(buffer = nil)
+      split(:vertical, buffer)
+    end
+
+    def close_current_window
+      return false if single_window?
+
+      current_node = @layout_root.find_window_node(@active_window)
+      return false unless current_node
+
+      remove_node(current_node)
+
+      @active_window = windows.first
+      update_layout
+      true
+    end
+
+    def close_all_except_current
+      return if single_window?
+
+      @layout_root = Layout::LeafNode.new(@active_window)
+      @layout_root.parent = nil
+      update_layout
+    end
+
+    def render_all(screen, selection: nil, search_state: nil)
+      windows.each do |window|
+        window_selection = window == @active_window ? selection : nil
+        window.render(screen, selection: window_selection, search_state:)
+      end
+      render_separators(screen)
+    end
+
+    def separators
+      return [] unless @layout_root.respond_to?(:separators)
+
+      @layout_root.separators
+    end
+
+    def update_sizes
+      update_layout
+    end
+
+    def focus_next
+      focus_cycle(1)
+    end
+
+    def focus_previous
+      focus_cycle(-1)
+    end
+
+    def focus_direction(direction)
+      return unless windows.size > 1
+
+      target = find_window_in_direction(direction)
+      @active_window = target if target
+    end
+
+    def focus_window(window)
+      return false unless windows.include?(window)
+
+      @active_window = window
+      true
+    end
+
+    def windows
+      return [] unless @layout_root
+
+      @layout_root.windows
+    end
+
+    def window_count
+      windows.size
+    end
+
+    def single_window?
+      windows.size <= 1
+    end
+
+    def update_layout(y_offset: 0)
+      return unless @layout_root
+
+      @layout_calculator.calculate(
+        @layout_root, 0, y_offset, @screen.width, @screen.height - 1 - y_offset
+      )
+    end
+
+    private
+
+    def focus_cycle(offset)
+      all_windows = windows
+      return if all_windows.size <= 1
+
+      current_index = all_windows.index(@active_window) || 0
+      @active_window = all_windows[(current_index + offset) % all_windows.size]
+    end
+
+    def split(direction, buffer)
+      return nil unless @active_window
+
+      target_buffer = buffer || @active_window.buffer
+      new_window = create_window(target_buffer)
+
+      current_node = @layout_root.find_window_node(@active_window)
+      return nil unless current_node
+
+      parent = current_node.parent
+
+      new_leaf = Layout::LeafNode.new(new_window)
+      split_node = Layout::SplitNode.new(
+        direction:,
+        children: [current_node, new_leaf],
+        ratio: 0.5
+      )
+
+      if parent
+        parent.replace_child(current_node, split_node)
+      else
+        @layout_root = split_node
+      end
+
+      @active_window = new_window
+      update_layout
+      new_window
+    end
+
+    def remove_node(node)
+      parent = node.parent
+      return false unless parent
+
+      parent.remove_child(node)
+
+      if parent.children.size == 1
+        remaining_child = parent.children.first
+        grandparent = parent.parent
+
+        if grandparent
+          grandparent.replace_child(parent, remaining_child)
+        else
+          @layout_root = remaining_child
+          remaining_child.parent = nil
+        end
+      end
+
+      true
+    end
+
+    def find_window_in_direction(direction)
+      return nil unless @active_window
+
+      predicate = DIRECTION_PREDICATES[direction]
+      return nil unless predicate
+
+      current_x = @active_window.x + (@active_window.width / 2)
+      current_y = @active_window.y + (@active_window.height / 2)
+
+      candidates = windows.reject { |w| w == @active_window }
+                          .select { |w| predicate.call(w, @active_window) }
+
+      candidates.min_by do |w|
+        wx = w.x + (w.width / 2)
+        wy = w.y + (w.height / 2)
+        Math.sqrt(((wx - current_x)**2) + ((wy - current_y)**2))
+      end
+    end
+
+    def create_window(buffer)
+      Window.new(
+        buffer,
+        x: 0,
+        y: 0,
+        width: @screen.width,
+        height: @screen.height,
+        color_scheme: @color_scheme
+      )
+    end
+
+    def render_separators(screen)
+      style = separator_style
+      separators.each do |sep|
+        case sep[:type]
+        when :horizontal
+          render_horizontal_separator(screen, sep, style)
+        when :vertical
+          render_vertical_separator(screen, sep, style)
+        end
+      end
+    end
+
+    def render_horizontal_separator(screen, sep, style)
+      line = "─" * sep[:length]
+      screen.put_with_style(sep[:y], sep[:x], line, style)
+    end
+
+    def render_vertical_separator(screen, sep, style)
+      sep[:length].times do |i|
+        screen.put_with_style(sep[:y] + i, sep[:x], "│", style)
+      end
+    end
+
+    def separator_style
+      return nil unless @color_scheme
+
+      @color_scheme[:separator]
+    end
+  end
+end

data/lib/mui/wrap_cache.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mui
+  # Caches wrap calculation results for performance
+  # Cache key: [line_content, width]
+  class WrapCache
+    def initialize
+      @cache = {}
+    end
+
+    def get(line, width)
+      key = cache_key(line, width)
+      @cache[key]
+    end
+
+    def set(line, width, result)
+      key = cache_key(line, width)
+      @cache[key] = result
+    end
+
+    def invalidate(line)
+      # Remove all entries for this line content
+      @cache.delete_if { |k, _| k.start_with?("#{line}\x00") }
+    end
+
+    def clear
+      @cache.clear
+    end
+
+    def size
+      @cache.size
+    end
+
+    private
+
+    def cache_key(line, width)
+      "#{line}\x00#{width}"
+    end
+  end
+end

data/lib/mui/wrap_helper.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Mui
+  # Helper module for line wrapping calculations
+  module WrapHelper
+    class << self
+      # Wraps a line into screen lines based on display width
+      # Returns: [{ text:, start_col:, end_col: }, ...]
+      def wrap_line(line, width, cache: nil)
+        return [{ text: "", start_col: 0, end_col: 0 }] if line.nil? || line.empty?
+        return [{ text: line, start_col: 0, end_col: line.length }] if width <= 0
+
+        if cache
+          cached = cache.get(line, width)
+          return cached if cached
+        end
+
+        result = compute_wrap(line, width)
+        cache&.set(line, width, result)
+        result
+      end
+
+      # Converts logical column to screen position
+      # Returns: [screen_row_offset, screen_col]
+      def logical_to_screen(line, col, width, cache: nil)
+        return [0, 0] if line.nil? || line.empty? || col <= 0
+
+        wrapped = wrap_line(line, width, cache:)
+
+        wrapped.each_with_index do |segment, row|
+          next unless col <= segment[:end_col]
+
+          # Found the segment containing this column
+          relative_col = col - segment[:start_col]
+          prefix = segment[:text][0, relative_col] || ""
+          screen_col = UnicodeWidth.string_width(prefix)
+          return [row, screen_col]
+        end
+
+        # Column is past end of line, return last position
+        last_segment = wrapped.last
+        last_text = last_segment[:text]
+        [wrapped.size - 1, UnicodeWidth.string_width(last_text)]
+      end
+
+      # Returns the number of screen lines for a logical line
+      def screen_line_count(line, width, cache: nil)
+        wrap_line(line, width, cache:).size
+      end
+
+      private
+
+      def compute_wrap(line, width)
+        result = []
+        chars = line.chars
+        current_text = String.new
+        current_width = 0
+        start_col = 0
+        col = 0
+
+        chars.each do |char|
+          char_w = UnicodeWidth.char_width(char)
+
+          # Check if adding this character would exceed width
+          if current_width + char_w > width && !current_text.empty?
+            result << { text: current_text, start_col:, end_col: col }
+            current_text = String.new
+            current_width = 0
+            start_col = col
+          end
+
+          current_text << char
+          current_width += char_w
+          col += 1
+        end
+
+        # Add remaining text
+        result << { text: current_text, start_col:, end_col: col } unless current_text.empty?
+
+        result.empty? ? [{ text: String.new, start_col: 0, end_col: 0 }] : result
+      end
+    end
+  end
+end

data/lib/mui.rb

@@ -1,8 +1,177 @@
 # frozen_string_literal: true
 
 require_relative "mui/version"
+require_relative "mui/error"
+require_relative "mui/key_code"
+require_relative "mui/key_notation_parser"
+require_relative "mui/key_sequence"
+require_relative "mui/key_sequence_buffer"
+require_relative "mui/key_sequence_matcher"
+require_relative "mui/key_sequence_handler"
+require_relative "mui/unicode_width"
+require_relative "mui/wrap_cache"
+require_relative "mui/wrap_helper"
+require_relative "mui/config"
+require_relative "mui/color_scheme"
+require_relative "mui/color_manager"
+require_relative "mui/themes/default"
+require_relative "mui/terminal_adapter"
+require_relative "mui/screen"
+require_relative "mui/input"
+require_relative "mui/undoable_action"
+require_relative "mui/undo_manager"
+require_relative "mui/buffer"
+require_relative "mui/highlight"
+require_relative "mui/highlighters/base"
+require_relative "mui/highlighters/selection_highlighter"
+require_relative "mui/highlighters/search_highlighter"
+require_relative "mui/syntax/token"
+require_relative "mui/syntax/lexer_base"
+require_relative "mui/syntax/lexers/ruby_lexer"
+require_relative "mui/syntax/lexers/c_lexer"
+require_relative "mui/syntax/lexers/go_lexer"
+require_relative "mui/syntax/lexers/rust_lexer"
+require_relative "mui/syntax/lexers/javascript_lexer"
+require_relative "mui/syntax/lexers/typescript_lexer"
+require_relative "mui/syntax/lexers/markdown_lexer"
+require_relative "mui/syntax/lexers/html_lexer"
+require_relative "mui/syntax/lexers/css_lexer"
+require_relative "mui/syntax/token_cache"
+require_relative "mui/syntax/language_detector"
+require_relative "mui/highlighters/syntax_highlighter"
+require_relative "mui/line_renderer"
+require_relative "mui/status_line_renderer"
+require_relative "mui/layout/node"
+require_relative "mui/layout/leaf_node"
+require_relative "mui/layout/split_node"
+require_relative "mui/layout/calculator"
+require_relative "mui/window"
+require_relative "mui/window_manager"
+require_relative "mui/tab_page"
+require_relative "mui/tab_manager"
+require_relative "mui/tab_bar_renderer"
+require_relative "mui/mode"
+require_relative "mui/handler_result"
+require_relative "mui/command_history"
+require_relative "mui/command_line"
+require_relative "mui/completion_state"
+require_relative "mui/insert_completion_state"
+require_relative "mui/command_completer"
+require_relative "mui/file_completer"
+require_relative "mui/buffer_word_completer"
+require_relative "mui/buffer_word_cache"
+require_relative "mui/completion_renderer"
+require_relative "mui/insert_completion_renderer"
+require_relative "mui/floating_window"
+require_relative "mui/search_state"
+require_relative "mui/search_input"
+require_relative "mui/search_completer"
+require_relative "mui/motion"
+require_relative "mui/selection"
+require_relative "mui/register"
+require_relative "mui/key_handler"
+require_relative "mui/mode_manager"
+require_relative "mui/command_context"
+require_relative "mui/command_registry"
+require_relative "mui/autocmd"
+require_relative "mui/plugin"
+require_relative "mui/plugin_manager"
+require_relative "mui/job"
+require_relative "mui/job_manager"
+require_relative "mui/editor"
 
+# mui(無為) top level module
 module Mui
-  class Error < StandardError; end
-  # Your code goes here...
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def plugin_manager
+      @plugin_manager ||= PluginManager.new
+    end
+
+    def register
+      @register ||= Register.new
+    end
+
+    def set(key, value)
+      config.set(key, value)
+    end
+
+    # Register gem for lazy installation via bundler/inline
+    def use(gem_name, version = nil)
+      plugin_manager.add_gem(gem_name, version)
+    end
+
+    def keymap(mode, key, &block)
+      config.add_keymap(mode, key, block)
+    end
+
+    def command(name, &block)
+      config.add_command(name, block)
+    end
+
+    def autocmd(event, pattern: nil, &block)
+      config.add_autocmd(event, pattern, block)
+    end
+
+    def define_plugin(name, dependencies: [], &block)
+      plugin_manager.register(name, block, dependencies:)
+    end
+
+    def load_config
+      config.load_file(File.expand_path("~/.muirc"))
+      config.load_file(".lmuirc")
+    end
+
+    # Stub for LSP configuration DSL
+    # This allows .muirc to call Mui.lsp { ... } before mui-lsp gem is loaded
+    # When mui-lsp is loaded, it replaces this with the real ConfigDsl
+    def lsp(&block)
+      @lsp_config ||= LspConfigStub.new
+      @lsp_config.instance_eval(&block) if block
+      @lsp_config
+    end
+
+    def lsp_server_configs
+      @lsp_config&.server_configs || []
+    end
+  end
+
+  # Stub class for LSP configuration before mui-lsp gem is loaded
+  # Stores configuration to be applied when the actual gem loads
+  class LspConfigStub
+    attr_reader :server_configs
+
+    def initialize
+      @server_configs = []
+    end
+
+    # Stub methods that mirror Mui::Lsp::ConfigDsl
+    def use(name, **options)
+      @server_configs << { type: :preset, name: name.to_sym, options: }
+    end
+
+    def server(name:, command:, language_ids:, file_patterns:, auto_start: true, sync_on_change: true)
+      @server_configs << {
+        type: :custom,
+        name:,
+        command:,
+        language_ids:,
+        file_patterns:,
+        auto_start:,
+        sync_on_change:
+      }
+    end
+  end
+
+  class << self
+    def reset_config!
+      @config = nil
+      @plugin_manager = nil
+      @register = nil
+      @lsp_config = nil
+    end
+  end
 end