second_step 0.1.2 → 0.1.3

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rubygems/request.rb

@@ -1,244 +0,0 @@
-require 'net/http'
-require 'thread'
-require 'time'
-require 'rubygems/user_interaction'
-
-class Gem::Request
-
-  include Gem::UserInteraction
-
-  ###
-  # Legacy.  This is used in tests.
-  def self.create_with_proxy uri, request_class, last_modified, proxy # :nodoc:
-    cert_files = get_cert_files
-    proxy ||= get_proxy_from_env(uri.scheme)
-    pool       = ConnectionPools.new proxy_uri(proxy), cert_files
-
-    new(uri, request_class, last_modified, pool.pool_for(uri))
-  end
-
-  def self.proxy_uri proxy # :nodoc:
-    case proxy
-    when :no_proxy then nil
-    when URI::HTTP then proxy
-    else URI.parse(proxy)
-    end
-  end
-
-  def initialize(uri, request_class, last_modified, pool)
-    @uri = uri
-    @request_class = request_class
-    @last_modified = last_modified
-    @requests = Hash.new 0
-    @user_agent = user_agent
-
-    @connection_pool = pool
-  end
-
-  def proxy_uri; @connection_pool.proxy_uri; end
-  def cert_files; @connection_pool.cert_files; end
-
-  def self.get_cert_files
-    pattern = File.expand_path("./ssl_certs/*.pem", File.dirname(__FILE__))
-    Dir.glob(pattern)
-  end
-
-  def self.configure_connection_for_https(connection, cert_files)
-    require 'net/https'
-    connection.use_ssl = true
-    connection.verify_mode =
-      Gem.configuration.ssl_verify_mode || OpenSSL::SSL::VERIFY_PEER
-    store = OpenSSL::X509::Store.new
-
-    if Gem.configuration.ssl_client_cert then
-      pem = File.read Gem.configuration.ssl_client_cert
-      connection.cert = OpenSSL::X509::Certificate.new pem
-      connection.key = OpenSSL::PKey::RSA.new pem
-    end
-
-    store.set_default_paths
-    cert_files.each do |ssl_cert_file|
-      store.add_file ssl_cert_file
-    end
-    if Gem.configuration.ssl_ca_cert
-      if File.directory? Gem.configuration.ssl_ca_cert
-        store.add_path Gem.configuration.ssl_ca_cert
-      else
-        store.add_file Gem.configuration.ssl_ca_cert
-      end
-    end
-    connection.cert_store = store
-    connection
-  rescue LoadError => e
-    raise unless (e.respond_to?(:path) && e.path == 'openssl') ||
-                 e.message =~ / -- openssl$/
-
-    raise Gem::Exception.new(
-            'Unable to require openssl, install OpenSSL and rebuild ruby (preferred) or use non-HTTPS sources')
-  end
-
-  ##
-  # Creates or an HTTP connection based on +uri+, or retrieves an existing
-  # connection, using a proxy if needed.
-
-  def connection_for(uri)
-    @connection_pool.checkout
-  rescue defined?(OpenSSL::SSL) ? OpenSSL::SSL::SSLError : Errno::EHOSTDOWN,
-         Errno::EHOSTDOWN => e
-    raise Gem::RemoteFetcher::FetchError.new(e.message, uri)
-  end
-
-  def fetch
-    request = @request_class.new @uri.request_uri
-
-    unless @uri.nil? || @uri.user.nil? || @uri.user.empty? then
-      request.basic_auth Gem::UriFormatter.new(@uri.user).unescape,
-                         Gem::UriFormatter.new(@uri.password).unescape
-    end
-
-    request.add_field 'User-Agent', @user_agent
-    request.add_field 'Connection', 'keep-alive'
-    request.add_field 'Keep-Alive', '30'
-
-    if @last_modified then
-      request.add_field 'If-Modified-Since', @last_modified.httpdate
-    end
-
-    yield request if block_given?
-
-    perform_request request
-  end
-
-  ##
-  # Returns a proxy URI for the given +scheme+ if one is set in the
-  # environment variables.
-
-  def self.get_proxy_from_env scheme = 'http'
-    _scheme = scheme.downcase
-    _SCHEME = scheme.upcase
-    env_proxy = ENV["#{_scheme}_proxy"] || ENV["#{_SCHEME}_PROXY"]
-
-    no_env_proxy = env_proxy.nil? || env_proxy.empty?
-
-    return get_proxy_from_env 'http' if no_env_proxy and _scheme != 'http'
-    return :no_proxy                 if no_env_proxy
-
-    uri = URI(Gem::UriFormatter.new(env_proxy).normalize)
-
-    if uri and uri.user.nil? and uri.password.nil? then
-      user     = ENV["#{_scheme}_proxy_user"] || ENV["#{_SCHEME}_PROXY_USER"]
-      password = ENV["#{_scheme}_proxy_pass"] || ENV["#{_SCHEME}_PROXY_PASS"]
-
-      uri.user     = Gem::UriFormatter.new(user).escape
-      uri.password = Gem::UriFormatter.new(password).escape
-    end
-
-    uri
-  end
-
-  def perform_request request # :nodoc:
-    connection = connection_for @uri
-
-    retried = false
-    bad_response = false
-
-    begin
-      @requests[connection.object_id] += 1
-
-      verbose "#{request.method} #{@uri}"
-
-      file_name = File.basename(@uri.path)
-      # perform download progress reporter only for gems
-      if request.response_body_permitted? && file_name =~ /\.gem$/
-        reporter = ui.download_reporter
-        response = connection.request(request) do |incomplete_response|
-          if Net::HTTPOK === incomplete_response
-            reporter.fetch(file_name, incomplete_response.content_length)
-            downloaded = 0
-            data = ''
-
-            incomplete_response.read_body do |segment|
-              data << segment
-              downloaded += segment.length
-              reporter.update(downloaded)
-            end
-            reporter.done
-            if incomplete_response.respond_to? :body=
-              incomplete_response.body = data
-            else
-              incomplete_response.instance_variable_set(:@body, data)
-            end
-          end
-        end
-      else
-        response = connection.request request
-      end
-
-      verbose "#{response.code} #{response.message}"
-
-    rescue Net::HTTPBadResponse
-      verbose "bad response"
-
-      reset connection
-
-      raise Gem::RemoteFetcher::FetchError.new('too many bad responses', @uri) if bad_response
-
-      bad_response = true
-      retry
-    # HACK work around EOFError bug in Net::HTTP
-    # NOTE Errno::ECONNABORTED raised a lot on Windows, and make impossible
-    # to install gems.
-    rescue EOFError, Timeout::Error,
-           Errno::ECONNABORTED, Errno::ECONNRESET, Errno::EPIPE
-
-      requests = @requests[connection.object_id]
-      verbose "connection reset after #{requests} requests, retrying"
-
-      raise Gem::RemoteFetcher::FetchError.new('too many connection resets', @uri) if retried
-
-      reset connection
-
-      retried = true
-      retry
-    end
-
-    response
-  ensure
-    @connection_pool.checkin connection
-  end
-
-  ##
-  # Resets HTTP connection +connection+.
-
-  def reset(connection)
-    @requests.delete connection.object_id
-
-    connection.finish
-    connection.start
-  end
-
-  def user_agent
-    ua = "RubyGems/#{Gem::VERSION} #{Gem::Platform.local}"
-
-    ruby_version = RUBY_VERSION
-    ruby_version += 'dev' if RUBY_PATCHLEVEL == -1
-
-    ua << " Ruby/#{ruby_version} (#{RUBY_RELEASE_DATE}"
-    if RUBY_PATCHLEVEL >= 0 then
-      ua << " patchlevel #{RUBY_PATCHLEVEL}"
-    elsif defined?(RUBY_REVISION) then
-      ua << " revision #{RUBY_REVISION}"
-    end
-    ua << ")"
-
-    ua << " #{RUBY_ENGINE}" if defined?(RUBY_ENGINE) and RUBY_ENGINE != 'ruby'
-
-    ua
-  end
-
-end
-
-require 'rubygems/request/http_pool'
-require 'rubygems/request/https_pool'
-require 'rubygems/request/connection_pools'
-

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rubygems/request/connection_pools.rb

@@ -1,83 +0,0 @@
-require 'thread'
-
-class Gem::Request::ConnectionPools # :nodoc:
-
-  @client = Net::HTTP
-
-  class << self
-    attr_accessor :client
-  end
-
-  def initialize proxy_uri, cert_files
-    @proxy_uri  = proxy_uri
-    @cert_files = cert_files
-    @pools      = {}
-    @pool_mutex = Mutex.new
-  end
-
-  def pool_for uri
-    http_args = net_http_args(uri, @proxy_uri)
-    key       = http_args + [https?(uri)]
-    @pool_mutex.synchronize do
-      @pools[key] ||=
-        if https? uri then
-          Gem::Request::HTTPSPool.new(http_args, @cert_files, @proxy_uri)
-        else
-          Gem::Request::HTTPPool.new(http_args, @cert_files, @proxy_uri)
-        end
-    end
-  end
-
-  def close_all
-    @pools.each_value {|pool| pool.close_all}
-  end
-
-  private
-
-  ##
-  # Returns list of no_proxy entries (if any) from the environment
-
-  def get_no_proxy_from_env
-    env_no_proxy = ENV['no_proxy'] || ENV['NO_PROXY']
-
-    return [] if env_no_proxy.nil?  or env_no_proxy.empty?
-
-    env_no_proxy.split(/\s*,\s*/)
-  end
-
-  def https? uri
-    uri.scheme.downcase == 'https'
-  end
-
-  def no_proxy? host, env_no_proxy
-    host = host.downcase
-
-    env_no_proxy.any? do |pattern|
-      pattern = pattern.downcase
-
-      host[-pattern.length, pattern.length] == pattern or
-        (pattern.start_with? '.' and pattern[1..-1] == host)
-    end
-  end
-
-  def net_http_args uri, proxy_uri
-    net_http_args = [uri.host, uri.port]
-
-    no_proxy = get_no_proxy_from_env
-
-    if proxy_uri and not no_proxy?(uri.host, no_proxy) then
-      net_http_args + [
-        proxy_uri.host,
-        proxy_uri.port,
-        Gem::UriFormatter.new(proxy_uri.user).unescape,
-        Gem::UriFormatter.new(proxy_uri.password).unescape,
-      ]
-    elsif no_proxy? uri.host, no_proxy then
-      net_http_args + [nil, nil]
-    else
-      net_http_args
-    end
-  end
-
-end
-

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rubygems/request/http_pool.rb

@@ -1,47 +0,0 @@
-##
-# A connection "pool" that only manages one connection for now.  Provides
-# thread safe `checkout` and `checkin` methods.  The pool consists of one
-# connection that corresponds to `http_args`.  This class is private, do not
-# use it.
-
-class Gem::Request::HTTPPool # :nodoc:
-  attr_reader :cert_files, :proxy_uri
-
-  def initialize http_args, cert_files, proxy_uri
-    @http_args  = http_args
-    @cert_files = cert_files
-    @proxy_uri  = proxy_uri
-    @queue      = SizedQueue.new 1
-    @queue << nil
-  end
-
-  def checkout
-    @queue.pop || make_connection
-  end
-
-  def checkin connection
-    @queue.push connection
-  end
-
-  def close_all
-    until @queue.empty?
-      if connection = @queue.pop(true) and connection.started?
-        connection.finish
-      end
-    end
-    @queue.push(nil)
-  end
-
-  private
-
-  def make_connection
-    setup_connection Gem::Request::ConnectionPools.client.new(*@http_args)
-  end
-
-  def setup_connection connection
-    connection.start
-    connection
-  end
-
-end
-

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rubygems/request/https_pool.rb

@@ -1,10 +0,0 @@
-class Gem::Request::HTTPSPool < Gem::Request::HTTPPool # :nodoc:
-  private
-
-  def setup_connection connection
-    Gem::Request.configure_connection_for_https(connection, @cert_files)
-    super
-  end
-end
-
-

data/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/gems/2.2.0/gems/second_step-0.1.1/secondstep-notify-1.0.0-osx/lib/ruby/lib/ruby/2.2.0/rubygems/request_set.rb

@@ -1,413 +0,0 @@
-require 'tsort'
-
-##
-# A RequestSet groups a request to activate a set of dependencies.
-#
-#   nokogiri = Gem::Dependency.new 'nokogiri', '~> 1.6'
-#   pg = Gem::Dependency.new 'pg', '~> 0.14'
-#
-#   set = Gem::RequestSet.new nokogiri, pg
-#
-#   requests = set.resolve
-#
-#   p requests.map { |r| r.full_name }
-#   #=> ["nokogiri-1.6.0", "mini_portile-0.5.1", "pg-0.17.0"]
-
-class Gem::RequestSet
-
-  include TSort
-
-  ##
-  # Array of gems to install even if already installed
-
-  attr_accessor :always_install
-
-  attr_reader :dependencies
-
-  attr_accessor :development
-
-  ##
-  # Errors fetching gems during resolution.
-
-  attr_reader :errors
-
-  ##
-  # Set to true if you want to install only direct development dependencies.
-
-  attr_accessor :development_shallow
-
-  ##
-  # The set of git gems imported via load_gemdeps.
-
-  attr_reader :git_set # :nodoc:
-
-  ##
-  # When true, dependency resolution is not performed, only the requested gems
-  # are installed.
-
-  attr_accessor :ignore_dependencies
-
-  attr_reader :install_dir # :nodoc:
-
-  ##
-  # If true, allow dependencies to match prerelease gems.
-
-  attr_accessor :prerelease
-
-  ##
-  # When false no remote sets are used for resolving gems.
-
-  attr_accessor :remote
-
-  attr_reader :resolver # :nodoc:
-
-  ##
-  # Sets used for resolution
-
-  attr_reader :sets # :nodoc:
-
-  ##
-  # Treat missing dependencies as silent errors
-
-  attr_accessor :soft_missing
-
-  ##
-  # The set of vendor gems imported via load_gemdeps.
-
-  attr_reader :vendor_set # :nodoc:
-
-  ##
-  # Creates a RequestSet for a list of Gem::Dependency objects, +deps+.  You
-  # can then #resolve and #install the resolved list of dependencies.
-  #
-  #   nokogiri = Gem::Dependency.new 'nokogiri', '~> 1.6'
-  #   pg = Gem::Dependency.new 'pg', '~> 0.14'
-  #
-  #   set = Gem::RequestSet.new nokogiri, pg
-
-  def initialize *deps
-    @dependencies = deps
-
-    @always_install      = []
-    @conservative        = false
-    @dependency_names    = {}
-    @development         = false
-    @development_shallow = false
-    @errors              = []
-    @git_set             = nil
-    @ignore_dependencies = false
-    @install_dir         = Gem.dir
-    @prerelease          = false
-    @remote              = true
-    @requests            = []
-    @sets                = []
-    @soft_missing        = false
-    @sorted              = nil
-    @specs               = nil
-    @vendor_set          = nil
-
-    yield self if block_given?
-  end
-
-  ##
-  # Declare that a gem of name +name+ with +reqs+ requirements is needed.
-
-  def gem name, *reqs
-    if dep = @dependency_names[name] then
-      dep.requirement.concat reqs
-    else
-      dep = Gem::Dependency.new name, reqs
-      @dependency_names[name] = dep
-      @dependencies << dep
-    end
-  end
-
-  ##
-  # Add +deps+ Gem::Dependency objects to the set.
-
-  def import deps
-    @dependencies.concat deps
-  end
-
-  ##
-  # Installs gems for this RequestSet using the Gem::Installer +options+.
-  #
-  # If a +block+ is given an activation +request+ and +installer+ are yielded.
-  # The +installer+ will be +nil+ if a gem matching the request was already
-  # installed.
-
-  def install options, &block # :yields: request, installer
-    if dir = options[:install_dir]
-      requests = install_into dir, false, options, &block
-      return requests
-    end
-
-    cache_dir = options[:cache_dir] || Gem.dir
-    @prerelease = options[:prerelease]
-
-    requests = []
-
-    sorted_requests.each do |req|
-      if req.installed? then
-        req.spec.spec.build_extensions
-
-        if @always_install.none? { |spec| spec == req.spec.spec } then
-          yield req, nil if block_given?
-          next
-        end
-      end
-
-      path = req.download cache_dir
-
-      inst = Gem::Installer.new path, options
-
-      yield req, inst if block_given?
-
-      requests << inst.install
-    end
-
-    requests
-  ensure
-    raise if $!
-    return requests if options[:gemdeps]
-
-    specs = requests.map do |request|
-      case request
-      when Gem::Resolver::ActivationRequest then
-        request.spec.spec
-      else
-        request
-      end
-    end
-
-    require 'rubygems/dependency_installer'
-    inst = Gem::DependencyInstaller.new options
-    inst.installed_gems.replace specs
-
-    Gem.done_installing_hooks.each do |hook|
-      hook.call inst, specs
-    end unless Gem.done_installing_hooks.empty?
-  end
-
-  ##
-  # Installs from the gem dependencies files in the +:gemdeps+ option in
-  # +options+, yielding to the +block+ as in #install.
-  #
-  # If +:without_groups+ is given in the +options+, those groups in the gem
-  # dependencies file are not used.  See Gem::Installer for other +options+.
-
-  def install_from_gemdeps options, &block
-    gemdeps = options[:gemdeps]
-
-    @install_dir = options[:install_dir] || Gem.dir
-    @prerelease  = options[:prerelease]
-    @remote      = options[:domain] != :local
-    @conservative = true if options[:conservative]
-
-    gem_deps_api = load_gemdeps gemdeps, options[:without_groups], true
-
-    resolve
-
-    if options[:explain]
-      puts "Gems to install:"
-
-      sorted_requests.each do |spec|
-        puts "  #{spec.full_name}"
-      end
-
-      if Gem.configuration.really_verbose
-        @resolver.stats.display
-      end
-    else
-      installed = install options, &block
-
-      if options.fetch :lock, true then
-        lockfile =
-          Gem::RequestSet::Lockfile.new self, gemdeps, gem_deps_api.dependencies
-        lockfile.write
-      end
-
-      installed
-    end
-  end
-
-  def install_into dir, force = true, options = {}
-    gem_home, ENV['GEM_HOME'] = ENV['GEM_HOME'], dir
-
-    existing = force ? [] : specs_in(dir)
-    existing.delete_if { |s| @always_install.include? s }
-
-    dir = File.expand_path dir
-
-    installed = []
-
-    options[:development] = false
-    options[:install_dir] = dir
-    options[:only_install_dir] = true
-    @prerelease = options[:prerelease]
-
-    sorted_requests.each do |request|
-      spec = request.spec
-
-      if existing.find { |s| s.full_name == spec.full_name } then
-        yield request, nil if block_given?
-        next
-      end
-
-      spec.install options do |installer|
-        yield request, installer if block_given?
-      end
-
-      installed << request
-    end
-
-    installed
-  ensure
-    ENV['GEM_HOME'] = gem_home
-  end
-
-  ##
-  # Load a dependency management file.
-
-  def load_gemdeps path, without_groups = [], installing = false
-    @git_set    = Gem::Resolver::GitSet.new
-    @vendor_set = Gem::Resolver::VendorSet.new
-
-    @git_set.root_dir = @install_dir
-
-    lockfile = Gem::RequestSet::Lockfile.new self, path
-    lockfile.parse
-
-    gf = Gem::RequestSet::GemDependencyAPI.new self, path
-    gf.installing = installing
-    gf.without_groups = without_groups if without_groups
-    gf.load
-  end
-
-  def pretty_print q # :nodoc:
-    q.group 2, '[RequestSet:', ']' do
-      q.breakable
-
-      if @remote then
-        q.text 'remote'
-        q.breakable
-      end
-
-      if @prerelease then
-        q.text 'prerelease'
-        q.breakable
-      end
-
-      if @development_shallow then
-        q.text 'shallow development'
-        q.breakable
-      elsif @development then
-        q.text 'development'
-        q.breakable
-      end
-
-      if @soft_missing then
-        q.text 'soft missing'
-      end
-
-      q.group 2, '[dependencies:', ']' do
-        q.breakable
-        @dependencies.map do |dep|
-          q.text dep.to_s
-          q.breakable
-        end
-      end
-
-      q.breakable
-      q.text 'sets:'
-
-      q.breakable
-      q.pp @sets.map { |set| set.class }
-    end
-  end
-
-  ##
-  # Resolve the requested dependencies and return an Array of Specification
-  # objects to be activated.
-
-  def resolve set = Gem::Resolver::BestSet.new
-    @sets << set
-    @sets << @git_set
-    @sets << @vendor_set
-
-    set = Gem::Resolver.compose_sets(*@sets)
-    set.remote = @remote
-    set.prerelease = @prerelease
-
-    resolver = Gem::Resolver.new @dependencies, set
-    resolver.development         = @development
-    resolver.development_shallow = @development_shallow
-    resolver.ignore_dependencies = @ignore_dependencies
-    resolver.soft_missing        = @soft_missing
-
-    if @conservative
-      installed_gems = {}
-      Gem::Specification.find_all do |spec|
-        (installed_gems[spec.name] ||= []) << spec
-      end
-      resolver.skip_gems = installed_gems
-    end
-
-    @resolver = resolver
-
-    @requests = resolver.resolve
-
-    @errors = set.errors
-
-    @requests
-  end
-
-  ##
-  # Resolve the requested dependencies against the gems available via Gem.path
-  # and return an Array of Specification objects to be activated.
-
-  def resolve_current
-    resolve Gem::Resolver::CurrentSet.new
-  end
-
-  def sorted_requests
-    @sorted ||= strongly_connected_components.flatten
-  end
-
-  def specs
-    @specs ||= @requests.map { |r| r.full_spec }
-  end
-
-  def specs_in dir
-    Dir["#{dir}/specifications/*.gemspec"].map do |g|
-      Gem::Specification.load g
-    end
-  end
-
-  def tsort_each_node &block # :nodoc:
-    @requests.each(&block)
-  end
-
-  def tsort_each_child node # :nodoc:
-    node.spec.dependencies.each do |dep|
-      next if dep.type == :development and not @development
-
-      match = @requests.find { |r|
-        dep.match? r.spec.name, r.spec.version, @prerelease
-      }
-
-      unless match then
-        next if dep.type == :development and @development_shallow
-        next if @soft_missing
-        raise Gem::DependencyError,
-              "Unresolved dependency found during sorting - #{dep} (requested by #{node.spec.full_name})"
-      end
-
-      yield match
-    end
-  end
-
-end
-
-require 'rubygems/request_set/gem_dependency_api'
-require 'rubygems/request_set/lockfile'