scint 0.1.0

data/lib/scint/lockfile/parser.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require_relative "../source/rubygems"
+require_relative "../source/git"
+require_relative "../source/path"
+
+module Scint
+  module Lockfile
+    # Data returned by the lockfile parser.
+    LockfileData = Struct.new(
+      :specs, :dependencies, :platforms, :sources,
+      :bundler_version, :ruby_version, :checksums,
+      keyword_init: true,
+    )
+
+    # Parses a standard Gemfile.lock file into structured data.
+    # Compatible with the format produced by stock bundler.
+    class Parser
+      BUNDLED      = "BUNDLED WITH"
+      DEPENDENCIES = "DEPENDENCIES"
+      CHECKSUMS    = "CHECKSUMS"
+      PLATFORMS    = "PLATFORMS"
+      RUBY         = "RUBY VERSION"
+      GIT          = "GIT"
+      GEM          = "GEM"
+      PATH         = "PATH"
+      SPECS        = "  specs:"
+
+      OPTIONS = /^  ([a-z]+): (.*)$/i
+      SOURCE_TYPES = [GIT, GEM, PATH].freeze
+
+      # Regex for spec/dependency lines:
+      # 2 spaces = dependency, 4 spaces = spec, 6 spaces = spec dependency
+      NAME_VERSION = /
+        ^(\s{2}|\s{4}|\s{6})(?!\s) # exactly 2, 4, or 6 leading spaces
+        (.*?)                        # name
+        (?:\s\(([^-]*)               # version in parens
+        (?:-(.*))?\))?               # optional platform after dash
+        (!)?                         # optional pinned marker
+        (?:\s([^\s]+))?              # optional checksum
+        $
+      /x
+
+      # Accepts either lockfile contents or a file path.
+      def self.parse(lockfile_or_contents)
+        contents =
+          if lockfile_or_contents.is_a?(String) && File.exist?(lockfile_or_contents)
+            File.read(lockfile_or_contents)
+          else
+            lockfile_or_contents.to_s
+          end
+        new(contents).parse
+      end
+
+      def initialize(lockfile_contents)
+        @contents = lockfile_contents
+        @specs = []
+        @dependencies = {}
+        @platforms = []
+        @sources = []
+        @bundler_version = nil
+        @ruby_version = nil
+        @checksums = nil
+
+        @parse_method = nil
+        @current_source = nil
+        @current_spec = nil
+        @source_type = nil
+        @source_opts = {}
+      end
+
+      def parse
+        if @contents.match?(/(<<<<<<<|=======|>>>>>>>|\|\|\|\|\|\|\|)/)
+          raise LockfileError, "Lockfile contains merge conflicts"
+        end
+
+        @contents.each_line do |line|
+          line.chomp!
+
+          # Blank lines reset nothing; skip them
+          next if line.strip.empty?
+
+          if SOURCE_TYPES.include?(line)
+            @parse_method = :parse_source
+            @source_type = line
+            @source_opts = {}
+            @current_source = nil
+            next
+          elsif line == DEPENDENCIES
+            @parse_method = :parse_dependency
+            next
+          elsif line == CHECKSUMS
+            @checksums = {}
+            @parse_method = :parse_checksum
+            next
+          elsif line == PLATFORMS
+            @parse_method = :parse_platform
+            next
+          elsif line == RUBY
+            @parse_method = :parse_ruby
+            next
+          elsif line == BUNDLED
+            @parse_method = :parse_bundled_with
+            next
+          elsif line =~ /^[^\s]/
+            # Unknown section header
+            @parse_method = nil
+            next
+          end
+
+          next unless @parse_method
+
+          case @parse_method
+          when :parse_source then parse_source(line)
+          when :parse_dependency then parse_dependency(line)
+          when :parse_checksum then parse_checksum(line)
+          when :parse_platform then parse_platform(line)
+          when :parse_ruby then parse_ruby(line)
+          when :parse_bundled_with then parse_bundled_with(line)
+          end
+        end
+
+        LockfileData.new(
+          specs: @specs,
+          dependencies: @dependencies,
+          platforms: @platforms,
+          sources: @sources,
+          bundler_version: @bundler_version,
+          ruby_version: @ruby_version,
+          checksums: @checksums,
+        )
+      end
+
+      private
+
+      def parse_source(line)
+        case line
+        when SPECS
+          @current_source = build_source(@source_type, @source_opts)
+          @sources << @current_source if @current_source
+        when OPTIONS
+          key = $1
+          value = $2
+          value = true if value == "true"
+          value = false if value == "false"
+
+          if @source_opts[key]
+            @source_opts[key] = Array(@source_opts[key])
+            @source_opts[key] << value
+          else
+            @source_opts[key] = value
+          end
+        else
+          parse_spec(line)
+        end
+      end
+
+      def parse_spec(line)
+        return unless line =~ NAME_VERSION
+        spaces = $1
+        name = $2.freeze
+        version = $3
+        platform = $4
+
+        if spaces.length == 4
+          # This is a spec line (top-level spec under a source)
+          spec = {
+            name: name,
+            version: version,
+            platform: platform || "ruby",
+            dependencies: [],
+            source: @current_source,
+            checksum: nil,
+          }
+          @specs << spec
+          @current_spec = spec
+        elsif spaces.length == 6 && @current_spec
+          # This is a dependency of the current spec
+          dep_versions = version ? version.split(",").map(&:strip) : [">= 0"]
+          @current_spec[:dependencies] << { name: name, version_reqs: dep_versions }
+        end
+      end
+
+      def parse_dependency(line)
+        return unless line =~ NAME_VERSION
+        spaces = $1
+        return unless spaces.length == 2
+
+        name = $2.freeze
+        version = $3
+        pinned = $5
+
+        version_reqs = version ? version.split(",").map(&:strip) : [">= 0"]
+
+        @dependencies[name] = {
+          name: name,
+          version_reqs: version_reqs,
+          pinned: pinned == "!",
+        }
+      end
+
+      def parse_checksum(line)
+        return unless line =~ NAME_VERSION
+        spaces = $1
+        return unless spaces.length == 2
+
+        name = $2
+        version = $3
+        platform = $4 || "ruby"
+        checksums_str = $6
+
+        key = platform == "ruby" ? "#{name}-#{version}" : "#{name}-#{version}-#{platform}"
+
+        if checksums_str
+          @checksums[key] = checksums_str.split(",").map(&:strip)
+        else
+          @checksums[key] = []
+        end
+      end
+
+      def parse_platform(line)
+        stripped = line.strip
+        return if stripped.empty?
+        @platforms << stripped
+      end
+
+      def parse_ruby(line)
+        stripped = line.strip
+        return if stripped.empty?
+        @ruby_version = stripped
+      end
+
+      def parse_bundled_with(line)
+        stripped = line.strip
+        return if stripped.empty?
+        @bundler_version = stripped
+      end
+
+      def build_source(type, opts)
+        case type
+        when GEM
+          Source::Rubygems.from_lock(opts.dup)
+        when GIT
+          Source::Git.from_lock(opts.dup)
+        when PATH
+          Source::Path.from_lock(opts.dup)
+        end
+      end
+    end
+  end
+end

data/lib/scint/lockfile/writer.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+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, BUNDLED WITH.
+    class Writer
+      def self.write(lockfile_data)
+        new(lockfile_data).generate
+      end
+
+      def initialize(lockfile_data)
+        @data = lockfile_data
+      end
+
+      def generate
+        out = String.new
+
+        add_sources(out)
+        add_platforms(out)
+        add_dependencies(out)
+        add_checksums(out)
+        add_ruby_version(out)
+        add_bundled_with(out)
+
+        out
+      end
+
+      private
+
+      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 = matched || @data.sources.first
+          specs_by_source[target] ||= []
+          specs_by_source[target] << spec
+        end
+
+        first = true
+        @data.sources.each do |source|
+          out << "\n" unless first
+          first = false
+
+          out << source.to_lock
+          add_specs(out, specs_by_source[source] || [])
+        end
+      end
+
+      def normalize_source_uri(uri)
+        s = uri.to_s.chomp("/")
+        s.sub(%r{^https?://}, "").downcase
+      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}"
+          else
+            "#{s.name}-#{s.version}#{"-#{s.platform}" if s.platform != "ruby"}"
+          end
+        end
+
+        sorted.each do |spec|
+          name, version, platform, deps = if spec.is_a?(Hash)
+            [spec[:name], spec[:version], spec[:platform], spec[:dependencies] || []]
+          else
+            [spec.name, spec.version, spec.platform, spec.dependencies || []]
+          end
+
+          # Format: "    name (version)" or "    name (version-platform)"
+          version_str = platform && platform != "ruby" ? "#{version}-#{platform}" : version.to_s
+          out << "    #{name} (#{version_str})\n"
+
+          # Dependencies of this spec (6-space indent)
+          dep_list = deps.sort_by { |d| d.is_a?(Hash) ? d[:name] : d.name }
+          dep_list.each do |dep|
+            dep_name, dep_reqs = if dep.is_a?(Hash)
+              [dep[:name], dep[:version_reqs]]
+            else
+              [dep.name, dep.version_reqs]
+            end
+
+            if dep_reqs && dep_reqs != [">= 0"]
+              out << "      #{dep_name} (#{Array(dep_reqs).join(", ")})\n"
+            else
+              out << "      #{dep_name}\n"
+            end
+          end
+        end
+      end
+
+      def add_platforms(out)
+        return if @data.platforms.empty?
+        out << "\nPLATFORMS\n"
+        @data.platforms.sort.each do |p|
+          out << "  #{p}\n"
+        end
+      end
+
+      def add_dependencies(out)
+        return if @data.dependencies.empty?
+        out << "\nDEPENDENCIES\n"
+
+        deps = @data.dependencies
+        dep_list = if deps.is_a?(Hash)
+          deps.values
+        else
+          deps
+        end
+
+        dep_list.sort_by { |d| d.is_a?(Hash) ? d[:name] : d.name }.each do |dep|
+          name, reqs, pinned = if dep.is_a?(Hash)
+            [dep[:name], dep[:version_reqs], dep[:pinned]]
+          else
+            [dep.name, dep.version_reqs, dep.pinned]
+          end
+
+          out << "  #{name}"
+          if reqs && reqs != [">= 0"]
+            out << " (#{Array(reqs).join(", ")})"
+          end
+          out << "!" if pinned
+          out << "\n"
+        end
+      end
+
+      def add_checksums(out)
+        return unless @data.checksums
+        out << "\nCHECKSUMS\n"
+
+        @data.checksums.sort.each do |key, values|
+          if values && !values.empty?
+            out << "  #{key} #{values.join(",")}\n"
+          else
+            out << "  #{key}\n"
+          end
+        end
+      end
+
+      def add_ruby_version(out)
+        return unless @data.ruby_version
+        out << "\nRUBY 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
+  end
+end

data/lib/scint/platform.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "etc"
+require "rbconfig"
+
+module Scint
+  module Platform
+    module_function
+
+    def cpu_count
+      @cpu_count ||= Etc.nprocessors
+    end
+
+    def abi_key
+      @abi_key ||= begin
+        engine = RUBY_ENGINE          # "ruby", "jruby", etc.
+        version = RUBY_VERSION        # "3.3.0"
+        arch = RbConfig::CONFIG["arch"] # "arm64-darwin24"
+        "#{engine}-#{version}-#{arch}"
+      end
+    end
+
+    def local_platform
+      @local_platform ||= ::Gem::Platform.local
+    end
+
+    def match_platform?(spec_platform)
+      return true if spec_platform.nil?
+      return true if spec_platform == "ruby"
+
+      spec_plat = spec_platform.is_a?(::Gem::Platform) ? spec_platform : ::Gem::Platform.new(spec_platform)
+      spec_plat === local_platform
+    end
+
+    def ruby_engine
+      RUBY_ENGINE
+    end
+
+    def ruby_version
+      RUBY_VERSION
+    end
+
+    def extension_api_version
+      ::Gem.extension_api_version
+    end
+
+    def arch
+      RbConfig::CONFIG["arch"]
+    end
+
+    def gem_arch
+      local_platform.to_s
+    end
+
+    def os
+      RbConfig::CONFIG["host_os"]
+    end
+
+    def windows?
+      !!(os =~ /mswin|mingw|cygwin/)
+    end
+
+    def macos?
+      !!(os =~ /darwin/)
+    end
+
+    def linux?
+      !!(os =~ /linux/)
+    end
+  end
+end