heroku_hatchet 1.3.7 → 1.4.0

data/test/fixtures/buildpacks/heroku-buildpack-ruby/lib/language_pack/rails3.rb

@@ -1,86 +0,0 @@
-require "language_pack"
-require "language_pack/rails2"
-
-# Rails 3 Language Pack. This is for all Rails 3.x apps.
-class LanguagePack::Rails3 < LanguagePack::Rails2
-  # detects if this is a Rails 3.x app
-  # @return [Boolean] true if it's a Rails 3.x app
-  def self.use?
-    if gemfile_lock?
-      rails_version = LanguagePack::Ruby.gem_version('railties')
-      rails_version >= Gem::Version.new('3.0.0') && rails_version < Gem::Version.new('4.0.0') if rails_version
-    end
-  end
-
-  def name
-    "Ruby/Rails"
-  end
-
-  def default_process_types
-    # let's special case thin here
-    web_process = gem_is_bundled?("thin") ?
-                    "bundle exec thin start -R config.ru -e $RAILS_ENV -p $PORT" :
-                    "bundle exec rails server -p $PORT"
-
-    super.merge({
-      "web" => web_process,
-      "console" => "bundle exec rails console"
-    })
-  end
-
-private
-
-  def plugins
-    super.concat(%w( rails3_serve_static_assets )).uniq
-  end
-
-  # runs the tasks for the Rails 3.1 asset pipeline
-  def run_assets_precompile_rake_task
-    log("assets_precompile") do
-      setup_database_url_env
-
-      if rake_task_defined?("assets:precompile")
-        topic("Preparing app for Rails asset pipeline")
-        if File.exists?("public/assets/manifest.yml")
-          puts "Detected manifest.yml, assuming assets were compiled locally"
-        else
-          ENV["RAILS_GROUPS"] ||= "assets"
-          ENV["RAILS_ENV"]    ||= "production"
-
-          puts "Running: rake assets:precompile"
-          require 'benchmark'
-          time = Benchmark.realtime { pipe("env PATH=$PATH:bin bundle exec rake assets:precompile 2>&1") }
-
-          if $?.success?
-            log "assets_precompile", :status => "success"
-            puts "Asset precompilation completed (#{"%.2f" % time}s)"
-          else
-            log "assets_precompile", :status => "failure"
-            puts "Precompiling assets failed, enabling runtime asset compilation"
-            install_plugin("rails31_enable_runtime_asset_compilation")
-            puts "Please see this article for troubleshooting help:"
-            puts "http://devcenter.heroku.com/articles/rails31_heroku_cedar#troubleshooting"
-          end
-        end
-      end
-    end
-  end
-
-  # setup the database url as an environment variable
-  def setup_database_url_env
-    ENV["DATABASE_URL"] ||= begin
-      # need to use a dummy DATABASE_URL here, so rails can load the environment
-      scheme =
-        if gem_is_bundled?("pg")
-          "postgres"
-        elsif gem_is_bundled?("mysql")
-          "mysql"
-        elsif gem_is_bundled?("mysql2")
-          "mysql2"
-        elsif gem_is_bundled?("sqlite3") || gem_is_bundled?("sqlite3-ruby")
-          "sqlite3"
-        end
-      "#{scheme}://user:pass@127.0.0.1/dbname"
-    end
-  end
-end

data/test/fixtures/buildpacks/heroku-buildpack-ruby/lib/language_pack/rails4.rb

@@ -1,66 +0,0 @@
-require "language_pack"
-require "language_pack/rails3"
-
-# Rails 4 Language Pack. This is for all Rails 4.x apps.
-class LanguagePack::Rails4 < LanguagePack::Rails3
-  # detects if this is a Rails 3.x app
-  # @return [Boolean] true if it's a Rails 3.x app
-  def self.use?
-    if gemfile_lock?
-      rails_version = LanguagePack::Ruby.gem_version('railties')
-      rails_version >= Gem::Version.new('4.0.0.beta') && rails_version < Gem::Version.new('5.0.0') if rails_version
-    end
-  end
-
-  def name
-    "Ruby/Rails"
-  end
-
-  def default_process_types
-    web_process = gem_is_bundled?("thin") ?
-      "bin/rails server thin -p $PORT -e $RAILS_ENV" :
-      "bin/rails server -p $PORT -e $RAILS_ENV"
-    super.merge({
-      "web"     => web_process,
-      "console" => "bin/rails console"
-    })
-  end
-
-  private
-  def plugins
-    []
-  end
-
-  def run_assets_precompile_rake_task
-    log("assets_precompile") do
-      setup_database_url_env
-
-      if rake_task_defined?("assets:precompile")
-        topic("Preparing app for Rails asset pipeline")
-        if Dir.glob('public/assets/manifest-*.json').any?
-          puts "Detected manifest file, assuming assets were compiled locally"
-        else
-          ENV["RAILS_GROUPS"] ||= "assets"
-          ENV["RAILS_ENV"]    ||= "production"
-
-          puts "Running: rake assets:precompile"
-          require 'benchmark'
-          time = Benchmark.realtime { pipe("env PATH=$PATH:bin bundle exec rake assets:precompile 2>&1") }
-
-          if $?.success?
-            log "assets_precompile", :status => "success"
-            puts "Asset precompilation completed (#{"%.2f" % time}s)"
-          else
-            log "assets_precompile", :status => "failure"
-            error "Precompiling assets failed."
-          end
-        end
-      else
-        puts "Error detecting the assets:precompile task"
-      end
-    end
-  end
-
-  def create_database_yml
-  end
-end

data/test/fixtures/buildpacks/heroku-buildpack-ruby/lib/language_pack/ruby.rb

@@ -1,681 +0,0 @@
-require "tmpdir"
-require "rubygems"
-require "language_pack"
-require "language_pack/base"
-require "language_pack/bundler_lockfile"
-
-# base Ruby Language Pack. This is for any base ruby app.
-class LanguagePack::Ruby < LanguagePack::Base
-  include LanguagePack::BundlerLockfile
-  extend LanguagePack::BundlerLockfile
-
-  BUILDPACK_VERSION   = "v61"
-  LIBYAML_VERSION     = "0.1.4"
-  LIBYAML_PATH        = "libyaml-#{LIBYAML_VERSION}"
-  BUNDLER_VERSION     = "1.3.2"
-  BUNDLER_GEM_PATH    = "bundler-#{BUNDLER_VERSION}"
-  NODE_VERSION        = "0.4.7"
-  NODE_JS_BINARY_PATH = "node-#{NODE_VERSION}"
-  JVM_BASE_URL        = "http://heroku-jdk.s3.amazonaws.com"
-  JVM_VERSION         = "openjdk7-latest"
-
-  # detects if this is a valid Ruby app
-  # @return [Boolean] true if it's a Ruby app
-  def self.use?
-    File.exist?("Gemfile")
-  end
-
-  def self.lockfile_parser
-    require "bundler"
-    Bundler::LockfileParser.new(File.read("Gemfile.lock"))
-  end
-
-  def self.gem_version(name)
-    gem_version = nil
-    bootstrap_bundler do |bundler_path|
-      $: << "#{bundler_path}/gems/bundler-#{LanguagePack::Ruby::BUNDLER_VERSION}/lib"
-      gem         = lockfile_parser.specs.detect {|gem| gem.name == name }
-      gem_version = gem.version if gem
-    end
-
-    gem_version
-  end
-
-  def name
-    "Ruby"
-  end
-
-  def default_addons
-    add_dev_database_addon
-  end
-
-  def default_config_vars
-    vars = {
-      "LANG"     => "en_US.UTF-8",
-      "PATH"     => default_path,
-      "GEM_PATH" => slug_vendor_base,
-    }
-
-    ruby_version_jruby? ? vars.merge({
-      "JAVA_OPTS" => default_java_opts,
-      "JRUBY_OPTS" => default_jruby_opts,
-      "JAVA_TOOL_OPTIONS" => default_java_tool_options
-    }) : vars
-  end
-
-  def default_process_types
-    {
-      "rake"    => "bundle exec rake",
-      "console" => "bundle exec irb"
-    }
-  end
-
-  def compile
-    Dir.chdir(build_path)
-    remove_vendor_bundle
-    install_ruby
-    install_jvm
-    setup_language_pack_environment
-    setup_profiled
-    allow_git do
-      install_language_pack_gems
-      build_bundler
-      create_database_yml
-      install_binaries
-      run_assets_precompile_rake_task
-    end
-  end
-
-private
-
-  # the base PATH environment variable to be used
-  # @return [String] the resulting PATH
-  def default_path
-    "bin:#{slug_vendor_base}/bin:/usr/local/bin:/usr/bin:/bin"
-  end
-
-  # the relative path to the bundler directory of gems
-  # @return [String] resulting path
-  def slug_vendor_base
-    if @slug_vendor_base
-      @slug_vendor_base
-    elsif @ruby_version == "ruby-1.8.7"
-      @slug_vendor_base = "vendor/bundle/1.8"
-    else
-      @slug_vendor_base = run(%q(ruby -e "require 'rbconfig';puts \"vendor/bundle/#{RUBY_ENGINE}/#{RbConfig::CONFIG['ruby_version']}\"")).chomp
-    end
-  end
-
-  # the relative path to the vendored ruby directory
-  # @return [String] resulting path
-  def slug_vendor_ruby
-    "vendor/#{ruby_version}"
-  end
-
-  # the relative path to the vendored jvm
-  # @return [String] resulting path
-  def slug_vendor_jvm
-    "vendor/jvm"
-  end
-
-  # the absolute path of the build ruby to use during the buildpack
-  # @return [String] resulting path
-  def build_ruby_path
-    "/tmp/#{ruby_version}"
-  end
-
-  # fetch the ruby version from bundler
-  # @return [String, nil] returns the ruby version if detected or nil if none is detected
-  def ruby_version
-    return @ruby_version if @ruby_version_run
-
-    @ruby_version_run = true
-
-    bootstrap_bundler do |bundler_path|
-      old_system_path = "/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin"
-      @ruby_version = run_stdout("env PATH=#{old_system_path}:#{bundler_path}/bin GEM_PATH=#{bundler_path} bundle platform --ruby").chomp
-    end
-
-    if @ruby_version == "No ruby version specified" && ENV['RUBY_VERSION']
-      # for backwards compatibility.
-      # this will go away in the future
-      @ruby_version = ENV['RUBY_VERSION']
-      @ruby_version_env_var = true
-    elsif @ruby_version == "No ruby version specified"
-      @ruby_version = nil
-    else
-      @ruby_version = @ruby_version.sub('(', '').sub(')', '').split.join('-')
-      @ruby_version_env_var = false
-    end
-
-    @ruby_version
-  end
-
-  # determine if we're using rbx
-  # @return [Boolean] true if we are and false if we aren't
-  def ruby_version_rbx?
-    ruby_version ? ruby_version.match(/rbx-/) : false
-  end
-
-  # determine if we're using jruby
-  # @return [Boolean] true if we are and false if we aren't
-  def ruby_version_jruby?
-    @ruby_version_jruby ||= ruby_version ? ruby_version.match(/jruby-/) : false
-  end
-
-  # default JAVA_OPTS
-  # return [String] string of JAVA_OPTS
-  def default_java_opts
-    "-Xmx384m -Xss512k -XX:+UseCompressedOops -Dfile.encoding=UTF-8"
-  end
-
-  # default JRUBY_OPTS
-  # return [String] string of JRUBY_OPTS
-  def default_jruby_opts
-    "-Xcompile.invokedynamic=true"
-  end
-
-  # default JAVA_TOOL_OPTIONS
-  # return [String] string of JAVA_TOOL_OPTIONS
-  def default_java_tool_options
-    "-Djava.rmi.server.useCodebaseOnly=true"
-  end
-
-  # list the available valid ruby versions
-  # @note the value is memoized
-  # @return [Array] list of Strings of the ruby versions available
-  def ruby_versions
-    return @ruby_versions if @ruby_versions
-
-    Dir.mktmpdir("ruby_versions-") do |tmpdir|
-      Dir.chdir(tmpdir) do
-        run("curl -O #{VENDOR_URL}/ruby_versions.yml")
-        @ruby_versions = YAML::load_file("ruby_versions.yml")
-      end
-    end
-
-    @ruby_versions
-  end
-
-  # sets up the environment variables for the build process
-  def setup_language_pack_environment
-    setup_ruby_install_env
-
-    config_vars = default_config_vars.each do |key, value|
-      ENV[key] ||= value
-    end
-    ENV["GEM_HOME"] = slug_vendor_base
-    ENV["PATH"]     = "#{ruby_install_binstub_path}:#{config_vars["PATH"]}"
-  end
-
-  # sets up the profile.d script for this buildpack
-  def setup_profiled
-    set_env_override "GEM_PATH", "$HOME/#{slug_vendor_base}:$GEM_PATH"
-    set_env_default  "LANG",     "en_US.UTF-8"
-    set_env_override "PATH",     "$HOME/bin:$HOME/#{slug_vendor_base}/bin:$PATH"
-
-    if ruby_version_jruby?
-      set_env_default "JAVA_OPTS", default_java_opts
-      set_env_default "JRUBY_OPTS", default_jruby_opts
-      set_env_default "JAVA_TOOL_OPTIONS", default_java_tool_options
-    end
-  end
-
-  # determines if a build ruby is required
-  # @return [Boolean] true if a build ruby is required
-  def build_ruby?
-    @build_ruby ||= !ruby_version_rbx? && !ruby_version_jruby? && !%w{ruby-1.9.3 ruby-2.0.0}.include?(ruby_version)
-  end
-
-  # install the vendored ruby
-  # @return [Boolean] true if it installs the vendored ruby and false otherwise
-  def install_ruby
-    return false unless ruby_version
-
-    invalid_ruby_version_message = <<ERROR
-Invalid RUBY_VERSION specified: #{ruby_version}
-Valid versions: #{ruby_versions.join(", ")}
-ERROR
-
-    if build_ruby?
-      FileUtils.mkdir_p(build_ruby_path)
-      Dir.chdir(build_ruby_path) do
-        ruby_vm = ruby_version_rbx? ? "rbx" : "ruby"
-        run("curl #{VENDOR_URL}/#{ruby_version.sub(ruby_vm, "#{ruby_vm}-build")}.tgz -s -o - | tar zxf -")
-      end
-      error invalid_ruby_version_message unless $?.success?
-    end
-
-    FileUtils.mkdir_p(slug_vendor_ruby)
-    Dir.chdir(slug_vendor_ruby) do
-      run("curl #{VENDOR_URL}/#{ruby_version}.tgz -s -o - | tar zxf -")
-    end
-    error invalid_ruby_version_message unless $?.success?
-
-    bin_dir = "bin"
-    FileUtils.mkdir_p bin_dir
-    Dir["#{slug_vendor_ruby}/bin/*"].each do |bin|
-      run("ln -s ../#{bin} #{bin_dir}")
-    end
-
-    if !@ruby_version_env_var
-      topic "Using Ruby version: #{ruby_version}"
-    else
-      topic "Using RUBY_VERSION: #{ruby_version}"
-      puts  "WARNING: RUBY_VERSION support has been deprecated and will be removed entirely on August 1, 2012."
-      puts  "See https://devcenter.heroku.com/articles/ruby-versions#selecting_a_version_of_ruby for more information."
-    end
-
-    true
-  end
-
-  # vendors JVM into the slug for JRuby
-  def install_jvm
-    if ruby_version_jruby?
-      topic "Installing JVM: #{JVM_VERSION}"
-
-      FileUtils.mkdir_p(slug_vendor_jvm)
-      Dir.chdir(slug_vendor_jvm) do
-        run("curl #{JVM_BASE_URL}/#{JVM_VERSION}.tar.gz -s -o - | tar xzf -")
-      end
-
-      bin_dir = "bin"
-      FileUtils.mkdir_p bin_dir
-      Dir["#{slug_vendor_jvm}/bin/*"].each do |bin|
-        run("ln -s ../#{bin} #{bin_dir}")
-      end
-    end
-  end
-
-  # find the ruby install path for its binstubs during build
-  # @return [String] resulting path or empty string if ruby is not vendored
-  def ruby_install_binstub_path
-    @ruby_install_binstub_path ||=
-      if build_ruby?
-        "#{build_ruby_path}/bin"
-      elsif ruby_version
-        "#{slug_vendor_ruby}/bin"
-      else
-        ""
-      end
-  end
-
-  # setup the environment so we can use the vendored ruby
-  def setup_ruby_install_env
-    ENV["PATH"] = "#{ruby_install_binstub_path}:#{ENV["PATH"]}"
-
-    if ruby_version_jruby?
-      ENV['JAVA_OPTS']  = default_java_opts
-    end
-  end
-
-  # list of default gems to vendor into the slug
-  # @return [Array] resulting list of gems
-  def gems
-    [BUNDLER_GEM_PATH]
-  end
-
-  # installs vendored gems into the slug
-  def install_language_pack_gems
-    FileUtils.mkdir_p(slug_vendor_base)
-    Dir.chdir(slug_vendor_base) do |dir|
-      gems.each do |gem|
-        run("curl #{VENDOR_URL}/#{gem}.tgz -s -o - | tar xzf -")
-      end
-      Dir["bin/*"].each {|path| run("chmod 755 #{path}") }
-    end
-  end
-
-  # default set of binaries to install
-  # @return [Array] resulting list
-  def binaries
-    add_node_js_binary
-  end
-
-  # vendors binaries into the slug
-  def install_binaries
-    binaries.each {|binary| install_binary(binary) }
-    Dir["bin/*"].each {|path| run("chmod +x #{path}") }
-  end
-
-  # vendors individual binary into the slug
-  # @param [String] name of the binary package from S3.
-  #   Example: https://s3.amazonaws.com/language-pack-ruby/node-0.4.7.tgz, where name is "node-0.4.7"
-  def install_binary(name)
-    bin_dir = "bin"
-    FileUtils.mkdir_p bin_dir
-    Dir.chdir(bin_dir) do |dir|
-      run("curl #{VENDOR_URL}/#{name}.tgz -s -o - | tar xzf -")
-    end
-  end
-
-  # removes a binary from the slug
-  # @param [String] relative path of the binary on the slug
-  def uninstall_binary(path)
-    FileUtils.rm File.join('bin', File.basename(path)), :force => true
-  end
-
-  # install libyaml into the LP to be referenced for psych compilation
-  # @param [String] tmpdir to store the libyaml files
-  def install_libyaml(dir)
-    FileUtils.mkdir_p dir
-    Dir.chdir(dir) do |dir|
-      run("curl #{VENDOR_URL}/#{LIBYAML_PATH}.tgz -s -o - | tar xzf -")
-    end
-  end
-
-  # remove `vendor/bundle` that comes from the git repo
-  # in case there are native ext.
-  # users should be using `bundle pack` instead.
-  # https://github.com/heroku/heroku-buildpack-ruby/issues/21
-  def remove_vendor_bundle
-    if File.exists?("vendor/bundle")
-      topic "WARNING:  Removing `vendor/bundle`."
-      puts  "Checking in `vendor/bundle` is not supported. Please remove this directory"
-      puts  "and add it to your .gitignore. To vendor your gems with Bundler, use"
-      puts  "`bundle pack` instead."
-      FileUtils.rm_rf("vendor/bundle")
-    end
-  end
-
-  # runs bundler to install the dependencies
-  def build_bundler
-    log("bundle") do
-      bundle_without = ENV["BUNDLE_WITHOUT"] || "development:test"
-      bundle_command = "bundle install --without #{bundle_without} --path vendor/bundle --binstubs vendor/bundle/bin"
-
-      unless File.exist?("Gemfile.lock")
-        error "Gemfile.lock is required. Please run \"bundle install\" locally\nand commit your Gemfile.lock."
-      end
-
-      if has_windows_gemfile_lock?
-        topic "WARNING: Removing `Gemfile.lock` because it was generated on Windows."
-        puts "Bundler will do a full resolve so native gems are handled properly."
-        puts "This may result in unexpected gem versions being used in your app."
-
-        log("bundle", "has_windows_gemfile_lock")
-        File.unlink("Gemfile.lock")
-      else
-        # using --deployment is preferred if we can
-        bundle_command += " --deployment"
-        cache_load ".bundle"
-      end
-
-      version = run_stdout("bundle version").strip
-      topic("Installing dependencies using #{version}")
-
-      load_bundler_cache
-
-      bundler_output = ""
-      Dir.mktmpdir("libyaml-") do |tmpdir|
-        libyaml_dir = "#{tmpdir}/#{LIBYAML_PATH}"
-        install_libyaml(libyaml_dir)
-
-        # need to setup compile environment for the psych gem
-        yaml_include   = File.expand_path("#{libyaml_dir}/include")
-        yaml_lib       = File.expand_path("#{libyaml_dir}/lib")
-        pwd            = run("pwd").chomp
-        bundler_path   = "#{pwd}/#{slug_vendor_base}/gems/#{BUNDLER_GEM_PATH}/lib"
-        # we need to set BUNDLE_CONFIG and BUNDLE_GEMFILE for
-        # codon since it uses bundler.
-        env_vars       = "env BUNDLE_GEMFILE=#{pwd}/Gemfile BUNDLE_CONFIG=#{pwd}/.bundle/config CPATH=#{yaml_include}:$CPATH CPPATH=#{yaml_include}:$CPPATH LIBRARY_PATH=#{yaml_lib}:$LIBRARY_PATH RUBYOPT=\"#{syck_hack}\""
-        env_vars      += " BUNDLER_LIB_PATH=#{bundler_path}" if ruby_version.match(/^ruby-1\.8\.7/)
-        puts "Running: #{bundle_command}"
-        bundler_output << pipe("#{env_vars} #{bundle_command} --no-clean 2>&1")
-
-      end
-
-      if $?.success?
-        log "bundle", :status => "success"
-        puts "Cleaning up the bundler cache."
-        pipe "bundle clean 2> /dev/null"
-        cache_store ".bundle"
-        cache_store "vendor/bundle"
-
-        # Keep gem cache out of the slug
-        FileUtils.rm_rf("#{slug_vendor_base}/cache")
-
-        # symlink binstubs
-        bin_dir = "bin"
-        FileUtils.mkdir_p bin_dir
-        Dir["#{slug_vendor_base}/bin/*"].each do |bin|
-          run("ln -s ../#{bin} #{bin_dir}") unless File.exist?("#{bin_dir}/#{bin}")
-        end
-      else
-        log "bundle", :status => "failure"
-        error_message = "Failed to install gems via Bundler."
-        if bundler_output.match(/Installing sqlite3 \([\w.]+\) with native extensions\s+Gem::Installer::ExtensionBuildError: ERROR: Failed to build gem native extension./)
-          error_message += <<ERROR
-
-
-Detected sqlite3 gem which is not supported on Heroku.
-http://devcenter.heroku.com/articles/how-do-i-use-sqlite3-for-development
-ERROR
-        end
-
-        error error_message
-      end
-    end
-  end
-
-  # RUBYOPT line that requires syck_hack file
-  # @return [String] require string if needed or else an empty string
-  def syck_hack
-    syck_hack_file = File.expand_path(File.join(File.dirname(__FILE__), "../../vendor/syck_hack"))
-    ruby_version   = run_stdout('ruby -e "puts RUBY_VERSION"').chomp
-    # < 1.9.3 includes syck, so we need to use the syck hack
-    if Gem::Version.new(ruby_version) < Gem::Version.new("1.9.3")
-      "-r#{syck_hack_file}"
-    else
-      ""
-    end
-  end
-
-  # writes ERB based database.yml for Rails. The database.yml uses the DATABASE_URL from the environment during runtime.
-  def create_database_yml
-    log("create_database_yml") do
-      return unless File.directory?("config")
-      topic("Writing config/database.yml to read from DATABASE_URL")
-      File.open("config/database.yml", "w") do |file|
-        file.puts <<-DATABASE_YML
-<%
-
-require 'cgi'
-require 'uri'
-
-begin
-  uri = URI.parse(ENV["DATABASE_URL"])
-rescue URI::InvalidURIError
-  raise "Invalid DATABASE_URL"
-end
-
-raise "No RACK_ENV or RAILS_ENV found" unless ENV["RAILS_ENV"] || ENV["RACK_ENV"]
-
-def attribute(name, value, force_string = false)
-  if value
-    value_string =
-      if force_string
-        '"' + value + '"'
-      else
-        value
-      end
-    "\#{name}: \#{value_string}"
-  else
-    ""
-  end
-end
-
-adapter = uri.scheme
-adapter = "postgresql" if adapter == "postgres"
-
-database = (uri.path || "").split("/")[1]
-
-username = uri.user
-password = uri.password
-
-host = uri.host
-port = uri.port
-
-params = CGI.parse(uri.query || "")
-
-%>
-
-<%= ENV["RAILS_ENV"] || ENV["RACK_ENV"] %>:
-  <%= attribute "adapter",  adapter %>
-  <%= attribute "database", database %>
-  <%= attribute "username", username %>
-  <%= attribute "password", password, true %>
-  <%= attribute "host",     host %>
-  <%= attribute "port",     port %>
-
-<% params.each do |key, value| %>
-  <%= key %>: <%= value.first %>
-<% end %>
-        DATABASE_YML
-      end
-    end
-  end
-
-  # add bundler to the load path
-  # @note it sets a flag, so the path can only be loaded once
-  def add_bundler_to_load_path
-    return if @bundler_loadpath
-    $: << File.expand_path(Dir["#{slug_vendor_base}/gems/bundler*/lib"].first)
-    @bundler_loadpath = true
-  end
-
-  # detects whether the Gemfile.lock contains the Windows platform
-  # @return [Boolean] true if the Gemfile.lock was created on Windows
-  def has_windows_gemfile_lock?
-    lockfile_parser.platforms.detect do |platform|
-      /mingw|mswin/.match(platform.os) if platform.is_a?(Gem::Platform)
-    end
-  end
-
-  # detects if a gem is in the bundle.
-  # @param [String] name of the gem in question
-  # @return [String, nil] if it finds the gem, it will return the line from bundle show or nil if nothing is found.
-  def gem_is_bundled?(gem)
-    @bundler_gems ||= lockfile_parser.specs.map(&:name)
-    @bundler_gems.include?(gem)
-  end
-
-  # setup the lockfile parser
-  # @return [Bundler::LockfileParser] a Bundler::LockfileParser
-  def lockfile_parser
-    add_bundler_to_load_path
-    @lockfile_parser ||= LanguagePack::Ruby.lockfile_parser
-  end
-
-  # detects if a rake task is defined in the app
-  # @param [String] the task in question
-  # @return [Boolean] true if the rake task is defined in the app
-  def rake_task_defined?(task)
-    run("env PATH=$PATH bundle exec rake #{task} --dry-run") && $?.success?
-  end
-
-  # executes the block with GIT_DIR environment variable removed since it can mess with the current working directory git thinks it's in
-  # @param [block] block to be executed in the GIT_DIR free context
-  def allow_git(&blk)
-    git_dir = ENV.delete("GIT_DIR") # can mess with bundler
-    blk.call
-    ENV["GIT_DIR"] = git_dir
-  end
-
-  # decides if we need to enable the dev database addon
-  # @return [Array] the database addon if the pg gem is detected or an empty Array if it isn't.
-  def add_dev_database_addon
-    gem_is_bundled?("pg") ? ['heroku-postgresql:dev'] : []
-  end
-
-  # decides if we need to install the node.js binary
-  # @note execjs will blow up if no JS RUNTIME is detected and is loaded.
-  # @return [Array] the node.js binary path if we need it or an empty Array
-  def add_node_js_binary
-    gem_is_bundled?('execjs') ? [NODE_JS_BINARY_PATH] : []
-  end
-
-  def run_assets_precompile_rake_task
-    if rake_task_defined?("assets:precompile")
-      require 'benchmark'
-
-      topic "Running: rake assets:precompile"
-      time = Benchmark.realtime { pipe("env PATH=$PATH:bin bundle exec rake assets:precompile 2>&1") }
-      if $?.success?
-        puts "Asset precompilation completed (#{"%.2f" % time}s)"
-      end
-    end
-  end
-
-  def bundler_cache
-    "vendor/bundle"
-  end
-
-  def load_bundler_cache
-    cache_load "vendor"
-
-    full_ruby_version       = run_stdout(%q(ruby -v)).chomp
-    rubygems_version        = run_stdout(%q(gem -v)).chomp
-    heroku_metadata         = "vendor/heroku"
-    old_rubygems_version    = nil
-    ruby_version_cache      = "#{heroku_metadata}/ruby_version"
-    buildpack_version_cache = "#{heroku_metadata}/buildpack_version"
-    bundler_version_cache   = "#{heroku_metadata}/bundler_version"
-    rubygems_version_cache  = "#{heroku_metadata}/rubygems_version"
-
-    old_rubygems_version = File.read(rubygems_version_cache).chomp if File.exists?(rubygems_version_cache)
-
-    # fix bug from v37 deploy
-    if File.exists?("vendor/ruby_version")
-      puts "Broken cache detected. Purging build cache."
-      cache_clear("vendor")
-      FileUtils.rm_rf("vendor/ruby_version")
-      purge_bundler_cache
-    # fix bug introduced in v38
-    elsif !File.exists?(buildpack_version_cache) && File.exists?(ruby_version_cache)
-      puts "Broken cache detected. Purging build cache."
-      purge_bundler_cache
-    elsif cache_exists?(bundler_cache) && File.exists?(ruby_version_cache) && full_ruby_version != File.read(ruby_version_cache).chomp
-      puts "Ruby version change detected. Clearing bundler cache."
-      puts "Old: #{File.read(ruby_version_cache).chomp}"
-      puts "New: #{full_ruby_version}"
-      purge_bundler_cache
-    end
-
-    # fix git gemspec bug from Bundler 1.3.0+ upgrade
-    if File.exists?(bundler_cache) && !File.exists?(bundler_version_cache) && !run("find vendor/bundle/*/*/bundler/gems/*/ -name *.gemspec").include?("No such file or directory")
-      puts "Old bundler cache detected. Clearing bundler cache."
-      purge_bundler_cache
-    end
-
-    # fix for https://github.com/heroku/heroku-buildpack-ruby/issues/86
-    if (!File.exists?(rubygems_version_cache) ||
-          (old_rubygems_version == "2.0.0" && old_rubygems_version != rubygems_version)) &&
-        File.exists?(ruby_version_cache) && File.read(ruby_version_cache).chomp.include?("ruby 2.0.0p0")
-      puts "Updating to rubygems #{rubygems_version}. Clearing bundler cache."
-      purge_bundler_cache
-    end
-
-    FileUtils.mkdir_p(heroku_metadata)
-    File.open(ruby_version_cache, 'w') do |file|
-      file.puts full_ruby_version
-    end
-    File.open(buildpack_version_cache, 'w') do |file|
-      file.puts BUILDPACK_VERSION
-    end
-    File.open(bundler_version_cache, 'w') do |file|
-      file.puts BUNDLER_VERSION
-    end
-    File.open(rubygems_version_cache, 'w') do |file|
-      file.puts rubygems_version
-    end
-    cache_store heroku_metadata
-  end
-
-  def purge_bundler_cache
-    FileUtils.rm_rf(bundler_cache)
-    cache_clear bundler_cache
-    # need to reinstall language pack gems
-    install_language_pack_gems
-  end
-end