gss 0.0.5

data/vendor/bundle/ruby/1.9.1/gems/mini_portile-0.6.0/History.txt

@@ -0,0 +1,86 @@
+=== 0.6.0 / 2014-04-18
+
+* Enhancements:
+  * Add default cert store and custom certs from `SSL_CERT_FILE` if present.
+    This increases compatibility with Ruby 1.8.7.
+
+* Bugfixes:
+  * Specify Accept-Encoding to make sure a raw file content is downloaded.
+    Pull #30. [knu]
+
+* Internal:
+  * Improve examples and use them as test harness.
+
+=== 0.5.3 / 2014-03-24
+
+* Bugfixes:
+  * Shell escape paths in tar command. Pull #29. [quickshiftin]
+  * Support older versions of tar that cannot auto-detect
+    the compression type. Pull #27. Closes #21. [b-dean]
+  * Try RbConfig's CC before fall back to 'gcc'. Ref #28.
+
+=== 0.5.2 / 2013-10-23
+
+* Bugfixes:
+  * Change tar detection order to support NetBSD 'gtar'. Closes #24
+  * Trick 'git-apply' when applying patches on nested Git checkouts. [larskanis]
+  * Respect ENV's MAKE before fallback to 'make'. [larskanis]
+  * Respect ENV's CC variable before fallback to 'gcc'.
+  * Avoid non-ASCII output of GCC cause host detection issues. Closes #22
+
+=== 0.5.1 / 2013-07-07
+
+* Bugfixes:
+  * Detect tar executable without shelling out. [jtimberman]
+
+=== 0.5.0 / 2012-11-17
+
+* Enhancements:
+  * Allow patching extracted files using `git apply`. [metaskills]
+
+=== 0.4.1 / 2012-10-24
+
+* Bugfixes:
+  * Syntax to process FTp binary chunks differs between Ruby 1.8.7 and 1.9.x
+
+=== 0.4.0 / 2012-10-24
+
+* Enhancements:
+  * Allow fetching of FTP URLs along HTTP ones. [metaskills]
+
+=== 0.3.0 / 2012-03-23
+
+* Enhancements:
+  * Use `gcc -v` to determine original host (platform) instead of Ruby one.
+
+* Deprecations:
+  * Dropped support for Rubies older than 1.8.7
+
+=== 0.2.2 / 2011-04-11
+
+* Minor enhancements:
+  * Use LDFLAGS when activating recipes for cross-compilation. Closes #6
+
+* Bugfixes:
+  * Remove memoization of *_path helpers. Closes #7
+
+=== 0.2.1 / 2011-04-06
+
+* Minor enhancements:
+  * Provide MiniPortile#path to obtain full path to installation directory. Closes GH-5
+
+=== 0.2.0 / 2011-04-05
+
+* Enhancements:
+  * Improve tar detection
+  * Improve and refactor configure_options
+  * Detect configure_options changes. Closes GH-1
+  * Add recipe examples
+
+* Bugfixes:
+  * MiniPortile#target can be changed now. Closes GH-2
+  * Always redirect tar output properly
+
+=== 0.1.0 / 2011-03-08
+
+* Initial release. Welcome to this world!

data/vendor/bundle/ruby/1.9.1/gems/mini_portile-0.6.0/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Luis Lavena.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/1.9.1/gems/mini_portile-0.6.0/README.rdoc

@@ -0,0 +1,169 @@
+= MiniPortile
+
+* {Source Code}[https://github.com/luislavena/mini_portile]
+* {Bug Reports}[https://github.com/luislavena/mini_portile/issues]
+
+This project is a minimalistic, simplistic and stupid implementation of a port/recipe
+system <b>for developers</b>.
+
+== Another port system, srsly?
+
+No, is not a general port system, is not aimed to take over apt, macports or
+anything like that.
+
+The rationale is simple.
+
+You create a library A that uses B at runtime or compile time. Target audience
+of your library might have different versions of B installed than yours.
+
+You know, <em>Works on my machine</em> is not what you expect from one
+developer to another.
+
+Developers having problems report them back to you, and what you do then?
+Compile B locally, replacing your existing installation of B or simply hacking
+things around so nothing breaks.
+
+All this, manually.
+
+Computers are tools, are meant to help us, not the other way around.
+
+What if I tell you the above scenario can be simplified with something like
+this:
+
+  rake compile B_VERSION=1.2.3
+
+And your library will use the version of B you specified. Done.
+
+== You make it sound easy, where is the catch?
+
+You got me, there is a catch. At this time (and highly likely will be always)
+MiniPortile is only compatible with GCC compilers and autoconf/configure-based
+projects.
+
+It assumes the library you want to build contains a <tt>configure</tt> script,
+which all the autoconf-based libraries do.
+
+=== How to use
+
+Now that you know the catch, and you're still reading this, let me show you a
+quick example:
+
+  require "mini_portile"
+  recipe = MiniPortile.new("libiconv", "1.13.1")
+  recipe.files = ["http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.13.1.tar.gz"]
+  recipe.cook
+  recipe.activate
+
+That's all. <tt>cook</tt> will download, extract, patch, configure and compile
+the library into a namespaced structure. <tt>activate</tt> ensures GCC find
+this library and prefers it over a system-wide installation.
+
+=== Structure
+
+At this time, if you haven't digged into the code yet, are wondering <em>what
+is all that structure talk about?</em>.
+
+MiniPortile follows the principle of <b>convention over configuration</b> and
+established a folder structure where is going to place files and perform work.
+
+Take the above example, and let's draw some picture:
+
+  mylib
+    |-- ports
+    |   |-- archives
+    |   |   `-- libiconv-1.13.1.tar.gz
+    |   `-- <platform>
+    |       `-- libiconv
+    |           `-- 1.13.1
+    |               |-- bin
+    |               |-- include
+    |               `-- lib
+    `-- tmp
+        `-- <platform>
+            `-- ports
+
+In above structure, <tt>platform</tt> refers to the architecture that represents
+the operating system you're using (e.g. i686-linux, i386-mingw32, etc).
+
+Inside this folder, MiniPortile will store the artifacts that result from the
+compilation process. As you cans see, it versions out the library so you can
+run multiple version combination without compromising these overlap each other.
+
+<tt>archives</tt> is where downloaded source files are stored. It is recommended
+you avoid trashing that folder so no further downloads will be required (save
+bandwidth, save the world).
+
+The <tt>tmp</tt> is where compilation is performed and can be safely discarded.
+
+Don't worry, you don't need to know the path structure by memory, just use recipe's
+<tt>path</tt> to obtain the full path to the installation directory:
+
+  recipe.cook
+  recipe.path # => /home/luis/projects/myapp/ports/i686-linux/libiconv/1.13.1
+
+=== How can I combine this with my compilation task?
+
+In the simplified proposal, the idea is that using Rake, your <tt>compile</tt>
+task depends on MiniPortile compilation and most important, activation.
+
+Take the following as a simplification of how you can use MiniPortile with
+Rake:
+
+  task :libiconv do
+    recipe = MiniPortile.new("libiconv", "1.13.1")
+    recipe.files = ["http://ftp.gnu.org/pub/gnu/libiconv/libiconv-1.13.1.tar.gz"]
+    checkpoint = ".#{recipe.name}-#{recipe.version}.installed"
+
+    unless File.exist?(checkpoint)
+      recipe.cook
+      touch checkpoint
+    end
+
+    recipe.activate
+  end
+
+  task :compile => [:libiconv] do
+    # ...
+  end
+
+This example will:
+
+* Compile the library only once (using a timestamp file)
+* Ensure compiled library gets activated every time
+* Make compile task depend on compiled library activation
+
+For your homework, you can make libiconv version be taken from <tt>ENV</tt>
+variables.
+
+=== Native or cross-compilation
+
+Above examples cover the normal use case: compile support libraries natively.
+
+MiniPortile also covers another use case, which is the cross-compilation of the
+support libraries to be used as part of a binary gem compilation.
+
+It is the perfect complementary tool for rake-compiler and it's <tt>cross</tt>
+Rake task.
+
+Depending on your usage of rake-compiler, you will need to use <tt>host</tt> to
+match the installed cross-compiler toolchain.
+
+Please refer to the examples directory for simplified and practical usage.
+
+=== Supported scenarios
+
+As mentioned before, MiniPortile requires a GCC compiler toolchain. This has
+been tested against Ubuntu, OSX and even Windows (RubyInstaller with DevKit)
+
+== Disclaimer
+
+If you have any trouble, don't hesitate to contact the author. As always,
+I'm not going to say <em>Use at your own risk</em> because I don't want this
+library to be risky.
+
+If you trip on something, I'll share the liability by repairing things
+as quickly as I can. Your responsibility is to report the inadequacies.
+
+== License
+
+This library is licensed under MIT license. Please see LICENSE.txt for details.

data/vendor/bundle/ruby/1.9.1/gems/mini_portile-0.6.0/Rakefile

@@ -0,0 +1,53 @@
+require "rake/clean"
+require "rubygems/package_task"
+
+GEM_SPEC = Gem::Specification.new do |s|
+  # basic information
+  s.name        = "mini_portile"
+  s.version     = "0.6.0"
+  s.platform    = Gem::Platform::RUBY
+
+  # description and details
+  s.summary     = "Simplistic port-like solution for developers"
+  s.description = "Simplistic port-like solution for developers. It provides a standard and simplified way to compile against dependency libraries without messing up your system."
+
+  # requirements
+  s.required_ruby_version = ">= 1.8.7"
+  s.required_rubygems_version = ">= 1.3.5"
+
+  # dependencies (add_dependency)
+  # development dependencies (add_development_dependency)
+
+  # components, files and paths
+  s.files = FileList["examples/Rakefile", "lib/**/*.rb", "Rakefile", "*.{rdoc,txt}"]
+
+  s.require_path = 'lib'
+
+  # documentation
+  s.has_rdoc = true
+  s.rdoc_options << '--main'  << 'README.rdoc' << '--title' << 'MiniPortile -- Documentation'
+
+  s.extra_rdoc_files = %w(README.rdoc History.txt LICENSE.txt)
+
+  # project information
+  s.homepage          = 'http://github.com/luislavena/mini_portile'
+  s.licenses          = ['MIT']
+
+  # author and contributors
+  s.author      = 'Luis Lavena'
+  s.email       = 'luislavena@gmail.com'
+end
+
+Gem::PackageTask.new(GEM_SPEC) do |pkg|
+  pkg.need_tar = false
+  pkg.need_zip = false
+end
+
+desc "Test MiniPortile by compiling examples"
+task :test do
+  Dir.chdir("examples") do
+    sh "rake ports:all"
+  end
+end
+
+task :default => [:test]

data/vendor/bundle/ruby/1.9.1/gems/mini_portile-0.6.0/examples/Rakefile

@@ -0,0 +1,113 @@
+require File.expand_path("mini_portile", File.join(File.dirname(__FILE__), "../lib"))
+
+recipes = []
+
+# libiconv
+libiconv = MiniPortile.new "libiconv", "1.14"
+libiconv.files << "ftp://ftp.gnu.org/pub/gnu/#{libiconv.name}/#{libiconv.name}-#{libiconv.version}.tar.gz"
+
+recipes.push libiconv
+
+# sqlite3
+sqlite3 = MiniPortile.new "sqlite3", "3.8.4.1"
+sqlite3.files << "http://sqlite.org/2014/sqlite-autoconf-3080401.tar.gz"
+
+recipes.push sqlite3
+
+# c-ares
+c_ares = MiniPortile.new "c-ares", "1.7.5"
+c_ares.files << "https://s3.amazonaws.com/distfiles.openknapsack.org/#{c_ares.name}/#{c_ares.name}-#{c_ares.version}.tar.gz"
+
+recipes.push c_ares
+
+# zlib
+class ZlibRecipe < MiniPortile
+  def windows?
+    !(host =~ /mswin|mingw/).nil?
+  end
+
+  def configure
+    return super unless windows?
+
+    Dir.chdir work_path do
+      mk = File.read 'win32/Makefile.gcc'
+      File.open 'win32/Makefile.gcc', 'wb' do |f|
+        f.puts "BINARY_PATH = #{path}/bin"
+        f.puts "LIBRARY_PATH = #{path}/lib"
+        f.puts "INCLUDE_PATH = #{path}/include"
+
+        cross_build? and
+          mk.sub!(/^PREFIX\s*=\s*$/, "PREFIX = #{host}-")
+
+        f.puts mk
+      end
+    end
+  end
+
+  def configure_defaults
+    ["--static"]
+  end
+
+  def configured?
+    return super unless windows?
+
+    !!(File.read(File.join(work_path, 'win32/Makefile.gcc')) =~ /^BINARY_PATH/)
+  end
+
+  def compile
+    return super unless windows?
+
+    execute "compile", "make -f win32/Makefile.gcc"
+  end
+
+  def install
+    return if installed?
+    return super unless windows?
+
+    execute "install", %Q(#{make_cmd} -f win32/Makefile.gcc install)
+  end
+
+  def cross_build?
+    host != original_host
+  end
+end
+
+zlib = ZlibRecipe.new "zlib", "1.2.8"
+zlib.files << "http://zlib.net/#{zlib.name}-#{zlib.version}.tar.gz"
+
+recipes.push zlib
+
+namespace :ports do
+  directory "ports"
+
+  recipes.each do |recipe|
+    desc "Install port #{recipe.name} #{recipe.version}"
+    task recipe.name => ["ports"] do |t|
+      checkpoint = "ports/.#{recipe.name}-#{recipe.version}-#{recipe.host}.installed"
+
+      unless File.exist?(checkpoint)
+        recipe.cook
+        touch checkpoint
+      end
+
+      recipe.activate
+    end
+
+    task :all => recipe.name
+  end
+
+  desc "Install all ports and display installation location"
+  task :all do
+    recipes.each do |recipe|
+      puts "Artifacts of '#{recipe.name}' in '#{recipe.path}'"
+    end
+    puts "LDFLAGS: " << ENV['LDFLAGS'].inspect
+  end
+end
+
+desc "Adjust all recipes host for cross-compilation"
+task :cross do
+  recipes.each do |recipe|
+    recipe.host = "i686-w64-mingw32"
+  end
+end

data/vendor/bundle/ruby/1.9.1/gems/mini_portile-0.6.0/lib/mini_portile.rb

@@ -0,0 +1,437 @@
+require 'rbconfig'
+require 'net/http'
+require 'net/https'
+require 'net/ftp'
+require 'fileutils'
+require 'tempfile'
+require 'digest/md5'
+
+class MiniPortile
+  attr_reader :name, :version, :original_host
+  attr_writer :configure_options
+  attr_accessor :host, :files, :patch_files, :target, :logger
+
+  def initialize(name, version)
+    @name = name
+    @version = version
+    @target = 'ports'
+    @files = []
+    @patch_files = []
+    @logger = STDOUT
+
+    @original_host = @host = detect_host
+  end
+
+  def download
+    @files.each do |url|
+      filename = File.basename(url)
+      download_file(url, File.join(archives_path, filename))
+    end
+  end
+
+  def extract
+    @files.each do |url|
+      filename = File.basename(url)
+      extract_file(File.join(archives_path, filename), tmp_path)
+    end
+  end
+
+  def patch
+    # Set GIT_DIR while appying patches to work around
+    # git-apply doing nothing when started within another
+    # git directory.
+    ENV['GIT_DIR'], old_git = '.', ENV['GIT_DIR']
+    begin
+      @patch_files.each do |full_path|
+        next unless File.exists?(full_path)
+        output "Running git apply with #{full_path}..."
+        execute('patch', %Q(git apply #{full_path}))
+      end
+    ensure
+      ENV['GIT_DIR'] = old_git
+    end
+  end
+
+  def configure_options
+    @configure_options ||= configure_defaults
+  end
+
+  def configure
+    return if configured?
+
+    md5_file = File.join(tmp_path, 'configure.md5')
+    digest   = Digest::MD5.hexdigest(computed_options)
+    File.open(md5_file, "w") { |f| f.write digest }
+
+    execute('configure', %Q(sh configure #{computed_options}))
+  end
+
+  def compile
+    execute('compile', make_cmd)
+  end
+
+  def install
+    return if installed?
+    execute('install', %Q(#{make_cmd} install))
+  end
+
+  def downloaded?
+    missing = @files.detect do |url|
+      filename = File.basename(url)
+      !File.exist?(File.join(archives_path, filename))
+    end
+
+    missing ? false : true
+  end
+
+  def configured?
+    configure = File.join(work_path, 'configure')
+    makefile  = File.join(work_path, 'Makefile')
+    md5_file  = File.join(tmp_path, 'configure.md5')
+
+    stored_md5  = File.exist?(md5_file) ? File.read(md5_file) : ""
+    current_md5 = Digest::MD5.hexdigest(computed_options)
+
+    (current_md5 == stored_md5) && newer?(makefile, configure)
+  end
+
+  def installed?
+    makefile  = File.join(work_path, 'Makefile')
+    target_dir = Dir.glob("#{port_path}/*").find { |d| File.directory?(d) }
+
+    newer?(target_dir, makefile)
+  end
+
+  def cook
+    download unless downloaded?
+    extract
+    patch
+    configure unless configured?
+    compile
+    install unless installed?
+
+    return true
+  end
+
+  def activate
+    lib_path = File.join(port_path, "lib")
+    vars = {
+      'PATH'          => File.join(port_path, 'bin'),
+      'CPATH'         => File.join(port_path, 'include'),
+      'LIBRARY_PATH'  => lib_path
+    }.reject { |env, path| !File.directory?(path) }
+
+    output "Activating #{@name} #{@version} (from #{port_path})..."
+    vars.each do |var, path|
+      full_path = File.expand_path(path)
+
+      # turn into a valid Windows path (if required)
+      full_path.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+
+      # save current variable value
+      old_value = ENV[var] || ''
+
+      unless old_value.include?(full_path)
+        ENV[var] = "#{full_path}#{File::PATH_SEPARATOR}#{old_value}"
+      end
+    end
+
+    # rely on LDFLAGS when cross-compiling
+    if File.exist?(lib_path) && (@host != @original_host)
+      full_path = File.expand_path(lib_path)
+
+      old_value = ENV.fetch("LDFLAGS", "")
+
+      unless old_value.include?(full_path)
+        ENV["LDFLAGS"] = "-L#{full_path} #{old_value}".strip
+      end
+    end
+  end
+
+  def path
+    File.expand_path(port_path)
+  end
+
+private
+
+  def tmp_path
+    "tmp/#{@host}/ports/#{@name}/#{@version}"
+  end
+
+  def port_path
+    "#{@target}/#{@host}/#{@name}/#{@version}"
+  end
+
+  def archives_path
+    "#{@target}/archives"
+  end
+
+  def work_path
+    Dir.glob("#{tmp_path}/*").find { |d| File.directory?(d) }
+  end
+
+  def configure_defaults
+    [
+      "--host=#{@host}",    # build for specific target (host)
+      "--enable-static",    # build static library
+      "--disable-shared"    # disable generation of shared object
+    ]
+  end
+
+  def configure_prefix
+    "--prefix=#{File.expand_path(port_path)}"
+  end
+
+  def computed_options
+    [
+      configure_options,     # customized or default options
+      configure_prefix,      # installation target
+    ].flatten.join(' ')
+  end
+
+  def log_file(action)
+    File.join(tmp_path, "#{action}.log")
+  end
+
+  def tar_exe
+    @@tar_exe ||= begin
+      %w[gtar bsdtar tar basic-bsdtar].find { |c|
+        which(c)
+      }
+    end
+  end
+
+  def tar_compression_switch(filename)
+    case File.extname(filename)
+      when '.gz', '.tgz'
+        'z'
+      when '.bz2', '.tbz2'
+        'j'
+      when '.Z'
+        'Z'
+      else
+        ''
+    end
+  end
+
+  # From: http://stackoverflow.com/a/5471032/7672
+  # Thanks, Mislav!
+  #
+  # Cross-platform way of finding an executable in the $PATH.
+  #
+  #   which('ruby') #=> /usr/bin/ruby
+  def which(cmd)
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+      exts.each { |ext|
+        exe = File.join(path, "#{cmd}#{ext}")
+        return exe if File.executable? exe
+      }
+    end
+    return nil
+  end
+
+  def detect_host
+    return @detect_host if defined?(@detect_host)
+
+    begin
+      ENV["LC_ALL"], old_lc_all = "C", ENV["LC_ALL"]
+
+      output = `#{gcc_cmd} -v 2>&1`
+      if m = output.match(/^Target\: (.*)$/)
+        @detect_host = m[1]
+      end
+
+      @detect_host
+    ensure
+      ENV["LC_ALL"] = old_lc_all
+    end
+  end
+
+  def extract_file(file, target)
+    filename = File.basename(file)
+    FileUtils.mkdir_p target
+
+    message "Extracting #{filename} into #{target}... "
+    result = `#{tar_exe} #{tar_compression_switch(filename)}xf "#{file}" -C "#{target}" 2>&1`
+    if $?.success?
+      output "OK"
+    else
+      output "ERROR"
+      output result
+      raise "Failed to complete extract task"
+    end
+  end
+
+  def execute(action, command)
+    log        = log_file(action)
+    log_out    = File.expand_path(log)
+    redirected = command << " >#{log_out} 2>&1"
+
+    Dir.chdir work_path do
+      message "Running '#{action}' for #{@name} #{@version}... "
+      system redirected
+      if $?.success?
+        output "OK"
+        return true
+      else
+        output "ERROR, review '#{log}' to see what happened."
+        raise "Failed to complete #{action} task"
+      end
+    end
+  end
+
+  def newer?(target, checkpoint)
+    if (target && File.exist?(target)) && (checkpoint && File.exist?(checkpoint))
+      File.mtime(target) > File.mtime(checkpoint)
+    else
+      false
+    end
+  end
+
+  # print out a message with the logger
+  def message(text)
+    @logger.print text
+    @logger.flush
+  end
+
+  # print out a message using the logger but return to a new line
+  def output(text = "")
+    @logger.puts text
+    @logger.flush
+  end
+
+  # Slighly modified from RubyInstaller uri_ext, Rubinius configure
+  # and adaptations of Wayne's RailsInstaller
+  def download_file(url, full_path, count = 3)
+    return if File.exist?(full_path)
+    uri = URI.parse(url)
+    begin
+      case uri.scheme.downcase
+      when /ftp/
+        download_file_ftp(uri, full_path)
+      when /http|https/
+        download_file_http(url, full_path, count)
+      end
+    rescue Exception => e
+      File.unlink full_path if File.exists?(full_path)
+      output "ERROR: #{e.message}"
+      raise "Failed to complete download task"
+    end
+  end
+
+  def download_file_http(url, full_path, count = 3)
+    filename = File.basename(full_path)
+    uri = URI.parse(url)
+
+    if ENV['http_proxy']
+      _, userinfo, p_host, p_port = URI.split(ENV['http_proxy'])
+      proxy_user, proxy_pass = userinfo.split(/:/) if userinfo
+      http = Net::HTTP.new(uri.host, uri.port, p_host, p_port, proxy_user, proxy_pass)
+    else
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      if URI::HTTPS === uri
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+        store = OpenSSL::X509::Store.new
+
+        # Auto-include system-provided certificates
+        store.set_default_paths
+
+        if ENV.has_key?("SSL_CERT_FILE") && File.exist?(ENV["SSL_CERT_FILE"])
+          store.add_file ENV["SSL_CERT_FILE"]
+        end
+
+        http.cert_store = store
+      end
+    end
+
+    message "Downloading #{filename} "
+    http.start do |h|
+      h.request_get(uri.path, 'Accept-Encoding' => 'identity') do |response|
+        case response
+        when Net::HTTPNotFound
+          output "404 - Not Found"
+          return false
+
+        when Net::HTTPClientError
+          output "Error: Client Error: #{response.inspect}"
+          return false
+
+        when Net::HTTPRedirection
+          raise "Too many redirections for the original URL, halting." if count <= 0
+          url = response["location"]
+          return download_file(url, full_path, count - 1)
+
+        when Net::HTTPOK
+          return with_tempfile(filename, full_path) do |temp_file|
+            size = 0
+            progress = 0
+            total = response.header["Content-Length"].to_i
+            response.read_body do |chunk|
+              temp_file << chunk
+              size += chunk.size
+              new_progress = (size * 100) / total
+              unless new_progress == progress
+                message "\rDownloading %s (%3d%%) " % [filename, new_progress]
+              end
+              progress = new_progress
+            end
+            output
+          end
+        end
+      end
+    end
+  end
+
+  def download_file_ftp(uri, full_path)
+    filename = File.basename(uri.path)
+    with_tempfile(filename, full_path) do |temp_file|
+      size = 0
+      progress = 0
+      Net::FTP.open(uri.host, uri.user, uri.password) do |ftp|
+        ftp.passive = true
+        ftp.login
+        remote_dir = File.dirname(uri.path)
+        ftp.chdir(remote_dir) unless remote_dir == '.'
+        total = ftp.size(filename)
+        ftp.getbinaryfile(filename, temp_file.path, 8192) do |chunk|
+          # Ruby 1.8.7 already wrote the chunk into the file
+          unless RUBY_VERSION < "1.9"
+            temp_file << chunk
+          end
+
+          size += chunk.size
+          new_progress = (size * 100) / total
+          unless new_progress == progress
+            message "\rDownloading %s (%3d%%) " % [filename, new_progress]
+          end
+          progress = new_progress
+        end
+      end
+      output
+    end
+  end
+
+  def with_tempfile(filename, full_path)
+    temp_file = Tempfile.new("download-#{filename}")
+    temp_file.binmode
+    yield temp_file
+    temp_file.close
+    File.unlink full_path if File.exists?(full_path)
+    FileUtils.mkdir_p File.dirname(full_path)
+    FileUtils.mv temp_file.path, full_path, :force => true
+  end
+
+  def gcc_cmd
+    cc = ENV["CC"] || RbConfig::CONFIG["CC"] || "gcc"
+    return cc.dup
+  end
+
+  def make_cmd
+    m = ENV['MAKE'] || ENV['make'] || 'make'
+    return m.dup
+  end
+end