pebblescape 0.0.1

data/lib/pebbles/command/apps.rb

@@ -0,0 +1,225 @@
+require "pebbles/command/base"
+
+# manage apps (create, destroy)
+#
+class Pebbles::Command::Apps < Pebbles::Command::Base
+
+  # apps
+  #
+  # list your apps
+  #
+  #Example:
+  #
+  # $ pebbles apps
+  # === My Apps
+  # example
+  # example2
+  #
+  def index
+    validate_arguments!
+
+    apps = api.get_apps.body
+
+    unless apps.empty?
+      styled_header("My Apps")
+      styled_array(apps.map { |app| app_name(app) })
+    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:
+  #
+  # $ pebbles apps:info
+  # === example
+  # Git URL:   https://git.pebblescape.com/example.git
+  # Repo Size: 5M
+  # ...
+  #
+  # $ pebbles apps:info --shell
+  # git_url=https://git.pebblescape.com/example.git
+  # repo_size=5000000
+  # ...
+  #
+  def info
+    validate_arguments!
+    app_data = api.get_app(app).body
+
+    unless options[:shell]
+      styled_header(app_data["name"])
+    end
+    
+    if options[:shell]
+      app_data['git_url'] = git_url(app_data['name'])
+      if app_data['domain_name']
+        app_data['domain_name'] = app_data['domain_name']['domain']
+      end
+      app_data['owner'].delete('id')
+      flatten_hash(app_data, 'owner')
+      app_data.keys.sort_by { |a| a.to_s }.each do |key|
+        hputs("#{key}=#{app_data[key]}")
+      end
+    else
+      data = {}
+      
+      if app_data["create_status"] && app_data["create_status"] != "complete"
+        data["Create Status"] = app_data["create_status"]
+      end
+
+      data["Git URL"] = git_url(app_data['name'])
+
+      
+      if app_data["owner"]
+        data["Owner Email"] = app_data["owner"]["email"]
+        data["Owner"] = app_data["owner"]["name"]
+      end
+      data["Repo Size"] = format_bytes(app_data["repo_size"]) if app_data["repo_size"]
+      data["Build Size"] = format_bytes(app_data["build_size"]) if app_data["build_size"]
+      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 "pebbles"
+  #     --ssh-git              # Use SSH git protocol
+  #     --http-git             # HIDDEN: Use HTTP git protocol
+  #
+  #Examples:
+  #
+  # $ pebbles apps:create
+  # Creating floating-dragon-42... done, stack is cedar
+  # http://floating-dragon-42.pebblesinspace.com/ | https://git.pebblesinspace.com/floating-dragon-42.git
+  #
+  # # specify a name
+  # $ pebbles apps:create example
+  # Creating example... done, stack is cedar
+  # http://example.pebblesinspace.com/ | https://git.pebblesinspace.com/example.git
+  #
+  # # create a staging app
+  # $ pebbles apps:create example-staging --remote staging
+  #
+  def create
+    name    = shift_argument || options[:app] || ENV['PEBBLES_APP']
+    validate_arguments!
+
+    params = {
+      "name" => name,
+    }
+
+    info = api.post_app(params).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
+      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"], git_url(info['name']) ].join(" | "))
+    rescue Timeout::Error
+      hputs("Timed Out! Run `pebbles status` to check for known platform issues.")
+    end
+
+    unless options[:no_remote].is_a? FalseClass
+      create_git_remote(options[:remote] || "pebbles", git_url(info['name']))
+    end
+  end
+
+  alias_command "create", "apps:create"
+
+  # apps:destroy --app APP
+  #
+  # permanently destroy an app
+  #
+  #Example:
+  #
+  # $ pebbles apps:destroy -a example --confirm example
+  # Destroying example (including all add-ons)... done
+  #
+  def destroy
+    @app = shift_argument || options[:app] || options[:confirm]
+    validate_arguments!
+
+    unless @app
+      error("Usage: pebbles 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"
+  
+  # apps:open --app APP
+  #
+  # open the app in a web browser
+  #
+  #Example:
+  #
+  # $ heroku apps:open
+  # Opening example... done
+  #
+  def open
+    path = shift_argument
+    validate_arguments!
+
+    app_data = api.get_app(app).body
+
+    url = [app_data['web_url'], path].join
+    launchy("Opening #{app}", url)
+  end
+
+  private
+
+  def app_name(app)
+    app["name"]
+  end
+end

data/lib/pebbles/command/auth.rb

@@ -0,0 +1,85 @@
+require "pebbles/command/base"
+
+# authentication (login, logout)
+#
+class Pebbles::Command::Auth < Pebbles::Command::Base
+
+  # auth
+  #
+  # Authenticate, display token and current user
+  def index
+    validate_arguments!
+
+    Pebbles::Command::Help.new.send(:help_for_command, current_command)
+  end
+
+  # auth:login
+  #
+  # log in with your Pebblescape credentials
+  #
+  #Example:
+  #
+  # $ pebbles auth:login
+  # Enter your Pebblescape credentials:
+  # Email: email@example.com
+  # Password (typing will be hidden):
+  # Authentication successful.
+  #
+  def login
+    validate_arguments!
+
+    Pebbles::Auth.login
+    display "Authentication successful."
+  end
+
+  alias_command "login", "auth:login"
+
+  # auth:logout
+  #
+  # clear local authentication credentials
+  #
+  #Example:
+  #
+  # $ pebbles auth:logout
+  # Local credentials cleared.
+  #
+  def logout
+    validate_arguments!
+
+    Pebbles::Auth.logout
+    display "Local credentials cleared."
+  end
+
+  alias_command "logout", "auth:logout"
+
+  # auth:token
+  #
+  # display your api token
+  #
+  #Example:
+  #
+  # $ pebbles auth:token
+  # ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCD
+  #
+  def token
+    validate_arguments!
+
+    display Pebbles::Auth.api_key
+  end
+
+  # auth:whoami
+  #
+  # display your Pebblescape email address
+  #
+  #Example:
+  #
+  # $ pebbles auth:whoami
+  # email@example.com
+  #
+  def whoami
+    validate_arguments!
+
+    display Pebbles::Auth.user
+  end
+
+end

data/lib/pebbles/command/base.rb

@@ -0,0 +1,231 @@
+require "fileutils"
+require "pebbles/auth"
+require "pebbles/command"
+
+class Pebbles::Command::Base
+  include Pebbles::Helpers
+  
+  def self.namespace
+    self.to_s.split("::").last.downcase
+  end
+
+  attr_reader :args
+  attr_reader :options
+
+  def initialize(args=[], options={})
+    @args = args
+    @options = options
+  end
+
+  def app
+    @app ||= Pebbles.app_name = if options[:confirm].is_a?(String)
+      if options[:app] && (options[:app] != options[:confirm])
+        error("Mismatch between --app and --confirm")
+      end
+      options[:confirm]
+    elsif options[:app].is_a?(String)
+      options[:app]
+    elsif ENV.has_key?('PEBBLES_APP')
+      ENV['PEBBLES_APP']
+    elsif app_from_dir = extract_app_in_dir(Dir.pwd)
+      app_from_dir
+    else
+      # raise instead of using error command to enable rescuing when app is optional
+      raise Pebbles::Command::CommandFailed.new("No app specified.\nRun this command from an app folder or specify which app to use with --app APP.") unless options[:ignore_no_app]
+    end
+  end
+  
+  def api
+    Pebbles::Auth.api
+  end
+
+protected
+
+  def self.inherited(klass)
+    unless klass == Pebbles::Command::Base
+      help = extract_help_from_caller(caller.first)
+
+      Pebbles::Command.register_namespace(
+        :name => klass.namespace,
+        :description => help.first
+      )
+    end
+  end
+
+  def self.method_added(method)
+    return if self == Pebbles::Command::Base
+    return if private_method_defined?(method)
+    return if protected_method_defined?(method)
+
+    help = extract_help_from_caller(caller.first)
+    resolved_method = (method.to_s == "index") ? nil : method.to_s
+    command = [ self.namespace, resolved_method ].compact.join(":")
+    banner = extract_banner(help) || command
+
+    Pebbles::Command.register_command(
+      :klass       => self,
+      :method      => method,
+      :namespace   => self.namespace,
+      :command     => command,
+      :banner      => banner.strip,
+      :help        => help.join("\n"),
+      :summary     => extract_summary(help),
+      :description => extract_description(help),
+      :options     => extract_options(help)
+    )
+
+    alias_command command.gsub(/_/, '-'), command if command =~ /_/
+  end
+
+  def self.alias_command(new, old)
+    raise "no such command: #{old}" unless Pebbles::Command.commands[old]
+    Pebbles::Command.command_aliases[new] = old
+  end
+
+  #
+  # Parse the caller format and identify the file and line number as identified
+  # in : http://www.ruby-doc.org/core/classes/Kernel.html#M001397.  This will
+  # look for a colon followed by a digit as the delimiter.  The biggest
+  # complication is windows paths, which have a colon after the drive letter.
+  # This regex will match paths as anything from the beginning to a colon
+  # directly followed by a number (the line number).
+  #
+  # Examples of the caller format :
+  # * c:/Ruby192/lib/.../lib/heroku/command/addons.rb:8:in `<module:Command>'
+  # * c:/Ruby192/lib/.../heroku-2.0.1/lib/heroku/command/pg.rb:96:in `<class:Pg>'
+  # * /Users/ph7/...../xray-1.1/lib/xray/thread_dump_signal_handler.rb:9
+  #
+  def self.extract_help_from_caller(line)
+    # pull out of the caller the information for the file path and line number
+    if line =~ /^(.+?):(\d+)/
+      extract_help($1, $2)
+    else
+      raise("unable to extract help from caller: #{line}")
+    end
+  end
+
+  def self.extract_help(file, line_number)
+    buffer = []
+    lines = Pebbles::Command.files[file]
+
+    (line_number.to_i-2).downto(0) do |i|
+      line = lines[i]
+      case line[0..0]
+        when ""
+        when "#"
+          buffer.unshift(line[1..-1])
+        else
+          break
+      end
+    end
+
+    buffer
+  end
+
+  def self.extract_banner(help)
+    help.first
+  end
+
+  def self.extract_summary(help)
+    extract_description(help).split("\n")[2].to_s.split("\n").first
+  end
+
+  def self.extract_description(help)
+    help.reject do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.join("\n")
+  end
+
+  def self.extract_options(help)
+    help.select do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.inject([]) do |options, line|
+      args = line.split('#', 2).first
+      args = args.split(/,\s*/).map {|arg| arg.strip}.sort.reverse
+      name = args.last.split(' ', 2).first[2..-1]
+      options << { :name => name, :args => args }
+    end
+  end
+
+  def current_command
+    Pebbles::Command.current_command
+  end
+
+  def extract_option(key)
+    options[key.dup.gsub('-','_').to_sym]
+  end
+
+  def invalid_arguments
+    Pebbles::Command.invalid_arguments
+  end
+
+  def shift_argument
+    Pebbles::Command.shift_argument
+  end
+
+  def validate_arguments!
+    Pebbles::Command.validate_arguments!
+  end
+
+  def extract_app_in_dir(dir)
+    return unless remotes = git_remotes(dir)
+
+    if remote = options[:remote]
+      remotes[remote]
+    elsif remote = extract_remote_from_git_config
+      remotes[remote]
+    else
+      apps = remotes.values.uniq
+      if apps.size == 1
+        apps.first
+      else
+        raise(Pebbles::Command::CommandFailed, "Multiple apps in folder and no app specified.\nSpecify app with --app APP.") unless options[:ignore_no_app]
+      end
+    end
+  end
+
+  def extract_remote_from_git_config
+    remote = git("config pebbles.remote")
+    remote == "" ? nil : remote
+  end
+
+  def git_url(app_name)
+    if options[:ssh_git]
+      "git@#{Pebbles::Auth.git_host}:#{app_name}.git"
+    else
+      unless has_http_git_entry_in_netrc
+        warn "WARNING: Incomplete credentials detected, git may not work with Pebblescape. Run `pebbles login` to update your credentials."
+        exit 1
+      end
+      "https://#{Pebbles::Auth.http_git_host}/#{app_name}.git"
+    end
+  end
+
+  def git_remotes(base_dir=Dir.pwd)
+    remotes = {}
+    original_dir = Dir.pwd
+    Dir.chdir(base_dir)
+    
+    return unless File.exists?(".git")
+    git("remote -v").split("\n").each do |remote|
+      name, url, _ = remote.split(/\s/)
+      if url =~ /^git@#{Pebbles::Auth.git_host}(?:[\.\w]*):([\w\d-]+)\.git$/ ||
+         url =~ /^https:\/\/#{Pebbles::Auth.http_git_host}\/([\w\d-]+)\.git$/
+        remotes[name] = $1
+      end
+    end
+
+    Dir.chdir(original_dir)
+    if remotes.empty?
+      nil
+    else
+      remotes
+    end
+  end
+end
+
+module Pebbles::Command
+  unless const_defined?(:BaseWithApp)
+    BaseWithApp = Base
+  end
+end