shopify-bundler 1.10.7

data/lib/bundler/inline.rb

@@ -0,0 +1,58 @@
+# Allows for declaring a Gemfile inline in a ruby script, optionally installing
+# any gems that aren't already installed on the user's system.
+#
+# @note Every gem that is specified in this 'Gemfile' will be `require`d, as if
+#       the user had manually called `Bundler.require`. To avoid a requested gem
+#       being automatically required, add the `:require => false` option to the
+#       `gem` dependency declaration.
+#
+# @param install [Boolean] whether gems that aren't already installed on the
+#                          user's system should be installed.
+#                          Defaults to `false`.
+#
+# @param gemfile [Proc]    a block that is evaluated as a `Gemfile`.
+#
+# @example Using an inline Gemfile
+#
+#          #!/usr/bin/env ruby
+#
+#          require 'bundler/inline'
+#
+#          gemfile do
+#            source 'https://rubygems.org'
+#            gem 'json', require: false
+#            gem 'nap', require: 'rest'
+#            gem 'cocoapods', '~> 0.34.1'
+#          end
+#
+#          puts Pod::VERSION # => "0.34.4"
+#
+def gemfile(install = false, &gemfile)
+  require "bundler"
+  old_root = Bundler.method(:root)
+  def Bundler.root
+    Bundler::SharedHelpers.pwd.expand_path
+  end
+  ENV["BUNDLE_GEMFILE"] ||= "Gemfile"
+
+  builder = Bundler::Dsl.new
+  builder.instance_eval(&gemfile)
+
+  definition = builder.to_definition(nil, true)
+  def definition.lock(*); end
+  definition.validate_ruby!
+
+  if install
+    Bundler.ui = Bundler::UI::Shell.new
+    Bundler::Installer.install(Bundler.root, definition, :system => true)
+    Bundler::Installer.post_install_messages.each do |name, message|
+      Bundler.ui.info "Post-install message from #{name}:\n#{message}"
+    end
+  end
+
+  runtime = Bundler::Runtime.new(nil, definition)
+  runtime.setup.require
+
+  bundler_module = class << Bundler; self; end
+  bundler_module.send(:define_method, :root, old_root)
+end

data/lib/bundler/installer.rb

@@ -0,0 +1,242 @@
+require "erb"
+require "rubygems/dependency_installer"
+require "bundler/worker"
+require "bundler/installer/parallel_installer"
+require "bundler/installer/standalone"
+
+module Bundler
+  class Installer < Environment
+    class << self
+      attr_accessor :post_install_messages, :ambiguous_gems
+
+      Installer.post_install_messages = {}
+      Installer.ambiguous_gems = []
+    end
+
+    # Begins the installation process for Bundler.
+    # For more information see the #run method on this class.
+    def self.install(root, definition, options = {})
+      installer = new(root, definition)
+      installer.run(options)
+      installer
+    end
+
+    # Runs the install procedures for a specific Gemfile.
+    #
+    # Firstly, this method will check to see if Bundler.bundle_path exists
+    # and if not then will create it. This is usually the location of gems
+    # on the system, be it RVM or at a system path.
+    #
+    # Secondly, it checks if Bundler has been configured to be "frozen"
+    # Frozen ensures that the Gemfile and the Gemfile.lock file are matching.
+    # This stops a situation where a developer may update the Gemfile but may not run
+    # `bundle install`, which leads to the Gemfile.lock file not being correctly updated.
+    # If this file is not correctly updated then any other developer running
+    # `bundle install` will potentially not install the correct gems.
+    #
+    # Thirdly, Bundler checks if there are any dependencies specified in the Gemfile using
+    # Bundler::Environment#dependencies. If there are no dependencies specified then
+    # Bundler returns a warning message stating so and this method returns.
+    #
+    # Fourthly, Bundler checks if the default lockfile (Gemfile.lock) exists, and if so
+    # then proceeds to set up a defintion based on the default gemfile (Gemfile) and the
+    # default lock file (Gemfile.lock). However, this is not the case if the platform is different
+    # to that which is specified in Gemfile.lock, or if there are any missing specs for the gems.
+    #
+    # Fifthly, Bundler resolves the dependencies either through a cache of gems or by remote.
+    # This then leads into the gems being installed, along with stubs for their executables,
+    # but only if the --binstubs option has been passed or Bundler.options[:bin] has been set
+    # earlier.
+    #
+    # Sixthly, a new Gemfile.lock is created from the installed gems to ensure that the next time
+    # that a user runs `bundle install` they will receive any updates from this process.
+    #
+    # Finally: TODO add documentation for how the standalone process works.
+    def run(options)
+      create_bundle_path
+
+      if Bundler.settings[:frozen]
+        @definition.ensure_equivalent_gemfile_and_lockfile(options[:deployment])
+      end
+
+      if dependencies.empty?
+        Bundler.ui.warn "The Gemfile specifies no dependencies"
+        lock
+        return
+      end
+
+      resolve_if_need(options)
+      install(options)
+
+      lock unless Bundler.settings[:frozen]
+      Standalone.new(options[:standalone], @definition).generate if options[:standalone]
+    end
+
+    def install_gem_from_spec(spec, standalone = false, worker = 0, force = false)
+      # Fetch the build settings, if there are any
+      settings = Bundler.settings["build.#{spec.name}"]
+      install_options = { :force => force, :ensure_builtin_gems_cached => standalone }
+
+      post_install_message = nil
+      if settings
+        # Build arguments are global, so this is mutexed
+        Bundler.rubygems.with_build_args [settings] do
+          post_install_message = spec.source.install(spec, install_options)
+        end
+      else
+        post_install_message = spec.source.install(spec, install_options)
+      end
+
+      Bundler.ui.debug "#{worker}:  #{spec.name} (#{spec.version}) from #{spec.loaded_from}"
+
+      if Bundler.settings[:bin] && standalone
+        generate_standalone_bundler_executable_stubs(spec)
+      elsif Bundler.settings[:bin]
+        generate_bundler_executable_stubs(spec, :force => true)
+      end
+
+      post_install_message
+    rescue Errno::ENOSPC
+      raise Bundler::InstallError, "Your disk is out of space. Free some " \
+        "space to be able to install your bundle."
+    rescue Exception => e
+      # if install hook failed or gem signature is bad, just die
+      raise e if e.is_a?(Bundler::InstallHookError) || e.is_a?(Bundler::SecurityError)
+
+      # other failure, likely a native extension build failure
+      Bundler.ui.info ""
+      Bundler.ui.warn "#{e.class}: #{e.message}"
+      msg = "An error occurred while installing #{spec.name} (#{spec.version}),"
+      msg << " and Bundler cannot continue."
+
+      unless spec.source.options["git"]
+        msg << "\nMake sure that `gem install"
+        msg << " #{spec.name} -v '#{spec.version}'` succeeds before bundling."
+      end
+      Bundler.ui.debug e.backtrace.join("\n")
+      raise Bundler::InstallError, msg
+    end
+
+    def generate_bundler_executable_stubs(spec, options = {})
+      if options[:binstubs_cmd] && spec.executables.empty?
+        options = {}
+        spec.runtime_dependencies.each do |dep|
+          bins = @definition.specs[dep].first.executables
+          options[dep.name] = bins unless bins.empty?
+        end
+        if options.any?
+          Bundler.ui.warn "#{spec.name} has no executables, but you may want " \
+            "one from a gem it depends on."
+          options.each {|name, bins| Bundler.ui.warn "  #{name} has: #{bins.join(", ")}" }
+        else
+          Bundler.ui.warn "There are no executables for the gem #{spec.name}."
+        end
+        return
+      end
+
+      # double-assignment to avoid warnings about variables that will be used by ERB
+      bin_path = bin_path = Bundler.bin_path
+      template = template = File.read(File.expand_path("../templates/Executable", __FILE__))
+      relative_gemfile_path = relative_gemfile_path = Bundler.default_gemfile.relative_path_from(bin_path)
+      ruby_command = ruby_command = Thor::Util.ruby_command
+
+      exists = []
+      spec.executables.each do |executable|
+        next if executable == "bundle"
+
+        binstub_path = "#{bin_path}/#{executable}"
+        if File.exist?(binstub_path) && !options[:force]
+          exists << executable
+          next
+        end
+
+        File.open(binstub_path, "w", 0777 & ~File.umask) do |f|
+          f.puts ERB.new(template, nil, "-").result(binding)
+        end
+      end
+
+      if options[:binstubs_cmd] && exists.any?
+        case exists.size
+        when 1
+          Bundler.ui.warn "Skipped #{exists[0]} since it already exists."
+        when 2
+          Bundler.ui.warn "Skipped #{exists.join(" and ")} since they already exist."
+        else
+          items = exists[0...-1].empty? ? nil : exists[0...-1].join(", ")
+          skipped = [items, exists[-1]].compact.join(" and ")
+          Bundler.ui.warn "Skipped #{skipped} since they already exist."
+        end
+        Bundler.ui.warn "If you want to overwrite skipped stubs, use --force."
+      end
+    end
+
+  private
+
+    # the order that the resolver provides is significant, since
+    # dependencies might actually affect the installation of a gem.
+    # that said, it's a rare situation (other than rake), and parallel
+    # installation is just SO MUCH FASTER. so we let people opt in.
+    def install(options)
+      force = options["force"]
+      jobs = 1
+      jobs = [Bundler.settings[:jobs].to_i - 1, 1].max if can_install_in_parallel?
+      install_in_parallel jobs, options[:standalone], force
+    end
+
+    def can_install_in_parallel?
+      if Bundler.rubygems.provides?(">= 2.1.0")
+        true
+      else
+        Bundler.ui.warn "Rubygems #{Gem::VERSION} is not threadsafe, so your "\
+          "gems will be installed one at a time. Upgrade to Rubygems 2.1.0 " \
+          "or higher to enable parallel gem installation."
+        false
+      end
+    end
+
+    def generate_standalone_bundler_executable_stubs(spec)
+      # double-assignment to avoid warnings about variables that will be used by ERB
+      bin_path = Bundler.bin_path
+      template = File.read(File.expand_path("../templates/Executable.standalone", __FILE__))
+      ruby_command = ruby_command = Thor::Util.ruby_command
+
+      spec.executables.each do |executable|
+        next if executable == "bundle"
+        standalone_path = standalone_path = Pathname(Bundler.settings[:path]).expand_path.relative_path_from(bin_path)
+        executable_path = executable_path = Pathname(spec.full_gem_path).join(spec.bindir, executable).relative_path_from(bin_path)
+        File.open "#{bin_path}/#{executable}", "w", 0755 do |f|
+          f.puts ERB.new(template, nil, "-").result(binding)
+        end
+      end
+    end
+
+    def install_in_parallel(size, standalone, force = false)
+      ParallelInstaller.call(self, specs, size, standalone, force)
+    end
+
+    def create_bundle_path
+      SharedHelpers.filesystem_access(Bundler.bundle_path.to_s) do |p|
+        Bundler.mkdir_p(p)
+      end unless Bundler.bundle_path.exist?
+    rescue Errno::EEXIST
+      raise PathError, "Could not install to path `#{Bundler.settings[:path]}` " \
+        "because of an invalid symlink. Remove the symlink so the directory can be created."
+    end
+
+    def resolve_if_need(options)
+      if Bundler.default_lockfile.exist? && !options["update"]
+        local = Bundler.ui.silence do
+          begin
+            tmpdef = Definition.build(Bundler.default_gemfile, Bundler.default_lockfile, nil)
+            true unless tmpdef.new_platform? || tmpdef.missing_specs.any?
+          rescue BundlerError
+          end
+        end
+      end
+
+      unless local
+        options["local"] ? @definition.resolve_with_cache! : @definition.resolve_remotely!
+      end
+    end
+  end
+end

data/lib/bundler/installer/parallel_installer.rb

@@ -0,0 +1,122 @@
+require "bundler/worker"
+
+class ParallelInstaller
+  class SpecInstallation
+    attr_accessor :spec, :name, :post_install_message, :state
+    def initialize(spec)
+      @spec = spec
+      @name = spec.name
+      @state = :none
+      @post_install_message = ""
+    end
+
+    def installed?
+      state == :installed
+    end
+
+    def enqueued?
+      state == :enqueued
+    end
+
+    # Only true when spec in neither installed nor already enqueued
+    def ready_to_enqueue?
+      !installed? && !enqueued?
+    end
+
+    def has_post_install_message?
+      !post_install_message.empty?
+    end
+
+    def ignorable_dependency?(dep)
+      dep.type == :development || dep.name == @name
+    end
+
+    # Checks installed dependencies against spec's dependencies to make
+    # sure needed dependencies have been installed.
+    def dependencies_installed?(all_specs)
+      installed_specs = all_specs.select(&:installed?).map(&:name)
+      dependencies(all_specs.map(&:name)).all? {|d| installed_specs.include? d.name }
+    end
+
+    # Represents only the non-development dependencies, the ones that are
+    # itself and are in the total list.
+    def dependencies(all_spec_names)
+      @dependencies ||= begin
+        deps = all_dependencies.reject {|dep| ignorable_dependency? dep }
+        missing = deps.reject {|dep| all_spec_names.include? dep.name }
+        if missing.size > 0
+          raise Bundler::LockfileError, "Your Gemfile.lock is corrupt. The following #{missing.size > 1 ? "gems are" : "gem is"} missing " \
+                              "from the DEPENDENCIES section: '#{missing.map(&:name).join('\' \'')}'"
+        end
+        deps
+      end
+    end
+
+    # Represents all dependencies
+    def all_dependencies
+      @spec.dependencies
+    end
+  end
+
+  def self.call(*args)
+    new(*args).call
+  end
+
+  # Returns max number of threads machine can handle with a min of 1
+  def self.max_threads
+    [Bundler.settings[:jobs].to_i - 1, 1].max
+  end
+
+  def initialize(installer, all_specs, size, standalone, force)
+    @installer = installer
+    @size = size
+    @standalone = standalone
+    @force = force
+    @specs = all_specs.map {|s| SpecInstallation.new(s) }
+  end
+
+  def call
+    enqueue_specs
+    process_specs until @specs.all?(&:installed?)
+  ensure
+    worker_pool && worker_pool.stop
+  end
+
+  def worker_pool
+    @worker_pool ||= Bundler::Worker.new @size, lambda { |spec_install, worker_num|
+      message = @installer.install_gem_from_spec spec_install.spec, @standalone, worker_num, @force
+      spec_install.post_install_message = message unless message.nil?
+      spec_install
+    }
+  end
+
+  # Dequeue a spec and save its post-install message and then enqueue the
+  # remaining specs.
+  # Some specs might've had to wait til this spec was installed to be
+  # processed so the call to `enqueue_specs` is important after every
+  # dequeue.
+  def process_specs
+    spec = worker_pool.deq
+    spec.state = :installed
+    collect_post_install_message spec if spec.has_post_install_message?
+    enqueue_specs
+  end
+
+  def collect_post_install_message(spec)
+    Bundler::Installer.post_install_messages[spec.name] = spec.post_install_message
+  end
+
+  # Keys in the remains hash represent uninstalled gems specs.
+  # We enqueue all gem specs that do not have any dependencies.
+  # Later we call this lambda again to install specs that depended on
+  # previously installed specifications. We continue until all specs
+  # are installed.
+  def enqueue_specs
+    @specs.select(&:ready_to_enqueue?).each do |spec|
+      if spec.dependencies_installed? @specs
+        worker_pool.enq spec
+        spec.state = :enqueued
+      end
+    end
+  end
+end

data/lib/bundler/installer/standalone.rb

@@ -0,0 +1,48 @@
+module Bundler
+  class Standalone
+    def initialize(groups, definition)
+      @specs = groups.empty? ? definition.requested_specs : definition.specs_for(groups.map(&:to_sym))
+    end
+
+    def generate
+      SharedHelpers.filesystem_access(bundler_path) do |p|
+        FileUtils.mkdir_p(p)
+      end
+      File.open File.join(bundler_path, "setup.rb"), "w" do |file|
+        file.puts "require 'rbconfig'"
+        file.puts "# ruby 1.8.7 doesn't define RUBY_ENGINE"
+        file.puts "ruby_engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'"
+        file.puts "ruby_version = RbConfig::CONFIG[\"ruby_version\"]"
+        file.puts "path = File.expand_path('..', __FILE__)"
+        paths.each do |path|
+          file.puts %{$:.unshift "\#{path}/#{path}"}
+        end
+      end
+    end
+
+  private
+
+    def paths
+      @specs.map do |spec|
+        next if spec.name == "bundler"
+        Array(spec.require_paths).map do |path|
+          gem_path(path, spec).sub(version_dir, '#{ruby_engine}/#{ruby_version}')
+          # This is a static string intentionally. It's interpolated at a later time.
+        end
+      end.flatten
+    end
+
+    def version_dir
+      "#{Bundler.ruby_version.engine}/#{RbConfig::CONFIG["ruby_version"]}"
+    end
+
+    def bundler_path
+      File.join(Bundler.settings[:path], "bundler")
+    end
+
+    def gem_path(path, spec)
+      full_path = Pathname.new(path).absolute? ? path : File.join(spec.full_gem_path, path)
+      Pathname.new(full_path).relative_path_from(Bundler.root.join(bundler_path)).to_s
+    end
+  end
+end