nimbu 0.4 → 0.5.1

data/lib/nimbu.rb

@@ -1,28 +1,12 @@
 require "nimbu/version"
-require "nimbu/client"
+require "nimbu-api"
 
 module Nimbu
   def self.debug=(value)
-    @@debug = value
+    @debug = value
   end
 
   def self.debug
-    @@debug
-  end
-
-  def self.development=(value)
-    @@development = value
-  end
-
-  def self.development
-    @@development
-  end
-
-  def self.v2=(value)
-    @@v2 = value
-  end
-
-  def self.v2
-    @@v2
+    @debug || false
   end
 end

data/lib/nimbu/auth.rb

@@ -1,6 +1,5 @@
 require "yaml"
 require "nimbu"
-require "nimbu/client"
 require "nimbu/helpers"
 
 class Nimbu::Auth
@@ -12,9 +11,7 @@ class Nimbu::Auth
 
     def client
       @client ||= begin
-        client = Nimbu::Client.new(user, password, host)
-        client.on_warning { |msg| self.display("\n#{msg}\n\n") }
-        client
+        Nimbu::Client.new(:oauth_token => token, :endpoint => host)
       end
     end
 
@@ -29,34 +26,38 @@ class Nimbu::Auth
 
     # just a stub; will raise if not authenticated
     def check
-      client.list
+      client.sites.list
+    end
+
+    def host
+      ENV['NIMBU_HOST'] || "https://api.nimbu.io"
     end
 
     def default_host
-      "getnimbu.com"
+      "https://api.nimbu.io"
     end
 
-    def host
-      @host ||= ENV['NIMBU_HOST'] || get_nimbu_host
+    def admin_host
+      @admin_host ||= host.gsub(/https?\:\/\/api\./,'')
+    end
+
+    def site
+      @site ||= ENV['NIMBU_SITE'] || get_nimbu_site
     end
 
     def theme
       @theme ||= ENV['NIMBU_THEME'] || get_nimbu_theme
     end
 
-    def get_nimbu_host
-      if Nimbu.development
-        get_configuration[:development]
-      else
-        get_configuration[:hostname]
-      end
+    def get_nimbu_site
+      get_configuration["site"]
     end
 
     def get_nimbu_theme
-      get_configuration[:theme] || "default-theme"
+      get_configuration["theme"] || "default-theme"
     end
 
-    def get_configuration    # :nodoc:
+    def get_configuration
       @configuration ||= (read_configuration || ask_for_and_save_configuration)
     end
 
@@ -75,20 +76,75 @@ class Nimbu::Auth
       @host = nil
     end
 
-   def ask_for_configuration
-      puts "What is the hostname for this Nimbu site?"
-      print "Hostname: "
-      hostname = ask
+    def ask_for_configuration
 
-      puts "What is the theme you are developing in this directory?"
-      print "Theme (i.e. default): "
-      theme = ask
+      subdomain = nil
+      sites = client.sites.list
 
-      {:hostname => hostname, :theme => theme}
+      unless sites.respond_to?(:any?) && sites.any?
+        display "You don't have access to any Nimbu sites you can edit yet..."
+        display ""
+        display "Please visit http://nimbu.io, start your 30-day trial and discover our amazing platform!"
+        exit(1)
+      else
+        print_separator
+        display "\nLet's first setup the configuration for this directory..."
+        display "\nYou have access to following sites:\n"
+        sites.each_with_index do |site,i|
+          display " #{i+1}) #{site.name.white.bold} => http://#{site.domain}"
+        end
+        site_number = 0
+        retry_site = false
+        while site_number < 1 || site_number > sites.length
+          unless retry_site
+            print "\nOn which site would you like to work? "
+          else
+            print "\nPlease enter the number of your site (between 1-#{sites.length}): "
+          end
+          site_number_string = ask
+          site_number = site_number_string.to_i rescue 0
+          retry_site = true
+        end
+        puts ""
+        site = sites[site_number-1]
+        display "Site chosen => #{site.name.white.bold} (http://#{site.domain})"
+        subdomain = site.subdomain
+        @site = subdomain
+      end
+
+      themes = client.themes(:subdomain => subdomain).list
+      current_theme = if themes.length > 1
+        theme_number = 0
+        retry_theme = false
+        while theme_number < 1 || theme_number > themes.length
+          unless retry_theme
+            print "\nOn which theme would you like to work in this directory? "
+          else
+            print "\nPlease enter the number of your theme (between 1-#{themes.length}): "
+          end
+          theme_number_string = ask
+          theme_number = theme_number_string.to_i rescue 0
+          retry_theme = true
+        end
+        puts ""
+        display "Theme chosen => #{themes[theme_number-1].name}"
+        themes[theme_number-1]
+      else
+        themes.first
+      end
+      @theme = current_theme.short
+      print_separator
+
+      { "site" => subdomain, "theme" => current_theme.short }
     end
 
     def read_configuration
-      File.exists?(configuration_file) and YAML::load(File.open( configuration_file ))
+      existing_config = YAML::load(File.open( configuration_file )) if File.exists?(configuration_file)
+      if existing_config && ! existing_config["site"].nil?
+        existing_config
+      else
+        nil
+      end
     end
 
     def write_configuration
@@ -102,23 +158,15 @@ class Nimbu::Auth
       @credentials = ask_for_and_save_credentials
     end
 
-    def user    # :nodoc:
-      get_credentials[0]
-    end
-
-    def password    # :nodoc:
-      get_credentials[1]
-    end
-
-    def api_key
-      Nimbu::Client.auth(user, password)["api_key"]
+    def token    # :nodoc:
+      get_credentials
     end
 
     def credentials_file
       if host == default_host
         "#{home_directory}/.nimbu/credentials"
       else
-        "#{home_directory}/.nimbu/credentials.#{CGI.escape(host)}"
+        "#{home_directory}/.nimbu/credentials.#{CGI.escape(host.gsub(/https?\:\/\//,''))}"
       end
     end
 
@@ -132,16 +180,17 @@ class Nimbu::Auth
     end
 
     def read_credentials
-      if ENV['NIMBU_API_KEY']
-        ['', ENV['NIMBU_API_KEY']]
+      credentials = File.read(credentials_file) if File.exists?(credentials_file)
+      if credentials && credentials =~ /^(bearer|oauth2|token) ([\w]+)$/i
+        $2
       else
-        File.exists?(credentials_file) and File.read(credentials_file).split("\n")
+        nil
       end
     end
 
     def write_credentials
       FileUtils.mkdir_p(File.dirname(credentials_file))
-      File.open(credentials_file, 'w') {|credentials| credentials.puts(self.credentials)}
+      File.open(credentials_file, 'w') {|credentials| credentials.print("token #{self.credentials}")}
       FileUtils.chmod(0700, File.dirname(credentials_file))
       FileUtils.chmod(0600, credentials_file)
     end
@@ -159,16 +208,21 @@ class Nimbu::Auth
     end
 
     def ask_for_credentials
-      puts "Enter your Nimbu credentials."
-
-      print "Email: "
+      print "Login: "
       user = ask
 
       print "Password: "
       password = running_on_windows? ? ask_for_password_on_windows : ask_for_password
-      api_key = Nimbu::Client.auth(user, password)['api_key']
 
-      [user, api_key]
+      begin
+        oauth = Nimbu::Client.new(:basic_auth => "#{user}:#{password}", :endpoint => host).authenticate
+        oauth.token
+      rescue Exception => e
+        if e.respond_to?(:http_status_code) && e.http_status_code == 401
+          display " => could not login... please check your username and/or password!\n\n"
+        end
+        nil
+      end
     end
 
     def ask_for_password_on_windows
@@ -202,15 +256,11 @@ class Nimbu::Auth
     end
 
     def ask_for_and_save_credentials
+      display "Please authenticate with Nimbu.io:"
       begin
         @credentials = ask_for_credentials
         write_credentials
         check
-      rescue ::RestClient::Unauthorized, ::RestClient::ResourceNotFound => e
-        delete_credentials
-        display "Authentication failed."
-        retry if retry_login?
-        exit 1
       rescue Exception => e
         delete_credentials
         raise e
@@ -218,55 +268,16 @@ class Nimbu::Auth
       @credentials
     end
 
-    def check_for_associated_ssh_key
-      return unless client.keys.empty?
-      associate_or_generate_ssh_key
-    end
-
-    def associate_or_generate_ssh_key
-      public_keys = Dir.glob("#{home_directory}/.ssh/*.pub").sort
-
-      case public_keys.length
-      when 0 then
-        display "Could not find an existing public key."
-        display "Would you like to generate one? [Yn] ", false
-        unless ask.strip.downcase == "n"
-          display "Generating new SSH public key."
-          generate_ssh_key("id_rsa")
-          associate_key("#{home_directory}/.ssh/id_rsa.pub")
-        end
-      when 1 then
-        display "Found existing public key: #{public_keys.first}"
-        associate_key(public_keys.first)
-      else
-        display "Found the following SSH public keys:"
-        public_keys.each_with_index do |key, index|
-          display "#{index+1}) #{File.basename(key)}"
-        end
-        display "Which would you like to use with your Nimbu account? ", false
-        chosen = public_keys[ask.to_i-1] rescue error("Invalid choice")
-        associate_key(chosen)
-      end
-    end
-
-    def generate_ssh_key(keyfile)
-      ssh_dir = File.join(home_directory, ".ssh")
-      unless File.exists?(ssh_dir)
-        FileUtils.mkdir_p ssh_dir
-        File.chmod(0700, ssh_dir)
-      end
-      `ssh-keygen -t rsa -N "" -f \"#{home_directory}/.ssh/#{keyfile}\" 2>&1`
-    end
-
-    def associate_key(key)
-      display "Uploading SSH public key #{key}"
-      client.add_key(File.read(key))
-    end
-
     def retry_login?
       @login_attempts ||= 0
       @login_attempts += 1
       @login_attempts < 3
     end
+
+    def print_separator
+      print "\n"
+      60.times { print "#"}
+      print "\n"
+    end
   end
 end

data/lib/nimbu/cli.rb

@@ -1,12 +1,29 @@
 require "nimbu"
 require "nimbu/command"
+require "nimbu/helpers"
 
 class Nimbu::CLI
 
+  extend Nimbu::Helpers
+
   def self.start(*args)
-    command = args.shift.strip rescue "help"
-    Nimbu::Command.load
-    Nimbu::Command.run(command, args)
+    begin
+      if $stdin.isatty
+        $stdin.sync = true
+      end
+      if $stdout.isatty
+        $stdout.sync = true
+      end
+      command = args.shift.strip rescue "help"
+      Nimbu::Command.load
+      Nimbu::Command.run(command, args)
+    rescue Interrupt
+      `stty icanon echo`
+      error("Command cancelled.")
+    rescue => error
+      styled_error(error)
+      exit(1)
+    end
   end
 
 end

data/lib/nimbu/command.rb

@@ -1,7 +1,12 @@
 require 'nimbu/helpers'
 require 'nimbu/version'
+require 'term/ansicolor'
 require "optparse"
 
+class String
+  include Term::ANSIColor
+end
+
 module Nimbu
   module Command
     class CommandFailed  < RuntimeError; end
@@ -22,6 +27,10 @@ module Nimbu
       @@command_aliases ||= {}
     end
 
+    def self.files
+      @@files ||= Hash.new {|hash,key| hash[key] = File.readlines(key).map {|line| line.strip}}
+    end
+
     def self.namespaces
       @@namespaces ||= {}
     end
@@ -38,72 +47,70 @@ module Nimbu
       @current_command
     end
 
+    def self.current_command=(new_current_command)
+      @current_command = new_current_command
+    end
+
     def self.current_args
       @current_args
     end
 
     def self.current_options
-      @current_options
+      @current_options ||= {}
     end
 
     def self.global_options
       @global_options ||= []
     end
 
-    def self.global_option(name, *args)
-      global_options << { :name => name, :args => args }
+    def self.global_option(name, *args, &blk)
+      global_options << { :name => name.to_s, :args => args.sort.reverse, :proc => blk }
+    end
+
+    def self.warnings
+      @warnings ||= []
+    end
+
+    def self.display_warnings
+      unless warnings.empty?
+        $stderr.puts(warnings.map {|warning| " !    #{warning}"}.join("\n"))
+      end
     end
 
-    global_option :app,     "--app APP", "-a"
-    global_option :confirm, "--confirm APP"
     global_option :help,    "--help", "-h"
-    global_option :remote,  "--remote REMOTE"
+    global_option :debug,  "--debug"
 
     def self.prepare_run(cmd, args=[])
       command = parse(cmd)
 
-      unless command
-        if %w( -v --version ).include?(cmd)
-          display Nimbu::VERSION
-          exit
-        end
-
-        output_with_bang("`#{cmd}` is not a nimbu command.")
-
-        distances = {}
-        (commands.keys + command_aliases.keys).each do |suggestion|
-          distance = string_distance(cmd, suggestion)
-          distances[distance] ||= []
-          distances[distance] << suggestion
-        end
-
-        if distances.keys.min < 4
-          suggestions = distances[distances.keys.min].sort
-          if suggestions.length == 1
-            output_with_bang("Perhaps you meant `#{suggestions.first}`.")
-          else
-            output_with_bang("Perhaps you meant #{suggestions[0...-1].map {|suggestion| "`#{suggestion}`"}.join(', ')} or `#{suggestions.last}`.")
-          end
-        end
+      if args.include?('-h') || args.include?('--help')
+        args.unshift(cmd) unless cmd =~ /^-.*/
+        cmd = 'help'
+        command = parse(cmd)
+      end
 
-        output_with_bang("See `nimbu help` for additional details.")
-        exit(1)
+      if cmd == '--version'
+        cmd = 'version'
+        command = parse(cmd)
       end
 
       @current_command = cmd
+      @anonymized_args, @normalized_args = [], []
 
       opts = {}
       invalid_options = []
 
       parser = OptionParser.new do |parser|
-        global_options.each do |global_option|
-          parser.on(*global_option[:args]) do |value|
-            opts[global_option[:name]] = value
-          end
-        end
-        command[:options].each do |name, option|
-          parser.on("-#{option[:short]}", "--#{option[:long]}", option[:desc]) do |value|
-            opts[name.gsub("-", "_").to_sym] = value
+        parser.base.long.delete('version')
+        (global_options + (command && command[:options] || [])).each do |option|
+          parser.on(*option[:args]) do |value|
+            if option[:proc]
+              option[:proc].call(value)
+            end
+            opts[option[:name].gsub('-', '_').to_sym] = value
+            ARGV.join(' ') =~ /(#{option[:args].map {|arg| arg.split(' ', 2).first}.join('|')})/
+            @anonymized_args << "#{$1} _"
+            @normalized_args << "#{option[:args].last.split(' ', 2).first} _"
           end
         end
       end
@@ -111,53 +118,116 @@ module Nimbu
       begin
         parser.order!(args) do |nonopt|
           invalid_options << nonopt
+          @anonymized_args << '!'
+          @normalized_args << '!'
         end
       rescue OptionParser::InvalidOption => ex
         invalid_options << ex.args.first
+        @anonymized_args << '!'
+        @normalized_args << '!'
         retry
       end
 
-      raise OptionParser::ParseError if opts[:help]
-
       args.concat(invalid_options)
 
       @current_args = args
       @current_options = opts
+      @invalid_arguments = invalid_options
+
+      if opts[:debug]
+        Nimbu.debug = true
+      end
+
+      @anonymous_command = [ARGV.first, *@anonymized_args].join(' ')
+      begin
+        usage_directory = "#{home_directory}/.nimbu/usage"
+        FileUtils.mkdir_p(usage_directory)
+        usage_file = usage_directory << "/#{Nimbu::VERSION}"
+        usage = if File.exists?(usage_file)
+          json_decode(File.read(usage_file))
+        else
+          {}
+        end
+        usage[@anonymous_command] ||= 0
+        usage[@anonymous_command] += 1
+        File.write(usage_file, json_encode(usage) + "\n")
+      rescue
+        # usage writing is not important, allow failures
+      end
+
+      if command
+        command_instance = command[:klass].new(args.dup, opts.dup)
 
-      [ command[:klass].new(args.dup, opts.dup), command[:method] ]
+        if !@normalized_args.include?('--app _') && (implied_app = command_instance.app rescue nil)
+          @normalized_args << '--app _'
+        end
+        @normalized_command = [ARGV.first, @normalized_args.sort_by {|arg| arg.gsub('-', '')}].join(' ')
+
+        [ command_instance, command[:method] ]
+      else
+        error([
+          "`#{cmd}` is not a Nimbu command.",
+          suggestion(cmd, commands.keys + command_aliases.keys),
+          "See `Nimbu help` for a list of available commands."
+        ].compact.join("\n"))
+      end
     end
 
     def self.run(cmd, arguments=[])
-      object, method = prepare_run(cmd, arguments.dup)
-      object.send(method)
-    rescue RestClient::Unauthorized
-      puts "Authentication failure"
-      unless ENV['HEROKU_API_KEY'] 
-        run "login"
-        retry
-      end
-    rescue RestClient::PaymentRequired => e
-      retry if run('account:confirm_billing', arguments.dup)
-    rescue RestClient::ResourceNotFound => e
-      error extract_error(e.http_body) {
-        e.http_body =~ /^[\w\s]+ not found$/ ? e.http_body : "Resource not found"
-      }
-    rescue RestClient::Locked => e
-      app = e.response.headers[:x_confirmation_required]
-      if confirm_command(app, extract_error(e.response.body))
-        arguments << '--confirm' << app
-        retry
+      begin
+        object, method = prepare_run(cmd, arguments.dup)
+        object.send(method)
+      rescue Interrupt, StandardError, SystemExit => error
+        # load likely error classes, as they may not be loaded yet due to defered loads
+        require 'rest_client'
+        raise(error)
       end
-    rescue RestClient::RequestFailed => e
-      error extract_error(e.http_body)
-    rescue RestClient::RequestTimeout
-      error "API request timed out. Please try again, or contact support@nimbu.com if this issue persists."
+    # rescue Nimbu::API::Errors::Unauthorized, RestClient::Unauthorized
+    #   puts "Authentication failure"
+    #   unless ENV['Nimbu_API_KEY']
+    #     run "login"
+    #     retry
+    #   end
+    # rescue Nimbu::API::Errors::VerificationRequired, RestClient::PaymentRequired => e
+    #   retry if Nimbu::Helpers.confirm_billing
+    # rescue Nimbu::API::Errors::NotFound => e
+    #   error extract_error(e.response.body) {
+    #     e.response.body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+    #   }
+    # rescue RestClient::ResourceNotFound => e
+    #   error extract_error(e.http_body) {
+    #     e.http_body =~ /^([\w\s]+ not found).?$/ ? $1 : "Resource not found"
+    #   }
+    # rescue Nimbu::API::Errors::Locked => e
+    #   app = e.response.headers[:x_confirmation_required]
+    #   if confirm_command(app, extract_error(e.response.body))
+    #     arguments << '--confirm' << app
+    #     retry
+    #   end
+    # rescue RestClient::Locked => e
+    #   app = e.response.headers[:x_confirmation_required]
+    #   if confirm_command(app, extract_error(e.http_body))
+    #     arguments << '--confirm' << app
+    #     retry
+    #   end
+    # rescue Nimbu::API::Errors::Timeout, RestClient::RequestTimeout
+    #   error "API request timed out. Please try again, or contact support@Nimbu.com if this issue persists."
+    # rescue Nimbu::API::Errors::ErrorWithResponse => e
+    #   error extract_error(e.response.body)
+    # rescue RestClient::RequestFailed => e
+    #   error extract_error(e.http_body)
     rescue CommandFailed => e
       error e.message
-    rescue OptionParser::ParseError => ex
+    rescue OptionParser::ParseError
       commands[cmd] ? run("help", [cmd]) : run("help")
-    rescue Interrupt => e
-      error "\n[exited]"
+    rescue Excon::Errors::SocketError => e
+      if e.message == 'getaddrinfo: nodename nor servname provided, or not known (SocketError)'
+        error("Unable to connect to Nimbu API, please check internet connectivity and try again.")
+      else
+        raise(e)
+      end
+    ensure
+      display_warnings
     end
 
     def self.parse(cmd)