scint 0.1.0 → 0.7.0

data/lib/scint/installer/extension_builder.rb

@@ -3,6 +3,7 @@
 require_relative "../fs"
 require_relative "../platform"
 require_relative "../errors"
+require_relative "../spec_utils"
 require "open3"
 
 module Scint
@@ -16,7 +17,7 @@ module Scint
       # abi_key:      e.g. "ruby-3.3.0-arm64-darwin24" (defaults to Platform.abi_key)
       def build(prepared_gem, bundle_path, cache_layout, abi_key: Platform.abi_key, compile_slots: 1, output_tail: nil)
         spec = prepared_gem.spec
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         build_ruby_dir = cache_layout.install_ruby_dir
 
         # Check global extension cache first
@@ -28,17 +29,28 @@ module Scint
 
         # Build in a temp dir, then cache
         src_dir = prepared_gem.extracted_path
-        ext_dirs = find_extension_dirs(src_dir)
-        raise ExtensionBuildError, "No extension directories found for #{spec.name}" if ext_dirs.empty?
-
         FS.with_tempdir("scint-ext") do |tmpdir|
-          build_dir = File.join(tmpdir, "build")
+          # Stage the full gem source tree in an isolated workspace.
+          # Many extconf scripts use paths like ../../vendor relative to ext/,
+          # which only work when the full gem layout is preserved.
+          staged_src_dir = File.join(tmpdir, "source")
+          FS.clone_tree(src_dir, staged_src_dir)
+
+          ext_dirs = find_extension_dirs(staged_src_dir)
+          raise ExtensionBuildError, "No extension directories found for #{spec.name}" if ext_dirs.empty?
+
+          build_root = File.join(tmpdir, "build")
           install_dir = File.join(tmpdir, "install")
-          FS.mkdir_p(build_dir)
+          FS.mkdir_p(build_root)
           FS.mkdir_p(install_dir)
 
-          ext_dirs.each do |ext_dir|
-            compile_extension(ext_dir, build_dir, install_dir, src_dir, spec, build_ruby_dir, compile_slots, output_tail)
+          ext_dirs.each_with_index do |ext_dir, idx|
+            # Keep isolated build trees per extension directory. Some gems
+            # invoke multiple CMake projects under ext/ and CMake caches are
+            # source-tree specific.
+            ext_build_dir = File.join(build_root, idx.to_s)
+            FS.mkdir_p(ext_build_dir)
+            compile_extension(ext_dir, ext_build_dir, install_dir, staged_src_dir, spec, build_ruby_dir, compile_slots, output_tail)
           end
 
           # Write marker
@@ -65,12 +77,47 @@ module Scint
         spec = prepared_gem.spec
         return false unless cached_build_available?(spec, cache_layout, abi_key: abi_key)
 
-        ruby_dir = ruby_install_dir(bundle_path)
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
         cached_ext = cache_layout.ext_path(spec, abi_key)
         link_extensions(cached_ext, ruby_dir, spec, abi_key)
         true
       end
 
+      # True when a gem has native extension sources that need compiling.
+      # Platform-specific gems usually ship precompiled binaries and should
+      # not be compiled from ext/ unless they lack support for this Ruby.
+      def needs_build?(spec, gem_dir)
+        platform = spec.respond_to?(:platform) ? spec.platform : nil
+        if platform && !platform.to_s.empty? && platform.to_s != "ruby"
+          return prebuilt_missing_for_ruby?(gem_dir) && buildable_source_dir?(gem_dir)
+        end
+
+        buildable_source_dir?(gem_dir)
+      end
+
+      # Detect versioned prebuilt extension folders like:
+      #   lib/sqlite3/3.1, lib/sqlite3/3.2 ...
+      # If present, the current Ruby minor must exist or we need a build.
+      def prebuilt_missing_for_ruby?(gem_dir)
+        ruby_minor = RUBY_VERSION[/\d+\.\d+/]
+        lib_dir = File.join(gem_dir, "lib")
+        return false unless Dir.exist?(lib_dir)
+
+        Dir.children(lib_dir).each do |child|
+          child_path = File.join(lib_dir, child)
+          next unless File.directory?(child_path)
+
+          version_dirs = Dir.children(child_path).select do |entry|
+            File.directory?(File.join(child_path, entry)) && entry.match?(/\A\d+\.\d+\z/)
+          end
+          next if version_dirs.empty?
+
+          return true unless version_dirs.include?(ruby_minor)
+        end
+
+        false
+      end
+
       # --- private ---
 
       def buildable_source_dir?(gem_dir)
@@ -85,9 +132,18 @@ module Scint
           dirs << File.dirname(path)
         end
 
-        # CMakeLists.txt in ext/
-        Dir.glob(File.join(gem_dir, "ext", "**", "CMakeLists.txt")).each do |path|
-          dir = File.dirname(path)
+        # CMakeLists.txt in ext/. Keep only top-level CMake roots, so vendored
+        # subprojects (e.g. deps/*) are not built standalone.
+        cmake_dirs = Dir.glob(File.join(gem_dir, "ext", "**", "CMakeLists.txt"))
+                        .map { |path| File.dirname(path) }
+                        .uniq
+                        .sort_by { |dir| [dir.length, dir] }
+        cmake_roots = []
+        cmake_dirs.each do |dir|
+          next if cmake_roots.any? { |root| dir.start_with?("#{root}/") }
+          cmake_roots << dir
+        end
+        cmake_roots.each do |dir|
           dirs << dir unless dirs.include?(dir)
         end
 
@@ -106,7 +162,7 @@ module Scint
         env = build_env(gem_dir, build_ruby_dir, make_jobs)
 
         if File.exist?(File.join(ext_dir, "extconf.rb"))
-          compile_extconf(ext_dir, build_dir, install_dir, env, make_jobs, output_tail)
+          compile_extconf(ext_dir, gem_dir, build_dir, install_dir, env, make_jobs, output_tail)
         elsif File.exist?(File.join(ext_dir, "CMakeLists.txt"))
           compile_cmake(ext_dir, build_dir, install_dir, env, make_jobs, output_tail)
         elsif File.exist?(File.join(ext_dir, "Rakefile"))
@@ -116,13 +172,18 @@ module Scint
         end
       end
 
-      def compile_extconf(ext_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
+      def compile_extconf(ext_dir, gem_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
+        # Build in-place within the staged ext directory so extconf scripts
+        # that navigate relative paths (../../vendor, ../..) behave like
+        # Bundler's install layout.
+        _ = gem_dir
+        _ = build_dir
         run_cmd(env, RbConfig.ruby, File.join(ext_dir, "extconf.rb"),
                 "--with-opt-dir=#{RbConfig::CONFIG["prefix"]}",
-                chdir: build_dir, output_tail: output_tail)
-        run_cmd(env, "make", "-j#{make_jobs}", "-C", build_dir, output_tail: output_tail)
+                chdir: ext_dir, output_tail: output_tail)
+        run_cmd(env, "make", "-j#{make_jobs}", "-C", ext_dir, output_tail: output_tail)
         run_cmd(env, "make", "install", "DESTDIR=", "sitearchdir=#{install_dir}", "sitelibdir=#{install_dir}",
-                chdir: build_dir, output_tail: output_tail)
+                chdir: ext_dir, output_tail: output_tail)
       end
 
       def compile_cmake(ext_dir, build_dir, install_dir, env, make_jobs, output_tail = nil)
@@ -173,9 +234,21 @@ module Scint
         ext_install_dir = File.join(ruby_dir, "extensions",
                                     Platform.gem_arch, Platform.extension_api_version,
                                     spec_full_name(spec))
-        return if Dir.exist?(ext_install_dir)
+        FS.clone_tree(cached_ext, ext_install_dir) unless Dir.exist?(ext_install_dir)
+        sync_extension_artifacts_into_gem(ext_install_dir, ruby_dir, spec)
+      end
+
+      def sync_extension_artifacts_into_gem(ext_install_dir, ruby_dir, spec)
+        gem_dir = File.join(ruby_dir, "gems", spec_full_name(spec))
+        lib_dir = File.join(gem_dir, "lib")
+        return unless Dir.exist?(lib_dir)
 
-        FS.hardlink_tree(cached_ext, ext_install_dir)
+        Dir.glob(File.join(ext_install_dir, "**", "*.{so,bundle,dll,dylib}")).each do |artifact|
+          rel = artifact.delete_prefix("#{ext_install_dir}/")
+          dest = File.join(lib_dir, rel)
+          FS.mkdir_p(File.dirname(dest))
+          FS.clonefile(artifact, dest)
+        end
       end
 
       def build_env(gem_dir, build_ruby_dir, make_jobs)
@@ -244,21 +317,13 @@ module Scint
       end
 
       def spec_full_name(spec)
-        name = spec.name
-        version = spec.version
-        plat = spec.respond_to?(:platform) ? spec.platform : nil
-        base = "#{name}-#{version}"
-        (plat.nil? || plat.to_s == "ruby" || plat.to_s.empty?) ? base : "#{base}-#{plat}"
-      end
-
-      def ruby_install_dir(bundle_path)
-        File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
+        SpecUtils.full_name(spec)
       end
 
       private_class_method :find_extension_dirs, :compile_extension,
                            :compile_extconf, :compile_cmake, :compile_rake,
-                           :find_rake_executable, :link_extensions, :build_env, :run_cmd,
-                           :spec_full_name, :ruby_install_dir
+                           :find_rake_executable, :link_extensions, :sync_extension_artifacts_into_gem,
+                           :build_env, :run_cmd, :prebuilt_missing_for_ruby?
     end
   end
 end

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,12 +29,12 @@ 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)
         unless Dir.exist?(gem_dest)
-          FS.hardlink_tree(prepared_gem.extracted_path, gem_dest)
+          FS.clone_tree(prepared_gem.extracted_path, gem_dest)
         end
 
         # 2. Write gemspec into specifications/
@@ -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,16 +19,17 @@ 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
 
-        # Stable partition: downloads first (big→small), then everything else
-        downloads, rest = entries.partition { |e| e.action == :download }
+        # Keep built-ins first, then downloads (big->small), then the rest.
+        builtins, non_builtins = entries.partition { |e| e.action == :builtin }
+        downloads, rest = non_builtins.partition { |e| e.action == :download }
         downloads.sort_by! { |e| -(estimated_size(e.spec)) }
 
-        downloads + rest
+        builtins + downloads + rest
       end
 
       def plan_one(spec, ruby_dir, cache_layout)
@@ -58,7 +60,7 @@ module Scint
         # Local path sources are linked directly from their source tree.
         local_source = local_source_path(spec)
         if local_source
-          action = ExtensionBuilder.buildable_source_dir?(local_source) ? :build_ext : :link
+          action = ExtensionBuilder.needs_build?(spec, local_source) ? :build_ext : :link
           return PlanEntry.new(spec: spec, action: action, cached_path: local_source, gem_path: gem_path)
         end
 
@@ -75,7 +77,7 @@ module Scint
 
       def needs_ext_build?(spec, cache_layout)
         extracted = cache_layout.extracted_path(spec)
-        return false unless ExtensionBuilder.buildable_source_dir?(extracted)
+        return false unless ExtensionBuilder.needs_build?(spec, extracted)
 
         !ExtensionBuilder.cached_build_available?(spec, cache_layout)
       end
@@ -83,7 +85,7 @@ module Scint
       def extension_link_missing?(spec, ruby_dir, cache_layout)
         extracted = cache_layout.extracted_path(spec)
         return false unless Dir.exist?(extracted)
-        return false unless ExtensionBuilder.buildable_source_dir?(extracted)
+        return false unless ExtensionBuilder.needs_build?(spec, extracted)
 
         full = cache_layout.full_name(spec)
         ext_install_dir = File.join(
@@ -97,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)
@@ -130,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,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../spec_utils"
+
 module Scint
   module Lockfile
     # Writes a standard Gemfile.lock file from structured data.
@@ -33,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 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_uri(uri)
-        s = uri.to_s.chomp("/")
-        s.sub(%r{^https?://}, "").downcase
+      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)
@@ -153,19 +183,31 @@ 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)
@@ -173,6 +215,7 @@ module Scint
         out << "\nBUNDLED WITH\n"
         out << "   #{@data.bundler_version}\n"
       end
+
     end
   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