carat 1.9.9.pre1

data/lib/carat/lazy_specification.rb

@@ -0,0 +1,83 @@
+require "uri"
+require "rubygems/spec_fetcher"
+require "carat/match_platform"
+
+module Carat
+  class LazySpecification
+    include MatchPlatform
+
+    attr_reader :name, :version, :dependencies, :platform
+    attr_accessor :source, :source_uri
+
+    def initialize(name, version, platform, source = nil)
+      @name          = name
+      @version       = version
+      @dependencies  = []
+      @platform      = platform
+      @source        = source
+      @specification = nil
+    end
+
+    def full_name
+      if platform == Gem::Platform::RUBY or platform.nil? then
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    def ==(other)
+      identifier == other.identifier
+    end
+
+    def satisfies?(dependency)
+      @name == dependency.name && dependency.requirement.satisfied_by?(Gem::Version.new(@version))
+    end
+
+    def to_lock
+      if platform == Gem::Platform::RUBY or platform.nil?
+        out = "    #{name} (#{version})\n"
+      else
+        out = "    #{name} (#{version}-#{platform})\n"
+      end
+
+      dependencies.sort_by {|d| d.to_s }.uniq.each do |dep|
+        next if dep.type == :development
+        out << "    #{dep.to_lock}\n"
+      end
+
+      out
+    end
+
+    def __materialize__
+      @specification = source.specs.search(Gem::Dependency.new(name, version)).last
+    end
+
+    def respond_to?(*args)
+      super || @specification.respond_to?(*args)
+    end
+
+    def to_s
+      @__to_s ||= "#{name} (#{version})"
+    end
+
+    def identifier
+      @__identifier ||= [name, version, source, platform, dependencies].hash
+    end
+
+  private
+
+    def to_ary
+      nil
+    end
+
+    def method_missing(method, *args, &blk)
+      raise "LazySpecification has not been materialized yet (calling :#{method} #{args.inspect})" unless @specification
+
+      return super unless respond_to?(method)
+
+      @specification.send(method, *args, &blk)
+    end
+
+  end
+end

data/lib/carat/lockfile_parser.rb

@@ -0,0 +1,167 @@
+require "strscan"
+
+# Some versions of the Carat 1.1 RC series introduced corrupted
+# lockfiles. There were two major problems:
+#
+# * multiple copies of the same GIT section appeared in the lockfile
+# * when this happened, those sections got multiple copies of gems
+#   in those sections.
+#
+# As a result, Carat 1.1 contains code that fixes the earlier
+# corruption. We will remove this fix-up code in Carat 1.2.
+
+module Carat
+  class LockfileParser
+    attr_reader :sources, :dependencies, :specs, :platforms
+
+    DEPENDENCIES = "DEPENDENCIES"
+    PLATFORMS    = "PLATFORMS"
+    GIT          = "GIT"
+    GEM          = "GEM"
+    PATH         = "PATH"
+    SPECS        = "  specs:"
+    OPTIONS      = /^  ([a-z]+): (.*)$/i
+    SOURCE       = [GIT, GEM, PATH]
+
+    def initialize(lockfile)
+      @platforms    = []
+      @sources      = []
+      @dependencies = []
+      @state        = nil
+      @specs        = {}
+
+      @rubygems_aggregate = Source::Rubygems.new
+
+      if lockfile.match(/<<<<<<<|=======|>>>>>>>|\|\|\|\|\|\|\|/)
+        raise LockfileError, "Your Gemfile.lock contains merge conflicts.\n" \
+          "Run `git checkout HEAD -- Gemfile.lock` first to get a clean lock."
+      end
+
+      lockfile.split(/(?:\r?\n)+/).each do |line|
+        if SOURCE.include?(line)
+          @state = :source
+          parse_source(line)
+        elsif line == DEPENDENCIES
+          @state = :dependency
+        elsif line == PLATFORMS
+          @state = :platform
+        elsif line =~ /^[^\s]/
+          @state = nil
+        elsif @state
+          send("parse_#{@state}", line)
+        end
+      end
+      @sources << @rubygems_aggregate
+      @specs = @specs.values
+    rescue ArgumentError => e
+      Carat.ui.debug(e)
+      raise LockfileError, "Your lockfile is unreadable. Run `rm Gemfile.lock` " \
+        "and then `carat install` to generate a new lockfile."
+    end
+
+  private
+
+    TYPES = {
+      GIT  => Carat::Source::Git,
+      GEM  => Carat::Source::Rubygems,
+      PATH => Carat::Source::Path,
+    }
+
+    def parse_source(line)
+      case line
+      when GIT, GEM, PATH
+        @current_source = nil
+        @opts, @type = {}, line
+      when SPECS
+        case @type
+        when PATH
+          @current_source = TYPES[@type].from_lock(@opts)
+          @sources << @current_source
+        when GIT
+          @current_source = TYPES[@type].from_lock(@opts)
+          # Strip out duplicate GIT sections
+          if @sources.include?(@current_source)
+            @current_source = @sources.find { |s| s == @current_source }
+          else
+            @sources << @current_source
+          end
+        when GEM
+          Array(@opts["remote"]).each do |url|
+            @rubygems_aggregate.add_remote(url)
+          end
+          @current_source = @rubygems_aggregate
+        end
+      when OPTIONS
+        value = $2
+        value = true if value == "true"
+        value = false if value == "false"
+
+        key = $1
+
+        if @opts[key]
+          @opts[key] = Array(@opts[key])
+          @opts[key] << value
+        else
+          @opts[key] = value
+        end
+      else
+        parse_spec(line)
+      end
+    end
+
+    NAME_VERSION = '(?! )(.*?)(?: \(([^-]*)(?:-(.*))?\))?'
+    NAME_VERSION_2 = %r{^ {2}#{NAME_VERSION}(!)?$}
+    NAME_VERSION_4 = %r{^ {4}#{NAME_VERSION}$}
+    NAME_VERSION_6 = %r{^ {6}#{NAME_VERSION}$}
+
+    def parse_dependency(line)
+      if line =~ NAME_VERSION_2
+        name, version, pinned = $1, $2, $4
+        version = version.split(",").map { |d| d.strip } if version
+
+        dep = Carat::Dependency.new(name, version)
+
+        if pinned && dep.name != 'carat'
+          spec = @specs.find {|k, v| v.name == dep.name }
+          dep.source = spec.last.source if spec
+
+          # Path sources need to know what the default name / version
+          # to use in the case that there are no gemspecs present. A fake
+          # gemspec is created based on the version set on the dependency
+          # TODO: Use the version from the spec instead of from the dependency
+          if version && version.size == 1 && version.first =~ /^\s*= (.+)\s*$/ && dep.source.is_a?(Carat::Source::Path)
+            dep.source.name    = name
+            dep.source.version = $1
+          end
+        end
+
+        @dependencies << dep
+      end
+    end
+
+    def parse_spec(line)
+      if line =~ NAME_VERSION_4
+        name, version = $1, Gem::Version.new($2)
+        platform = $3 ? Gem::Platform.new($3) : Gem::Platform::RUBY
+        @current_spec = LazySpecification.new(name, version, platform)
+        @current_spec.source = @current_source
+
+        # Avoid introducing multiple copies of the same spec (caused by
+        # duplicate GIT sections)
+        @specs[@current_spec.identifier] ||= @current_spec
+      elsif line =~ NAME_VERSION_6
+        name, version = $1, $2
+        version = version.split(',').map { |d| d.strip } if version
+        dep = Gem::Dependency.new(name, version)
+        @current_spec.dependencies << dep
+      end
+    end
+
+    def parse_platform(line)
+      if line =~ /^  (.*)$/
+        @platforms << Gem::Platform.new($1)
+      end
+    end
+
+  end
+end

data/lib/carat/match_platform.rb

@@ -0,0 +1,13 @@
+require 'carat/gem_helpers'
+
+module Carat
+  module MatchPlatform
+    include GemHelpers
+
+    def match_platform(p)
+      Gem::Platform::RUBY == platform or
+      platform.nil? or p == platform or
+      generic(Gem::Platform.new(platform)) === p
+    end
+  end
+end

data/lib/carat/psyched_yaml.rb

@@ -0,0 +1,26 @@
+# Psych could be a gem, so try to ask for it
+begin
+  gem 'psych'
+rescue LoadError
+end if defined?(gem)
+
+# Psych could just be in the stdlib
+# but it's too late if Syck is already loaded
+begin
+  require 'psych' unless defined?(Syck)
+rescue LoadError
+  # Apparently Psych wasn't available. Oh well.
+end
+
+# At least load the YAML stdlib, whatever that may be
+require 'yaml' unless defined?(YAML.dump)
+
+module Carat
+  # On encountering invalid YAML,
+  # Psych raises Psych::SyntaxError
+  if defined?(::Psych::SyntaxError)
+    YamlSyntaxError = ::Psych::SyntaxError
+  else # Syck raises ArgumentError
+    YamlSyntaxError = ::ArgumentError
+  end
+end

data/lib/carat/remote_specification.rb

@@ -0,0 +1,57 @@
+require "uri"
+require "rubygems/spec_fetcher"
+
+module Carat
+  # Represents a lazily loaded gem specification, where the full specification
+  # is on the source server in rubygems' "quick" index. The proxy object is to
+  # be seeded with what we're given from the source's abbreviated index - the
+  # full specification will only be fetched when necessary.
+  class RemoteSpecification
+    include MatchPlatform
+
+    attr_reader :name, :version, :platform
+    attr_accessor :source, :source_uri
+
+    def initialize(name, version, platform, spec_fetcher)
+      @name         = name
+      @version      = version
+      @platform     = platform
+      @spec_fetcher = spec_fetcher
+    end
+
+    # Needed before installs, since the arch matters then and quick
+    # specs don't bother to include the arch in the platform string
+    def fetch_platform
+      @platform = _remote_specification.platform
+    end
+
+    def full_name
+      if platform == Gem::Platform::RUBY or platform.nil? then
+        "#{@name}-#{@version}"
+      else
+        "#{@name}-#{@version}-#{platform}"
+      end
+    end
+
+    # Because Rubyforge cannot be trusted to provide valid specifications
+    # once the remote gem is downloaded, the backend specification will
+    # be swapped out.
+    def __swap__(spec)
+      @specification = spec
+    end
+
+  private
+
+    def _remote_specification
+      @specification ||= @spec_fetcher.fetch_spec([@name, @version, @platform])
+    end
+
+    def method_missing(method, *args, &blk)
+      if Gem::Specification.new.respond_to?(method)
+        _remote_specification.send(method, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/carat/resolver.rb

@@ -0,0 +1,334 @@
+require 'set'
+
+# This is the latest iteration of the gem dependency resolving algorithm. As of now,
+# it can resolve (as a success or failure) any set of gem dependencies we throw at it
+# in a reasonable amount of time. The most iterations I've seen it take is about 150.
+# The actual implementation of the algorithm is not as good as it could be yet, but that
+# can come later.
+
+module Carat
+  class Resolver
+
+    require 'carat/vendored_molinillo'
+
+    class Molinillo::VersionConflict
+      def clean_req(req)
+        if req.to_s.include?(">= 0")
+          req.to_s.gsub(/ \(.*?\)$/, '')
+        else
+          req.to_s.gsub(/\, (runtime|development)\)$/, ')')
+        end
+      end
+
+      def message
+        conflicts.values.flatten.reduce('') do |o, conflict|
+          o << %(Carat could not find compatible versions for gem "#{conflict.requirement.name}":\n)
+          if conflict.locked_requirement
+            o << %(  In snapshot (Gemfile.lock):\n)
+            o << %(    #{clean_req conflict.locked_requirement}\n)
+            o << %(\n)
+          end
+          o << %(  In Gemfile:\n)
+          o << conflict.requirement_trees.map do |tree|
+            t = ''
+            depth = 2
+            tree.each do |req|
+              t << '  ' * depth << %(#{clean_req req})
+              t << %( depends on) unless tree[-1] == req
+              t << %(\n)
+              depth += 1
+            end
+            t
+          end.join("\n")
+
+          if conflict.requirement.name == 'carat'
+            o << %(\n  Current Carat version:\n    carat (#{Carat::VERSION}))
+            other_carat_required = !conflict.requirement.requirement.satisfied_by?(Gem::Version.new Carat::VERSION)
+          end
+
+          if conflict.requirement.name == "carat" && other_carat_required
+            o << "\n"
+            o << "This Gemfile requires a different version of Carat.\n"
+            o << "Perhaps you need to update Carat by running `gem install carat`?\n"
+          end
+          if conflict.locked_requirement
+            o << "\n"
+            o << %(Running `carat update` will rebuild your snapshot from scratch, using only\n)
+            o << %(the gems in your Gemfile, which may resolve the conflict.\n)
+          elsif !conflict.existing
+            if conflict.requirement_trees.first.size > 1
+              o << "Could not find gem '#{clean_req(conflict.requirement)}', which is required by "
+              o << "gem '#{clean_req(conflict.requirement_trees.first[-2])}', in any of the sources."
+            else
+              o << "Could not find gem '#{clean_req(conflict.requirement)} in any of the sources\n"
+            end
+          end
+          o
+        end
+      end
+    end
+
+    ALL = Carat::Dependency::PLATFORM_MAP.values.uniq.freeze
+
+    class SpecGroup < Array
+      include GemHelpers
+
+      attr_reader :activated, :required_by
+
+      def initialize(a)
+        super
+        @required_by  = []
+        @activated    = []
+        @dependencies = nil
+        @specs        = {}
+
+        ALL.each do |p|
+          @specs[p] = reverse.find { |s| s.match_platform(p) }
+        end
+      end
+
+      def initialize_copy(o)
+        super
+        @required_by = o.required_by.dup
+        @activated   = o.activated.dup
+      end
+
+      def to_specs
+        specs = {}
+
+        @activated.each do |p|
+          if s = @specs[p]
+            platform = generic(Gem::Platform.new(s.platform))
+            next if specs[platform]
+
+            lazy_spec = LazySpecification.new(name, version, platform, source)
+            lazy_spec.dependencies.replace s.dependencies
+            specs[platform] = lazy_spec
+          end
+        end
+        specs.values
+      end
+
+      def activate_platform(platform)
+        unless @activated.include?(platform)
+          if for?(platform)
+            @activated << platform
+            return __dependencies[platform] || []
+          end
+        end
+        []
+      end
+
+      def name
+        @name ||= first.name
+      end
+
+      def version
+        @version ||= first.version
+      end
+
+      def source
+        @source ||= first.source
+      end
+
+      def for?(platform)
+        @specs[platform]
+      end
+
+      def to_s
+        "#{name} (#{version})"
+      end
+
+      def dependencies_for_activated_platforms
+        @activated.map { |p| __dependencies[p] }.flatten
+      end
+
+      def platforms_for_dependency_named(dependency)
+        __dependencies.select { |p, deps| deps.map(&:name).include? dependency }.keys
+      end
+
+    private
+
+      def __dependencies
+        @dependencies ||= begin
+          dependencies = {}
+          ALL.each do |p|
+            if spec = @specs[p]
+              dependencies[p] = []
+              spec.dependencies.each do |dep|
+                next if dep.type == :development
+                dependencies[p] << DepProxy.new(dep, p)
+              end
+            end
+          end
+          dependencies
+        end
+      end
+    end
+
+    # Figures out the best possible configuration of gems that satisfies
+    # the list of passed dependencies and any child dependencies without
+    # causing any gem activation errors.
+    #
+    # ==== Parameters
+    # *dependencies<Gem::Dependency>:: The list of dependencies to resolve
+    #
+    # ==== Returns
+    # <GemBundle>,nil:: If the list of dependencies can be resolved, a
+    #   collection of gemspecs is returned. Otherwise, nil is returned.
+    def self.resolve(requirements, index, source_requirements = {}, base = [])
+      base = SpecSet.new(base) unless base.is_a?(SpecSet)
+      resolver = new(index, source_requirements, base)
+      result = resolver.start(requirements)
+      SpecSet.new(result)
+    end
+
+
+    def initialize(index, source_requirements, base)
+      @index = index
+      @source_requirements = source_requirements
+      @base = base
+      @resolver = Molinillo::Resolver.new(self, self)
+      @search_for = {}
+      @prereleases_cache = Hash.new { |h,k| h[k] = k.prerelease? }
+      @base_dg = Molinillo::DependencyGraph.new
+      @base.each { |ls| @base_dg.add_root_vertex ls.name, Dependency.new(ls.name, ls.version) }
+    end
+
+    def start(requirements)
+      verify_gemfile_dependencies_are_found!(requirements)
+      dg = @resolver.resolve(requirements, @base_dg)
+      dg.map(&:payload).map(&:to_specs).flatten
+    rescue Molinillo::VersionConflict => e
+      raise VersionConflict.new(e.conflicts.keys.uniq, e.message)
+    rescue Molinillo::CircularDependencyError => e
+      names = e.dependencies.sort_by(&:name).map { |d| "gem '#{d.name}'"}
+      raise CyclicDependencyError, "Your Gemfile requires gems that depend" \
+        " on each other, creating an infinite loop. Please remove" \
+        " #{names.count > 1 ? 'either ' : '' }#{names.join(' or ')}" \
+        " and try again."
+    end
+
+    include Molinillo::UI
+
+    # Conveys debug information to the user.
+    #
+    # @param [Integer] depth the current depth of the resolution process.
+    # @return [void]
+    def debug(depth = 0)
+      if debug?
+        debug_info = yield
+        debug_info = debug_info.inspect unless debug_info.is_a?(String)
+        STDERR.puts debug_info.split("\n").map { |s| '  ' * depth + s }
+      end
+    end
+
+    def debug?
+      ENV['DEBUG_RESOLVER'] || ENV['DEBUG_RESOLVER_TREE']
+    end
+
+    def before_resolution
+      Carat.ui.info 'Resolving dependencies...', false
+    end
+
+    def after_resolution
+      Carat.ui.info ''
+    end
+
+    def indicate_progress
+      Carat.ui.info '.', false
+    end
+
+    private
+
+    include Molinillo::SpecificationProvider
+
+    def dependencies_for(specification)
+      specification.dependencies_for_activated_platforms
+    end
+
+    def search_for(dependency)
+      platform = dependency.__platform
+      dependency = dependency.dep unless dependency.is_a? Gem::Dependency
+      search = @search_for[dependency] ||= begin
+        index = @source_requirements[dependency.name] || @index
+        results = index.search(dependency, @base[dependency.name])
+        if vertex = @base_dg.vertex_named(dependency.name)
+          locked_requirement = vertex.payload.requirement
+        end
+        if results.any?
+          version = results.first.version
+          nested  = [[]]
+          results.each do |spec|
+            if spec.version != version
+              nested << []
+              version = spec.version
+            end
+            nested.last << spec
+          end
+          groups = nested.map { |a| SpecGroup.new(a) }
+          !locked_requirement ? groups : groups.select { |sg| locked_requirement.satisfied_by? sg.version }
+        else
+          []
+        end
+      end
+      search.select { |sg| sg.for?(platform) }.each { |sg| sg.activate_platform(platform) }
+    end
+
+    def name_for(dependency)
+      dependency.name
+    end
+
+    def name_for_explicit_dependency_source
+      'Gemfile'
+    end
+
+    def name_for_locking_dependency_source
+      'Gemfile.lock'
+    end
+
+    def requirement_satisfied_by?(requirement, activated, spec)
+      requirement.matches_spec?(spec)
+    end
+
+    def sort_dependencies(dependencies, activated, conflicts)
+      dependencies.sort_by do |dependency|
+        name = name_for(dependency)
+        [
+          activated.vertex_named(name).payload ? 0 : 1,
+          @prereleases_cache[dependency.requirement] ? 0 : 1,
+          conflicts[name] ? 0 : 1,
+          activated.vertex_named(name).payload ? 0 : search_for(dependency).count,
+        ]
+      end
+    end
+
+    def verify_gemfile_dependencies_are_found!(requirements)
+      requirements.each do |requirement|
+        next if requirement.name == 'carat'
+        if search_for(requirement).empty?
+          if base = @base[requirement.name] and !base.empty?
+            version = base.first.version
+            message = "You have requested:\n" \
+              "  #{requirement.name} #{requirement.requirement}\n\n" \
+              "The bundle currently has #{requirement.name} locked at #{version}.\n" \
+              "Try running `carat update #{requirement.name}`"
+          elsif requirement.source
+            name = requirement.name
+            versions = @source_requirements[name][name].map { |s| s.version }
+            message  = "Could not find gem '#{requirement}' in #{requirement.source}.\n"
+            if versions.any?
+              message << "Source contains '#{name}' at: #{versions.join(', ')}"
+            else
+              message << "Source does not contain any versions of '#{requirement}'"
+            end
+          else
+            message = "Could not find gem '#{requirement}' in any of the gem sources listed in your Gemfile or installed on this machine."
+          end
+          raise GemNotFound, message
+        end
+      end
+    end
+
+  end
+end