shopify-bundler 1.10.7

data/lib/bundler/fetcher/base.rb

@@ -0,0 +1,26 @@
+module Bundler
+  class Fetcher
+    class Base
+      attr_reader :downloader
+      attr_reader :remote_uri
+      attr_reader :fetch_uri
+      attr_reader :display_uri
+
+      def initialize(downloader, remote_uri, fetch_uri, display_uri)
+        raise "Abstract class" if self.class == Base
+        @downloader = downloader
+        @remote_uri = remote_uri
+        @fetch_uri = fetch_uri
+        @display_uri = display_uri
+      end
+
+      def api_available?
+        api_fetcher?
+      end
+
+      def api_fetcher?
+        false
+      end
+    end
+  end
+end

data/lib/bundler/fetcher/dependency.rb

@@ -0,0 +1,88 @@
+require "bundler/fetcher/base"
+require "cgi"
+
+module Bundler
+  class Fetcher
+    class Dependency < Base
+      def api_available?
+        downloader.fetch(dependency_api_uri)
+      rescue NetworkDownError => e
+        raise HTTPError, e.message
+      rescue AuthenticationRequiredError
+        # We got a 401 from the server. Just fail.
+        raise
+      rescue HTTPError
+      end
+
+      def api_fetcher?
+        true
+      end
+
+      def specs(gem_names, full_dependency_list = [], last_spec_list = [])
+        query_list = gem_names - full_dependency_list
+
+        # only display the message on the first run
+        if Bundler.ui.debug?
+          Bundler.ui.debug "Query List: #{query_list.inspect}"
+        else
+          Bundler.ui.info ".", false
+        end
+
+        return { remote_uri => last_spec_list } if query_list.empty?
+
+        remote_specs = Bundler::Retry.new("dependency api", AUTH_ERRORS).attempts do
+          dependency_specs(query_list)
+        end
+
+        spec_list, deps_list = remote_specs
+        returned_gems = spec_list.map(&:first).uniq
+        specs(deps_list, full_dependency_list + returned_gems, spec_list + last_spec_list)
+      rescue HTTPError, MarshalError, GemspecError
+        Bundler.ui.info "" unless Bundler.ui.debug? # new line now that the dots are over
+        Bundler.ui.debug "could not fetch from the dependency API, trying the full index"
+        return nil
+      end
+
+      def dependency_specs(gem_names)
+        Bundler.ui.debug "Query Gemcutter Dependency Endpoint API: #{gem_names.join(",")}"
+        gem_list = []
+        deps_list = []
+
+        gem_names.each_slice(Source::Rubygems::API_REQUEST_SIZE) do |names|
+          marshalled_deps = downloader.fetch dependency_api_uri(names)
+          gem_list += Bundler.load_marshal(marshalled_deps)
+        end
+
+        spec_list = gem_list.map do |s|
+          dependencies = s[:dependencies].map do |name, requirement|
+            dep = well_formed_dependency(name, requirement.split(", "))
+            deps_list << dep.name
+            dep
+          end
+
+          [s[:name], Gem::Version.new(s[:number]), s[:platform], dependencies]
+        end
+
+        [spec_list, deps_list.uniq]
+      end
+
+      def dependency_api_uri(gem_names = [])
+        uri = fetch_uri + "api/v1/dependencies"
+        uri.query = "gems=#{CGI.escape(gem_names.join(","))}" if gem_names.any?
+        uri
+      end
+
+      def well_formed_dependency(name, *requirements)
+        Gem::Dependency.new(name, *requirements)
+      rescue ArgumentError => e
+        illformed = 'Ill-formed requirement ["#<YAML::Syck::DefaultKey'
+        raise e unless e.message.include?(illformed)
+        puts # we shouldn't print the error message on the "fetching info" status line
+        raise GemspecError,
+          "Unfortunately, the gem #{s[:name]} (#{s[:number]}) has an invalid " \
+          "gemspec. \nPlease ask the gem author to yank the bad version to fix " \
+          "this issue. For more information, see http://bit.ly/syck-defaultkey."
+      end
+    end
+  end
+end

data/lib/bundler/fetcher/downloader.rb

@@ -0,0 +1,60 @@
+module Bundler
+  class Fetcher
+    class Downloader
+      attr_reader :connection
+      attr_reader :redirect_limit
+
+      def initialize(connection, redirect_limit)
+        @connection = connection
+        @redirect_limit = redirect_limit
+      end
+
+      def fetch(uri, counter = 0)
+        raise HTTPError, "Too many redirects" if counter >= redirect_limit
+
+        response = request(uri)
+        Bundler.ui.debug("HTTP #{response.code} #{response.message}")
+
+        case response
+        when Net::HTTPRedirection
+          new_uri = URI.parse(response["location"])
+          if new_uri.host == uri.host
+            new_uri.user = uri.user
+            new_uri.password = uri.password
+          end
+          fetch(new_uri, counter + 1)
+        when Net::HTTPSuccess
+          response.body
+        when Net::HTTPRequestEntityTooLarge
+          raise FallbackError, response.body
+        when Net::HTTPUnauthorized
+          raise AuthenticationRequiredError, uri.host
+        else
+          raise HTTPError, "#{response.class}: #{response.body}"
+        end
+      end
+
+      def request(uri)
+        Bundler.ui.debug "HTTP GET #{uri}"
+        req = Net::HTTP::Get.new uri.request_uri
+        if uri.user
+          user = CGI.unescape(uri.user)
+          password = uri.password ? CGI.unescape(uri.password) : nil
+          req.basic_auth(user, password)
+        end
+        connection.request(uri, req)
+      rescue OpenSSL::SSL::SSLError
+        raise CertificateFailureError.new(uri)
+      rescue *HTTP_ERRORS => e
+        Bundler.ui.trace e
+        case e.message
+        when /host down:/, /getaddrinfo: nodename nor servname provided/
+          raise NetworkDownError, "Could not reach host #{uri.host}. Check your network " \
+          "connection and try again."
+        else
+          raise HTTPError, "Network error while fetching #{uri}"
+        end
+      end
+    end
+  end
+end

data/lib/bundler/fetcher/index.rb

@@ -0,0 +1,32 @@
+require "bundler/fetcher/base"
+require "rubygems/remote_fetcher"
+
+module Bundler
+  class Fetcher
+    class Index < Base
+      def specs(_gem_names)
+        old_sources = Bundler.rubygems.sources
+        Bundler.rubygems.sources = [remote_uri.to_s]
+        Bundler.rubygems.fetch_all_remote_specs
+      rescue Gem::RemoteFetcher::FetchError, OpenSSL::SSL::SSLError, Net::HTTPFatalError => e
+        case e.message
+        when /certificate verify failed/
+          raise CertificateFailureError.new(display_uri)
+        when /401/
+          raise AuthenticationRequiredError, remote_uri
+        when /403/
+          if remote_uri.userinfo
+            raise BadAuthenticationError, remote_uri
+          else
+            raise AuthenticationRequiredError, remote_uri
+          end
+        else
+          Bundler.ui.trace e
+          raise HTTPError, "Could not fetch specs from #{display_uri}"
+        end
+      ensure
+        Bundler.rubygems.sources = old_sources
+      end
+    end
+  end
+end

data/lib/bundler/friendly_errors.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+require "cgi"
+require "bundler/vendored_thor"
+
+module Bundler
+  def self.with_friendly_errors
+    yield
+  rescue Bundler::Dsl::DSLError => e
+    Bundler.ui.error e.message
+    exit e.status_code
+  rescue Bundler::GemRequireError => e
+    Bundler.ui.error e.message
+    Bundler.ui.trace e.orig_exception, nil, true
+    exit e.status_code
+  rescue Bundler::BundlerError => e
+    Bundler.ui.error e.message, :wrap => true
+    Bundler.ui.trace e
+    exit e.status_code
+  rescue Thor::AmbiguousTaskError => e
+    Bundler.ui.error e.message
+    exit 15
+  rescue Thor::UndefinedTaskError => e
+    Bundler.ui.error e.message
+    exit 15
+  rescue Thor::Error => e
+    Bundler.ui.error e.message
+    exit 1
+  rescue LoadError => e
+    raise e unless e.message =~ /cannot load such file -- openssl|openssl.so|libcrypto.so/
+    Bundler.ui.error "\nCould not load OpenSSL."
+    Bundler.ui.warn <<-WARN, :wrap => true
+      You must recompile Ruby with OpenSSL support or change the sources in your \
+      Gemfile from 'https' to 'http'. Instructions for compiling with OpenSSL \
+      using RVM are available at http://rvm.io/packages/openssl.
+    WARN
+    Bundler.ui.trace e
+    exit 1
+  rescue Interrupt => e
+    Bundler.ui.error "\nQuitting..."
+    Bundler.ui.trace e
+    exit 1
+  rescue SystemExit => e
+    exit e.status
+  rescue Exception => e
+    request_issue_report_for(e)
+    exit 1
+  end
+
+  def self.request_issue_report_for(e)
+    Bundler.ui.info <<-EOS.gsub(/^ {6}/, "")
+      --- ERROR REPORT TEMPLATE -------------------------------------------------------
+      - What did you do?
+
+        I ran the command `#{$PROGRAM_NAME} #{ARGV.join(" ")}`
+
+      - What did you expect to happen?
+
+        I expected Bundler to...
+
+      - What happened instead?
+
+        Instead, what actually happened was...
+
+
+      Error details
+
+          #{e.class}: #{e.message}
+            #{e.backtrace.join("\n            ")}
+
+      #{Bundler::Env.new.report(:print_gemfile => false, :print_gemspecs => false).gsub(/\n/, "\n      ").strip}
+      --- TEMPLATE END ----------------------------------------------------------------
+
+    EOS
+
+    Bundler.ui.error "Unfortunately, an unexpected error occurred, and Bundler cannot continue."
+
+    Bundler.ui.warn <<-EOS.gsub(/^ {6}/, "")
+
+      First, try this link to see if there are any existing issue reports for this error:
+      #{issues_url(e)}
+
+      If there aren't any reports for this error yet, please create copy and paste the report template above into a new issue. Don't forget to anonymize any private data! The new issue form is located at:
+      https://github.com/bundler/bundler/issues/new
+    EOS
+  end
+
+  def self.issues_url(exception)
+    "https://github.com/bundler/bundler/search?q=" \
+    "#{CGI.escape(exception.message.lines.first.chomp)}&type=Issues"
+  end
+
+end

data/lib/bundler/gem_helper.rb

@@ -0,0 +1,191 @@
+require "bundler/vendored_thor" unless defined?(Thor)
+require "bundler"
+
+module Bundler
+  class GemHelper
+    include Rake::DSL if defined? Rake::DSL
+
+    class << self
+      # set when install'd.
+      attr_accessor :instance
+
+      def install_tasks(opts = {})
+        new(opts[:dir], opts[:name]).install
+      end
+
+      def gemspec(&block)
+        gemspec = instance.gemspec
+        block.call(gemspec) if block
+        gemspec
+      end
+    end
+
+    attr_reader :spec_path, :base, :gemspec
+
+    def initialize(base = nil, name = nil)
+      Bundler.ui = UI::Shell.new
+      @base = (base ||= SharedHelpers.pwd)
+      gemspecs = name ? [File.join(base, "#{name}.gemspec")] : Dir[File.join(base, "{,*}.gemspec")]
+      raise "Unable to determine name from existing gemspec. Use :name => 'gemname' in #install_tasks to manually set it." unless gemspecs.size == 1
+      @spec_path = gemspecs.first
+      @gemspec = Bundler.load_gemspec(@spec_path)
+    end
+
+    def install
+      built_gem_path = nil
+
+      desc "Build #{name}-#{version}.gem into the pkg directory."
+      task "build" do
+        built_gem_path = build_gem
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems."
+      task "install" => "build" do
+        install_gem(built_gem_path)
+      end
+
+      desc "Build and install #{name}-#{version}.gem into system gems without network access."
+      task "install:local" => "build" do
+        install_gem(built_gem_path, :local)
+      end
+
+      desc "Create tag #{version_tag} and build and push #{name}-#{version}.gem to Rubygems\n" \
+           "To prevent publishing in Rubygems use `gem_push=no rake release`"
+      task "release", [:remote] => ["build", "release:guard_clean",
+                                    "release:source_control_push", "release:rubygem_push"] do
+      end
+
+      task "release:guard_clean" do
+        guard_clean
+      end
+
+      task "release:source_control_push", [:remote] do |_, args|
+        tag_version { git_push(args[:remote]) } unless already_tagged?
+      end
+
+      task "release:rubygem_push" do
+        rubygem_push(built_gem_path) if gem_push?
+      end
+
+      GemHelper.instance = self
+    end
+
+    def build_gem
+      file_name = nil
+      sh("gem build -V '#{spec_path}'") {
+        file_name = File.basename(built_gem_path)
+        SharedHelpers.filesystem_access(File.join(base, "pkg")) {|p| FileUtils.mkdir_p(p) }
+        FileUtils.mv(built_gem_path, "pkg")
+        Bundler.ui.confirm "#{name} #{version} built to pkg/#{file_name}."
+      }
+      File.join(base, "pkg", file_name)
+    end
+
+    def install_gem(built_gem_path = nil, local = false)
+      built_gem_path ||= build_gem
+      out, _ = sh_with_code("gem install '#{built_gem_path}'#{" --local" if local}")
+      raise "Couldn't install gem, run `gem install #{built_gem_path}' for more detailed output" unless out[/Successfully installed/]
+      Bundler.ui.confirm "#{name} (#{version}) installed."
+    end
+
+  protected
+
+    def rubygem_push(path)
+      if Pathname.new("~/.gem/credentials").expand_path.exist?
+        allowed_push_host = nil
+        gem_command = "gem push '#{path}'"
+        if spec.respond_to?(:metadata)
+          allowed_push_host = @gemspec.metadata["allowed_push_host"]
+          gem_command << " --host #{allowed_push_host}" if allowed_push_host
+        end
+        sh(gem_command)
+        Bundler.ui.confirm "Pushed #{name} #{version} to #{allowed_push_host ? allowed_push_host : "rubygems.org."}"
+      else
+        raise "Your rubygems.org credentials aren't set. Run `gem push` to set them."
+      end
+    end
+
+    def built_gem_path
+      Dir[File.join(base, "#{name}-*.gem")].sort_by {|f| File.mtime(f) }.last
+    end
+
+    def git_push(remote = "")
+      perform_git_push remote
+      perform_git_push "#{remote} --tags"
+      Bundler.ui.confirm "Pushed git commits and tags."
+    end
+
+    def perform_git_push(options = "")
+      cmd = "git push #{options}"
+      out, code = sh_with_code(cmd)
+      raise "Couldn't git push. `#{cmd}' failed with the following output:\n\n#{out}\n" unless code == 0
+    end
+
+    def already_tagged?
+      if sh("git tag").split(/\n/).include?(version_tag)
+        Bundler.ui.confirm "Tag #{version_tag} has already been created."
+        true
+      end
+    end
+
+    def guard_clean
+      clean? && committed? or raise("There are files that need to be committed first.")
+    end
+
+    def clean?
+      sh_with_code("git diff --exit-code")[1] == 0
+    end
+
+    def committed?
+      sh_with_code("git diff-index --quiet --cached HEAD")[1] == 0
+    end
+
+    def tag_version
+      sh "git tag -a -m \"Version #{version}\" #{version_tag}"
+      Bundler.ui.confirm "Tagged #{version_tag}."
+      yield if block_given?
+    rescue
+      Bundler.ui.error "Untagging #{version_tag} due to error."
+      sh_with_code "git tag -d #{version_tag}"
+      raise
+    end
+
+    def version
+      gemspec.version
+    end
+
+    def version_tag
+      "v#{version}"
+    end
+
+    def name
+      gemspec.name
+    end
+
+    def sh(cmd, &block)
+      out, code = sh_with_code(cmd, &block)
+      if code == 0
+        out
+      else
+        raise(out.empty? ? "Running `#{cmd}' failed. Run this command directly for more detailed output." : out)
+      end
+    end
+
+    def sh_with_code(cmd, &block)
+      cmd << " 2>&1"
+      outbuf = ""
+      Bundler.ui.debug(cmd)
+      SharedHelpers.chdir(base) {
+        outbuf = `#{cmd}`
+        if $? == 0
+          block.call(outbuf) if block
+        end
+      }
+      [outbuf, $?]
+    end
+
+    def gem_push?
+      ! %w{n no nil false off 0}.include?(ENV["gem_push"].to_s.downcase)
+    end
+  end
+end