gel 0.2.0

data/lib/gel/lock_parser.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+class Gel::LockParser
+  def parse(content)
+    sections = []
+
+    scanner = StringScanner.new(content)
+    while section = scanner.scan(/^(\w.+)\n/)
+      section.chomp!
+      case section
+      when "GIT", "PATH", "GEM"
+        content = {}
+        while scanner.skip(/^  \b/)
+          label = scanner.scan(/[^:]+:/).chop
+          if scanner.skip(/ /)
+            value = scanner.scan(/.*/)
+            scanner.skip(/\n/)
+            (content[label] ||= []) << value
+          else
+            scanner.skip(/\n/)
+            value = []
+            while scanner.skip(/^    \b/)
+              entry = scanner.scan(/.*/)
+              scanner.skip(/\n/)
+              children = []
+              while scanner.skip(/^      \b/)
+                child = scanner.scan(/.*/)
+                children << child
+                scanner.skip(/\n/)
+              end
+              if children.empty?
+                value << [entry]
+              else
+                value << [entry, children]
+              end
+            end
+            content[label] = value
+          end
+        end
+      when "PLATFORMS", "DEPENDENCIES"
+        content = []
+        while scanner.skip(/^  \b/)
+          entry = scanner.scan(/.*/)
+          content << entry
+          scanner.skip(/\n/)
+        end
+      when "BUNDLED WITH"
+        content = []
+        while scanner.skip(/^   \b/)
+          entry = scanner.scan(/.*/)
+          content << entry
+          scanner.skip(/\n/)
+        end
+      end
+      scanner.skip(/\n+/)
+
+      sections << [section, content]
+    end
+
+    sections
+  end
+end

data/lib/gel/locked_store.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+class Gel::LockedStore
+  attr_reader :inner
+
+  def initialize(inner)
+    @inner = inner
+    @locked_versions = nil
+
+    @lib_cache = Hash.new { |h, k| h[k] = [] }
+    @full_cache = false
+  end
+
+  def paths
+    @inner.paths
+  end
+
+  def root
+    @inner.root
+  end
+
+  def inspect
+    content = @locked_versions.map { |name, version| "#{name}=#{version.is_a?(String) ? version : version.root}" }
+    content = ["(none)"] if content.empty?
+    content.sort!
+
+    "#<#{self.class} inner=#{@inner.inspect} locks=#{content.join(",")}>"
+  end
+
+  def prepare(locks)
+    return if @full_cache
+
+    inner_versions = {}
+    locks.each do |name, version|
+      if version.is_a?(Gel::StoreGem)
+        version.libs do |file, subdir|
+          @lib_cache[file] << [version, subdir]
+        end
+      else
+        inner_versions[name] = version
+      end
+    end
+
+    g = @inner.gems(inner_versions)
+    @inner.libs_for_gems(inner_versions) do |name, version, subs|
+      subs.each do |subdir, files|
+        v = [g[name], subdir]
+        files.each do |file|
+          @lib_cache[file] << v
+        end
+      end
+    end
+  end
+
+  def lock(locks)
+    @locked_versions = locks.dup
+    prepare(locks)
+    @full_cache = true
+  end
+
+  def locked?(gem)
+    !@locked_versions || @locked_versions[gem.name] == gem.version
+  end
+
+  def locked_gems
+    @locked_versions ? @locked_versions.values.grep(Gel::StoreGem) : []
+  end
+
+  def gem(name, version)
+    if !@locked_versions || @locked_versions[name] == version
+      @inner.gem(name, version)
+    else
+      locked_gems.find { |g| g.name == name && g.version == version }
+    end
+  end
+
+  def gems(name_version_pairs)
+    r = @inner.gems(name_version_pairs)
+    locked_gems.each do |g|
+      r[g.name] = g
+    end
+    r
+  end
+
+  def gems_for_lib(file)
+    if c = @lib_cache.fetch(file, nil)
+      c.each { |gem, subdir| yield gem, subdir }
+      return
+    end
+
+    hits = []
+    unless @full_cache
+      @inner.gems_for_lib(file) do |gem, subdir|
+        if locked?(gem)
+          hits << [gem, subdir]
+          yield gem, subdir
+        end
+      end
+    end
+
+    locked_gems.each do |gem|
+      if File.exist?(gem.path(file) + ".rb")
+        hits << [gem, nil]
+        yield gem, nil
+      end
+    end
+
+    @lib_cache[file] = hits
+  end
+
+  def each(gem_name = nil)
+    return enum_for(__callee__, gem_name) unless block_given?
+
+    list = locked_gems
+
+    @inner.each(gem_name) do |gem|
+      next unless locked?(gem)
+      yield gem
+      list.delete gem
+    end
+
+    list.each do |gem|
+      yield gem if !gem_name || gem.name == gem_name
+    end
+  end
+end

data/lib/gel/multi_store.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+require_relative "stub_set"
+
+class Gel::MultiStore
+  VERSION = "#{RbConfig::CONFIG["ruby_version"]}"
+
+  attr_reader :root
+  attr_reader :monitor
+
+  def initialize(root, stores)
+    @root = File.realpath(File.expand_path(root)) if root
+    @stores = stores
+
+    @monitor = Monitor.new
+  end
+
+  def stub_set
+    @stub_set ||= Gel::StubSet.new(@root)
+  end
+
+  def paths
+    @stores.values.flat_map(&:paths).uniq
+  end
+
+  def [](architecture, version = false)
+    @stores[self.class.subkey(architecture, version)]
+  end
+
+  def self.subkey(architecture, version)
+    architecture ||= "ruby"
+    if version && architecture == "ruby"
+      VERSION
+    elsif version
+      "#{architecture}-#{VERSION}"
+    else
+      "#{architecture}"
+    end
+  end
+
+  def prepare(versions)
+    @stores.each do |_, store|
+      store.prepare(versions)
+    end
+  end
+
+  def gems_for_lib(file)
+    @stores.each do |_, store|
+      store.gems_for_lib(file) do |gem, subdir|
+        yield gem, subdir
+      end
+    end
+  end
+
+  def each(gem_name = nil, &block)
+    return enum_for(__callee__, gem_name) unless block_given?
+
+    @stores.each do |_, store|
+      store.each(gem_name, &block)
+    end
+  end
+
+  def gem(name, version)
+    @stores.each do |_, store|
+      g = store.gem(name, version)
+      return g if g
+    end
+    nil
+  end
+
+  def gems(name_version_pairs)
+    result = {}
+
+    @stores.each do |_, store|
+      result.update(store.gems(name_version_pairs)) do |l, r|
+        l
+      end
+    end
+
+    result
+  end
+
+  def gem?(name, version, platform = nil)
+    @stores.any? do |key, store|
+      next if platform && !key.start_with?(platform)
+      store.gem?(name, version)
+    end
+  end
+
+  def libs_for_gems(versions, &block)
+    @stores.each do |_, store|
+      store.libs_for_gems(versions, &block)
+    end
+  end
+end

data/lib/gel/package.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "yaml"
+
+require_relative "support/tar"
+
+module Gel
+  class Package
+    class Specification
+      def initialize(inner)
+        @inner = inner
+      end
+
+      def name
+        @inner.name
+      end
+
+      def version
+        @inner.version
+      end
+
+      def architecture
+        @inner.architecture
+      end
+
+      def bindir
+        @inner.bindir
+      end
+
+      def executables
+        @inner.executables
+      end
+
+      def require_paths
+        @inner.require_paths
+      end
+
+      def extensions
+        @inner.extensions
+      end
+
+      def runtime_dependencies
+        h = {}
+        @inner.dependencies.each do |dep|
+          next unless dep.type == :runtime || dep.type.nil?
+          req = dep.requirement || dep.version_requirements
+          h[dep.name] = req.requirements.map { |pair| pair.map(&:to_s) }
+        end
+        h
+      end
+    end
+
+    class YAMLLoader < ::YAML::ClassLoader::Restricted
+      #--
+      # Based on YAML.safe_load
+      def self.load(yaml, filename)
+        result = if Psych::VERSION < "3.1" # Ruby 2.5 & below
+                   ::YAML.parse(yaml, filename)
+                 else
+                   ::YAML.parse(yaml, filename: filename)
+                 end
+        return unless result
+
+        class_loader = self.new
+        scanner      = ::YAML::ScalarScanner.new class_loader
+
+        visitor = ::YAML::Visitors::ToRuby.new scanner, class_loader
+        visitor.accept result
+      end
+
+      def initialize
+        super(%w(Symbol Time), [])
+      end
+
+      def find(klass)
+        case klass
+        when "Gem::Specification"
+          Gem_Specification
+        when "Gem::Version"
+          Gem_Version
+        when "Gem::Version::Requirement", "Gem::Requirement"
+          Gem_Requirement
+        when "Gem::Platform"
+          Gem_Platform
+        when "Gem::Dependency"
+          Gem_Dependency
+        else
+          super
+        end
+      end
+
+      class Gem_Specification
+        attr_accessor :architecture, :bindir, :executables, :name, :require_paths, :specification_version, :version, :dependencies, :extensions
+      end
+      class Gem_Dependency
+        attr_accessor :name, :requirement, :type, :version_requirements
+      end
+      class Gem_Platform; end
+      Gem_Version = Gel::Support::GemVersion
+      class Gem_Requirement
+        attr_accessor :requirements
+      end
+    end
+
+    def self.with_file(reader, filename, checksums)
+      reader.seek(filename) do |stream|
+        if checksums
+          data = stream.read
+          stream.rewind
+
+          checksums.each do |type, map|
+            next unless %w(SHA1 SHA512).include?(type)
+            calculated = Digest(type).hexdigest(data)
+            raise "#{type} checksum mismatch on #{filename}" unless calculated == map[filename]
+          end
+        end
+
+        yield stream
+      end
+    end
+
+    def self.extract(filename, receiver)
+      File.open(filename) do |io|
+        Gel::Support::Tar::TarReader.new(io) do |package_reader|
+          sums = with_file(package_reader, "checksums.yaml.gz", nil) do |sum_stream|
+            yaml = Zlib::GzipReader.new(sum_stream).read
+
+            if Psych::VERSION < "3.1" # Ruby 2.5 & below
+              ::YAML.safe_load(yaml, [], [], false, "#{filename}:checksums.yaml.gz")
+            else
+              ::YAML.safe_load(yaml, filename: "#{filename}:checksums.yaml.gz")
+            end
+          end
+
+          spec = with_file(package_reader, "metadata.gz", sums) do |meta_stream|
+            yaml = Zlib::GzipReader.new(meta_stream).read
+            loaded = YAMLLoader.load(yaml, "#{filename}:metadata.gz")
+            Specification.new(loaded)
+          end or raise "no metadata.gz"
+
+          return receiver.gem(spec) do |target|
+            with_file(package_reader, "data.tar.gz", sums) do |data_stream|
+              Gel::Support::Tar::TarReader.new(Zlib::GzipReader.new(data_stream)) do |data_reader|
+                data_reader.each do |entry|
+                  target.file(entry.full_name, entry, entry.header.mode)
+                end
+              end
+              true
+            end or raise "no data.tar.gz"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gel/package/inspector.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Gel
+  class Package
+    class Inspector
+      def initialize(&block)
+        @block = block
+      end
+
+      attr_reader :spec
+
+      def gem(spec)
+        @spec = spec
+
+        yield self if @block
+      end
+
+      def file(filename, io, _mode)
+        @block.call filename, io
+      end
+    end
+  end
+end