gel 0.2.0

data/lib/gel/pub_grub/preference_strategy.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Gel::PubGrub
+  class PreferenceStrategy
+    def initialize(loader, overrides, bump: :major, strict: false)
+      @loader = loader
+      @overrides = overrides
+      @bump = bump
+      @strict = strict
+    end
+
+    # Overrides first, then packages for which we have a preference (and
+    # that preference is still in play), then everything else.
+    def package_priority(package, versions)
+      if package.name =~ /^~/
+        -1000
+      elsif @overrides.key?(package.name)
+        -100
+      elsif range = ranges[package.name]
+        yes, no = versions.partition { |version| range.satisfied_by?(version) }
+        if yes.any? && no.any?
+          -50
+        else
+          0
+        end
+      else
+        0
+      end
+    end
+
+    def sort_versions_by_preferred(package, versions)
+      return versions if @strict # already filtered
+      return versions unless range = ranges[package.name]
+      versions.partition { |version| range.satisfied_by?(version) }.inject(:+)
+    end
+
+    def constraints
+      ranges = @strict ? self.ranges : @overrides
+
+      result = {}
+      ranges.each do |package_name, range|
+        result[package_name] = [range] if range
+      end
+      result
+    end
+
+    private
+
+    def ranges
+      @ranges ||=
+        begin
+          result = @overrides.dup
+          @loader.each_gem do |section, body, name, version, platform, deps|
+            next if @overrides.key?(name)
+
+            result[name] = range_for(version, @bump)
+          end
+          result.delete_if { |_, v| !v }
+          result
+        end
+    end
+
+    def range_for(version, bump)
+      version = Gel::Support::GemVersion.new(version)
+
+      case bump
+      when :major
+        Gel::Support::GemRequirement.new ">= #{version}"
+      when :minor
+        next_major = version.bump
+        next_major = next_major.bump while next_major.segments.size > 2
+        Gel::Support::GemRequirement.new [">= #{version}", "< #{next_major}"]
+      when :patch
+        next_minor = version.bump
+        next_minor = next_minor.bump while next_minor.segments.size > 3
+        Gel::Support::GemRequirement.new [">= #{version}", "< #{next_minor}"]
+      when :hold
+        Gel::Support::GemRequirement.new "= #{version}"
+      end
+    end
+  end
+end

data/lib/gel/pub_grub/source.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "pub_grub"
+require "pub_grub/basic_package_source"
+require "pub_grub/rubygems"
+
+module Gel::PubGrub
+  class Source < ::PubGrub::BasicPackageSource
+    Spec = Struct.new(:catalog, :name, :version, :info) do
+      def gem_version
+        @gem_version ||= Gel::Support::GemVersion.new(version)
+      end
+    end
+
+    attr_reader :root, :root_version
+
+    def initialize(gemfile, catalogs, active_platforms, preference_strategy)
+      @gemfile = gemfile
+      @catalogs = catalogs
+      @active_platforms = active_platforms
+      @preference_strategy = preference_strategy
+
+      @packages = Hash.new {|h, k| h[k] = PubGrub::Package.new(k) }
+      @root = PubGrub::Package.root
+      @root_version = PubGrub::Package.root_version
+
+      @cached_specs = Hash.new { |h, k| h[k] = {} }
+      @specs_by_package_version = {}
+
+      super()
+    end
+
+    def spec_for_version(package, version)
+      if package.name =~ /^~/
+        return Spec.new(nil, package.name, version, [])
+      end
+
+      @specs_by_package_version[package][version.to_s]
+    end
+
+    def all_versions_for(package)
+      if package.name =~ /^~/
+        return [Gem::Version.new("0")]
+      end
+
+      fetch_package_info(package)
+
+      @specs_by_package_version[package].values.map(&:gem_version)
+    end
+
+    def sort_versions_by_preferred(package, sorted_versions)
+      sorted_versions = sorted_versions.reverse
+
+      if @preference_strategy
+        sorted_versions = @preference_strategy.sort_versions_by_preferred(package, sorted_versions)
+      end
+
+      prereleases, releases = sorted_versions.partition(&:prerelease?)
+      releases.concat(prereleases)
+    end
+
+    def dependencies_for(package, version)
+      deps = {}
+
+      case package.name
+      when "~arguments"
+        if @preference_strategy
+          @preference_strategy.constraints.each do |name, constraints|
+            deps[name] ||= []
+            deps[name].concat constraints.flatten
+          end
+        end
+      when /^~/
+        raise "Unknown pseudo-package"
+      else
+        fetch_package_info(package) # probably already done, can't hurt
+
+        spec = @specs_by_package_version[package][version.to_s]
+        info = spec.info
+        info = info.select { |p, i| @active_platforms.include?(p) }
+
+        info.flat_map { |_, i| i[:dependencies] }.each do |n, cs|
+          deps[n] ||= []
+          deps[n].concat cs
+        end
+
+        # FIXME: ruby_constraints ???
+      end
+
+      deps
+    end
+
+    def root_dependencies
+      deps = { "~arguments" => [] }
+
+      @gemfile.gems.select do |_, _, options|
+        next true unless platforms = options[:platforms]
+        !([*platforms] & [:ruby, :mri]).empty?
+      end.each do |name, constraints, _|
+        deps[name] ||= []
+        deps[name].concat constraints.flatten
+      end
+
+      deps.values.each(&:uniq!)
+
+      deps
+    end
+
+    def parse_dependency(package, requirement)
+      ::PubGrub::VersionConstraint.new(@packages[package], range: to_range(requirement))
+    end
+
+    private
+
+    def fetch_package_info(package)
+      return if @specs_by_package_version.key?(package)
+
+      specs = []
+      @catalogs.each do |catalog|
+        if catalog.nil?
+          break unless specs.empty?
+          next
+        end
+
+        if info = catalog.gem_info(package.name)
+          @cached_specs[catalog][package.name] ||=
+            begin
+              grouped_versions = info.to_a.map do |full_version, attributes|
+                version, platform = full_version.split("-", 2)
+                platform ||= "ruby"
+                [version, platform, attributes]
+              end.group_by(&:first)
+
+              grouped_versions.map { |version, tuples| Spec.new(catalog, package.name, version, tuples.map { |_, p, a| [p, a] }) }
+            end
+
+          specs.concat @cached_specs[catalog][package.name]
+        end
+      end
+
+      @specs_by_package_version[package] = {}
+      specs.each do |spec|
+        # TODO: are we going to find specs in multiple catalogs this way?
+        @specs_by_package_version[package][spec.version] = spec
+      end
+    end
+
+    def to_range(constraints)
+      requirement = Gel::Support::GemRequirement.new(constraints)
+      ::PubGrub::RubyGems.requirement_to_range(requirement)
+    end
+  end
+end

data/lib/gel/runtime.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "../gel"
+
+dir = ENV["GEL_STORE"] || "~/.local/gel"
+dir = File.expand_path(dir)
+
+unless Dir.exist?(dir)
+  require "fileutils"
+  FileUtils.mkdir_p(dir)
+end
+
+dir = File.realpath(dir)
+
+stores = {}
+Gel::Environment.store_set.each do |key|
+  subdir = File.join(dir, key)
+  Dir.mkdir(subdir) unless Dir.exist?(subdir)
+  stores[key] = Gel::Store.new(subdir)
+end
+store = Gel::MultiStore.new(dir, stores)
+
+Gel::Environment.open(Gel::LockedStore.new(store))
+
+if ENV["GEL_LOCKFILE"] && ENV["GEL_LOCKFILE"] != ""
+  Gel::Environment.activate(output: $stderr)
+end

data/lib/gel/store.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require_relative "db"
+
+class Gel::Store
+  attr_reader :root
+  attr_reader :monitor
+
+  def initialize(root)
+    @root = File.realpath(File.expand_path(root))
+    @primary_db = Gel::DB.new(root, "store")
+    @lib_db = Gel::DB.new(root, "libs")
+    @rlib_db = Gel::DB::File.new(root, "meta")
+
+    @monitor = Monitor.new
+  end
+
+  def stub_set
+    @stub_set ||= Gel::StubSet.new(@root)
+  end
+
+  def paths
+    [@root.dup]
+  end
+
+  def add_gem(name, version, bindir, executables, require_paths, dependencies, extensions)
+    name = normalize_string(name)
+    version = normalize_string(version)
+    bindir = normalize_string(bindir)
+    executables = executables.map { |v| normalize_string(v) }
+    require_paths = require_paths.map { |v| normalize_string(v) }
+    _dependencies = {}
+    dependencies.each do |key, dep|
+      _dependencies[normalize_string(key)] = dep.map { |pair| pair.map { |v| normalize_string(v) } }
+    end
+    dependencies = _dependencies
+    extensions = !!extensions
+
+    @primary_db.writing do
+      vs = @primary_db["v/#{name}"] || []
+      raise "already installed" if vs.include?(version)
+      vs << version
+      vs.sort_by! { |v| Gel::Support::GemVersion.new(v) }
+      vs.reverse!
+      @primary_db["v/#{name}"] = vs
+
+      d = {}
+      d[:bindir] = bindir unless bindir == "bin"
+      d[:executables] = executables unless executables.empty?
+      d[:require_paths] = require_paths unless require_paths == ["lib"]
+      d[:dependencies] = dependencies unless dependencies.empty?
+      d[:extensions] = extensions if extensions
+      @primary_db["i/#{name}/#{version}"] = d
+
+      yield if block_given?
+    end
+  end
+
+  def add_lib(name, version, files)
+    name = normalize_string(name)
+    version = version.is_a?(Array) ? version.map { |v| normalize_string(v) } : normalize_string(version)
+    files = files.map { |v| normalize_string(v) }
+
+    @lib_db.writing do
+      @rlib_db.writing do |rst|
+        files.each do |file|
+          h = @lib_db[file] || {}
+          d = h[name] || []
+          raise "already installed" if d.include?(version)
+          d << version
+          h[name] = d.sort_by.with_index { |(v, _), idx| [Gel::Support::GemVersion.new(v), -idx] }.reverse
+          @lib_db[file] = h
+        end
+
+        v, d = version
+        ls = @rlib_db["#{name}-#{v}"] || []
+        unless sls = ls.assoc(d)
+          sls = [d, []]
+          ls << sls
+        end
+        sls.last.concat files
+        @rlib_db["#{name}-#{v}"] = ls
+      end
+    end
+  end
+
+  def gem?(name, version, _platform = nil)
+    !!gem_info(name, version)
+  end
+
+  def gem(name, version)
+    info = gem_info(name, version)
+    info && _gem(name, version, info)
+  end
+
+  def gems(name_version_pairs)
+    result = {}
+
+    name_version_pairs.each do |name, version|
+      if info = gem_info(name, version)
+        result[name] = _gem(name, version, info)
+      end
+    end
+
+    result
+  end
+
+  def gem_root(name, version)
+    "#{@root}/gems/#{name}-#{version}"
+  end
+
+  def extension_path(name, version)
+    "#{@root}/ext/#{name}-#{version}"
+  end
+
+  def prepare(versions)
+  end
+
+  def libs_for_gems(versions)
+    @rlib_db.reading do
+      versions.each do |name, version|
+        if libs = @rlib_db["#{name}-#{version}"]
+          yield name, version, libs
+        end
+      end
+    end
+  end
+
+  def gems_for_lib(file)
+    if h = @lib_db[file]
+      h.each do |name, versions|
+        versions.each do |version|
+          if version.is_a?(Array)
+            version, subdir = version
+            yield gem(name, version), subdir
+          else
+            yield gem(name, version)
+          end
+        end
+      end
+    end
+  end
+
+  def each(gem_name = nil)
+    return enum_for(__callee__, gem_name) unless block_given?
+
+    if gem_name
+      @primary_db.reading do
+        return unless vs = @primary_db["v/#{gem_name}"]
+        vs.each do |version|
+          if info = @primary_db["i/#{gem_name}/#{version}"]
+            yield _gem(gem_name, version, info)
+          end
+        end
+      end
+    else
+      gem_names = []
+      @primary_db.each_key do |k|
+        gem_names << $1 if k =~ /\Av\/(.*)\z/
+      end
+
+      block = Proc.new
+      gem_names.each do |n|
+        each(n, &block)
+      end
+    end
+  end
+
+  def inspect
+    content = each.map { |g| "#{g.name}-#{g.version}" }
+    content = ["(none)"] if content.empty?
+    content.sort!
+
+    "#<#{self.class} root=#{@root.inspect} content=#{content.join(",")}>"
+  end
+
+  private
+
+  def _gem(name, version, info)
+    info = inflate_info(info)
+    extensions = extension_path(name, version) if info[:extensions]
+    Gel::StoreGem.new(gem_root(name, version), name, version, extensions, info)
+  end
+
+  def gem_info(name, version)
+    @primary_db["i/#{name}/#{version}"]
+  end
+
+  def inflate_info(d)
+    d = d.dup
+    d[:bindir] = "bin" unless d.key?(:bindir)
+    d[:executables] = [] unless d.key?(:executables)
+    d[:require_paths] = ["lib"] unless d.key?(:require_paths)
+    d[:dependencies] = {} unless d.key?(:dependencies)
+    d
+  end
+
+  # Almost every string we store is pure ASCII, and binary strings
+  # marshal better.
+  def normalize_string(str)
+    str = str.to_s
+    str = str.b if str.ascii_only?
+    str
+  end
+end