pogo 2.31.2

data/lib/heroku/command/account.rb

@@ -0,0 +1,23 @@
+require "heroku/command/base"
+
+# manage heroku account options
+#
+class Heroku::Command::Account < Heroku::Command::Base
+
+  # account:confirm_billing
+  #
+  # Confirm that your account can be billed at the end of the month
+  #
+  #Example:
+  #
+  # $ heroku account:confirm_billing
+  # This action will cause your account to be billed at the end of the month
+  # For more information, see http://docs.heroku.com/billing
+  # Are you sure you want to do this? (y/n)
+  #
+  def confirm_billing
+    validate_arguments!
+    Heroku::Helpers.confirm_billing
+  end
+
+end

data/lib/heroku/command/accounts.rb

@@ -0,0 +1,34 @@
+if Heroku::Plugin.list.include?('heroku-accounts')
+
+  require "heroku/command/base"
+
+  # manage multiple heroku accounts
+  #
+  class Heroku::Command::Accounts < Heroku::Command::Base
+
+    # accounts:default
+    # set a system-wide default account
+    def default
+      name = shift_argument
+      validate_arguments!
+
+      unless name
+        error("Please specify an account name.")
+      end
+
+      unless account_exists?(name)
+        error("That account does not exist.")
+      end
+
+      result = %x{ git config --global heroku.account #{name} }
+
+      # update netrc
+      Heroku::Auth.instance_variable_set(:@account, nil) # kill memoization
+      Heroku::Auth.credentials = [Heroku::Auth.user, Heroku::Auth.password]
+      Heroku::Auth.write_credentials
+
+      result
+    end
+
+  end
+end

data/lib/heroku/command/addons.rb

@@ -0,0 +1,305 @@
+require "heroku/command/base"
+require "heroku/helpers/heroku_postgresql"
+
+module Heroku::Command
+
+  # manage addon resources
+  #
+  class Addons < Base
+
+    include Heroku::Helpers::HerokuPostgresql
+
+    # addons
+    #
+    # list installed addons
+    #
+    def index
+      validate_arguments!
+
+      installed = api.get_addons(app).body
+      if installed.empty?
+        display("#{app} has no add-ons.")
+      else
+        available, pending = installed.partition { |a| a['configured'] }
+
+        unless available.empty?
+          styled_header("#{app} Configured Add-ons")
+          styled_array(available.map do |a|
+            [a['name'], a['attachment_name'] || '']
+          end)
+        end
+
+        unless pending.empty?
+          styled_header("#{app} Add-ons to Configure")
+          styled_array(pending.map do |a|
+            [a['name'], app_addon_url(a['name'])]
+          end)
+        end
+      end
+    end
+
+    # addons:list
+    #
+    # list all available addons
+    #
+    def list
+      addons = heroku.addons
+      if addons.empty?
+        display "No addons available currently"
+      else
+        partitioned_addons = partition_addons(addons)
+        partitioned_addons.each do |key, addons|
+          partitioned_addons[key] = format_for_display(addons)
+        end
+        display_object(partitioned_addons)
+      end
+    end
+
+    # addons:add ADDON
+    #
+    # install an addon
+    #
+    def add
+      configure_addon('Adding') do |addon, config|
+        heroku.install_addon(app, addon, config)
+      end
+    end
+
+    # addons:upgrade ADDON
+    #
+    # upgrade an existing addon
+    #
+    def upgrade
+      configure_addon('Upgrading to') do |addon, config|
+        heroku.upgrade_addon(app, addon, config)
+      end
+    end
+
+    # addons:downgrade ADDON
+    #
+    # downgrade an existing addon
+    #
+    def downgrade
+      configure_addon('Downgrading to') do |addon, config|
+        heroku.upgrade_addon(app, addon, config)
+      end
+    end
+
+    # addons:remove ADDON1 [ADDON2 ...]
+    #
+    # uninstall one or more addons
+    #
+    def remove
+      return unless confirm_command
+
+      args.each do |name|
+        messages = nil
+        action("Removing #{name} on #{app}") do
+          messages = addon_run { heroku.uninstall_addon(app, name, :confirm => app) }
+        end
+        display(messages[:attachment]) if messages[:attachment]
+        display(messages[:message]) if messages[:message]
+      end
+    end
+
+    # addons:docs ADDON
+    #
+    # open an addon's documentation in your browser
+    #
+    def docs
+      unless addon = shift_argument
+        error("Usage: heroku addons:docs ADDON\nMust specify ADDON to open docs for.")
+      end
+      validate_arguments!
+
+      addon_names = api.get_addons.body.map {|a| a['name']}
+      addon_types = addon_names.map {|name| name.split(':').first}.uniq
+
+      name_matches = addon_names.select {|name| name =~ /^#{addon}/}
+      type_matches = addon_types.select {|name| name =~ /^#{addon}/}
+
+      if name_matches.include?(addon) || type_matches.include?(addon)
+        type_matches = [addon]
+      end
+
+      case type_matches.length
+      when 0 then
+        error([
+          "`#{addon}` is not a heroku add-on.",
+          suggestion(addon, addon_names + addon_types),
+          "See `heroku addons:list` for all available addons."
+        ].compact.join("\n"))
+      when 1
+        addon_type = type_matches.first
+        launchy("Opening #{addon_type} docs", addon_docs_url(addon_type))
+      else
+        error("Ambiguous addon name: #{addon}\nPerhaps you meant #{name_matches[0...-1].map {|match| "`#{match}`"}.join(', ')} or `#{name_matches.last}`.\n")
+      end
+    end
+
+    # addons:open ADDON
+    #
+    # open an addon's dashboard in your browser
+    #
+    def open
+      unless addon = shift_argument
+        error("Usage: heroku addons:open ADDON\nMust specify ADDON to open.")
+      end
+      validate_arguments!
+
+      app_addons = api.get_addons(app).body.map {|a| a['name']}
+      matches = app_addons.select {|a| a =~ /^#{addon}/}.sort
+
+      case matches.length
+      when 0 then
+        addon_names = api.get_addons.body.map {|a| a['name']}
+        if addon_names.any? {|name| name =~ /^#{addon}/}
+          error("Addon not installed: #{addon}")
+        else
+          error([
+            "`#{addon}` is not a heroku add-on.",
+            suggestion(addon, addon_names + addon_names.map {|name| name.split(':').first}.uniq),
+            "See `heroku addons:list` for all available addons."
+          ].compact.join("\n"))
+        end
+      when 1 then
+        addon_to_open = matches.first
+        launchy("Opening #{addon_to_open} for #{app}", app_addon_url(addon_to_open))
+      else
+        error("Ambiguous addon name: #{addon}\nPerhaps you meant #{matches[0...-1].map {|match| "`#{match}`"}.join(', ')} or `#{matches.last}`.\n")
+      end
+    end
+
+    private
+
+    def addon_docs_url(addon)
+      "https://devcenter.#{heroku.host}/articles/#{addon.split(':').first}"
+    end
+
+    def app_addon_url(addon)
+      "https://api.#{heroku.host}/myapps/#{app}/addons/#{addon}"
+    end
+
+    def partition_addons(addons)
+      addons.group_by{ |a| (a["state"] == "public" ? "available" : a["state"]) }
+    end
+
+    def format_for_display(addons)
+      grouped = addons.inject({}) do |base, addon|
+        group, short = addon['name'].split(':')
+        base[group] ||= []
+        base[group] << addon.merge('short' => short)
+        base
+      end
+      grouped.keys.sort.map do |name|
+        addons = grouped[name]
+        row = name.dup
+        if addons.any? { |a| a['short'] }
+          row << ':'
+          size = row.size
+          stop = false
+          row << addons.map { |a| a['short'] }.compact.sort.map do |short|
+            size += short.size
+            if size < 31
+              short
+            else
+              stop = true
+              nil
+            end
+          end.compact.join(', ')
+          row << '...' if stop
+        end
+        row
+      end
+    end
+
+    def addon_run
+      response = yield
+
+      if response
+        price = "(#{ response['price'] })" if response['price']
+
+        if response['message'] =~ /(Attached as [A-Z0-9_]+)\n(.*)/m
+          attachment = $1
+          message = $2
+        else
+          attachment = nil
+          message = response['message']
+        end
+
+        begin
+          release = api.get_release(app, 'current').body
+          release = release['name']
+        rescue Heroku::API::Errors::Error
+          release = nil
+        end
+      end
+
+      status [ release, price ].compact.join(' ')
+      { :attachment => attachment, :message => message }
+    rescue RestClient::ResourceNotFound => e
+      error Heroku::Command.extract_error(e.http_body) {
+        e.http_body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+      }
+    rescue RestClient::Locked => ex
+      raise
+    rescue RestClient::RequestFailed => e
+      retry if e.http_code == 402 && confirm_billing
+      error Heroku::Command.extract_error(e.http_body)
+    end
+
+    def configure_addon(label, &install_or_upgrade)
+      addon = args.shift
+      raise CommandFailed.new("Missing add-on name") if addon.nil? || ["--fork", "--follow"].include?(addon)
+
+      config = parse_options(args)
+      config.merge!(:confirm => app) if app == options[:confirm]
+      raise CommandFailed.new("Unexpected arguments: #{args.join(' ')}") unless args.empty?
+
+      hpg_translate_fork_and_follow(addon, config)
+
+      messages = nil
+      action("#{label} #{addon} on #{app}") do
+        messages = addon_run { install_or_upgrade.call(addon, config) }
+      end
+      display(messages[:attachment]) unless messages[:attachment].to_s.strip == ""
+      display(messages[:message]) unless messages[:message].to_s.strip == ""
+
+      display("Use `heroku addons:docs #{addon}` to view documentation.")
+    end
+
+    #this will clean up when we officially deprecate
+    def parse_options(args)
+      config = {}
+      deprecated_args = []
+      flag = /^--/
+
+      args.size.times do
+        break if args.empty?
+        peek = args.first
+        next unless peek && (peek.match(flag) || peek.match(/=/))
+        arg  = args.shift
+        peek = args.first
+        key  = arg
+        if key.match(/=/)
+          deprecated_args << key unless key.match(flag)
+          key, value = key.split('=', 2)
+        elsif peek.nil? || peek.match(flag)
+          value = true
+        else
+          value = args.shift
+        end
+        value = true if value == 'true'
+        config[key.sub(flag, '')] = value
+
+        if !deprecated_args.empty?
+          out_string = deprecated_args.map{|a| "--#{a}"}.join(' ')
+          display("Warning: non-unix style params have been deprecated, use #{out_string} instead")
+        end
+      end
+
+      config
+    end
+
+  end
+end

data/lib/heroku/command/apps.rb

@@ -0,0 +1,311 @@
+require "heroku/command/base"
+
+# manage apps (create, destroy)
+#
+class Heroku::Command::Apps < Heroku::Command::Base
+
+  # apps
+  #
+  # list your apps
+  #
+  #Example:
+  #
+  # $ heroku apps
+  # === My Apps
+  # myapp1
+  # myapp2
+  #
+  # === Collaborated Apps
+  # theirapp1   other@owner.name
+  #
+  def index
+    validate_arguments!
+    apps = api.get_apps.body
+    unless apps.empty?
+      my_apps, collaborated_apps = apps.partition do |app|
+        app["owner_email"] == Heroku::Auth.user
+      end
+
+      unless my_apps.empty?
+        styled_header("My Apps")
+        styled_array(my_apps.map { |app| app["name"] })
+      end
+
+      unless collaborated_apps.empty?
+        styled_header("Collaborated Apps")
+        styled_array(collaborated_apps.map { |app| [app["name"], app["owner_email"]] })
+      end
+    else
+      display("You have no apps.")
+    end
+  end
+
+  alias_command "list", "apps"
+
+  # apps:info
+  #
+  # show detailed app information
+  #
+  # -s, --shell  # output more shell friendly key/value pairs
+  #
+  #Examples:
+  #
+  # $ heroku apps:info
+  # === myapp
+  # Git URL:   git@heroku.com:myapp.git
+  # Repo Size: 5M
+  # ...
+  #
+  # $ heroku apps:info --shell
+  # git_url=git@heroku.com:myapp.git
+  # repo_size=5000000
+  # ...
+  #
+  def info
+    validate_arguments!
+    app_data = api.get_app(app).body
+
+    unless options[:shell]
+      styled_header(app_data["name"])
+    end
+
+    addons_data = api.get_addons(app).body.map {|addon| addon['name']}.sort
+    collaborators_data = api.get_collaborators(app).body.map {|collaborator| collaborator["email"]}.sort
+    collaborators_data.reject! {|email| email == app_data["owner_email"]}
+
+    if options[:shell]
+      if app_data['domain_name']
+        app_data['domain_name'] = app_data['domain_name']['domain']
+      end
+      unless addons_data.empty?
+        app_data['addons'] = addons_data.join(',')
+      end
+      unless collaborators_data.empty?
+        app_data['collaborators'] = collaborators_data.join(',')
+      end
+      app_data.keys.sort_by { |a| a.to_s }.each do |key|
+        hputs("#{key}=#{app_data[key]}")
+      end
+    else
+      data = {}
+
+      unless addons_data.empty?
+        data["Addons"] = addons_data
+      end
+
+      data["Collaborators"] = collaborators_data
+
+      if app_data["create_status"] && app_data["create_status"] != "complete"
+        data["Create Status"] = app_data["create_status"]
+      end
+
+      if app_data["cron_finished_at"]
+        data["Cron Finished At"] = format_date(app_data["cron_finished_at"])
+      end
+
+      if app_data["cron_next_run"]
+        data["Cron Next Run"] = format_date(app_data["cron_next_run"])
+      end
+
+      if app_data["database_size"]
+        data["Database Size"] = format_bytes(app_data["database_size"])
+      end
+
+      data["Git URL"] = app_data["git_url"]
+
+      if app_data["database_tables"]
+        data["Database Size"].gsub!('(empty)', '0K') + " in #{quantify("table", app_data["database_tables"])}"
+      end
+
+      if app_data["dyno_hours"].is_a?(Hash)
+        data["Dyno Hours"] = app_data["dyno_hours"].keys.map do |type|
+          "%s - %0.2f dyno-hours" % [ type.to_s.capitalize, app_data["dyno_hours"][type] ]
+        end
+      end
+
+      data["Owner Email"] = app_data["owner_email"]
+
+      if app_data["repo_size"]
+        data["Repo Size"] = format_bytes(app_data["repo_size"])
+      end
+
+      if app_data["slug_size"]
+        data["Slug Size"] = format_bytes(app_data["slug_size"])
+      end
+
+      data["Stack"] = app_data["stack"]
+      if data["Stack"] != "cedar"
+        data.merge!("Dynos" => app_data["dynos"], "Workers" => app_data["workers"])
+      end
+
+      data["Web URL"] = app_data["web_url"]
+
+      styled_hash(data)
+    end
+  end
+
+  alias_command "info", "apps:info"
+
+  # apps:create [NAME]
+  #
+  # create a new app
+  #
+  #     --addons ADDONS        # a comma-delimited list of addons to install
+  # -b, --buildpack BUILDPACK  # a buildpack url to use for this app
+  # -n, --no-remote            # don't create a git remote
+  # -r, --remote REMOTE        # the git remote to create, default "heroku"
+  # -s, --stack STACK          # the stack on which to create the app
+  #
+  #Examples:
+  #
+  # $ heroku apps:create
+  # Creating floating-dragon-42... done, stack is cedar
+  # http://floating-dragon-42.heroku.com/ | git@heroku.com:floating-dragon-42.git
+  #
+  # $ heroku apps:create -s bamboo
+  # Creating floating-dragon-42... done, stack is bamboo-mri-1.9.2
+  # http://floating-dragon-42.herokuapp.com/ | git@heroku.com:floating-dragon-42.git
+  #
+  # # specify a name
+  # $ heroku apps:create myapp
+  # Creating myapp... done, stack is cedar
+  # http://myapp.heroku.com/ | git@heroku.com:myapp.git
+  #
+  # # create a staging app
+  # $ heroku apps:create myapp-staging --remote staging
+  #
+  def create
+    name    = shift_argument || options[:app]
+    validate_arguments!
+
+    info    = api.post_app({ "name" => name, "stack" => options[:stack] }).body
+    begin
+      action("Creating #{info['name']}") do
+        if info['create_status'] == 'creating'
+          Timeout::timeout(options[:timeout].to_i) do
+            loop do
+              break if api.get_app(info['name']).body['create_status'] == 'complete'
+              sleep 1
+            end
+          end
+        end
+        status("stack is #{info['stack']}")
+      end
+
+      (options[:addons] || "").split(",").each do |addon|
+        addon.strip!
+        action("Adding #{addon} to #{info["name"]}") do
+          api.post_addon(info["name"], addon)
+        end
+      end
+
+      if buildpack = options[:buildpack]
+        api.put_config_vars(info["name"], "BUILDPACK_URL" => buildpack)
+        display("BUILDPACK_URL=#{buildpack}")
+      end
+
+      hputs([ info["web_url"], info["git_url"] ].join(" | "))
+    rescue Timeout::Error
+      hputs("Timed Out! Check heroku status for known issues.")
+    end
+
+    unless options[:no_remote].is_a? FalseClass
+      create_git_remote(options[:remote] || "heroku", info["git_url"])
+    end
+  end
+
+  alias_command "create", "apps:create"
+
+  # apps:rename NEWNAME
+  #
+  # rename the app
+  #
+  #Example:
+  #
+  # $ heroku apps:rename myapp-newname
+  # http://myapp-newname.herokuapp.com/ | git@heroku.com:myapp-newname.git
+  # Git remote heroku updated
+  #
+  def rename
+    newname = shift_argument
+    if newname.nil? || newname.empty?
+      error("Usage: heroku apps:rename NEWNAME\nMust specify NEWNAME to rename.")
+    end
+    validate_arguments!
+
+    action("Renaming #{app} to #{newname}") do
+      api.put_app(app, "name" => newname)
+    end
+
+    app_data = api.get_app(newname).body
+    hputs([ app_data["web_url"], app_data["git_url"] ].join(" | "))
+
+    if remotes = git_remotes(Dir.pwd)
+      remotes.each do |remote_name, remote_app|
+        next if remote_app != app
+        git "remote rm #{remote_name}"
+        git "remote add #{remote_name} #{app_data["git_url"]}"
+        hputs("Git remote #{remote_name} updated")
+      end
+    else
+      hputs("Don't forget to update your Git remotes on any local checkouts.")
+    end
+  end
+
+  alias_command "rename", "apps:rename"
+
+  # apps:open
+  #
+  # open the app in a web browser
+  #
+  #Example:
+  #
+  # $ heroku apps:open
+  # Opening myapp... done
+  #
+  def open
+    validate_arguments!
+
+    app_data = api.get_app(app).body
+    launchy("Opening #{app}", app_data['web_url'])
+  end
+
+  alias_command "open", "apps:open"
+
+  # apps:destroy
+  #
+  # permanently destroy an app
+  #
+  #Example:
+  #
+  # $ heroku apps:destroy -a myapp --confirm myapp
+  # Destroying myapp (including all add-ons)... done
+  #
+  def destroy
+    @app = shift_argument || options[:app] || options[:confirm]
+    validate_arguments!
+
+    unless @app
+      error("Usage: heroku apps:destroy --app APP\nMust specify APP to destroy.")
+    end
+
+    api.get_app(@app) # fail fast if no access or doesn't exist
+
+    message = "WARNING: Potentially Destructive Action\nThis command will destroy #{@app} (including all add-ons)."
+    if confirm_command(@app, message)
+      action("Destroying #{@app} (including all add-ons)") do
+        api.delete_app(@app)
+        if remotes = git_remotes(Dir.pwd)
+          remotes.each do |remote_name, remote_app|
+            next if @app != remote_app
+            git "remote rm #{remote_name}"
+          end
+        end
+      end
+    end
+  end
+
+  alias_command "destroy", "apps:destroy"
+  alias_command "apps:delete", "apps:destroy"
+
+end