gel 0.3.0 → 0.8.0.pre1

data/lib/gel/pub_grub/source.rb

@@ -1,51 +1,46 @@
 # frozen_string_literal: true
 
-require "pub_grub"
-require "pub_grub/basic_package_source"
-require "pub_grub/rubygems"
+require_relative "../vendor/pub_grub"
+require_relative "../../../vendor/pub_grub/lib/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
+require_relative "package"
+require_relative "../platform"
 
-    attr_reader :root, :root_version
+module Gel::PubGrub
+  class Source < Gel::Vendor::PubGrub::BasicPackageSource
+    attr_reader :root
 
-    def initialize(gemfile, catalogs, active_platforms, preference_strategy)
+    def initialize(gemfile, catalog_set, active_platforms, preference_strategy)
       @gemfile = gemfile
-      @catalogs = catalogs
+      @catalog_set = catalog_set
       @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
+      # pub_grub-0.5.0/lib/pub_grub/basic_package_source.rb:165
+      @packages = {}
 
-      @cached_specs = Hash.new { |h, k| h[k] = {} }
-      @specs_by_package_version = {}
+      @root = Package::Pseudo.new(:root)
 
       super()
     end
 
-    def spec_for_version(package, version)
-      if package.name =~ /^~/
-        return Spec.new(nil, package.name, version, [])
+    def active_platforms_map
+      @active_platforms_map ||= Hash.new(@active_platforms).tap do |result|
+        @gemfile.gems.each do |name, _, options|
+          if options.key?(:platforms)
+            filter = Array(options[:platforms] || ["ruby"]).map(&:to_s)
+            result[name] = Gel::Platform.filter(@active_platforms, filter)
+          end
+        end
       end
-
-      @specs_by_package_version[package][version.to_s]
     end
 
     def all_versions_for(package)
-      if package.name =~ /^~/
-        return [Gem::Version.new("0")]
+      if package.is_a?(Package::Pseudo)
+        return [Gel::Support::GemVersion.new("0")]
       end
 
-      fetch_package_info(package)
-
-      @specs_by_package_version[package].values.map(&:gem_version)
+      @catalog_set.entries_for(package).map(&:gem_version)
     end
 
     def sort_versions_by_preferred(package, sorted_versions)
@@ -62,92 +57,69 @@ module Gel::PubGrub
     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
+      if package.is_a?(Package::Pseudo)
+        case package.role
+        when :root
+          deps = { Package::Pseudo.new(:arguments) => [], Package::Pseudo.new(:gemfile) => [] }
 
-        spec = @specs_by_package_version[package][version.to_s]
-        info = spec.info
-        info = info.select { |p, i| @active_platforms.include?(p) }
+        when :gemfile
+          @gemfile.gems.each do |name, constraints, _|
+            platforms = active_platforms_map[name]
+            platforms = [nil] if platforms.empty?
 
-        info.flat_map { |_, i| i[:dependencies] }.each do |n, cs|
-          deps[n] ||= []
-          deps[n].concat cs
-        end
+            platforms.each do |platform|
+              (deps[Package.new(name, platform)] ||= []).concat(constraints.flatten)
+            end
+          end
 
-        # FIXME: ruby_constraints ???
-      end
+          deps.values.each(&:uniq!)
 
-      deps
-    end
-
-    def root_dependencies
-      deps = { "~arguments" => [] }
+        when :arguments
+          if @preference_strategy
+            @preference_strategy.constraints.each do |name, constraints|
+              @active_platforms.each do |platform|
+                (deps[Package.new(name, platform)] ||= []).concat(constraints.flatten)
+              end
+            end
+          end
 
-      @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
+        else
+          raise "Unknown pseudo-package #{package.inspect}"
+        end
+      else
+        @catalog_set.dependencies_for(package, version).each do |n, cs|
+          (deps[Package.new(n, package.platform)] ||= []).concat(cs.flatten)
+        end
       end
 
-      deps.values.each(&:uniq!)
-
       deps
     end
 
     def parse_dependency(package, requirement)
-      ::PubGrub::VersionConstraint.new(@packages[package], range: to_range(requirement))
+      Gel::Vendor::PubGrub::VersionConstraint.new(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)
+    def incompatibilities_for(package, version)
+      result = super
 
-              grouped_versions.map { |version, tuples| Spec.new(catalog, package.name, version, tuples.map { |_, p, a| [p, a] }) }
-            end
+      unless package.is_a?(Package::Pseudo)
+        other_platforms = @active_platforms - [package.platform]
 
-          specs.concat @cached_specs[catalog][package.name]
+        self_constraint = Gel::Vendor::PubGrub::VersionConstraint.new(package, range: Gel::Vendor::PubGrub::VersionRange.new(min: version, max: version, include_min: true, include_max: true))
+        result += other_platforms.map do |other_platform|
+          other_constraint = Gel::Vendor::PubGrub::VersionConstraint.new(Package.new(package.name, other_platform), range: Gel::Vendor::PubGrub::VersionUnion.new([Gel::Vendor::PubGrub::VersionRange.new(max: version), Gel::Vendor::PubGrub::VersionRange.new(min: version)]))
+          Gel::Vendor::PubGrub::Incompatibility.new([Gel::Vendor::PubGrub::Term.new(self_constraint, true), Gel::Vendor::PubGrub::Term.new(other_constraint, true)], cause: :dependency)
         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
+      result
     end
 
+    private
+
     def to_range(constraints)
       requirement = Gel::Support::GemRequirement.new(constraints)
-      ::PubGrub::RubyGems.requirement_to_range(requirement)
+      Gel::Vendor::PubGrub::RubyGems.requirement_to_range(requirement)
     end
   end
 end

data/lib/gel/resolved_gem_set.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require_relative "set"
+
+class Gel::ResolvedGemSet
+  class ResolvedGem
+    attr_reader :name, :version, :platform, :deps, :set
+
+    def initialize(name, version, platform, deps, set:, catalog: nil)
+      @name = name
+      @version = version
+      @platform = platform
+      @deps = deps
+
+      @set = set
+      @catalog = catalog
+    end
+
+    def catalog
+      @catalog || set.catalog_for(self)
+    end
+
+    def full_version
+      if platform
+        "#{version}-#{platform}"
+      else
+        version
+      end
+    end
+  end
+
+  attr_reader :filename
+
+  attr_writer :server_catalogs
+
+  attr_accessor :catalog_uris
+  attr_accessor :gems
+  attr_accessor :platforms
+  attr_accessor :ruby_version
+  attr_accessor :bundler_version
+  attr_accessor :dependencies
+
+  def initialize(filename = nil)
+    @filename = filename
+
+    @gems = {}
+  end
+
+  def catalog_for(resolved_gem)
+    # FIXME
+  end
+
+  def self.load(filename, git_depot: nil)
+    result = new(filename)
+
+    result.catalog_uris = Gel::Set.new
+
+    Gel::LockParser.new.parse(File.read(filename)).each do |(section, body)|
+      case section
+      when "GEM", "PATH", "GIT"
+        case section
+        when "GEM"
+          catalog = nil
+
+          body["remote"]&.each do |remote|
+            result.catalog_uris << remote
+          end
+        when "PATH"
+          require_relative "path_catalog"
+          catalog = Gel::PathCatalog.new(body["remote"].first)
+        when "GIT"
+          ref_type = [:branch, :tag, :ref].find { |t| body[t.to_s] } || :ref
+          require_relative "git_catalog"
+          catalog = Gel::GitCatalog.new(git_depot, body["remote"].first, ref_type, body[ref_type.to_s]&.first, body["revision"]&.first)
+        end
+
+        specs = body["specs"]
+        specs.each do |gem_spec, dep_specs|
+          gem_spec =~ /\A(.+) \(([^-]+)(?:-(.+))?\)\z/
+          name, version, platform = $1, $2, $3
+
+          if dep_specs
+            deps = dep_specs.map do |spec|
+              spec =~ /\A(.+?)(?: \((.+)\))?\z/
+              [$1, $2 ? $2.split(", ") : []]
+            end
+          else
+            deps = []
+          end
+
+          (result.gems[name] ||= []) << ResolvedGem.new(name, version, platform, deps, set: result, catalog: catalog)
+        end
+      when "PLATFORMS"
+        result.platforms = body
+      when "DEPENDENCIES"
+        result.dependencies = body.map { |name| name.chomp("!") }
+      when "RUBY VERSION"
+        result.ruby_version = body.first
+      when "BUNDLED WITH"
+        result.bundler_version = body.first
+      else
+        warn "Unknown lockfile section #{section.inspect}"
+      end
+    end
+
+    result
+  end
+
+  def server_catalogs
+    @server_catalogs ||=
+      begin
+        require_relative "catalog"
+
+        remote_catalogs = catalog_uris.map { |uri| Gel::Catalog.new(uri, work_pool: catalog_pool) }
+
+        vendor_path = File.expand_path("../vendor/cache", filename)
+        if Dir.exist?(vendor_path)
+          require_relative "vendor_catalog"
+
+          vendor_catalog = Gel::VendorCatalog.new(vendor_path)
+          vendor_catalog.prepare
+          [vendor_catalog] + remote_catalogs
+        else
+          remote_catalogs
+        end
+      end
+  end
+
+  def gem_names
+    @gems.keys
+  end
+
+  def dependency_names
+    dependencies&.map { |dep| dep.split(" ").first }
+  end
+
+  def dump
+    lock_content = []
+
+    output_specs_for = lambda do |results|
+      lock_content << "  specs:"
+      results.each do |resolved_gem|
+        next if resolved_gem.name == "bundler" || resolved_gem.name == "ruby"
+
+        lock_content << "    #{resolved_gem.name} (#{resolved_gem.full_version})"
+        sorted_deps = resolved_gem.deps.sort_by { |dep_name, dep_reqs| dep_name }
+        sorted_deps.each do |dep_name, dep_reqs|
+          if dep_reqs
+            lock_content << "      #{dep_name} (#{dep_reqs})"
+          else
+            lock_content << "      #{dep_name}"
+          end
+        end
+      end
+    end
+
+    grouped_graph = gems.values.flatten(1).sort_by { |rg| [rg.name, "#{rg.full_version}"] }.group_by { |rg|
+      catalog = rg.catalog
+      catalog.is_a?(Gel::PathCatalog) || catalog.is_a?(Gel::GitCatalog) ? catalog : nil
+    }
+    server_gems = grouped_graph.delete(nil)
+
+    grouped_graph.keys.sort_by do |catalog|
+      case catalog
+      when Gel::GitCatalog
+        [1, catalog.remote, catalog.revision]
+      when Gel::PathCatalog
+        [2, catalog.path]
+      end
+    end.each do |catalog|
+      case catalog
+      when Gel::GitCatalog
+        lock_content << "GIT"
+        lock_content << "  remote: #{catalog.remote}"
+        lock_content << "  revision: #{catalog.revision}"
+        lock_content << "  #{catalog.ref_type}: #{catalog.ref}" if catalog.ref
+      when Gel::PathCatalog
+        lock_content << "PATH"
+        lock_content << "  remote: #{catalog.path}"
+      end
+
+      output_specs_for.call(grouped_graph[catalog])
+      lock_content << ""
+    end
+
+    if server_gems
+      lock_content << "GEM"
+      server_catalogs.each do |catalog|
+        lock_content << "  remote: #{catalog}"
+      end
+      output_specs_for.call(server_gems)
+      lock_content << ""
+    end
+
+    if platforms && !platforms.empty?
+      lock_content << "PLATFORMS"
+      platforms.sort.each do |platform|
+        lock_content << "  #{platform}"
+      end
+      lock_content << ""
+    end
+
+    lock_content << "DEPENDENCIES"
+    bang_deps = (server_gems&.select { |rg| rg.catalog != server_catalogs.first }&.map(&:name) || []) +
+      grouped_graph.values.flatten(1).map(&:name)
+    dependencies.each do |dependency|
+      dependency_name = dependency.split(" ").first
+      bang = "!" if bang_deps.include?(dependency_name)
+      lock_content << "  #{dependency}#{bang}"
+    end
+    lock_content << ""
+
+    if ruby_version
+      lock_content << "RUBY VERSION"
+      lock_content << "   #{ruby_version}"
+      lock_content << ""
+    end
+
+    if bundler_version
+      lock_content << "BUNDLED WITH"
+      lock_content << "   #{bundler_version}"
+      lock_content << ""
+    end
+
+    lock_content.join("\n")
+  end
+
+  private
+
+  def catalog_pool
+    require_relative "work_pool"
+    @catalog_pool ||= Gel::WorkPool.new(8, name: "gel-catalog")
+  end
+end

data/lib/gel/runtime.rb

@@ -6,8 +6,8 @@ dir = ENV["GEL_STORE"] || "~/.local/gel"
 dir = File.expand_path(dir)
 
 unless Dir.exist?(dir)
-  require "fileutils"
-  FileUtils.mkdir_p(dir)
+  require_relative "util"
+  Gel::Util.mkdir_p(dir)
 end
 
 dir = File.realpath(dir)
@@ -23,5 +23,5 @@ 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)
+  Gel::Environment.activate(fast: true, output: $stderr)
 end

data/lib/gel/set.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class Gel::Set
+  include Enumerable
+
+  def initialize
+    @inner = {}
+  end
+
+  def initialize_copy(_original)
+    @inner = @inner.dup
+  end
+
+  def each(&block)
+    @inner.each_key(&block)
+  end
+
+  def include?(value)
+    @inner.key?(value)
+  end
+
+  def size
+    @inner.size
+  end
+
+  def add(value)
+    @inner[value] = true
+  end
+  alias << add
+
+  def delete(value)
+    @inner.delete(value)
+  end
+
+  def add?(value)
+    if @inner.key?(value)
+      false
+    else
+      @inner[value] = true
+    end
+  end
+
+  def merge(other)
+    other.each do |value|
+      add(value)
+    end
+    self
+  end
+
+  def subtract(other)
+    other.each do |value|
+      delete(value)
+    end
+    self
+  end
+
+  def |(other)
+    dup.tap do |result|
+      result.merge(other)
+    end
+  end
+end

data/lib/gel/stdlib.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+class Gel::Stdlib
+  PATHS = $LOAD_PATH & (RbConfig::CONFIG.values + [File.expand_path("../../slib", __dir__)])
+
+  def self.instance
+    @instance ||= new
+  end
+
+  def initialize
+    @files = {}
+    @active = {}
+
+    PATHS.each do |path|
+      path_prefix = Gel::Util.join(path, "")
+      exclusions = PATHS.
+        select { |nested| nested.start_with?(path_prefix) }.
+        map { |x| Gel::Util.join(x, "")[path_prefix.size..-1] }
+      exclusions << "rubygems" << "bundler" unless path == File.expand_path("../../slib", __dir__)
+
+      entry_for_ext = Hash.new { |h, k| h[k] = [k, path].freeze }
+      single_entry_for_ext = Hash.new { |h, k| h[k] = [entry_for_ext[k]].freeze }
+
+      Gel::Util.loadable_files(path).each do |file|
+        next if file != "rubygems/deprecate.rb" && exclusions.any? { |exc| file.start_with?(exc) }
+
+        basename, ext = Gel::Util.split_filename_for_require(file)
+
+        basename = -basename
+        ext = -ext
+
+        if @files.key?(basename)
+          @files[basename] = @files[basename].dup << entry_for_ext[ext]
+        else
+          @files[basename] = single_entry_for_ext[ext]
+        end
+      end
+    end
+
+    @builtins = $LOADED_FEATURES.grep(/\A[^\/\\]+\z/)
+    @builtins += @builtins.map { |s| Gel::Util.split_filename_for_require(s).first }
+
+    $LOADED_FEATURES.each do |feat|
+      @files.each do |basename, pairs|
+        next unless feat.include?(basename)
+        pairs.each do |ext, path|
+          if feat == Gel::Util.join(path, basename + ext)
+            @active[basename] = @active[-(basename + ext)] = true
+          end
+        end
+      end
+    end
+  end
+
+  def activate(path)
+    @active[path] = true
+  end
+
+  def active?(path)
+    @active[path]
+  end
+
+  def resolve(search_name, search_ext)
+    if @builtins.include?(search_name)
+      if search_ext
+        full_name = search_name + search_ext
+        if @builtins.include?(full_name)
+          return search_name
+        end
+      else
+        return search_name
+      end
+    end
+
+    @files[search_name]&.each do |ext, path|
+      return Gel::Util.join(path, search_name) if Gel::Util.ext_matches_requested?(ext, search_ext)
+    end
+
+    nil
+  end
+end