fzf-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1d8aeb61620f712a78d80f9efe0928314cd9eb96fcb8e47c15bf4911f7d31393
+  data.tar.gz: 68d72dcb58df89ac5d8f415af888d36e008dfad7c68fe50e2034f912b0fc5859
+SHA512:
+  metadata.gz: c18947f2ec169459782fdee57c3d0c5d6174407da594eaabef6babf6e8b53c75414c67d2583c6a4a7319f3c97f1af7f482b0cd6f179d3bae4110e551b2388e7d
+  data.tar.gz: 04ea977125b483d2e55007bfceb15af4cc5660f2a5f9f90cc522df00c81030b86897763d764c6f4e4e8ae8f0073154c3866d1175492496a534e467cee56be679

data/lib/fzf/tasks.rb

@@ -0,0 +1,195 @@
+# Rake tasks for building fzf from source.
+#
+# In your consuming project's Rakefile:
+#   require "fzf/tasks"
+#
+# Then:
+#   rake fzf:install   # clone + build fzf into ./bin/fzf (installs Go if needed)
+#   rake fzf:version   # print installed fzf version
+#   rake fzf:clean     # remove ./bin/fzf
+
+require "rake"
+require "tmpdir"
+require "fileutils"
+require "open-uri"
+require "rbconfig"
+
+module FzfRuby
+  module Tasks
+    extend Rake::DSL
+
+    # Source repository for fzf
+    FZF_REPO = "https://github.com/junegunn/fzf.git"
+
+    # Go's recommended install location (per https://go.dev/doc/install)
+    GO_HOME = "/usr/local/go"
+
+    # Go download base URL
+    GO_DL_BASE = "https://go.dev/dl"
+
+    # Map Ruby's RbConfig values to Go's platform naming
+    ARCH_MAP = {
+      "x86_64"  => "amd64",
+      "aarch64" => "arm64",
+      "arm64"   => "arm64",
+    }.freeze
+
+    OS_MAP = {
+      "linux"  => "linux",
+      "darwin" => "darwin",
+    }.freeze
+
+    # Detect the host OS in Go's naming convention
+    def self.detect_os
+      host = RbConfig::CONFIG["host_os"]
+      OS_MAP.each { |prefix, name| return name if host.start_with?(prefix) }
+      abort "Unsupported OS for Go auto-install: #{host}"
+    end
+
+    # Detect the host architecture in Go's naming convention
+    def self.detect_arch
+      cpu = RbConfig::CONFIG["host_cpu"]
+      ARCH_MAP.fetch(cpu) { abort "Unsupported arch for Go auto-install: #{cpu}" }
+    end
+
+    # Fetch the latest stable Go version string (e.g. "go1.26.5")
+    def self.fetch_go_version
+      # go.dev/VERSION?m=text returns the version on the first line
+      URI.open("https://go.dev/VERSION?m=text") { |f| f.readline.strip }
+    rescue => e
+      abort "Failed to fetch latest Go version: #{e.message}"
+    end
+
+    # Return the path to a working `go` binary, installing if necessary.
+    def self.ensure_go
+      # Check for system Go first
+      system_go = `which go 2>/dev/null`.strip
+      unless system_go.empty?
+        puts "Using system Go: #{`go version`.strip}"
+        return system_go
+      end
+
+      # Check for previously-installed Go in GO_HOME
+      local_go = File.join(GO_HOME, "bin", "go")
+      if File.executable?(local_go)
+        puts "Using Go from #{GO_HOME}: #{`#{local_go} version`.strip}"
+        return local_go
+      end
+
+      # Auto-install Go to GO_HOME
+      install_go
+    end
+
+    # Download and install Go to /usr/local/go (per Go's official docs).
+    # Requires sudo since /usr/local is root-owned.
+    def self.install_go
+      version = fetch_go_version
+      os      = detect_os
+      arch    = detect_arch
+      tarball = "#{version}.#{os}-#{arch}.tar.gz"
+      url     = "#{GO_DL_BASE}/#{tarball}"
+
+      puts "Go not found — installing #{version} to #{GO_HOME}..."
+      puts "Downloading #{url}..."
+
+      # Download the tarball
+      dl_path = File.join(Dir.tmpdir, tarball)
+      unless system("curl", "-fSL", "--progress-bar", url, "-o", dl_path)
+        abort "Failed to download Go from #{url}"
+      end
+
+      # Remove any stale partial install, then extract.
+      # The tarball contains a `go/` directory; extracting to /usr/local
+      # places it at /usr/local/go — exactly where Go docs recommend.
+      parent = File.dirname(GO_HOME)
+      puts "Installing to #{GO_HOME} (requires sudo)..."
+      unless system("sudo", "rm", "-rf", GO_HOME)
+        abort "Failed to remove old Go installation (sudo required)"
+      end
+      unless system("sudo", "tar", "-xzf", dl_path, "-C", parent)
+        abort "Failed to extract Go tarball (sudo required)"
+      end
+
+      # Clean up downloaded tarball
+      FileUtils.rm_f(dl_path)
+
+      go_bin = File.join(GO_HOME, "bin", "go")
+      unless File.executable?(go_bin)
+        abort "Go installation succeeded but binary not found at #{go_bin}"
+      end
+
+      puts "Installed #{`#{go_bin} version`.strip} to #{GO_HOME}"
+      go_bin
+    end
+
+    namespace :fzf do
+      desc "Build fzf from latest source and install to bin/ (auto-installs Go if needed)"
+      task :install do
+        bin_dir = File.join(Dir.pwd, "bin")
+        dest    = File.join(bin_dir, "fzf")
+
+        # Ensure Go is available (install if missing)
+        go_bin = FzfRuby::Tasks.ensure_go
+
+        # Prepend Go's bin dir to PATH so `make` can find it
+        go_bin_dir = File.dirname(go_bin)
+        env = { "PATH" => "#{go_bin_dir}:#{ENV['PATH']}" }
+
+        FileUtils.mkdir_p(bin_dir)
+
+        Dir.mktmpdir("fzf-build") do |tmpdir|
+          puts "Cloning fzf from #{FZF_REPO}..."
+          unless system("git", "clone", "--depth", "1", FZF_REPO, tmpdir)
+            abort "Failed to clone fzf repository"
+          end
+
+          puts "Building fzf..."
+          # `make install` compiles and places the binary in <source>/bin/fzf
+          unless system(env, "make", "install", chdir: tmpdir)
+            abort "Failed to build fzf"
+          end
+
+          built = File.join(tmpdir, "bin", "fzf")
+          unless File.exist?(built)
+            abort "Build succeeded but binary not found at #{built}"
+          end
+
+          FileUtils.cp(built, dest)
+          FileUtils.chmod(0o755, dest)
+          puts "Installed fzf to #{dest}"
+        end
+      end
+
+      desc "Print installed fzf version from bin/"
+      task :version do
+        fzf = File.join(Dir.pwd, "bin", "fzf")
+        if File.executable?(fzf)
+          system(fzf, "--version")
+        else
+          puts "fzf not found in bin/ — run `rake fzf:install`"
+        end
+      end
+
+      desc "Remove fzf binary from bin/"
+      task :clean do
+        fzf = File.join(Dir.pwd, "bin", "fzf")
+        if File.exist?(fzf)
+          FileUtils.rm(fzf)
+          puts "Removed #{fzf}"
+        else
+          puts "Nothing to clean"
+        end
+      end
+
+      desc "Remove Go installation from #{GO_HOME} (requires sudo)"
+      task :clean_go do
+        if Dir.exist?(GO_HOME)
+          system("sudo", "rm", "-rf", GO_HOME) || abort("Failed to remove #{GO_HOME}")
+          puts "Removed Go from #{GO_HOME}"
+        else
+          puts "No Go installation at #{GO_HOME}"
+        end
+      end
+    end
+  end
+end

data/lib/fzf/version.rb

@@ -0,0 +1,4 @@
+# Gem version constant
+module FzfRuby
+  VERSION = "0.1.0"
+end

data/lib/fzf.rb

@@ -0,0 +1,361 @@
+# fzf.rb — Ruby wrapper for the fzf fuzzy finder.
+#
+# Provides a single `fzf` method that pipes items into fzf and returns
+# the user's selection. Works as a module method or a top-level function.
+#
+# Usage:
+#   require "fzf"
+#
+#   # Basic selection
+#   choice = fzf("apple", "banana", "cherry")
+#
+#   # Multi-select with appearance options
+#   choices = fzf(*items, multi: true, prompt: "Pick> ", header: "Fruits",
+#                         border: :rounded, layout: :reverse, height: "40%")
+#
+#   # Preview pane and field extraction
+#   fzf(*entries, preview: "echo {}", preview_window: "right:50%:wrap",
+#                 delimiter: ":", nth: "1,2", with_nth: "1")
+#
+#   # Custom keybinds (string or hash form)
+#   fzf(*items, bind: { "ctrl-a" => "select-all", "ctrl-d" => "deselect-all" })
+#   fzf(*items, bind: "ctrl-a:select-all,ctrl-d:deselect-all")
+#
+#   # Bordered sections, labels and styling
+#   fzf(*items, style: :full, list_border: :rounded, list_label: " Files ",
+#               input_border: true, header_border: :sharp, footer: "enter to open")
+#
+#   # Search tuning
+#   fzf(*items, scheme: :path, tiebreak: "begin,length", ignore_case: true)
+
+require_relative "fzf/version"
+
+module FzfRuby
+  # Raised when fzf binary is not found in PATH
+  class FzfNotFoundError < StandardError; end
+
+  # Resolve the fzf binary path.
+  # Priority: FZF_PATH env var → project bin/fzf → system PATH
+  def self.fzf_binary
+    # Explicit override via environment variable
+    from_env = ENV["FZF_PATH"]
+    return from_env if from_env && File.executable?(from_env)
+
+    # Local project binary (installed via `rake fzf:install`)
+    local = File.join(project_root, "bin", "fzf")
+    return local if File.executable?(local)
+
+    # Fall back to system PATH
+    "fzf"
+  end
+
+  # Find the project root — the directory containing the Gemfile.
+  # Falls back to the current working directory.
+  def self.project_root
+    if defined?(Bundler)
+      Bundler.root.to_s
+    else
+      Dir.pwd
+    end
+  end
+
+  # Maps Ruby keyword options to fzf CLI flags.
+  # Organized by category, mirroring the sections of `fzf --help` (v0.73).
+  #
+  # Every flag fzf accepts should have exactly one entry here — this hash is
+  # the single source of truth for the supported option surface. Adding a flag
+  # means adding a line here, plus listing it in BOOLEAN_OPTIONS or
+  # OPTIONAL_VALUE_OPTIONS if it is not a plain required-value flag.
+  OPTION_FLAGS = {
+    # --- Selection ---
+    multi:               "--multi",
+    accept_nth:          "--accept-nth",           # fields to print on accept
+    id_nth:              "--id-nth",               # item identity fields for reloads
+
+    # --- Search behavior ---
+    query:               "--query",                # prefill the query string
+    filter:              "--filter",               # non-interactive filter mode
+    delimiter:           "--delimiter",
+    nth:                 "--nth",                  # fields to match against
+    with_nth:            "--with-nth",             # fields to display
+    scheme:              "--scheme",               # default | path | history
+    tiebreak:            "--tiebreak",             # length | chunk | begin | end | index
+    tail:                "--tail",                 # max items to keep in memory
+    exact:               "--exact",
+    literal:             "--literal",              # do not normalize latin letters
+    disabled:            "--disabled",             # do not perform search
+    ignore_case:         "--ignore-case",
+    no_ignore_case:      "--no-ignore-case",       # force case-sensitive
+    smart_case:          "--smart-case",           # fzf's default
+    no_extended:         "--no-extended",          # disable extended-search syntax
+    no_sort:             "--no-sort",
+    tac:                 "--tac",                  # reverse input order
+    track:               "--track",                # track selection across updates
+    sync:                "--sync",                 # for multi-staged filtering
+    cycle:               "--cycle",
+    select_1:            "--select-1",             # auto-select if only one match
+    exit_0:              "--exit-0",               # exit immediately if no match
+
+    # --- Prompt / input line ---
+    prompt:              "--prompt",
+    pointer:             "--pointer",
+    marker:              "--marker",
+    marker_multi_line:   "--marker-multi-line",
+    ghost:               "--ghost",                # placeholder shown on empty input
+    no_input:            "--no-input",             # hide the input section
+    input_border:        "--input-border",
+    input_label:         "--input-label",
+    input_label_pos:     "--input-label-pos",
+
+    # --- Info line ---
+    info:                "--info",                 # default | inline | hidden | inline-right
+    info_command:        "--info-command",
+    separator:           "--separator",
+    no_separator:        "--no-separator",
+
+    # --- Header ---
+    header:              "--header",
+    header_lines:        "--header-lines",         # treat first N input lines as header
+    header_first:        "--header-first",         # print header above the prompt
+    header_border:       "--header-border",
+    header_lines_border: "--header-lines-border",
+    header_label:        "--header-label",
+    header_label_pos:    "--header-label-pos",
+
+    # --- Footer ---
+    footer:              "--footer",
+    footer_border:       "--footer-border",
+    footer_label:        "--footer-label",
+    footer_label_pos:    "--footer-label-pos",
+
+    # --- Preview ---
+    preview:             "--preview",
+    preview_window:      "--preview-window",
+    preview_border:      "--preview-border",
+    preview_label:       "--preview-label",
+    preview_label_pos:   "--preview-label-pos",
+    preview_wrap_sign:   "--preview-wrap-sign",
+
+    # --- Layout / appearance ---
+    height:              "--height",
+    min_height:          "--min-height",           # floor when height is a percentage
+    layout:              "--layout",               # default | reverse | reverse-list
+    style:               "--style",                # default | minimal | full[:BORDER]
+    border:              "--border",               # rounded | sharp | bold | double | none | ...
+    border_label:        "--border-label",
+    border_label_pos:    "--border-label-pos",
+    list_border:         "--list-border",
+    list_label:          "--list-label",
+    list_label_pos:      "--list-label-pos",
+    margin:              "--margin",               # TRBL | TB,RL | T,RL,B | T,R,B,L
+    padding:             "--padding",              # same forms as margin
+    color:               "--color",
+    no_color:            "--no-color",
+    no_bold:             "--no-bold",
+    ansi:                "--ansi",                 # process ANSI color codes in input
+
+    # --- List rendering ---
+    highlight_line:      "--highlight-line",
+    wrap:                "--wrap",                 # char | word
+    wrap_sign:           "--wrap-sign",
+    no_multi_line:       "--no-multi-line",        # only meaningful with --read0
+    gap:                 "--gap",                  # blank lines between items
+    gap_line:            "--gap-line",             # string drawn in each gap
+    keep_right:          "--keep-right",
+    no_hscroll:          "--no-hscroll",
+    hscroll_off:         "--hscroll-off",
+    scroll_off:          "--scroll-off",
+    ellipsis:            "--ellipsis",
+    tabstop:             "--tabstop",
+    scrollbar:           "--scrollbar",
+    no_scrollbar:        "--no-scrollbar",
+    raw:                 "--raw",                  # show non-matching items
+    gutter:              "--gutter",
+    gutter_raw:          "--gutter-raw",
+    freeze_left:         "--freeze-left",          # fields frozen on the left
+    freeze_right:        "--freeze-right",
+
+    # --- History ---
+    history:             "--history",              # file path, not shell history
+    history_size:        "--history-size",
+
+    # --- Keybinds / navigation (bind gets special handling in build_command) ---
+    bind:                "--bind",
+    jump_labels:         "--jump-labels",
+    filepath_word:       "--filepath-word",        # word movements respect path separators
+
+    # --- Process / integration ---
+    with_shell:          "--with-shell",           # shell used for child processes
+    tmux:                "--tmux",                 # alias of --popup
+    popup:               "--popup",                # requires tmux 3.3+ / Zellij 0.44+
+    listen:              "--listen",               # HTTP server for remote actions
+  }.freeze
+
+  # Bare flags that take no value — emitted only when the option is truthy.
+  BOOLEAN_OPTIONS = %i[
+    multi exact literal disabled ignore_case no_ignore_case smart_case
+    no_extended no_sort tac track sync cycle select_1 exit_0 ansi
+    no_input no_separator header_first no_color no_bold highlight_line
+    no_multi_line keep_right no_hscroll no_scrollbar raw filepath_word
+  ].freeze
+
+  # Flags whose value is optional (`--flag` or `--flag=VALUE` in fzf's help).
+  # Passing `true` emits the bare flag; any other value emits `--flag=VALUE`.
+  OPTIONAL_VALUE_OPTIONS = %i[
+    border preview_border list_border input_border header_border
+    header_lines_border footer_border wrap gap gap_line scrollbar
+    tmux popup listen
+  ].freeze
+
+  # Options that put fzf in a mode where it can emit more than one line:
+  # multi-select accepts several items, and filter mode prints every match.
+  # Any of these makes fzf() return an Array instead of a single String.
+  LIST_RESULT_OPTIONS = %i[multi filter].freeze
+
+  module_function
+
+  # Invoke fzf with the given menu items and options.
+  #
+  # @param menu_items [Array<#to_s>] items to display in fzf (also accepts a single Array)
+  # @param options [Hash] any option from OPTION_FLAGS — see that constant for
+  #   the full list; unknown keys are ignored. Values follow three shapes:
+  #     - keys in BOOLEAN_OPTIONS take true/false (multi:, exact:, cycle:, ...)
+  #     - keys in OPTIONAL_VALUE_OPTIONS take true (fzf's default) or a value
+  #       (border: true, border: :rounded, wrap: :word, gap: 1, tmux: "80%")
+  #     - everything else takes a value (prompt:, header:, preview:, height:, ...)
+  #   Symbol values are hyphenated for fzf (layout: :reverse_list → reverse-list);
+  #   String values are passed through untouched.
+  #   Notable options:
+  #     multi:          [Boolean]  enable multi-select
+  #     prompt:         [String]   custom prompt string
+  #     header:         [String]   header text above the list
+  #     preview:        [String]   shell command for preview pane ({} = current item)
+  #     preview_window: [String]   preview pane layout (e.g. "right:50%:wrap")
+  #     height:         [String]   window height (e.g. "40%", "20")
+  #     layout:         [Symbol|String] :reverse, :reverse_list, or :default
+  #     border:         [Boolean|Symbol|String] true, :rounded, :sharp, :none, etc.
+  #     bind:           [String|Hash]  keybinds — hash form: { "ctrl-a" => "select-all" }
+  #     query:          [String]   prefill the search query
+  #     exact:          [Boolean]  exact (non-fuzzy) matching
+  #     cycle:          [Boolean]  wrap around the list
+  #     select_1:       [Boolean]  auto-select if only one match
+  #     exit_0:         [Boolean]  exit immediately when no match
+  # @return [String]          the selected item (single-select mode)
+  # @return [Array<String>]   selected items (multi:) or all matches (filter:)
+  # @return [nil]             if the user cancelled (Ctrl-C / Esc), or nothing matched
+  def fzf(*menu_items, **options)
+    # Flatten in case caller passes an array instead of splatted args
+    items = menu_items.flatten.map(&:to_s)
+
+    cmd    = build_command(options)
+    result = run_fzf(cmd, items)
+
+    # Return nil on cancel, an array for the modes that can yield several
+    # lines, a single string otherwise
+    return nil if result.nil?
+    list_result?(options) ? result : result.first
+  end
+
+  # Does this option set put fzf in a mode that can return more than one line?
+  #
+  # @param options [Hash] keyword options from the caller
+  # @return [Boolean]
+  def list_result?(options)
+    LIST_RESULT_OPTIONS.any? { |key| options[key] }
+  end
+
+  # Build the fzf command as an array (avoids shell interpolation).
+  #
+  # Values are always attached with `=` (`--prompt=Pick> `) rather than as a
+  # separate argument. fzf accepts both forms, but the `=` form is unambiguous
+  # for values that begin with a dash (e.g. pointer: "->") and is required for
+  # distinguishing a bare optional-value flag from one carrying a value.
+  #
+  # @param options [Hash] keyword options from the caller
+  # @return [Array<String>] command suitable for IO.popen
+  def build_command(options)
+    cmd = [FzfRuby.fzf_binary]
+
+    options.each do |key, value|
+      flag = OPTION_FLAGS[key]
+      next unless flag # ignore unknown options silently
+
+      if BOOLEAN_OPTIONS.include?(key)
+        # Boolean flags are added only when truthy
+        cmd << flag if value
+      elsif value.nil? || value == false
+        # Any option explicitly disabled is simply omitted
+        next
+      elsif OPTIONAL_VALUE_OPTIONS.include?(key)
+        # `true` means "use fzf's default" — emit the flag with no value
+        cmd << (value == true ? flag : "#{flag}=#{serialize_value(value)}")
+      elsif key == :bind
+        # Keybinds accept a string or a hash of { key_combo => action }
+        cmd << "#{flag}=#{serialize_bind(value)}"
+      else
+        cmd << "#{flag}=#{serialize_value(value)}"
+      end
+    end
+
+    cmd
+  end
+
+  # Serialize an option value for the command line.
+  #
+  # Symbols are treated as Ruby-flavoured spellings of fzf's hyphenated
+  # enum values (layout: :reverse_list → "reverse-list"). Every other type is
+  # passed through verbatim — strings are user data (labels, paths, preview
+  # commands) and must never be rewritten.
+  #
+  # @param value [Object] the raw option value
+  # @return [String] the value as fzf expects it
+  def serialize_value(value)
+    value.is_a?(Symbol) ? value.to_s.tr("_", "-") : value.to_s
+  end
+
+  # Serialize bind option to fzf's comma-separated key:action format.
+  #
+  # @param value [String, Hash] either a raw bind string or a hash mapping
+  #   key combos to actions (e.g. { "ctrl-a" => "select-all" })
+  # @return [String] fzf-compatible bind string
+  def serialize_bind(value)
+    case value
+    when Hash
+      # Convert { "ctrl-a" => "select-all", "ctrl-d" => "deselect-all" }
+      # into "ctrl-a:select-all,ctrl-d:deselect-all"
+      value.map { |k, v| "#{k}:#{v}" }.join(",")
+    else
+      value.to_s
+    end
+  end
+
+  # Pipe items into fzf via stdin and capture the selected lines.
+  #
+  # fzf reads candidates from stdin and opens /dev/tty for interactive
+  # user input, so IO.popen works without additional TTY wiring.
+  #
+  # @param cmd   [Array<String>] the fzf command array
+  # @param items [Array<String>] candidate lines
+  # @return [Array<String>, nil] selected lines, or nil on cancel/error
+  def run_fzf(cmd, items)
+    input = items.join("\n")
+
+    output = IO.popen(cmd, "r+") do |io|
+      io.write(input)
+      io.close_write
+      io.read
+    end
+
+    # fzf exit codes: 0 = ok, 1 = no match, 2 = error, 130 = cancelled
+    return nil unless $?.success?
+
+    selections = output.split("\n").reject(&:empty?)
+    selections.empty? ? nil : selections
+  rescue Errno::ENOENT
+    raise FzfNotFoundError,
+      "fzf is not installed or not found in PATH. Install it: https://github.com/junegunn/fzf#installation"
+  end
+end
+
+# Make fzf() available as a top-level method for convenience
+include FzfRuby

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: fzf-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- asmrtfm
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Pipes items into fzf and returns the user's selection. Supports multi-select,
+  preview panes, keybinds, layout, field extraction, and all major fzf options as
+  Ruby keywords.
+email:
+- asmrtfm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fzf.rb
+- lib/fzf/tasks.rb
+- lib/fzf/version.rb
+homepage: https://github.com/asmrtfm/fzf-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: |
+  fzf-ruby requires the `fzf` binary.
+
+  Build from source (requires Go >= 1.23):
+    1. Add to your Rakefile: require "fzf/tasks"
+    2. Run: rake fzf:install
+
+  This clones and compiles fzf into your project's bin/ directory.
+  Alternatively, install fzf system-wide: https://github.com/junegunn/fzf#installation
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Ruby wrapper for fzf — fuzzy find anything with `fzf(*items, **options)`
+test_files: []