hegeltest 0.1.0

data/lib/tasks/libhegel.rake

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "net/http"
+require_relative "../hegel/locate"
+require_relative "../hegel/libhegel_version"
+
+# Downloads the pinned libhegel release asset for the host platform into
+# tmp/libhegel/<version>/, verifying it against the published SHA-256 before
+# installing it. This is the one place in the codebase allowed to touch the
+# network (see lib/hegel/locate.rb's module comment); everything a test run
+# needs is fetched here ahead of time, not at resolution time.
+module Hegel
+  module LibhegelFetch
+    RELEASE_BASE = "https://github.com/hegeldev/hegel-rust/releases/download"
+    DEFAULT_ROOT = File.expand_path("../../tmp/libhegel", __dir__)
+
+    module_function
+
+    # Fetches the host's pinned asset into <root>/<version>/<asset>,
+    # skipping the download if it is already there. `downloader` is
+    # injectable so the orchestration (skip-if-present, checksum parsing,
+    # mismatch handling) is testable without the network; it defaults to a
+    # real HTTP GET.
+    def fetch_host_asset(version: Hegel::LIBHEGEL_VERSION, host_cpu: RbConfig::CONFIG["host_cpu"],
+      host_os: RbConfig::CONFIG["host_os"], root: DEFAULT_ROOT, downloader: method(:http_get))
+      asset = Hegel::Locate.asset_name(host_cpu: host_cpu, host_os: host_os)
+      dest = File.join(root, version, asset)
+      return dest if File.file?(dest)
+
+      base = "#{RELEASE_BASE}/v#{version}"
+      bytes = downloader.call("#{base}/#{asset}")
+      checksum_line = downloader.call("#{base}/#{asset}.sha256")
+      verify_and_install(bytes, expected_sha256(checksum_line), dest)
+    end
+
+    # The published checksum file is one line, "<hex>  <filename>"; the hex
+    # digest is its first whitespace-separated token.
+    def expected_sha256(checksum_line)
+      checksum_line.split.first
+    end
+
+    # Verifies `bytes` against `expected_hex` and, only on a match, writes
+    # them to `dest` (via a same-directory temp file, renamed into place so
+    # a reader never sees a partial file). On mismatch, raises without ever
+    # touching disk, so a failed fetch never leaves a corrupt file behind.
+    def verify_and_install(bytes, expected_hex, dest)
+      actual_hex = Digest::SHA256.hexdigest(bytes)
+      if actual_hex != expected_hex
+        raise Hegel::Error, "SHA-256 mismatch for #{File.basename(dest)}: expected #{expected_hex}, got #{actual_hex}"
+      end
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      tmp = "#{dest}.#{Process.pid}.partial"
+      File.binwrite(tmp, bytes)
+      File.rename(tmp, dest)
+      dest
+    end
+
+    # Fetches every published platform's asset (see Hegel::Locate::ASSET_NAMES),
+    # not just the host's, into <root>/<version>/<asset>: this is what
+    # `rake libhegel:fetch_all` stages the five platform gems from. Repeats
+    # fetch_host_asset's steps per asset rather than delegating to it,
+    # because delegating would mean computing a host_cpu/host_os pair for
+    # each published platform just to have asset_name recompute the asset
+    # name it already is.
+    def fetch_all_assets(version: Hegel::LIBHEGEL_VERSION, root: DEFAULT_ROOT, downloader: method(:http_get))
+      base = "#{RELEASE_BASE}/v#{version}"
+      Hegel::Locate::ASSET_NAMES.values.map do |asset|
+        dest = File.join(root, version, asset)
+        next dest if File.file?(dest)
+
+        bytes = downloader.call("#{base}/#{asset}")
+        checksum_line = downloader.call("#{base}/#{asset}.sha256")
+        verify_and_install(bytes, expected_sha256(checksum_line), dest)
+      end
+    end
+
+    # Minimal redirect-following GET: GitHub release assets serve a 302 to
+    # the actual blob storage host. `getter` is injectable (defaulting to a
+    # real Net::HTTP call) so the redirect/success/error branches are
+    # testable with hand-built responses, no network involved.
+    def http_get(url, redirects: 5, getter: Net::HTTP.method(:get_response))
+      response = getter.call(URI(url))
+      case response
+      when Net::HTTPRedirection
+        raise Hegel::Error, "too many redirects for #{url}" if redirects <= 0
+
+        http_get(response["location"], redirects: redirects - 1, getter: getter)
+      when Net::HTTPSuccess
+        response.body
+      else
+        raise Hegel::Error, "HTTP #{response.code} for #{url}"
+      end
+    end
+  end
+end
+
+namespace :libhegel do
+  desc "Download the pinned libhegel build for this host into tmp/libhegel/<version>/"
+  task :fetch do
+    dest = Hegel::LibhegelFetch.fetch_host_asset
+    puts "libhegel: #{dest}"
+  end
+
+  desc "Download the pinned libhegel build for every published platform into tmp/libhegel/<version>/, " \
+    "for `rake platform_gems:build` to package"
+  task :fetch_all do
+    Hegel::LibhegelFetch.fetch_all_assets.each { |dest| puts "libhegel: #{dest}" }
+  end
+end

data/lib/tasks/platform_gems.rake

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "tmpdir"
+require "rubygems/package"
+require_relative "../hegel/locate"
+require_relative "../hegel/libhegel_version"
+require_relative "../hegel/errors"
+
+# Packages this gem for the five platforms hegel-rust publishes a libhegel
+# build for (see Hegel::Locate::ASSET_NAMES), on top of the platform-
+# independent "ruby" gem `rake build` already produces. A platform gem
+# differs from that ruby gem in exactly two ways: spec.platform names the
+# platform, and lib/hegel/libhegel/ (Hegel::Locate::GEM_LIBHEGEL_DIR) carries
+# that platform's asset plus libhegel's own MIT notice.
+#
+# Building happens in a temporary staging directory copied from the working
+# tree, rather than in the working tree itself. Gem::Package reads every
+# spec.files entry relative to the process's current directory, and staging
+# keeps a five-platform build from ever writing a binary into the repository.
+#
+# This file does not reference Hegel::LibhegelFetch (lib/tasks/libhegel.rake):
+# it redeclares the tmp/libhegel/<version>/<asset> layout as its own
+# ASSET_ROOT so it loads and tests on its own, the same way libhegel.rake
+# does not depend on this file existing.
+module Hegel
+  module PlatformGems
+    ROOT = File.expand_path("../..", __dir__)
+    GEMSPEC_PATH = File.join(ROOT, "hegeltest.gemspec")
+    NOTICE_PATH = File.join(ROOT, "NOTICE-libhegel.txt")
+    DEFAULT_OUTPUT_DIR = File.join(ROOT, "pkg")
+    ASSET_ROOT = File.join(ROOT, "tmp", "libhegel")
+
+    # Where a platform gem carries its asset and notice, relative to the gem
+    # root. Matches Hegel::Locate::GEM_LIBHEGEL_DIR, the directory Locate
+    # resolves the bundled copy from once the gem is installed.
+    BUNDLE_DIR = "lib/hegel/libhegel"
+
+    module_function
+
+    # The gemspec, loaded fresh each call: Gem::Specification.load caches by
+    # path, so a caller who wants today's `git ls-files` (after adding a new
+    # file, say) must not memoize this across process lifetimes on their own.
+    def base_spec
+      Gem::Specification.load(GEMSPEC_PATH)
+    end
+
+    # The asset `rake libhegel:fetch_all` (or fetch_host_asset, for the
+    # host's own platform) already staged for `platform`, or raises if it has
+    # not run yet.
+    def asset_path(platform, version: Hegel::LIBHEGEL_VERSION, root: ASSET_ROOT)
+      asset = Hegel::Locate::ASSET_NAMES.fetch(platform)
+      path = File.join(root, version, asset)
+      return path if File.file?(path)
+
+      raise Hegel::Error, "no fetched libhegel asset for #{platform} at #{path}. Run `rake libhegel:fetch_all` first."
+    end
+
+    # Builds one platform's gem into `output_dir`, from `spec`'s file set plus
+    # that platform's asset and the libhegel notice, and returns the path to
+    # the built .gem. `spec`, `asset`, and `notice` are injectable so a test
+    # can verify the package's contents with fake files, without touching the
+    # real working tree or the network.
+    def build(spec:, platform:, asset:, notice: NOTICE_PATH, output_dir: DEFAULT_OUTPUT_DIR)
+      platform_spec = spec.dup
+      platform_spec.platform = Gem::Platform.new(platform)
+
+      extra_files = {
+        "#{BUNDLE_DIR}/#{File.basename(asset)}" => asset,
+        "#{BUNDLE_DIR}/#{File.basename(notice)}" => notice
+      }
+      platform_spec.files = spec.files + extra_files.keys
+
+      FileUtils.mkdir_p(output_dir)
+      gem_path = File.join(output_dir, "#{platform_spec.full_name}.gem")
+
+      Dir.mktmpdir do |stage|
+        spec.files.each { |relative| stage_copy(stage, relative, File.join(ROOT, relative)) }
+        extra_files.each { |relative, source| stage_copy(stage, relative, source) }
+
+        Dir.chdir(stage) { Gem::Package.build(platform_spec, false, false, gem_path) }
+      end
+
+      gem_path
+    end
+
+    def stage_copy(stage, relative, source)
+      dest = File.join(stage, relative)
+      FileUtils.mkdir_p(File.dirname(dest))
+      FileUtils.cp(source, dest)
+    end
+
+    # Builds every published platform's gem, each from an asset
+    # `rake libhegel:fetch_all` already staged under `root`.
+    def build_all(spec: base_spec, version: Hegel::LIBHEGEL_VERSION, root: ASSET_ROOT, notice: NOTICE_PATH,
+      output_dir: DEFAULT_OUTPUT_DIR)
+      Hegel::Locate::ASSET_NAMES.each_key.map do |platform|
+        build(spec: spec, platform: platform, asset: asset_path(platform, version: version, root: root),
+          notice: notice, output_dir: output_dir)
+      end
+    end
+  end
+end
+
+namespace :platform_gems do
+  desc "Build the hegeltest gem for every platform hegel-rust publishes libhegel for, " \
+    "from assets already fetched by `rake libhegel:fetch_all`"
+  task :build do
+    Hegel::PlatformGems.build_all.each { |path| puts "built: #{path}" }
+  end
+end