bundler-prehistoric 1.6.2

data/lib/bundler/source/svn.rb

@@ -0,0 +1,260 @@
+require 'fileutils'
+require 'uri'
+require 'digest/sha1'
+
+module Bundler
+  class Source
+
+    class SVN < Path
+      autoload :SVNProxy, 'bundler/source/svn/svn_proxy'
+
+      attr_reader :uri, :ref, :options
+
+      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 revision).each{|k| options[k] = options[k].to_s if options[k] }
+
+        @uri        = options["uri"]
+        @ref        = options["ref"] || 'HEAD'
+        @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 = "SVN\n"
+        out << "  remote: #{@uri}\n"
+        out << "  revision: #{revision}\n"
+        out << "  glob: #{@glob}\n" unless @glob == DEFAULT_GLOB
+        out << "  specs:\n"
+      end
+
+      def eql?(o)
+        o.is_a?(SVN)         &&
+        uri == o.uri         &&
+        ref == o.ref         &&
+        name == o.name       &&
+        version == o.version
+      end
+
+      alias == eql?
+
+      def to_s
+        at = if local?
+          path
+        elsif options["ref"]
+          options["ref"]
+        else
+          ref
+        end
+        "#{uri} (at #{at})"
+      end
+
+      def name
+        File.basename(@uri, '.svn')
+      end
+
+      # This is the path which is going to contain a specific
+      # checkout of the svn repository. When using local svn
+      # repos, this is set to the local repo.
+      def install_path
+        @install_path ||= begin
+          svn_scope = "#{base_name}-#{revision}"
+
+          if Bundler.requires_sudo?
+            Bundler.user_bundle_path.join(Bundler.ruby_scope).join(svn_scope)
+          else
+            Bundler.install_path.join(svn_scope)
+          end
+        end
+      end
+
+      alias :path :install_path
+
+      def extension_dir_name
+        "#{base_name}-#{revision}"
+      end
+
+      def unlock!
+        svn_proxy.revision = nil
+        @unlocked = true
+      end
+
+      def local_override!(path)
+        return false if local?
+
+        path = Pathname.new(path)
+        path = path.expand_path(Bundler.root) unless path.relative?
+
+        if options["ref"]
+          raise SVNError, "Cannot use local override for #{name} at #{path} because " \
+            ":ref is specified in Gemfile. Don't specify a revision or use " \
+            "`bundle config --delete` to remove the local override"
+        end
+
+        unless path.exist?
+          raise SVNError, "Cannot use local override for #{name} because #{path} " \
+            "does not exist. Check `bundle config --delete` to remove the local override"
+        end
+
+        set_local!(path)
+
+        # Create a new svn proxy without the cached revision
+        # so the Gemfile.lock always picks up the new revision.
+        @svn_proxy = SVNProxy.new(path, uri, ref)
+        true
+      end
+
+      # TODO: actually cache svn specs
+      def specs(*)
+        if has_app_cache? && !local?
+          set_local!(app_cache_path)
+        end
+
+        if requires_checkout? && !@copied
+          svn_proxy.checkout
+          svn_proxy.copy_to(install_path)
+          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}"
+          svn_proxy.copy_to(install_path)
+          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 Bundler.settings[:cache_all]
+        return if path == app_cache_path
+        cached!
+        FileUtils.rm_rf(app_cache_path)
+        svn_proxy.checkout if requires_checkout?
+        svn_proxy.copy_to(app_cache_path)
+        serialize_gemspecs_in(app_cache_path)
+      end
+
+      def load_spec_files
+        super
+      rescue PathError => e
+        Bundler.ui.trace e
+        raise SVNError, "#{to_s} is not yet checked out. Run `bundle install` first."
+      end
+
+      # This is the path which is going to contain a cache
+      # of the svn repository. When using the same svn repository
+      # across different projects, this cache will be shared.
+      # When using local svn repos, this is set to the local repo.
+      def cache_path
+        @cache_path ||= begin
+          svn_scope = "#{base_name}-#{uri_hash}"
+
+          if Bundler.requires_sudo?
+            Bundler.user_bundle_path.join("cache/svn", svn_scope)
+          else
+            Bundler.cache.join("svn", svn_scope)
+          end
+        end
+      end
+
+      def app_cache_dirname
+        "#{base_name}-#{(cached_revision || revision)}"
+      end
+
+      def revision
+        svn_proxy.revision
+      end
+
+      def allow_svn_ops?
+        @allow_remote || @allow_cached
+      end
+
+    private
+
+      def serialize_gemspecs_in(destination)
+        expanded_path = destination.expand_path(Bundler.root)
+        Dir["#{expanded_path}/#{@glob}"].each do |spec_path|
+          # Evaluate gemspecs and cache the result. Gemspecs
+          # in svn might require svn or other dependencies.
+          # The gemspecs we cache should already be evaluated.
+          spec = Bundler.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 = @svn_proxy = nil
+        @cache_path  = @install_path = path
+      end
+
+      def has_app_cache?
+        cached_revision && super
+      end
+
+      def local?
+        @local
+      end
+
+      def requires_checkout?
+        allow_svn_ops? && !local?
+      end
+
+      def base_name
+        File.basename(uri.sub(%r{^(\w+://)?([^/:]+:)?(//\w*/)?(\w*/)*},''),".svn")
+      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/svn URI
+          input = uri
+        end
+        Digest::SHA1.hexdigest(input)
+      end
+
+      def cached_revision
+        options["revision"]
+      end
+
+      def cached?
+        cache_path.exist?
+      end
+
+      def svn_proxy
+        @svn_proxy ||= SVNProxy.new(cache_path, uri, ref, cached_revision, self)
+      end
+
+    end
+
+  end
+end

data/lib/bundler/source/svn/svn_proxy.rb

@@ -0,0 +1,110 @@
+module Bundler
+  class Source
+    class SVN < Path
+
+      class SVNNotInstalledError < SVNError
+        def initialize
+          msg =  "You need to install svn to be able to use gems from svn repositories. "
+          msg << "For help installing svn, please refer to SVNook's tutorial at http://svnbook.red-bean.com/en/1.7/svn.intro.install.html"
+          super msg
+        end
+      end
+
+      class SVNNotAllowedError < SVNError
+        def initialize(command)
+          msg =  "Bundler is trying to run a `svn #{command}` at runtime. You probably need to run `bundle install`. However, "
+          msg << "this error message could probably be more useful. Please submit a ticket at http://github.com/bundler/bundler/issues "
+          msg << "with steps to reproduce as well as the following\n\nCALLER: #{caller.join("\n")}"
+          super msg
+        end
+      end
+
+      class SVNCommandError < SVNError
+        def initialize(command, path = nil)
+          msg =  "SVN error: command `svn #{command}` in directory #{Dir.pwd} has failed."
+          msg << "\nIf this error persists you could try removing the cache directory '#{path}'" if path && path.exist?
+          super msg
+        end
+      end
+
+      # The SVNProxy is responsible to interact with svn repositories.
+      # All actions required by the SVN source is encapsulated in this
+      # object.
+      class SVNProxy
+        attr_accessor :path, :uri, :ref
+        attr_writer :revision
+
+        def initialize(path, uri, ref, revision = nil, svn = nil)
+          @path     = path
+          @uri      = uri
+          @ref      = ref
+          @revision = revision
+          @svn      = svn
+          raise SVNNotInstalledError.new if allow? && !Bundler.svn_present?
+        end
+
+        def revision
+          @revision ||= svn("info --revision #{ref} #{uri_escaped} | grep \"Revision\" | awk '{print $2}'").strip
+        end
+
+        def checkout
+          if path.exist?
+            Bundler.ui.confirm "Updating #{uri}"
+            in_path do
+              svn_retry %|update --force --quiet --revision #{revision}|
+            end
+          else
+            Bundler.ui.info "Fetching #{uri}"
+            FileUtils.mkdir_p(path.dirname)
+            svn_retry %|checkout --revision #{revision} #{uri_escaped} "#{path}"|
+          end
+        end
+
+        def copy_to(destination)
+          FileUtils.mkdir_p(destination.dirname)
+          FileUtils.rm_rf(destination)
+          FileUtils.cp_r(path, destination)
+          File.chmod((0777 & ~File.umask), destination)
+        end
+
+      private
+
+        def svn_retry(command)
+          Bundler::Retry.new("svn #{command}", SVNNotAllowedError).attempts do
+            svn(command)
+          end
+        end
+
+        def svn(command, check_errors=true)
+          raise SVNNotAllowedError.new(command) unless allow?
+          out = %x{svn #{command}}
+          raise SVNCommandError.new(command, path) if check_errors && !$?.success?
+          out
+        end
+
+        # Escape the URI for svn commands
+        def uri_escaped
+          if Bundler::WINDOWS
+            # Windows quoting requires double quotes only, with double quotes
+            # inside the string escaped by being doubled.
+            '"' + uri.gsub('"') {|s| '""'} + '"'
+          else
+            # Bash requires single quoted strings, with the single quotes escaped
+            # by ending the string, escaping the quote, and restarting the string.
+            "'" + uri.gsub("'") {|s| "'\\''"} + "'"
+          end
+        end
+
+        def allow?
+          @svn ? @svn.allow_svn_ops? : true
+        end
+
+        def in_path(&blk)
+          checkout unless path.exist?
+          SharedHelpers.chdir(path, &blk)
+        end
+      end
+
+    end
+  end
+end

data/lib/bundler/spec_set.rb

@@ -0,0 +1,154 @@
+require 'tsort'
+require 'forwardable'
+
+module Bundler
+  class SpecSet
+    extend Forwardable
+    include TSort, Enumerable
+
+    def_delegators :@specs, :<<, :length, :add, :remove
+    def_delegators :sorted, :each
+
+    def initialize(specs)
+      @specs = specs.sort_by { |s| s.name }
+    end
+
+    def for(dependencies, skip = [], check = false, match_current_platform = false)
+      handled, deps, specs = {}, dependencies.dup, []
+      skip << 'bundler'
+
+      until deps.empty?
+        dep = deps.shift
+        next if handled[dep] || skip.include?(dep.name)
+
+        spec = lookup[dep.name].find do |s|
+          if match_current_platform
+            Gem::Platform.match(s.platform)
+          else
+            s.match_platform(dep.__platform)
+          end
+        end
+
+        handled[dep] = true
+
+        if spec
+          specs << spec
+
+          spec.dependencies.each do |d|
+            next if d.type == :development
+            d = DepProxy.new(d, dep.__platform) unless match_current_platform
+            deps << d
+          end
+        elsif check
+          return false
+        end
+      end
+
+      if spec = lookup['bundler'].first
+        specs << spec
+      end
+
+      check ? true : SpecSet.new(specs)
+    end
+
+    def valid_for?(deps)
+      self.for(deps, [], true)
+    end
+
+    def [](key)
+      key = key.name if key.respond_to?(:name)
+      lookup[key].reverse
+    end
+
+    def []=(key, value)
+      @specs << value
+      @lookup = nil
+      @sorted = nil
+      value
+    end
+
+    def sort!
+      self
+    end
+
+    def to_a
+      sorted.dup
+    end
+
+    def to_hash
+      lookup.dup
+    end
+
+    def materialize(deps, missing_specs = nil)
+      materialized = self.for(deps, [], false, true).to_a
+      deps = materialized.map {|s| s.name }.uniq
+      materialized.map! do |s|
+        next s unless s.is_a?(LazySpecification)
+        s.source.dependency_names = deps if s.source.respond_to?(:dependency_names=)
+        spec = s.__materialize__
+        if missing_specs
+          missing_specs << s unless spec
+        else
+          raise GemNotFound, "Could not find #{s.full_name} in any of the sources" unless spec
+        end
+        spec if spec
+      end
+      SpecSet.new(materialized.compact)
+    end
+
+    def merge(set)
+      arr = sorted.dup
+      set.each do |s|
+        next if arr.any? { |s2| s2.name == s.name && s2.version == s.version && s2.platform == s.platform }
+        arr << s
+      end
+      SpecSet.new(arr)
+    end
+
+  private
+
+    def sorted
+      rake = @specs.find { |s| s.name == 'rake' }
+      begin
+        @sorted ||= ([rake] + tsort).compact.uniq
+      rescue TSort::Cyclic => error
+        cgems = extract_circular_gems(error)
+        raise CyclicDependencyError, "Your Gemfile requires gems that depend" \
+          " depend on each other, creating an infinite loop. Please remove" \
+          " either gem '#{cgems[1]}' or gem '#{cgems[0]}' and try again."
+      end
+    end
+
+    def extract_circular_gems(error)
+      if Bundler.current_ruby.mri? && Bundler.current_ruby.on_19?
+        error.message.scan(/(\w+) \([^)]/).flatten
+      else
+        error.message.scan(/@name="(.*?)"/).flatten
+      end
+    end
+
+    def lookup
+      @lookup ||= begin
+        lookup = Hash.new { |h,k| h[k] = [] }
+        specs = @specs.sort_by do |s|
+          s.platform.to_s == 'ruby' ? "\0" : s.platform.to_s
+        end
+        specs.reverse_each do |s|
+          lookup[s.name] << s
+        end
+        lookup
+      end
+    end
+
+    def tsort_each_node
+      @specs.each { |s| yield s }
+    end
+
+    def tsort_each_child(s)
+      s.dependencies.sort_by { |d| d.name }.each do |d|
+        next if d.type == :development
+        lookup[d.name].each { |s2| yield s2 }
+      end
+    end
+  end
+end