scint 0.6.0 → 0.7.0

data/lib/scint/installer/linker.rb

@@ -2,6 +2,7 @@
 
 require_relative "../fs"
 require_relative "../platform"
+require_relative "../spec_utils"
 require "pathname"
 
 module Scint
@@ -20,7 +21,7 @@ module Scint
       # Link gem files + gemspec only (no binstubs).
       # This allows binstubs to be scheduled as a separate DAG task.
       def link_files(prepared_gem, bundle_path)
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         link_files_to_ruby_dir(prepared_gem, ruby_dir)
       end
 
@@ -28,7 +29,7 @@ module Scint
       # This is used for the install-time hermetic build environment.
       def link_files_to_ruby_dir(prepared_gem, ruby_dir)
         spec = prepared_gem.spec
-        full_name = spec_full_name(spec)
+        full_name = SpecUtils.full_name(spec)
 
         # 1. Link gem files into gems/{full_name}/
         gem_dest = File.join(ruby_dir, "gems", full_name)
@@ -42,9 +43,9 @@ module Scint
 
       # Write binstubs for one already-linked gem.
       def write_binstubs(prepared_gem, bundle_path)
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         spec = prepared_gem.spec
-        full_name = spec_full_name(spec)
+        full_name = SpecUtils.full_name(spec)
         gem_dest = File.join(ruby_dir, "gems", full_name)
         return unless Dir.exist?(gem_dest)
 
@@ -101,7 +102,7 @@ module Scint
           #!/usr/bin/env ruby
           # frozen_string_literal: true
           #
-          # This file was generated by scint for #{spec_full_name(spec)}
+          # This file was generated by scint for #{SpecUtils.full_name(spec)}
           #
           gem "#{spec.name}", "#{spec.version}"
           load Gem.bin_path("#{spec.name}", "#{exe_name}", "#{spec.version}")
@@ -193,34 +194,17 @@ module Scint
           Gem::Specification.new do |s|
             s.name = #{spec.name.inspect}
             s.version = #{spec.version.to_s.inspect}
-            s.platform = #{platform_str(spec).inspect}
+            s.platform = #{SpecUtils.platform_str(spec).inspect}
             s.authors = ["scint"]
             s.summary = "Installed by scint"
           end
         RUBY
       end
 
-      def spec_full_name(spec)
-        name = spec.name
-        version = spec.version
-        plat = platform_str(spec)
-        base = "#{name}-#{version}"
-        (plat == "ruby" || plat.empty?) ? base : "#{base}-#{plat}"
-      end
-
-      def platform_str(spec)
-        p = spec.respond_to?(:platform) ? spec.platform : nil
-        p.nil? ? "ruby" : p.to_s
-      end
-
-      def ruby_install_dir(bundle_path)
-        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
-      end
-
       private_class_method :write_gemspec, :write_binstubs_impl, :write_ruby_bin_stub,
                            :write_bundle_bin_wrapper, :extract_executables,
                            :detect_executables_from_files, :augment_executable_metadata, :infer_bindir,
-                           :minimal_gemspec, :spec_full_name, :platform_str, :ruby_install_dir
+                           :minimal_gemspec
     end
   end
 end

data/lib/scint/installer/planner.rb

@@ -7,6 +7,7 @@ module Scint
   module Installer
     module Planner
       module_function
+      PATH_GLOB_DEFAULT = "{,*,*/*}.gemspec"
 
       # Compare resolved specs against what's already installed.
       # Returns an Array of PlanEntry with action set to one of:
@@ -18,7 +19,7 @@ module Scint
       # Download entries are sorted largest-first so big gems start early,
       # keeping the pipeline saturated while small gems fill in gaps.
       def plan(resolved_specs, bundle_path, cache_layout)
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         entries = resolved_specs.map do |spec|
           plan_one(spec, ruby_dir, cache_layout)
         end
@@ -98,10 +99,6 @@ module Scint
         !Dir.exist?(ext_install_dir)
       end
 
-      def ruby_install_dir(bundle_path)
-        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
-      end
-
       # Rough size estimate for download ordering.
       # If we don't know, use 0 so unknowns sort after large known gems.
       def estimated_size(spec)
@@ -131,11 +128,37 @@ module Scint
         return nil if source_str.end_with?(".git") || source_str.include?(".git/")
 
         absolute = File.expand_path(source_str, Dir.pwd)
-        Dir.exist?(absolute) ? absolute : nil
+        return nil unless Dir.exist?(absolute)
+
+        spec_name =
+          if spec.respond_to?(:name)
+            spec.name.to_s
+          else
+            spec[:name].to_s
+          end
+        return absolute if spec_name.empty?
+        return absolute if File.exist?(File.join(absolute, "#{spec_name}.gemspec"))
+
+        glob =
+          if source.respond_to?(:glob) && !source.glob.to_s.empty?
+            source.glob.to_s
+          else
+            PATH_GLOB_DEFAULT
+          end
+
+        Dir.glob(File.join(absolute, glob)).each do |path|
+          return File.dirname(path) if File.basename(path, ".gemspec") == spec_name
+        end
+
+        Dir.glob(File.join(absolute, "**", "*.gemspec")).each do |path|
+          return File.dirname(path) if File.basename(path, ".gemspec") == spec_name
+        end
+
+        absolute
       end
 
       private_class_method :plan_one, :needs_ext_build?, :extension_link_missing?,
-                           :ruby_install_dir, :estimated_size, :local_source_path
+                           :estimated_size, :local_source_path
     end
   end
 end

data/lib/scint/installer/preparer.rb

@@ -6,6 +6,7 @@ require_relative "../gem/extractor"
 require_relative "../cache/layout"
 require_relative "../fs"
 require_relative "../errors"
+require_relative "../spec_utils"
 
 module Scint
   module Installer
@@ -182,15 +183,7 @@ module Scint
 
       def gem_download_uri(entry)
         spec = entry.spec
-        name = spec.respond_to?(:name) ? spec.name : spec[:name]
-        version = spec.respond_to?(:version) ? spec.version : spec[:version]
-        platform = spec.respond_to?(:platform) ? spec.platform : spec[:platform]
-
-        filename = if platform && platform.to_s != "ruby" && platform.to_s != ""
-                     "#{name}-#{version}-#{platform}.gem"
-                   else
-                     "#{name}-#{version}.gem"
-                   end
+        filename = "#{SpecUtils.full_name(spec)}.gem"
 
         # Use cached_path if provided, otherwise construct from source
         if entry.cached_path

data/lib/scint/lockfile/parser.rb

@@ -3,6 +3,7 @@
 require_relative "../source/rubygems"
 require_relative "../source/git"
 require_relative "../source/path"
+require_relative "../spec_utils"
 
 module Scint
   module Lockfile
@@ -209,7 +210,7 @@ module Scint
         platform = $4 || "ruby"
         checksums_str = $6
 
-        key = platform == "ruby" ? "#{name}-#{version}" : "#{name}-#{version}-#{platform}"
+        key = SpecUtils.full_name_for(name, version, platform)
 
         if checksums_str
           @checksums[key] = checksums_str.split(",").map(&:strip)

data/lib/scint/lockfile/writer.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require_relative "../spec_utils"
+
 module Scint
   module Lockfile
     # Writes a standard Gemfile.lock file from structured data.
     # Produces output compatible with stock bundler.
     #
     # Sections in order: source blocks (GEM/GIT/PATH), PLATFORMS,
-    # DEPENDENCIES, CHECKSUMS (if present), RUBY VERSION.
+    # DEPENDENCIES, CHECKSUMS (if present), RUBY VERSION, BUNDLED WITH.
     class Writer
       def self.write(lockfile_data)
         new(lockfile_data).generate
@@ -24,6 +26,7 @@ module Scint
         add_dependencies(out)
         add_checksums(out)
         add_ruby_version(out)
+        add_bundled_with(out)
 
         out
       end
@@ -32,67 +35,95 @@ module Scint
 
       def add_sources(out)
         # Group specs by source, preserving source order.
-        # Specs store source as a URI string; sources are Source objects.
-        # Match by checking if the spec's source URI matches any remote.
         specs_by_source = {}
         @data.sources.each { |s| specs_by_source[s] = [] }
 
         @data.specs.each do |spec|
-          spec_src = spec.is_a?(Hash) ? spec[:source] : spec.source
-          spec_uri = normalize_source_uri(spec_src)
-
-          matched = @data.sources.find do |source|
-            if source.respond_to?(:remotes)
-              source.remotes.any? { |r| normalize_source_uri(r) == spec_uri }
-            elsif source.respond_to?(:uri)
-              normalize_source_uri(source.uri) == spec_uri
-            else
-              source == spec_src
-            end
-          end
+          target = match_source_for_spec(spec) || @data.sources.first
+          next unless target
 
-          target = matched || @data.sources.first
           specs_by_source[target] ||= []
           specs_by_source[target] << spec
         end
 
-        first = true
+        emitted = false
         @data.sources.each do |source|
-          out << "\n" unless first
-          first = false
+          source_specs = specs_by_source[source] || []
+          next if source_specs.empty?
+
+          out << "\n" if emitted
+          emitted = true
 
           out << source.to_lock
-          add_specs(out, specs_by_source[source] || [])
+          add_specs(out, source_specs)
         end
       end
 
-      def normalize_source_uri(uri)
-        s = uri.to_s.chomp("/")
-        s.sub(%r{^https?://}, "").downcase
+      def match_source_for_spec(spec)
+        spec_source = spec.is_a?(Hash) ? spec[:source] : spec.source
+        return nil unless spec_source
+
+        @data.sources.find { |source| source_matches?(source, spec_source) }
+      end
+
+      def source_matches?(source, spec_source)
+        return true if source.equal?(spec_source)
+        return true if source == spec_source
+
+        spec_key = normalize_source_key(spec_source)
+        return false unless spec_key
+
+        if source.respond_to?(:remotes)
+          source.remotes.any? { |remote| normalize_source_key(remote) == spec_key }
+        elsif source.respond_to?(:uri)
+          normalize_source_key(source.uri) == spec_key
+        else
+          normalize_source_key(source) == spec_key
+        end
+      end
+
+      def normalize_source_key(source_ref)
+        raw =
+          if source_ref.respond_to?(:uri)
+            source_ref.uri.to_s
+          elsif source_ref.respond_to?(:path)
+            source_ref.path.to_s
+          else
+            source_ref.to_s
+          end
+        return nil if raw.empty?
+
+        if raw.match?(%r{\Ahttps?://}i)
+          raw = raw.sub(%r{\Ahttps?://}i, "")
+          raw = raw.sub(%r{\.git/?\z}i, "")
+          raw.chomp("/").downcase
+        elsif raw.start_with?("/") || raw.start_with?(".")
+          File.expand_path(raw)
+        else
+          raw.sub(%r{\.git/?\z}i, "").chomp("/").downcase
+        end
       end
 
       def add_specs(out, specs)
         # Sort by full name (name-version-platform) for consistency
         sorted = specs.sort_by do |s|
           if s.is_a?(Hash)
-            n = s[:name]
-            v = s[:version]
-            p = s[:platform]
-            p == "ruby" ? "#{n}-#{v}" : "#{n}-#{v}-#{p}"
+            SpecUtils.full_name_for(s[:name], s[:version], s[:platform])
           else
-            "#{s.name}-#{s.version}#{"-#{s.platform}" if s.platform != "ruby"}"
+            SpecUtils.full_name_for(s.name, s.version, s.platform)
           end
         end
 
         sorted.each do |spec|
-          name, version, platform, deps = if spec.is_a?(Hash)
-            [spec[:name], spec[:version], spec[:platform], spec[:dependencies] || []]
+          name, version, deps = if spec.is_a?(Hash)
+            [spec[:name], spec[:version], spec[:dependencies] || []]
           else
-            [spec.name, spec.version, spec.platform, spec.dependencies || []]
+            [spec.name, spec.version, spec.dependencies || []]
           end
 
           # Format: "    name (version)" or "    name (version-platform)"
-          version_str = platform && platform != "ruby" ? "#{version}-#{platform}" : version.to_s
+          platform_str = SpecUtils.platform_str(spec)
+          version_str = platform_str == "ruby" ? version.to_s : "#{version}-#{platform_str}"
           out << "    #{name} (#{version_str})\n"
 
           # Dependencies of this spec (6-space indent)
@@ -152,19 +183,37 @@ module Scint
         return unless @data.checksums
         out << "\nCHECKSUMS\n"
 
-        @data.checksums.sort.each do |key, values|
+        @data.checksums.each do |key, values|
+          rendered_key = format_checksum_key(key)
           if values && !values.empty?
-            out << "  #{key} #{values.join(",")}\n"
+            out << "  #{rendered_key} #{values.join(",")}\n"
           else
-            out << "  #{key}\n"
+            out << "  #{rendered_key}\n"
           end
         end
       end
 
+      def format_checksum_key(key)
+        match = key.to_s.match(/\A(.+)-(\d[^-]*)(?:-(.+))?\z/)
+        return key unless match
+
+        name = match[1]
+        version = match[2]
+        platform = match[3]
+        version_str = platform ? "#{version}-#{platform}" : version
+        "#{name} (#{version_str})"
+      end
+
       def add_ruby_version(out)
         return unless @data.ruby_version
         out << "\nRUBY VERSION\n"
-        out << "  #{@data.ruby_version}\n"
+        out << "   #{@data.ruby_version}\n"
+      end
+
+      def add_bundled_with(out)
+        return unless @data.bundler_version
+        out << "\nBUNDLED WITH\n"
+        out << "   #{@data.bundler_version}\n"
       end
 
     end

data/lib/scint/platform.rb

@@ -40,6 +40,14 @@ module Scint
       RUBY_VERSION
     end
 
+    def ruby_minor_version_dir
+      @ruby_minor_version_dir ||= RUBY_VERSION.split(".")[0, 2].join(".") + ".0"
+    end
+
+    def ruby_install_dir(base)
+      File.join(base, "ruby", ruby_minor_version_dir)
+    end
+
     def extension_api_version
       ::Gem.extension_api_version
     end

data/lib/scint/resolver/provider.rb

@@ -86,7 +86,7 @@ module Scint
             pg = @path_gems[name]
             deps = {}
             (pg[:dependencies] || []).each do |dep_name, dep_req_str|
-              deps[dep_name] = Gem::Requirement.new(dep_req_str || ">= 0")
+              deps[dep_name] = build_requirement(dep_req_str)
             end
             deps
           else
@@ -99,7 +99,7 @@ module Scint
               next unless requirements_match?(reqs)
               dep_hash.each do |dep_name, dep_req_str|
                 # Merge constraints from all matching platform entries
-                req = Gem::Requirement.new(dep_req_str.split(", "))
+                req = build_requirement(dep_req_str)
                 deps[dep_name] = if deps[dep_name]
                   merge_requirements(deps[dep_name], req)
                 else
@@ -276,6 +276,19 @@ module Scint
 
         Gem::Requirement.new(filtered.map { |op, version| "#{op} #{version}" })
       end
+
+      def build_requirement(value)
+        case value
+        when Gem::Requirement
+          value
+        when Array
+          parts = value.flatten.compact.map(&:to_s).reject(&:empty?)
+          Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        else
+          parts = value.to_s.split(",").map(&:strip).reject(&:empty?)
+          Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        end
+      end
     end
   end
 end

data/lib/scint/runtime/exec.rb

@@ -2,8 +2,10 @@
 
 require_relative "setup"
 require_relative "../fs"
+require_relative "../platform"
 require "base64"
 require "pathname"
+require "rbconfig"
 
 module Scint
   module Runtime
@@ -19,40 +21,40 @@ module Scint
       # lock_path: path to .bundle/scint.lock.marshal
       def exec(command, args, lock_path)
         original_env = ENV.to_hash
-        lock_data = Setup.load_lock(lock_path)
+        Setup.load_lock(lock_path)
+        command, args = rewrite_bundle_exec(command, args)
+        passthrough_bundle = bundle_command?(command)
 
         bundle_dir = File.dirname(lock_path)
         scint_lib_dir = File.expand_path("../..", __dir__)
-        ruby_dir = File.join(bundle_dir, "ruby",
-                             RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
-
-        # Collect all load paths from the runtime config
-        paths = []
-        lock_data.each_value do |info|
-          Array(info[:load_paths]).each do |p|
-            paths << p if File.directory?(p)
-          end
+        ruby_dir = Platform.ruby_install_dir(bundle_dir)
+
+        # Set RUBYLIB to make our Bundler shim loadable. We intentionally avoid
+        # injecting all gem load paths here because large apps can exceed exec
+        # argument/environment limits when RUBYLIB gets too long.
+        # Gem load paths are still activated via Scint::Runtime::Setup from
+        # `-rbundler/setup`.
+        unless passthrough_bundle
+          existing = ENV["RUBYLIB"]
+          rubylib = scint_lib_dir
+          rubylib = "#{rubylib}#{File::PATH_SEPARATOR}#{existing}" if existing && !existing.empty?
+          ENV["RUBYLIB"] = rubylib
         end
 
-        # Ensure our bundler shim wins over global bundler.
-        # Order matters: scint lib first, then gem load paths.
-        paths.unshift(scint_lib_dir)
-
-        # Set RUBYLIB so the child process inherits load paths.
-        existing = ENV["RUBYLIB"]
-        rubylib = paths.join(File::PATH_SEPARATOR)
-        rubylib = "#{rubylib}#{File::PATH_SEPARATOR}#{existing}" if existing && !existing.empty?
-        ENV["RUBYLIB"] = rubylib
-
         ENV["SCINT_RUNTIME_LOCK"] = lock_path
         ENV["GEM_HOME"] = ruby_dir
-        ENV["GEM_PATH"] = ruby_dir
+        ENV["GEM_PATH"] = build_gem_path(ruby_dir, original_env["GEM_PATH"])
         ENV["BUNDLE_PATH"] = bundle_dir
         ENV["BUNDLE_APP_CONFIG"] = bundle_dir
         ENV["BUNDLE_GEMFILE"] = find_gemfile(bundle_dir)
-        ENV["PATH"] = prepend_path(File.join(ruby_dir, "bin"), ENV["PATH"])
+        ruby_interpreter_bin = File.dirname(RbConfig.ruby)
+
+        # Keep interpreter/bin ahead of .bundle/bin so `#!/usr/bin/env ruby`
+        # resolves to the interpreter, not a gem-provided "ruby" executable.
         ENV["PATH"] = prepend_path(File.join(bundle_dir, "bin"), ENV["PATH"])
-        prepend_rubyopt("-rbundler/setup")
+        ENV["PATH"] = prepend_path(File.join(ruby_dir, "bin"), ENV["PATH"])
+        ENV["PATH"] = prepend_path(ruby_interpreter_bin, ENV["PATH"])
+        prepend_rubyopt("-rbundler/setup") unless passthrough_bundle
         export_original_env(original_env)
 
         command = resolve_command(command, bundle_dir, ruby_dir)
@@ -76,9 +78,9 @@ module Scint
 
       def prepend_path(prefix, current_path)
         return prefix unless current_path && !current_path.empty?
-        return current_path if current_path.split(File::PATH_SEPARATOR).include?(prefix)
-
-        "#{prefix}#{File::PATH_SEPARATOR}#{current_path}"
+        parts = current_path.split(File::PATH_SEPARATOR).reject(&:empty?)
+        parts.delete(prefix)
+        ([prefix] + parts).join(File::PATH_SEPARATOR)
       end
 
       def export_original_env(original_env)
@@ -87,6 +89,29 @@ module Scint
         # Non-fatal: shim can fallback to current ENV.
       end
 
+      def build_gem_path(bundle_ruby_dir, original_gem_path)
+        paths = [bundle_ruby_dir]
+        if defined?(Gem) && Gem.respond_to?(:default_path)
+          paths.concat(Array(Gem.default_path))
+        end
+        if original_gem_path && !original_gem_path.empty?
+          paths.concat(original_gem_path.split(File::PATH_SEPARATOR))
+        end
+        paths.reject(&:empty?).uniq.join(File::PATH_SEPARATOR)
+      end
+
+      def bundle_command?(command)
+        File.basename(command.to_s) == "bundle"
+      end
+
+      def rewrite_bundle_exec(command, args)
+        return [command, args] unless bundle_command?(command)
+        return [command, args] unless args.first == "exec"
+        return [command, args] if args.length < 2
+
+        [args[1], args[2..] || []]
+      end
+
       def resolve_command(command, bundle_dir, ruby_dir)
         return command if command.include?(File::SEPARATOR)
 
@@ -135,6 +160,7 @@ module Scint
       end
 
       private_class_method :find_gemfile, :prepend_rubyopt, :prepend_path, :export_original_env,
+                           :bundle_command?, :rewrite_bundle_exec, :build_gem_path,
                            :resolve_command, :find_gem_executable, :write_bundle_exec_wrapper
     end
   end

data/lib/scint/runtime/setup.rb

@@ -29,6 +29,7 @@ module Scint
         $LOAD_PATH.unshift(*paths)
 
         ENV["BUNDLE_GEMFILE"] ||= find_gemfile(File.dirname(lock_path))
+        hydrate_loaded_specs(lock_data)
 
         lock_data
       end
@@ -39,7 +40,34 @@ module Scint
         File.exist?(gemfile) ? gemfile : nil
       end
 
-      private_class_method :find_gemfile
+      def hydrate_loaded_specs(lock_data)
+        return unless defined?(Gem) && Gem.respond_to?(:loaded_specs)
+
+        lock_data.each do |name, info|
+          gem_name = name.to_s
+          next if gem_name.empty? || Gem.loaded_specs[gem_name]
+
+          version = info.is_a?(Hash) ? info[:version] : nil
+          spec = find_installed_spec(gem_name, version)
+          Gem.loaded_specs[gem_name] = spec if spec
+        end
+      rescue StandardError
+        # Best-effort compatibility with gems expecting Gem.loaded_specs.
+      end
+
+      def find_installed_spec(gem_name, version)
+        version_req = version.to_s.strip
+        if !version_req.empty?
+          exact = Gem::Specification.find_all_by_name(gem_name, version_req)
+          return exact.find { |spec| spec.version.to_s == version_req } || exact.first
+        end
+
+        Gem::Specification.find_all_by_name(gem_name).max_by(&:version)
+      rescue StandardError
+        nil
+      end
+
+      private_class_method :find_gemfile, :hydrate_loaded_specs, :find_installed_spec
     end
   end
 end

data/lib/scint/scheduler.rb

@@ -329,7 +329,12 @@ module Scint
           job.error = error
           @failed[job.id] = job
           @errors << { job_id: job.id, type: job.type, name: job.name, error: error }
-          @aborted = true if @fail_fast
+          if @fail_fast
+            @aborted = true
+            # Drop queued work immediately; wait_all will return once current
+            # in-flight jobs drain.
+            @pending.clear
+          end
         else
           job.state = :completed
           @completed[job.id] = job

data/lib/scint/spec_utils.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Scint
+  module SpecUtils
+    module_function
+
+    def name(spec)
+      spec.respond_to?(:name) ? spec.name : spec[:name]
+    end
+
+    def version(spec)
+      spec.respond_to?(:version) ? spec.version : spec[:version]
+    end
+
+    def platform(spec)
+      return spec.platform if spec.respond_to?(:platform)
+      return spec[:platform] if spec.is_a?(Hash)
+      return nil unless spec.respond_to?(:[])
+
+      spec[:platform]
+    rescue NameError, ArgumentError
+      nil
+    end
+
+    def platform_str(spec)
+      platform_value(platform(spec))
+    end
+
+    def platform_value(platform)
+      value = platform.nil? ? "ruby" : platform.to_s
+      value.empty? ? "ruby" : value
+    end
+
+    def full_name(spec)
+      base = "#{name(spec)}-#{version(spec)}"
+      plat = platform_str(spec)
+      return base if plat == "ruby"
+
+      "#{base}-#{plat}"
+    end
+
+    def full_name_for(name, version, platform = "ruby")
+      base = "#{name}-#{version}"
+      plat = platform_value(platform)
+      return base if plat == "ruby"
+
+      "#{base}-#{plat}"
+    end
+
+    def full_key(spec)
+      full_key_for(name(spec), version(spec), platform(spec))
+    end
+
+    def full_key_for(name, version, platform = "ruby")
+      "#{name}-#{version}-#{platform_value(platform)}"
+    end
+  end
+end