bowline-bundler 0.0.1

data/lib/bowline/bundler/bundle.rb

@@ -0,0 +1,323 @@
+module Bundler
+  class InvalidRepository < StandardError ; end
+
+  class Bundle
+    attr_reader :gemfile, :environment
+
+    def self.load(gemfile = nil)
+      gemfile = Pathname.new(gemfile || default_gemfile).expand_path
+
+      unless gemfile.file?
+        raise ManifestFileNotFound, "Manifest file not found: #{gemfile.to_s.inspect}"
+      end
+
+      new(gemfile)
+    end
+
+    def self.default_gemfile
+      current = Pathname.new(Dir.pwd)
+
+      until current.root?
+        filename = current.join("Gemfile")
+        return filename if filename.exist?
+        current = current.parent
+      end
+
+      raise DefaultManifestNotFound
+    end
+
+    # TODO: passing in the filename is not good
+    def initialize(gemfile)
+      @gemfile = gemfile
+      @environment = Environment.new(self)
+      Dsl.evaluate(gemfile, self, @environment)
+
+      # path   = env.gem_path
+
+      FileUtils.mkdir_p(gem_path)
+
+      @cache_path = gem_path.join('cache')
+      @cache = GemDirectorySource.new(self, :location => @cache_path)
+
+      @specs_path = gem_path.join('specifications')
+      @gems_path  = gem_path.join('gems')
+    end
+
+    def root
+      gemfile.parent
+    end
+
+    def path
+      @path ||= root.join("vendor/gems")
+    end
+
+    def path=(path)
+      @path = (path.relative? ? root.join(path) : path).expand_path
+    end
+
+    def gem_path
+      path.join("#{Gem.ruby_engine}/#{Gem::ConfigMap[:ruby_version]}")
+    end
+
+    def bindir
+      @bindir ||= root.join("bin")
+    end
+
+    def bindir=(path)
+      @bindir = (path.relative? ? root.join(path) : path).expand_path
+    end
+
+    def install(options = {})
+      dependencies = @environment.dependencies
+      sources      = @environment.sources
+
+      # ========== from env
+      if only_envs = options[:only]
+        dependencies.reject! { |d| !only_envs.any? {|env| d.in?(env) } }
+      end
+      # ==========
+
+      # TODO: clean this up
+      sources.each do |s|
+        s.local = options[:cached]
+      end
+
+      # Check to see whether the existing cache meets all the requirements
+      begin
+        valid = nil
+        # valid = Resolver.resolve(dependencies, [source_index], source_requirements)
+      rescue Bundler::GemNotFound
+      end
+
+      sources = only_local(sources) if options[:cached]
+
+      # Check the remote sources if the existing cache does not meet the requirements
+      # or the user passed --update
+      if options[:update] || !valid
+        Bundler.logger.info "Calculating dependencies..."
+        bundle = Resolver.resolve(dependencies, [@cache] + sources)
+        download(bundle, options)
+        do_install(bundle, options)
+        valid = bundle
+      end
+
+      generate_bins(valid, options)
+      cleanup(valid, options)
+      configure(valid, options)
+
+      Bundler.logger.info "Done."
+    end
+
+    def cache(*gemfiles)
+      FileUtils.mkdir_p(@cache_path)
+      gemfiles.each do |gemfile|
+        Bundler.logger.info "Caching: #{File.basename(gemfile)}"
+        FileUtils.cp(gemfile, @cache_path)
+      end
+    end
+
+    def list_outdated(options={})
+      outdated_gems = source_index.outdated.sort
+
+      if outdated_gems.empty?
+        Bundler.logger.info "All gems are up to date."
+      else
+        Bundler.logger.info "Outdated gems:"
+        outdated_gems.each do |name|
+          Bundler.logger.info " * #{name}"
+        end
+      end
+    end
+
+    def prune(options = {})
+      dependencies, sources = @environment.gem_dependencies, @environment.sources
+
+      sources.each do |s|
+        s.local = true
+      end
+
+      sources = only_local(sources)
+      bundle = Resolver.resolve(dependencies, [@cache] + sources)
+      @cache.gems.each do |name, specs|
+        specs.each do |spec|
+          unless bundle.any? { |s| s.name == spec.name && s.version == spec.version }
+            Bundler.logger.info "Pruning #{spec.name} (#{spec.version}) from the cache"
+            FileUtils.rm @cache_path.join("#{spec.full_name}.gem")
+          end
+        end
+      end
+    end
+
+    def list(options = {})
+      Bundler.logger.info "Currently bundled gems:"
+      gems.each do |spec|
+        Bundler.logger.info " * #{spec.name} (#{spec.version})"
+      end
+    end
+
+    def gems
+      source_index.gems.values
+    end
+
+    def source_index
+      index = Gem::SourceIndex.from_gems_in(@specs_path)
+      index.each { |n, spec| spec.loaded_from = @specs_path.join("#{spec.full_name}.gemspec") }
+      index
+    end
+
+    def download_path_for(type)
+      @repos[type].download_path_for
+    end
+
+    def setup_environment
+      unless @environment.system_gems
+        ENV["GEM_HOME"] = gem_path
+        ENV["GEM_PATH"] = gem_path
+      end
+      ENV["PATH"]     = "#{bindir}:#{ENV["PATH"]}"
+      ENV["RUBYOPT"]  = "-r#{gem_path}/environment #{ENV["RUBYOPT"]}"
+    end
+
+  private
+
+    def only_local(sources)
+      sources.select { |s| s.can_be_local? }
+    end
+
+    def download(bundle, options)
+      bundle.sort_by {|s| s.full_name.downcase }.each do |spec|
+        next if spec.no_bundle?
+        spec.source.download(spec)
+      end
+    end
+
+    def do_install(bundle, options)
+      bundle.each do |spec|
+        next if spec.no_bundle?
+        spec.loaded_from = @specs_path.join("#{spec.full_name}.gemspec")
+        # Do nothing if the gem is already expanded
+        next if @gems_path.join(spec.full_name).directory?
+
+        case spec.source
+        when GemSource, GemDirectorySource, SystemGemSource
+          expand_gemfile(spec, options)
+        else
+          expand_vendored_gem(spec, options)
+        end
+      end
+    end
+
+    def generate_bins(bundle, options)
+      bundle.each do |spec|
+        next if spec.no_bundle?
+        # HAX -- Generate the bin
+        bin_dir = bindir
+        path    = gem_path
+        gems_path = @gems_path
+        installer = Gem::Installer.allocate
+        installer.instance_eval do
+          @spec     = spec
+          @bin_dir  = bin_dir
+          @gem_dir  = gems_path.join(spec.full_name)
+          @gem_home = path
+          @wrappers = true
+          @format_executable = false
+          @env_shebang = false
+        end
+        installer.generate_bin
+      end
+    end
+
+    def expand_gemfile(spec, options)
+      Bundler.logger.info "Installing #{spec.name} (#{spec.version})"
+
+      gemfile = @cache_path.join("#{spec.full_name}.gem").to_s
+
+      if build_args = options[:build_options] && options[:build_options][spec.name]
+        Gem::Command.build_args = build_args.map {|k,v| "--with-#{k}=#{v}"}
+      end
+
+      installer = Gem::Installer.new(gemfile, options.merge(
+        :install_dir         => gem_path,
+        :ignore_dependencies => true,
+        :env_shebang         => true,
+        :wrappers            => true,
+        :bin_dir             => bindir
+      ))
+      installer.install
+    rescue Gem::InstallError
+      cleanup_spec(spec)
+      raise
+    ensure
+      Gem::Command.build_args = []
+    end
+
+    def expand_vendored_gem(spec, options)
+      add_spec(spec)
+      FileUtils.mkdir_p(@gems_path)
+      File.symlink(spec.location, @gems_path.join(spec.full_name))
+    end
+
+    def add_spec(spec)
+      destination = @specs_path
+      destination.mkdir unless destination.exist?
+
+      File.open(destination.join("#{spec.full_name}.gemspec"), 'w') do |f|
+        f.puts spec.to_ruby
+      end
+    end
+
+    def cleanup(valid, options)
+      to_delete = gems
+      to_delete.delete_if do |spec|
+        valid.any? { |other| spec.name == other.name && spec.version == other.version }
+      end
+
+      valid_executables = valid.map { |s| s.executables }.flatten.compact
+
+      to_delete.each do |spec|
+        Bundler.logger.info "Deleting gem: #{spec.name} (#{spec.version})"
+        cleanup_spec(spec)
+        # Cleanup the bin directory
+        spec.executables.each do |bin|
+          next if valid_executables.include?(bin)
+          Bundler.logger.info "Deleting bin file: #{bin}"
+          FileUtils.rm_rf(bindir.join(bin))
+        end
+      end
+    end
+
+    def cleanup_spec(spec)
+      FileUtils.rm_rf(@specs_path.join("#{spec.full_name}.gemspec"))
+      FileUtils.rm_rf(@gems_path.join(spec.full_name))
+    end
+
+    def expand(options)
+      each_repo do |repo|
+        repo.expand(options)
+      end
+    end
+
+    def configure(specs, options)
+      FileUtils.mkdir_p(gem_path)
+
+      File.open(gem_path.join("environment.rb"), "w") do |file|
+        file.puts @environment.environment_rb(specs, options)
+      end
+
+      generate_environment_picker
+    end
+
+    def generate_environment_picker
+      FileUtils.cp("#{File.dirname(__FILE__)}/templates/environment_picker.erb", path.join("environment.rb"))
+    end
+
+    def require_code(file, dep)
+      constraint = case
+      when dep.only   then %{ if #{dep.only.inspect}.include?(env)}
+      when dep.except then %{ unless #{dep.except.inspect}.include?(env)}
+      end
+      "require #{file.inspect}#{constraint}"
+    end
+  end
+end

data/lib/bowline/bundler/cli.rb

@@ -0,0 +1,87 @@
+require "optparse"
+
+module Bundler
+  class CLI
+    def self.run(command, options = {})
+      new(options).run(command)
+    rescue DefaultManifestNotFound => e
+      Bundler.logger.error "Could not find a Gemfile to use"
+      exit 3
+    rescue InvalidEnvironmentName => e
+      Bundler.logger.error "Gemfile error: #{e.message}"
+      exit 4
+    rescue InvalidRepository => e
+      Bundler.logger.error e.message
+      exit 5
+    rescue VersionConflict => e
+      Bundler.logger.error e.message
+      exit 6
+    rescue GemNotFound => e
+      Bundler.logger.error e.message
+      exit 7
+    rescue InvalidCacheArgument => e
+      Bundler.logger.error e.message
+      exit 8
+    rescue SourceNotCached => e
+      Bundler.logger.error e.message
+      exit 9
+    rescue ManifestFileNotFound => e
+      Bundler.logger.error e.message
+      exit 10
+    end
+
+    def initialize(options)
+      @options = options
+      @bundle = Bundle.load(@options[:manifest])
+    end
+
+    def bundle
+      @bundle.install(@options)
+    end
+
+    def cache
+      gemfile = @options[:cache]
+
+      if File.extname(gemfile) == ".gem"
+        if !File.exist?(gemfile)
+          raise InvalidCacheArgument, "'#{gemfile}' does not exist."
+        end
+        @bundle.cache(gemfile)
+      elsif File.directory?(gemfile) || gemfile.include?('/')
+        if !File.directory?(gemfile)
+          raise InvalidCacheArgument, "'#{gemfile}' does not exist."
+        end
+        gemfiles = Dir["#{gemfile}/*.gem"]
+        if gemfiles.empty?
+          raise InvalidCacheArgument, "'#{gemfile}' contains no gemfiles"
+        end
+        @bundle.cache(*gemfiles)
+      else
+        raise InvalidCacheArgument, "w0t? '#{gemfile}' means nothing to me."
+      end
+    end
+
+    def prune
+      @bundle.prune(@options)
+    end
+
+    def list
+      @bundle.list(@options)
+    end
+
+    def list_outdated
+      @bundle.list_outdated(@options)
+    end
+
+    def exec
+      @bundle.setup_environment
+      # w0t?
+      super(*$command)
+    end
+
+    def run(command)
+      send(command)
+    end
+
+  end
+end

data/lib/bowline/bundler/dependency.rb

@@ -0,0 +1,62 @@
+module Bundler
+  class InvalidEnvironmentName < StandardError; end
+
+  class Dependency < Gem::Dependency
+    attr_reader :name, :version, :require_as, :only, :except
+    attr_accessor :source
+
+    def initialize(name, options = {}, &block)
+      options.each do |k, v|
+        options[k.to_s] = v
+      end
+
+      super(name, options["version"] || ">= 0")
+
+      @require_as = options["require_as"]
+      @only       = options["only"]
+      @except     = options["except"]
+      @source     = options["source"]
+      @block      = block
+
+      if (@only && @only.include?("rubygems")) || (@except && @except.include?("rubygems"))
+        raise InvalidEnvironmentName, "'rubygems' is not a valid environment name"
+      end
+    end
+
+    def in?(environment)
+      environment = environment.to_s
+
+      return false unless !@only || @only.include?(environment)
+      return false if @except && @except.include?(environment)
+      true
+    end
+
+    def require_env(environment)
+      return unless in?(environment)
+
+      if @require_as
+        Array(@require_as).each { |file| require file }
+      else
+        begin
+          require name
+        rescue LoadError
+          # Do nothing
+        end
+      end
+
+      @block.call if @block
+    end
+
+    def no_bundle?
+      source == SystemGemSource.instance
+    end
+
+    def ==(o)
+      [name, version, require_as, only, except] ==
+        [o.name, o.version, o.require_as, o.only, o.except]
+    end
+
+    alias version version_requirements
+
+  end
+end

data/lib/bowline/bundler/dsl.rb

@@ -0,0 +1,182 @@
+module Bundler
+  class ManifestFileNotFound < StandardError; end
+  class InvalidKey < StandardError; end
+  class DefaultManifestNotFound < StandardError; end
+
+  class Dsl
+    def self.evaluate(file, bundle, environment)
+      builder = new(bundle, environment)
+      builder.instance_eval(File.read(file.to_s), file.to_s, 1)
+      environment
+    end
+
+    def initialize(bundle, environment)
+      @bundle = bundle
+      @environment = environment
+      @directory_sources = []
+      @git_sources = {}
+      @only, @except, @directory, @git = nil, nil, nil, nil
+    end
+
+    def bundle_path(path)
+      @bundle.path = Pathname.new(path)
+    end
+
+    def bin_path(path)
+      @bundle.bindir = Pathname.new(path)
+    end
+
+    def disable_rubygems
+      @environment.rubygems = false
+    end
+
+    def disable_system_gems
+      @environment.system_gems = false
+    end
+
+    def source(source)
+      source = GemSource.new(@bundle, :uri => source)
+      unless @environment.sources.include?(source)
+        @environment.add_source(source)
+      end
+    end
+
+    def only(*env)
+      old, @only = @only, _combine_only(env)
+      yield
+      @only = old
+    end
+
+    def except(*env)
+      old, @except = @except, _combine_except(env)
+      yield
+      @except = old
+    end
+
+    def directory(path, options = {})
+      raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
+      @directory = DirectorySource.new(@bundle, options.merge(:location => path))
+      @directory_sources << @directory
+      @environment.add_priority_source(@directory)
+      retval = yield if block_given?
+      @directory = nil
+      retval
+    end
+
+    def git(uri, options = {})
+      raise DirectorySourceError, "cannot nest calls to directory or git" if @directory || @git
+      @git = GitSource.new(@bundle, options.merge(:uri => uri))
+      @git_sources[uri] = @git
+      @environment.add_priority_source(@git)
+      retval = yield if block_given?
+      @git = nil
+      retval
+    end
+
+    def clear_sources
+      @environment.clear_sources
+    end
+
+    def gem(name, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      version = args.last
+
+      keys = :vendored_at, :path, :only, :except, :git, :path, :bundle, :require_as, :tag, :branch, :ref
+      unless (invalid = options.keys - keys).empty?
+        raise InvalidKey, "Only #{keys.join(", ")} are valid options to #gem. You used #{invalid.join(", ")}"
+      end
+
+      if path = options.delete(:vendored_at)
+        options[:path] = path
+        warn "The :vendored_at option is deprecated. Use :path instead.\nFrom #{caller[0]}"
+      end
+
+      options[:only] = _combine_only(options[:only] || options["only"])
+      options[:except] = _combine_except(options[:except] || options["except"])
+
+      dep = Dependency.new(name, options.merge(:version => version))
+
+      if options.key?(:bundle) && !options[:bundle]
+        dep.source = SystemGemSource.new(@bundle)
+      elsif @git || options[:git]
+        dep.source = _handle_git_option(name, version, options)
+      elsif @directory || options[:path]
+        dep.source = _handle_vendored_option(name, version, options)
+      end
+
+      @environment.dependencies << dep
+    end
+
+  private
+
+    def _version?(version)
+      version && Gem::Version.new(version) rescue false
+    end
+
+    def _handle_vendored_option(name, version, options)
+      dir, path = _find_directory_source(options[:path])
+
+      if dir
+        dir.required_specs << name
+        dir.add_spec(path, name, version) if _version?(version)
+        dir
+      else
+        directory options[:path] do
+          _handle_vendored_option(name, version, {})
+        end
+      end
+    end
+
+    def _find_directory_source(path)
+      if @directory
+        return @directory, Pathname.new(path || '')
+      end
+
+      path = @bundle.gemfile.dirname.join(path)
+
+      @directory_sources.each do |s|
+        if s.location.expand_path.to_s < path.expand_path.to_s
+          return s, path.relative_path_from(s.location)
+        end
+      end
+
+      nil
+    end
+
+    def _handle_git_option(name, version, options)
+      git    = options[:git].to_s
+      ref    = options[:ref] || options[:tag]
+      branch = options[:branch]
+
+      if source = @git || @git_sources[git]
+        if ref && source.ref != ref
+          raise GitSourceError, "'#{git}' already specified with ref: #{source.ref}"
+        elsif branch && source.branch != branch
+          raise GitSourceError, "'#{git}' already specified with branch: #{source.branch}"
+        end
+
+        source.required_specs << name
+        source.add_spec(Pathname.new(options[:path] || '.'), name, version) if _version?(version)
+        source
+      else
+        git(git, :ref => ref, :branch => branch) do
+          _handle_git_option(name, version, options)
+        end
+      end
+    end
+
+    def _combine_only(only)
+      return @only unless only
+      only = Array(only).compact.uniq.map { |o| o.to_s }
+      only &= @only if @only
+      only
+    end
+
+    def _combine_except(except)
+      return @except unless except
+      except = Array(except).compact.uniq.map { |o| o.to_s }
+      except |= @except if @except
+      except
+    end
+  end
+end