fzf-ruby 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d8aeb61620f712a78d80f9efe0928314cd9eb96fcb8e47c15bf4911f7d31393
-  data.tar.gz: 68d72dcb58df89ac5d8f415af888d36e008dfad7c68fe50e2034f912b0fc5859
+  metadata.gz: 3219f16fc90118b1bccef8ba71a98faab74a9b8bc007997e4d4ef2904ee652bf
+  data.tar.gz: abafdedf74c201202bf79c916f5c536ed12979d651c82198304ae0c45b3b6c68
 SHA512:
-  metadata.gz: c18947f2ec169459782fdee57c3d0c5d6174407da594eaabef6babf6e8b53c75414c67d2583c6a4a7319f3c97f1af7f482b0cd6f179d3bae4110e551b2388e7d
-  data.tar.gz: 04ea977125b483d2e55007bfceb15af4cc5660f2a5f9f90cc522df00c81030b86897763d764c6f4e4e8ae8f0073154c3866d1175492496a534e467cee56be679
+  metadata.gz: 1ad1d363b716fc4fd20cf43d253c06a56ee81df717748c71bd458f5a3b66b1fe3515339ff5170c3d3e780f51f6fe8c7f7fc73f218bc4942a4f7d4988dc0697bc
+  data.tar.gz: f9b0fbe46c078db77f8373586fac96bbd4bffa8c52c8a138bbd94636693b2774789f17562b1c3f065097749fb3a8139e3d2a3c2b27cbceaa82ab7dcc6c618b1d

data/ext/fzf/extconf.rb

@@ -0,0 +1,137 @@
+# Install-time hook: fetch the fzf binary so the gem works straight after
+# `gem install` / `bundle install`, with no follow-up steps for the user.
+#
+# RubyGems runs this file as a "native extension". Nothing is compiled — the
+# official prebuilt release for the host platform is downloaded, checksum
+# verified, and unpacked into the gem's own lib/fzf/bin/ directory, which is
+# where FzfRuby.fzf_binary looks. A no-op Makefile is written at the end
+# because RubyGems always invokes `make` afterwards.
+#
+# Building from source is deliberately not attempted here: it would require Go
+# on every machine that installs the gem. `rake fzf:install` (lib/fzf/tasks.rb)
+# still offers that route for anyone who wants it.
+
+require "digest"
+require "fileutils"
+require "open-uri"
+require "tmpdir"
+
+require_relative "../../lib/fzf/platform"
+
+module FzfRuby
+  module Installer
+    # Release of fzf to install. Overridable so a project can pin a different
+    # version at install time: FZF_VERSION=0.70.0 bundle install
+    FZF_VERSION = ENV.fetch("FZF_VERSION", "0.74.1").freeze
+
+    # Where release assets live.
+    RELEASE_BASE = "https://github.com/junegunn/fzf/releases/download".freeze
+
+    # Upstream installation instructions, cited when we cannot help further.
+    FZF_INSTALL_URL = "https://github.com/junegunn/fzf#installation".freeze
+
+    # Asset name templates. Both are published for every release.
+    ASSET_TEMPLATE     = "fzf-%<version>s-%<slug>s.tar.gz".freeze
+    CHECKSUMS_TEMPLATE = "fzf_%<version>s_checksums.txt".freeze
+
+    # Final resting place of the binary, inside the installed gem.
+    BIN_DIR = File.expand_path("../../lib/fzf/bin", __dir__).freeze
+
+    # Seconds to wait on each network call before giving up.
+    DOWNLOAD_TIMEOUT = 60
+
+    # Raised when no usable binary can be installed.
+    class InstallError < StandardError; end
+
+    # Download a URL into memory, surfacing network failures as InstallError.
+    def self.fetch(url)
+      URI.parse(url).open(open_timeout: DOWNLOAD_TIMEOUT, read_timeout: DOWNLOAD_TIMEOUT, &:read)
+    rescue StandardError => e
+      raise InstallError, <<~MSG
+        Could not download #{url}
+          #{e.class}: #{e.message}
+
+        If this machine has no network access, install fzf yourself and point
+        the gem at it with FZF_PATH=/path/to/fzf, or see #{FZF_INSTALL_URL}
+      MSG
+    end
+
+    # Expected SHA256 for an asset, read from the release's checksums file.
+    # The file lists one "<sha256>  <filename>" pair per line.
+    def self.expected_checksum(asset)
+      checksums = fetch("#{RELEASE_BASE}/v#{FZF_VERSION}/#{format(CHECKSUMS_TEMPLATE, version: FZF_VERSION)}")
+      line = checksums.lines.find { |l| l.split(/\s+/).last == asset }
+      raise InstallError, "No checksum listed for #{asset}" unless line
+
+      line.split(/\s+/).first
+    end
+
+    # Download, verify and unpack the release, leaving the binary at BIN_DIR/fzf.
+    def self.install
+      slug = FzfRuby::Platform.slug
+      raise unsupported_platform_error unless slug
+
+      asset = format(ASSET_TEMPLATE, version: FZF_VERSION, slug: slug)
+      url   = "#{RELEASE_BASE}/v#{FZF_VERSION}/#{asset}"
+
+      puts "fzf-ruby: downloading #{asset}"
+      tarball = fetch(url)
+
+      # Verify before unpacking — never execute an unverified download.
+      actual   = Digest::SHA256.hexdigest(tarball)
+      expected = expected_checksum(asset)
+      unless actual == expected
+        raise InstallError, "Checksum mismatch for #{asset}\n  expected #{expected}\n  actual   #{actual}"
+      end
+
+      Dir.mktmpdir("fzf-install") do |tmpdir|
+        archive = File.join(tmpdir, asset)
+        File.binwrite(archive, tarball)
+
+        # The release tarballs contain a single `fzf` binary at the root.
+        unless system("tar", "-xzf", archive, "-C", tmpdir)
+          raise InstallError, "Failed to unpack #{asset}"
+        end
+
+        extracted = File.join(tmpdir, "fzf")
+        raise InstallError, "#{asset} did not contain an fzf binary" unless File.exist?(extracted)
+
+        FileUtils.mkdir_p(BIN_DIR)
+        FileUtils.cp(extracted, File.join(BIN_DIR, "fzf"))
+        FileUtils.chmod(0o755, File.join(BIN_DIR, "fzf"))
+      end
+
+      puts "fzf-ruby: installed fzf #{FZF_VERSION} to #{BIN_DIR}/fzf"
+    end
+
+    # No prebuilt release matches this machine, so there is nothing to install.
+    def self.unsupported_platform_error
+      InstallError.new(<<~MSG)
+        fzf-ruby: no prebuilt fzf release exists for this platform
+          host_os:   #{RbConfig::CONFIG["host_os"]}
+          host_cpu:  #{RbConfig::CONFIG["host_cpu"]}
+
+        Install fzf by hand and point the gem at it:
+          export FZF_PATH=/path/to/fzf
+
+        Installation options, including building from source:
+          #{FZF_INSTALL_URL}
+      MSG
+    end
+  end
+end
+
+FzfRuby::Installer.install
+
+# RubyGems runs `make` and `make install` after this script regardless of what
+# it did, so hand it a Makefile whose targets are all satisfied.
+File.write("Makefile", <<~MAKEFILE)
+  all:
+  \t@true
+
+  install:
+  \t@true
+
+  clean:
+  \t@true
+MAKEFILE

data/lib/fzf/platform.rb

@@ -0,0 +1,65 @@
+# Host platform detection, in the naming scheme fzf uses.
+#
+# fzf's release assets and Go's own toolchain share one naming convention
+# ("linux_amd64", "darwin_arm64"), so a single set of maps serves both the
+# install-time downloader (ext/fzf/extconf.rb) and the source build
+# (lib/fzf/tasks.rb). This file is the one home for those names.
+#
+# Detection returns nil rather than aborting — callers decide whether an
+# unsupported platform is fatal (source build) or merely a reason to fall
+# back to a system fzf (install-time download).
+
+require "rbconfig"
+
+module FzfRuby
+  module Platform
+    # RbConfig host_cpu → fzf/Go architecture name.
+    # Keys are matched as prefixes, since host_cpu carries suffixes such as
+    # "armv7l" that the release names ("armv7") do not.
+    ARCH_MAP = {
+      "x86_64"  => "amd64",
+      "amd64"   => "amd64",
+      "aarch64" => "arm64",
+      "arm64"   => "arm64",
+      "armv7"   => "armv7",
+      "armv6"   => "armv6",
+      "armv5"   => "armv5",
+      "loong64" => "loong64",
+      "ppc64le" => "ppc64le",
+      "riscv64" => "riscv64",
+      "s390x"   => "s390x",
+    }.freeze
+
+    # RbConfig host_os → fzf/Go operating system name.
+    # Keys are matched as prefixes ("linux-gnu", "darwin23" and so on).
+    OS_MAP = {
+      "linux"   => "linux",
+      "darwin"  => "darwin",
+      "freebsd" => "freebsd",
+      "openbsd" => "openbsd",
+    }.freeze
+
+    # Operating system in fzf's naming, or nil when unrecognised.
+    def self.os
+      host = RbConfig::CONFIG["host_os"]
+      OS_MAP.each { |prefix, name| return name if host.start_with?(prefix) }
+      nil
+    end
+
+    # Architecture in fzf's naming, or nil when unrecognised.
+    def self.arch
+      cpu = RbConfig::CONFIG["host_cpu"]
+      ARCH_MAP.each { |prefix, name| return name if cpu.start_with?(prefix) }
+      nil
+    end
+
+    # Platform slug as it appears in a release asset name, e.g. "linux_amd64".
+    # nil when either half is unrecognised, meaning no prebuilt asset exists.
+    def self.slug
+      detected_os, detected_arch = os, arch
+      return nil unless detected_os && detected_arch
+
+      "#{detected_os}_#{detected_arch}"
+    end
+  end
+end

data/lib/fzf/tasks.rb

@@ -14,6 +14,8 @@ require "fileutils"
 require "open-uri"
 require "rbconfig"
 
+require_relative "platform"
+
 module FzfRuby
   module Tasks
     extend Rake::DSL
@@ -27,29 +29,19 @@ module FzfRuby
     # 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
+    # Go and fzf share one platform naming scheme, so the maps live in
+    # FzfRuby::Platform and are used by the install-time downloader too.
+    # Platform returns nil for anything unrecognised; Go's own downloads are
+    # all-or-nothing, so here that is fatal.
 
     # 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}"
+      FzfRuby::Platform.os || abort("Unsupported OS for Go auto-install: #{RbConfig::CONFIG["host_os"]}")
     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}" }
+      FzfRuby::Platform.arch || abort("Unsupported arch for Go auto-install: #{RbConfig::CONFIG["host_cpu"]}")
     end
 
     # Fetch the latest stable Go version string (e.g. "go1.26.5")

data/lib/fzf/version.rb

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

data/lib/fzf.rb

@@ -34,8 +34,11 @@ module FzfRuby
   # Raised when fzf binary is not found in PATH
   class FzfNotFoundError < StandardError; end
 
+  # Binary installed with the gem itself by ext/fzf/extconf.rb.
+  VENDORED_BINARY = File.join(__dir__, "fzf", "bin", "fzf").freeze
+
   # Resolve the fzf binary path.
-  # Priority: FZF_PATH env var → project bin/fzf → system PATH
+  # Priority: FZF_PATH env var → project bin/fzf → gem's own bin → system PATH
   def self.fzf_binary
     # Explicit override via environment variable
     from_env = ENV["FZF_PATH"]
@@ -45,6 +48,9 @@ module FzfRuby
     local = File.join(project_root, "bin", "fzf")
     return local if File.executable?(local)
 
+    # Binary downloaded when the gem was installed
+    return VENDORED_BINARY if File.executable?(VENDORED_BINARY)
+
     # Fall back to system PATH
     "fzf"
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fzf-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - asmrtfm
@@ -15,25 +15,19 @@ description: Pipes items into fzf and returns the user's selection. Supports mul
 email:
 - asmrtfm@gmail.com
 executables: []
-extensions: []
+extensions:
+- ext/fzf/extconf.rb
 extra_rdoc_files: []
 files:
+- ext/fzf/extconf.rb
 - lib/fzf.rb
+- lib/fzf/platform.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