carat 1.9.9.pre1

data/lib/carat/setup.rb

@@ -0,0 +1,24 @@
+require 'carat/shared_helpers'
+
+if Carat::SharedHelpers.in_bundle?
+  require 'carat'
+
+  if STDOUT.tty? || ENV['CARAT_FORCE_TTY']
+    begin
+      Carat.setup
+    rescue Carat::CaratError => e
+      puts "\e[31m#{e.message}\e[0m"
+      puts e.backtrace.join("\n") if ENV["DEBUG"]
+      if e.is_a?(Carat::GemNotFound)
+        puts "\e[33mRun `carat install` to install missing gems.\e[0m"
+      end
+      exit e.status_code
+    end
+  else
+    Carat.setup
+  end
+
+  # Add carat to the load path after disabling system gems
+  carat_lib = File.expand_path("../..", __FILE__)
+  $LOAD_PATH.unshift(carat_lib) unless $LOAD_PATH.include?(carat_lib)
+end

data/lib/carat/shared_helpers.rb

@@ -0,0 +1,149 @@
+require 'pathname'
+require 'rubygems'
+
+require 'carat/constants'
+require 'carat/rubygems_integration'
+require 'carat/current_ruby'
+
+module Gem
+  class Dependency
+    if !instance_methods.map { |m| m.to_s }.include?("requirement")
+      def requirement
+        version_requirements
+      end
+    end
+  end
+end
+
+module Carat
+  module SharedHelpers
+    attr_accessor :gem_loaded
+
+    def default_gemfile
+      gemfile = find_gemfile
+      raise GemfileNotFound, "Could not locate Gemfile" unless gemfile
+      Pathname.new(gemfile)
+    end
+
+    def default_lockfile
+      gemfile = default_gemfile
+
+      case gemfile.basename.to_s
+      when 'gems.rb' then Pathname.new(gemfile.sub(/.rb$/, '.locked'))
+      else Pathname.new("#{gemfile}.lock")
+      end
+    end
+
+    def default_bundle_dir
+      bundle_dir = find_directory(".carat")
+      return nil unless bundle_dir
+
+      global_bundle_dir = File.join(Carat.rubygems.user_home, ".carat")
+      return nil if bundle_dir == global_bundle_dir
+
+      Pathname.new(bundle_dir)
+    end
+
+    def in_bundle?
+      find_gemfile
+    end
+
+    def chdir(dir, &blk)
+      Carat.rubygems.ext_lock.synchronize do
+        Dir.chdir dir, &blk
+      end
+    end
+
+    def pwd
+      Carat.rubygems.ext_lock.synchronize do
+        Dir.pwd
+      end
+    end
+
+    def with_clean_git_env(&block)
+      keys    = %w[GIT_DIR GIT_WORK_TREE]
+      old_env = keys.inject({}) do |h, k|
+        h.update(k => ENV[k])
+      end
+
+      keys.each {|key| ENV.delete(key) }
+
+      block.call
+    ensure
+      keys.each {|key| ENV[key] = old_env[key] }
+    end
+
+    def set_bundle_environment
+      # Set PATH
+      paths = (ENV["PATH"] || "").split(File::PATH_SEPARATOR)
+      paths.unshift "#{Carat.bundle_path}/bin"
+      ENV["PATH"] = paths.uniq.join(File::PATH_SEPARATOR)
+
+      # Set RUBYOPT
+      rubyopt = [ENV["RUBYOPT"]].compact
+      if rubyopt.empty? || rubyopt.first !~ /-rcarat\/setup/
+        rubyopt.unshift %|-rcarat/setup|
+        ENV["RUBYOPT"] = rubyopt.join(' ')
+      end
+
+      # Set RUBYLIB
+      rubylib = (ENV["RUBYLIB"] || "").split(File::PATH_SEPARATOR)
+      rubylib.unshift File.expand_path('../..', __FILE__)
+      ENV["RUBYLIB"] = rubylib.uniq.join(File::PATH_SEPARATOR)
+    end
+
+  private
+
+    def find_gemfile
+      given = ENV['BUNDLE_GEMFILE']
+      return given if given && !given.empty?
+
+      find_file('Gemfile', 'gems.rb')
+    end
+
+    def find_file(*names)
+      search_up(*names) {|filename|
+        return filename if File.file?(filename)
+      }
+    end
+
+    def find_directory(*names)
+      search_up(*names) do |dirname|
+        return dirname if File.directory?(dirname)
+      end
+    end
+
+    def search_up(*names)
+      previous = nil
+      current  = File.expand_path(SharedHelpers.pwd)
+
+      until !File.directory?(current) || current == previous
+        if ENV['BUNDLE_SPEC_RUN']
+          # avoid stepping above the tmp directory when testing
+          return nil if File.file?(File.join(current, 'carat.gemspec'))
+        end
+
+        names.each do |name|
+          filename = File.join(current, name)
+          yield filename
+        end
+        current, previous = File.expand_path("..", current), current
+      end
+    end
+
+    def clean_load_path
+      # handle 1.9 where system gems are always on the load path
+      if defined?(::Gem)
+        me = File.expand_path("../../", __FILE__)
+        $LOAD_PATH.reject! do |p|
+          next if File.expand_path(p) =~ /^#{Regexp.escape(me)}/
+          p != File.dirname(__FILE__) &&
+            Carat.rubygems.gem_path.any?{|gp| p =~ /^#{Regexp.escape(gp)}/ }
+        end
+        $LOAD_PATH.uniq!
+      end
+    end
+
+    extend self
+  end
+end

data/lib/carat/similarity_detector.rb

@@ -0,0 +1,63 @@
+module Carat
+  class SimilarityDetector
+    SimilarityScore = Struct.new(:string, :distance)
+
+    # initialize with an array of words to be matched against
+    def initialize(corpus)
+      @corpus = corpus
+    end
+
+    # return an array of words similar to 'word' from the corpus
+    def similar_words(word, limit=3)
+      words_by_similarity = @corpus.map{|w| SimilarityScore.new(w, levenshtein_distance(word, w))}
+      words_by_similarity.select{|s| s.distance<=limit}.sort_by(&:distance).map(&:string)
+    end
+
+    # return the result of 'similar_words', concatenated into a list
+    # (eg "a, b, or c")
+    def similar_word_list(word, limit=3)
+      words = similar_words(word,limit)
+      if words.length==1
+        words[0]
+      elsif words.length>1
+        [words[0..-2].join(', '), words[-1]].join(' or ')
+      end
+    end
+
+
+  protected
+    # http://www.informit.com/articles/article.aspx?p=683059&seqNum=36
+    def levenshtein_distance(this, that, ins=2, del=2, sub=1)
+      # ins, del, sub are weighted costs
+      return nil if this.nil?
+      return nil if that.nil?
+      dm = []        # distance matrix
+
+      # Initialize first row values
+      dm[0] = (0..this.length).collect { |i| i * ins }
+      fill = [0] * (this.length - 1)
+
+      # Initialize first column values
+      for i in 1..that.length
+        dm[i] = [i * del, fill.flatten]
+      end
+
+      # populate matrix
+      for i in 1..that.length
+        for j in 1..this.length
+          # critical comparison
+          dm[i][j] = [
+               dm[i-1][j-1] +
+                 (this[j-1] == that[i-1] ? 0 : sub),
+                   dm[i][j-1] + ins,
+               dm[i-1][j] + del
+         ].min
+        end
+      end
+
+      # The last value in matrix is the Levenshtein distance between the strings
+      dm[that.length][this.length]
+    end
+
+  end
+end

data/lib/carat/source.rb

@@ -0,0 +1,46 @@
+module Carat
+  class Source
+    autoload :Rubygems, 'carat/source/rubygems'
+    autoload :Path,     'carat/source/path'
+    autoload :Git,      'carat/source/git'
+
+    def self.mirror_for(uri)
+      uri = URI(uri.to_s) unless uri.is_a?(URI)
+
+      # Settings keys are all downcased
+      mirrors = Carat.settings.gem_mirrors
+      normalized_key = URI(uri.to_s.downcase)
+
+      mirrors[normalized_key] || uri
+    end
+
+    attr_accessor :dependency_names
+
+    def unmet_deps
+      specs.unmet_dependency_names
+    end
+
+    def version_message(spec)
+      message = "#{spec.name} #{spec.version}"
+
+      if Carat.locked_gems
+        locked_spec = Carat.locked_gems.specs.find { |s| s.name == spec.name }
+        locked_spec_version = locked_spec.version if locked_spec
+        if locked_spec_version && spec.version != locked_spec_version
+          message << " (was #{locked_spec_version})"
+        end
+      end
+
+      message
+    end
+
+    def can_lock?(spec)
+      spec.source == self
+    end
+
+    def include?(other)
+      other == self
+    end
+
+  end
+end

data/lib/carat/source/git.rb

@@ -0,0 +1,294 @@
+require 'fileutils'
+require 'uri'
+require 'digest/sha1'
+
+module Carat
+  class Source
+
+    class Git < Path
+      autoload :GitProxy, 'carat/source/git/git_proxy'
+
+      attr_reader :uri, :ref, :branch, :options, :submodules
+
+      def initialize(options)
+        @options = options
+        @glob = options["glob"] || DEFAULT_GLOB
+
+        @allow_cached = false
+        @allow_remote = false
+
+        # Stringify options that could be set as symbols
+        %w(ref branch tag revision).each{|k| options[k] = options[k].to_s if options[k] }
+
+        @uri        = options["uri"] || ''
+        @branch     = options["branch"]
+        @ref        = options["ref"] || options["branch"] || options["tag"] || 'master'
+        @submodules = options["submodules"]
+        @name       = options["name"]
+        @version    = options["version"]
+
+        @copied     = false
+        @local      = false
+      end
+
+      def self.from_lock(options)
+        new(options.merge("uri" => options.delete("remote")))
+      end
+
+      def to_lock
+        out = "GIT\n"
+        out << "  remote: #{@uri}\n"
+        out << "  revision: #{revision}\n"
+        %w(ref branch tag submodules).each do |opt|
+          out << "  #{opt}: #{options[opt]}\n" if options[opt]
+        end
+        out << "  glob: #{@glob}\n" unless @glob == DEFAULT_GLOB
+        out << "  specs:\n"
+      end
+
+      def hash
+        [self.class, uri, ref, branch, name, version, submodules].hash
+      end
+
+      def eql?(o)
+        o.is_a?(Git)         &&
+        uri == o.uri         &&
+        ref == o.ref         &&
+        branch == o.branch   &&
+        name == o.name       &&
+        version == o.version &&
+        submodules == o.submodules
+      end
+
+      alias == eql?
+
+      def to_s
+        at = if local?
+          path
+        elsif options["ref"]
+          shortref_for_display(options["ref"])
+        else
+          ref
+        end
+        "#{uri} (at #{at})"
+      end
+
+      def name
+        File.basename(@uri, '.git')
+      end
+
+      # This is the path which is going to contain a specific
+      # checkout of the git repository. When using local git
+      # repos, this is set to the local repo.
+      def install_path
+        @install_path ||= begin
+          git_scope = "#{base_name}-#{shortref_for_path(revision)}"
+          path = Carat.install_path.join(git_scope)
+
+          if !path.exist? && Carat.requires_sudo?
+            Carat.user_bundle_path.join(Carat.ruby_scope).join(git_scope)
+          else
+            path
+          end
+        end
+      end
+
+      alias :path :install_path
+
+      def extension_dir_name
+        "#{base_name}-#{shortref_for_path(revision)}"
+      end
+
+      def unlock!
+        git_proxy.revision = nil
+        @unlocked = true
+      end
+
+      def local_override!(path)
+        return false if local?
+
+        path = Pathname.new(path)
+        path = path.expand_path(Carat.root) unless path.relative?
+
+        unless options["branch"] || Carat.settings[:disable_local_branch_check]
+          raise GitError, "Cannot use local override for #{name} at #{path} because " \
+            ":branch is not specified in Gemfile. Specify a branch or use " \
+            "`carat config --delete` to remove the local override"
+        end
+
+        unless path.exist?
+          raise GitError, "Cannot use local override for #{name} because #{path} " \
+            "does not exist. Check `carat config --delete` to remove the local override"
+        end
+
+        set_local!(path)
+
+        # Create a new git proxy without the cached revision
+        # so the Gemfile.lock always picks up the new revision.
+        @git_proxy = GitProxy.new(path, uri, ref)
+
+        if git_proxy.branch != options["branch"] && !Carat.settings[:disable_local_branch_check]
+          raise GitError, "Local override for #{name} at #{path} is using branch " \
+            "#{git_proxy.branch} but Gemfile specifies #{options["branch"]}"
+        end
+
+        changed = cached_revision && cached_revision != git_proxy.revision
+
+        if changed && !@unlocked && !git_proxy.contains?(cached_revision)
+          raise GitError, "The Gemfile lock is pointing to revision #{shortref_for_display(cached_revision)} " \
+            "but the current branch in your local override for #{name} does not contain such commit. " \
+            "Please make sure your branch is up to date."
+        end
+
+        changed
+      end
+
+      # TODO: actually cache git specs
+      def specs(*)
+        if has_app_cache? && !local?
+          set_local!(app_cache_path)
+        end
+
+        if requires_checkout? && !@copied
+          git_proxy.checkout
+          git_proxy.copy_to(install_path, submodules)
+          serialize_gemspecs_in(install_path)
+          @copied = true
+        end
+
+        local_specs
+      end
+
+      def install(spec)
+        debug = nil
+        if requires_checkout? && !@copied
+          debug = "  * Checking out revision: #{ref}"
+          git_proxy.copy_to(install_path, submodules)
+          serialize_gemspecs_in(install_path)
+          @copied = true
+        end
+        generate_bin(spec)
+        if requires_checkout? && spec.post_install_message
+          Installer.post_install_messages[spec.name] = spec.post_install_message
+        end
+        ["Using #{version_message(spec)} from #{to_s}", nil, debug]
+      end
+
+      def cache(spec, custom_path = nil)
+        app_cache_path = app_cache_path(custom_path)
+        return unless Carat.settings[:cache_all]
+        return if path == app_cache_path
+        cached!
+        FileUtils.rm_rf(app_cache_path)
+        git_proxy.checkout if requires_checkout?
+        git_proxy.copy_to(app_cache_path, @submodules)
+        serialize_gemspecs_in(app_cache_path)
+      end
+
+      def load_spec_files
+        super
+      rescue PathError => e
+        Carat.ui.trace e
+        raise GitError, "#{to_s} is not yet checked out. Run `carat install` first."
+      end
+
+      # This is the path which is going to contain a cache
+      # of the git repository. When using the same git repository
+      # across different projects, this cache will be shared.
+      # When using local git repos, this is set to the local repo.
+      def cache_path
+        @cache_path ||= begin
+          git_scope = "#{base_name}-#{uri_hash}"
+
+          if Carat.requires_sudo?
+            Carat.user_bundle_path.join("cache/git", git_scope)
+          else
+            Carat.cache.join("git", git_scope)
+          end
+        end
+      end
+
+      def app_cache_dirname
+        "#{base_name}-#{shortref_for_path(cached_revision || revision)}"
+      end
+
+      def revision
+        git_proxy.revision
+      end
+
+      def allow_git_ops?
+        @allow_remote || @allow_cached
+      end
+
+      private
+
+      def serialize_gemspecs_in(destination)
+        expanded_path = destination.expand_path(Carat.root)
+        Dir["#{expanded_path}/#{@glob}"].each do |spec_path|
+          # Evaluate gemspecs and cache the result. Gemspecs
+          # in git might require git or other dependencies.
+          # The gemspecs we cache should already be evaluated.
+          spec = Carat.load_gemspec(spec_path)
+          next unless spec
+          File.open(spec_path, 'wb') {|file| file.write(spec.to_ruby) }
+        end
+      end
+
+      def set_local!(path)
+        @local       = true
+        @local_specs = @git_proxy = nil
+        @cache_path  = @install_path = path
+      end
+
+      def has_app_cache?
+        cached_revision && super
+      end
+
+      def local?
+        @local
+      end
+
+      def requires_checkout?
+        allow_git_ops? && !local?
+      end
+
+      def base_name
+        File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)?(//\w*/)?(\w*/)*},''),".git")
+      end
+
+      def shortref_for_display(ref)
+        ref[0..6]
+      end
+
+      def shortref_for_path(ref)
+        ref[0..11]
+      end
+
+      def uri_hash
+        if uri =~ %r{^\w+://(\w+@)?}
+          # Downcase the domain component of the URI
+          # and strip off a trailing slash, if one is present
+          input = URI.parse(uri).normalize.to_s.sub(%r{/$},'')
+        else
+          # If there is no URI scheme, assume it is an ssh/git URI
+          input = uri
+        end
+        Digest::SHA1.hexdigest(input)
+      end
+
+      def cached_revision
+        options["revision"]
+      end
+
+      def cached?
+        cache_path.exist?
+      end
+
+      def git_proxy
+        @git_proxy ||= GitProxy.new(cache_path, uri, ref, cached_revision, self)
+      end
+
+    end
+
+  end
+end