textbringer-minibuffer-extension 1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 80aa383081c6f047cb35a6399ce675bb3e17b0e5ba841a96c4573d18d49826a5
+  data.tar.gz: b45edea4eda4ea837935a964db6198273e0ffffaa78fd8c316f523fac4062395
+SHA512:
+  metadata.gz: 447c6a9624e1665d182d06e3c93cfdfe1fa747938702937ae2f45d36f0a9f35cbbe1d8fec4a4b383b5f79015239852d4d5a1ca737eff752fb8b2372ee69ad1f7
+  data.tar.gz: 3ae39ad150f0bfb126e73904f55f8db713b4d82c94a30b70e2f33a318933fbefbe5a8ff0b1e3a7606f790ab82e89cb5049a5153df93490ed269442cb1deb3c07

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/
+*.gem
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025
+
+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,76 @@
+# textbringer-minibuffer-extension
+
+Minibuffer extensions for [Textbringer](https://github.com/shugo/textbringer).
+
+## Features
+
+### Minibuffer History
+
+Navigate through minibuffer input history using:
+
+- `M-p` / `Up` - Previous history element
+- `M-n` / `Down` - Next history element
+
+History is automatically saved for:
+- File names (`:file`)
+- Buffer names (`:buffer`)
+- Command names (`:command`)
+
+### Tab Completion Cycling
+
+zsh-style tab completion cycling for minibuffer:
+
+- **1st TAB** - Complete to the common prefix and show candidates in `*Completions*` buffer
+- **2nd TAB** (when no further prefix progress) - Start cycling through candidates
+- **Subsequent TABs** - Cycle to the next candidate (wraps around at the end)
+- **Shift-TAB** - Cycle backward through candidates
+- **Any other key** - Reset cycling state
+
+The currently selected candidate is highlighted in the `*Completions*` buffer.
+
+This replaces the default `complete_minibuffer` command on the TAB key.
+
+### Context-Aware Arrow Keys
+
+The Up/Down arrow keys intelligently switch behavior based on context:
+
+- **During completion cycling** - Up/Down move backward/forward through candidates (same as Shift-TAB/TAB)
+- **Otherwise** - Up/Down navigate through minibuffer history (same as M-p/M-n)
+
+This allows seamless navigation: start cycling with TAB, then use arrow keys to fine-tune your selection.
+
+## Installation
+
+### Via git clone
+
+Clone this repository to your Textbringer plugins directory:
+
+```bash
+git clone https://github.com/kurod1492/textbringer-minibuffer-extension.git ~/.textbringer/plugins/textbringer-minibuffer-extension
+```
+
+### Via rake install
+
+After checking out the repo, run `bundle install` to install dependencies.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Configuration
+
+You can customize the history behavior in your `~/.textbringer.rb`:
+
+```ruby
+# Maximum number of history entries (default: 100)
+CONFIG[:history_length] = 100
+
+# Remove duplicate entries (default: true)
+CONFIG[:history_delete_duplicates] = true
+
+# Optional: Add C-p/C-n keybindings for history navigation
+MINIBUFFER_LOCAL_MAP.define_key(?\C-p, :previous_history_element)
+MINIBUFFER_LOCAL_MAP.define_key(?\C-n, :next_history_element)
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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", "test/**/test_*.rb"]
+end
+
+task default: :test

data/lib/textbringer/minibuffer_extension/commands.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    define_command(:previous_history_element,
+                   doc: "Get previous element from minibuffer history.") do
+      history = Buffer.minibuffer[:history]
+      if history.nil?
+        raise EditorError, "No history"
+      end
+
+      list = history.is_a?(Symbol) ? MinibufferHistory.get(history) : history
+      if list.empty?
+        raise EditorError, "Beginning of history; no preceding item"
+      end
+
+      index = Buffer.minibuffer[:history_index]
+
+      # Save current input on first navigation
+      if index < 0
+        Buffer.minibuffer[:history_input] = Buffer.minibuffer.to_s
+      end
+
+      new_index = index + 1
+      if new_index >= list.size
+        raise EditorError, "Beginning of history; no preceding item"
+      end
+
+      Buffer.minibuffer[:history_index] = new_index
+      Buffer.minibuffer.clear
+      Buffer.minibuffer.insert(list[new_index])
+    end
+
+    define_command(:minibuffer_up,
+                   doc: "Navigate up in minibuffer: cycle backward if cycling, else previous history.") do
+      unless cycle_candidates_directly(-1)
+        previous_history_element
+      end
+    end
+
+    define_command(:minibuffer_down,
+                   doc: "Navigate down in minibuffer: cycle forward if cycling, else next history.") do
+      unless cycle_candidates_directly(1)
+        next_history_element
+      end
+    end
+
+    define_command(:next_history_element,
+                   doc: "Get next element from minibuffer history.") do
+      history = Buffer.minibuffer[:history]
+      if history.nil?
+        raise EditorError, "No history"
+      end
+
+      index = Buffer.minibuffer[:history_index]
+      if index < 0
+        raise EditorError, "End of history; no default available"
+      end
+
+      new_index = index - 1
+      Buffer.minibuffer[:history_index] = new_index
+      Buffer.minibuffer.clear
+
+      if new_index < 0
+        # Restore original input
+        input = Buffer.minibuffer[:history_input]
+        Buffer.minibuffer.insert(input) if input
+      else
+        list = history.is_a?(Symbol) ? MinibufferHistory.get(history) : history
+        Buffer.minibuffer.insert(list[new_index])
+      end
+    end
+  end
+end

data/lib/textbringer/minibuffer_extension/completion_cycling.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Commands
+    CYCLING_COMMANDS = [
+      :cycle_complete_minibuffer,
+      :cycle_complete_minibuffer_backward,
+      :minibuffer_up,
+      :minibuffer_down
+    ].freeze
+
+    define_command(:cycle_complete_minibuffer,
+                   doc: "Complete minibuffer input with cycling support.") do
+      cycle_complete_minibuffer_internal(1)
+    end
+
+    define_command(:cycle_complete_minibuffer_backward,
+                   doc: "Complete minibuffer input with backward cycling.") do
+      cycle_complete_minibuffer_internal(-1)
+    end
+
+    # 既存の candidates を使って cycling だけを行う（last_command チェックなし）
+    def cycle_candidates_directly(direction)
+      minibuffer = Buffer.minibuffer
+      candidates = minibuffer[:cycle_candidates]
+      return false unless candidates && candidates.size > 1
+      cycle_index = minibuffer[:cycle_index]
+      new_index = (cycle_index + direction) % candidates.size
+      minibuffer[:cycle_index] = new_index
+      complete_minibuffer_with_string(candidates[new_index])
+      update_completions_with_selection(candidates, new_index)
+      true
+    end
+    private :cycle_candidates_directly
+
+    def cycle_complete_minibuffer_internal(direction)
+      minibuffer = Buffer.minibuffer
+      completion_proc = minibuffer[:completion_proc]
+      return unless completion_proc
+      ignore_case = minibuffer[:completion_ignore_case]
+      current_text = minibuffer.to_s
+
+      candidates = minibuffer[:cycle_candidates]
+      if CYCLING_COMMANDS.include?(Controller.current.last_command) &&
+         candidates && candidates.size > 1
+        cycle_candidates_directly(direction)
+      else
+        xs = completion_proc.call(current_text)
+        update_completions(xs)
+        if xs.empty?
+          message("No match", sit_for: 1)
+          minibuffer[:cycle_candidates] = nil
+          return
+        end
+        if xs.size == 1
+          complete_minibuffer_with_string(xs[0])
+          minibuffer[:cycle_candidates] = nil
+          return
+        end
+        y, *ys = xs
+        s = y.size.downto(1).lazy.map { |i| y[0, i] }.find { |i|
+          ci = ignore_case ? i.downcase : i
+          ys.all? { |j|
+            cj = ignore_case ? j.downcase : j
+            cj.start_with?(ci)
+          }
+        }
+        if s
+          complete_minibuffer_with_string(s)
+        end
+        completed_text = minibuffer.to_s
+        if completed_text == current_text
+          minibuffer[:cycle_candidates] = xs
+          start_index = direction == 1 ? 0 : xs.size - 1
+          minibuffer[:cycle_index] = start_index
+          complete_minibuffer_with_string(xs[start_index])
+          update_completions_with_selection(xs, start_index)
+        else
+          minibuffer[:cycle_candidates] = xs
+          minibuffer[:cycle_index] = -1
+        end
+      end
+    end
+    private :cycle_complete_minibuffer_internal
+
+    def update_completions_with_selection(xs, selected_index)
+      if COMPLETION[:completions_window].nil?
+        Window.list.last.split
+        COMPLETION[:completions_window] = Window.list.last
+      end
+      completions = Buffer.find_or_new("*Completions*", undo_limit: 0)
+      if !completions.mode.is_a?(CyclingCompletionListMode)
+        completions.apply_mode(CyclingCompletionListMode)
+      end
+      CyclingCompletionListMode.set_selected_pattern(xs[selected_index])
+      completions.read_only = false
+      begin
+        completions.clear
+        xs.each do |x|
+          completions.insert("#{x}\n")
+        end
+        completions.beginning_of_buffer
+        selected_index.times { completions.next_line }
+        COMPLETION[:completions_window].buffer = completions
+      ensure
+        completions.read_only = true
+      end
+    end
+    private :update_completions_with_selection
+  end
+end

data/lib/textbringer/minibuffer_extension/cycling_completion_list_mode.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Textbringer
+  Face.define :completion_selected, reverse: true
+
+  class CyclingCompletionListMode < CompletionListMode
+    @syntax_table = {}
+    define_syntax :completion_selected, /\z\A/
+    define_syntax :link, /^.+$/
+
+    def self.set_selected_pattern(candidate)
+      @syntax_table[:completion_selected] = /^#{Regexp.escape(candidate)}$/
+    end
+
+    def choose_completion
+      unless Window.echo_area.active?
+        raise EditorError, "Minibuffer is not active"
+      end
+      s = @buffer.save_excursion {
+        @buffer.beginning_of_line
+        @buffer.looking_at?(/^(.*)/)
+        @buffer.match_string(1)
+      }
+      if s && s.size > 0
+        Window.current = Window.echo_area
+        complete_minibuffer_with_string(s)
+        delete_completions_window
+      end
+    end
+  end
+end

data/lib/textbringer/minibuffer_extension/history.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Textbringer
+  MINIBUFFER_HISTORY = Hash.new { |h, k| h[k] = [] }
+
+  CONFIG[:history_length] = 100
+  CONFIG[:history_delete_duplicates] = true
+
+  module MinibufferHistory
+    class << self
+      def get(name)
+        MINIBUFFER_HISTORY[name]
+      end
+
+      def add(name, value)
+        return if value.nil? || value.empty?
+        list = MINIBUFFER_HISTORY[name]
+        list.delete(value) if CONFIG[:history_delete_duplicates]
+        list.unshift(value)
+        list.pop while list.size > CONFIG[:history_length]
+      end
+    end
+  end
+end

data/lib/textbringer/minibuffer_extension/keymap.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Textbringer
+  MINIBUFFER_LOCAL_MAP.define_key("\M-p", :previous_history_element)
+  MINIBUFFER_LOCAL_MAP.define_key("\M-n", :next_history_element)
+  MINIBUFFER_LOCAL_MAP.define_key(:up, :minibuffer_up)
+  MINIBUFFER_LOCAL_MAP.define_key(:down, :minibuffer_down)
+  MINIBUFFER_LOCAL_MAP.define_key(?\t, :cycle_complete_minibuffer)
+  MINIBUFFER_LOCAL_MAP.define_key(:btab, :cycle_complete_minibuffer_backward)
+end

data/lib/textbringer/minibuffer_extension/utils_extension.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Textbringer
+  module Utils
+    alias_method :read_from_minibuffer_without_history, :read_from_minibuffer
+
+    def read_from_minibuffer(prompt, completion_proc: nil, default: nil,
+                             initial_value: nil, completion_ignore_case: false,
+                             keymap: MINIBUFFER_LOCAL_MAP,
+                             history: nil)
+      if Window.echo_area.active?
+        raise EditorError,
+          "Command attempted to use minibuffer while in minibuffer"
+      end
+      old_buffer = Buffer.current
+      old_minibuffer_selected = Window.minibuffer_selected
+      Window.minibuffer_selected = Window.current
+      old_completion_proc = Buffer.minibuffer[:completion_proc]
+      old_completion_ignore_case = Buffer.minibuffer[:completion_ignore_case]
+      old_history = Buffer.minibuffer[:history]
+      old_history_index = Buffer.minibuffer[:history_index]
+      old_history_input = Buffer.minibuffer[:history_input]
+      old_current_prefix_arg = Controller.current.current_prefix_arg
+      old_minibuffer_map = Buffer.minibuffer.keymap
+      Buffer.minibuffer.keymap = keymap
+      Buffer.minibuffer[:completion_proc] = completion_proc
+      Buffer.minibuffer[:completion_ignore_case] = completion_ignore_case
+      Buffer.minibuffer[:history] = history
+      Buffer.minibuffer[:history_index] = -1
+      Buffer.minibuffer[:history_input] = nil
+      Buffer.minibuffer[:cycle_candidates] = nil
+      Buffer.minibuffer[:cycle_index] = nil
+      Window.echo_area.active = true
+      begin
+        Window.current = Window.echo_area
+        Buffer.minibuffer.clear
+        Buffer.minibuffer.insert(initial_value) if initial_value
+        if default
+          prompt = prompt.sub(/:/, " (default #{default}):")
+        end
+        Window.echo_area.prompt = prompt
+        Window.echo_area.redisplay
+        Window.update
+        recursive_edit
+        s = Buffer.minibuffer.to_s
+        result = if default && s.empty?
+          default
+        else
+          s
+        end
+        # Add to history if using symbol-based history
+        if history.is_a?(Symbol) && result && !result.empty?
+          MinibufferHistory.add(history, result)
+        end
+        result
+      ensure
+        Window.echo_area.clear
+        Window.echo_area.redisplay
+        Window.update
+        Window.echo_area.active = false
+        Window.current = Window.minibuffer_selected
+        Window.current.buffer = Buffer.current = old_buffer
+        Window.minibuffer_selected = old_minibuffer_selected
+        Buffer.minibuffer[:completion_ignore_case] = old_completion_ignore_case
+        Buffer.minibuffer[:completion_proc] = old_completion_proc
+        Buffer.minibuffer[:history] = old_history
+        Buffer.minibuffer[:history_index] = old_history_index
+        Buffer.minibuffer[:history_input] = old_history_input
+        Buffer.minibuffer[:cycle_candidates] = nil
+        Buffer.minibuffer[:cycle_index] = nil
+        Buffer.minibuffer.keymap = old_minibuffer_map
+        Buffer.minibuffer.disable_input_method
+        Controller.current.current_prefix_arg = old_current_prefix_arg
+        delete_completions_window
+      end
+    end
+
+    alias_method :read_file_name_without_history, :read_file_name
+
+    def read_file_name(prompt, default: nil, history: :file)
+      f = ->(s) {
+        s = File.expand_path(s) if s.start_with?("~")
+        Dir.glob(s + "*").map { |file|
+          if File.directory?(file)
+            file + "/"
+          else
+            file
+          end
+        }
+      }
+      initial_value = default&.dup || Dir.pwd + "/"
+      ignore_case = CONFIG[:read_file_name_completion_ignore_case]
+      file = read_from_minibuffer(prompt, completion_proc: f,
+                                  initial_value: initial_value,
+                                  completion_ignore_case: ignore_case,
+                                  history: history)
+      File.expand_path(file)
+    end
+
+    alias_method :read_buffer_without_history, :read_buffer
+
+    def read_buffer(prompt, default: Buffer.other.name, history: :buffer)
+      f = ->(s) { complete_for_minibuffer(s, Buffer.names) }
+      read_from_minibuffer(prompt, completion_proc: f, default: default,
+                           history: history)
+    end
+
+    alias_method :read_command_name_without_history, :read_command_name
+
+    def read_command_name(prompt, history: :command)
+      f = ->(s) {
+        complete_for_minibuffer(s.tr("-", "_"), Commands.list.map(&:to_s))
+      }
+      read_from_minibuffer(prompt, completion_proc: f, history: history)
+    end
+  end
+end

data/lib/textbringer/minibuffer_extension/version.rb

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

data/lib/textbringer/minibuffer_extension.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "minibuffer_extension/version"
+require_relative "minibuffer_extension/history"
+require_relative "minibuffer_extension/commands"
+require_relative "minibuffer_extension/cycling_completion_list_mode"
+require_relative "minibuffer_extension/completion_cycling"
+require_relative "minibuffer_extension/utils_extension"
+require_relative "minibuffer_extension/keymap"

data/lib/textbringer_plugin.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "textbringer/minibuffer_extension"

data/textbringer-minibuffer-extension.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "textbringer/minibuffer_extension/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "textbringer-minibuffer-extension"
+  spec.version       = Textbringer::MinibufferExtension::VERSION
+  spec.authors       = ["Akihiro Kurotani"]
+  spec.email         = ["kurod1492@gmail.com"]
+
+  spec.summary       = "Minibuffer extensions for Textbringer."
+  spec.description   = "Provides minibuffer history navigation and other enhancements for Textbringer."
+  spec.homepage      = "https://github.com/kurod1492/textbringer-minibuffer-extension"
+  spec.license       = "MIT"
+  spec.metadata      = { "rubygems_mfa_required" => "true" }
+
+  spec.required_ruby_version = ">= 3.2"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "textbringer", ">= 1.4"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", ">= 12.0"
+  spec.add_development_dependency "test-unit"
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: textbringer-minibuffer-extension
+version: !ruby/object:Gem::Version
+  version: '1'
+platform: ruby
+authors:
+- Akihiro Kurotani
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: textbringer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides minibuffer history navigation and other enhancements for Textbringer.
+email:
+- kurod1492@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/textbringer/minibuffer_extension.rb
+- lib/textbringer/minibuffer_extension/commands.rb
+- lib/textbringer/minibuffer_extension/completion_cycling.rb
+- lib/textbringer/minibuffer_extension/cycling_completion_list_mode.rb
+- lib/textbringer/minibuffer_extension/history.rb
+- lib/textbringer/minibuffer_extension/keymap.rb
+- lib/textbringer/minibuffer_extension/utils_extension.rb
+- lib/textbringer/minibuffer_extension/version.rb
+- lib/textbringer_plugin.rb
+- textbringer-minibuffer-extension.gemspec
+homepage: https://github.com/kurod1492/textbringer-minibuffer-extension
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.7
+specification_version: 4
+summary: Minibuffer extensions for Textbringer.
+test_files: []