af 0.3.12.3 → 0.3.13.beta.5

data/lib/cli/commands/base.rb

@@ -1,7 +1,6 @@
 
 require 'rubygems'
 require 'terminal-table/import'
-require 'highline/import'
 
 module VMC::Cli
 
@@ -15,16 +14,10 @@ module VMC::Cli
         @no_prompt = @options[:noprompts]
         @prompt_ok = !no_prompt
 
-        # Fix for system ruby and Highline (stdin) on MacOSX
-        if RUBY_PLATFORM =~ /darwin/ && RUBY_VERSION == '1.8.7' && RUBY_PATCHLEVEL <= 174
-          HighLine.track_eof = false
-        end
-
         # Suppress colorize on Windows systems for now.
-        if !!RUBY_PLATFORM['mingw'] || !!RUBY_PLATFORM['mswin32'] || !!RUBY_PLATFORM['cygwin']
+        if WINDOWS
           VMC::Cli::Config.colorize = false
         end
-
       end
 
       def client
@@ -36,18 +29,19 @@ module VMC::Cli
       end
 
       def client_info
-        return @client_info if @client_info
-        @client_info = client.info
+        @client_info ||= client.info
       end
 
       def target_url
-        return @target_url if @target_url
-        @target_url = VMC::Cli::Config.target_url
+        @target_url ||= VMC::Cli::Config.target_url
+      end
+
+      def target_base
+        @target_base ||= VMC::Cli::Config.suggest_url
       end
 
       def auth_token
-        return @auth_token if @auth_token
-        @auth_token = VMC::Cli::Config.auth_token
+        @auth_token ||= VMC::Cli::Config.auth_token
       end
 
       def runtimes_info
@@ -72,7 +66,6 @@ module VMC::Cli
         end
         @frameworks
       end
-
     end
   end
 end

data/lib/cli/commands/misc.rb

@@ -2,7 +2,7 @@ module VMC::Cli::Command
 
   class Misc < Base
     def version
-      say "vmc #{VMC::Cli::VERSION}"
+      say "af #{VMC::Cli::VERSION}"
     end
 
     def target
@@ -30,9 +30,10 @@ module VMC::Cli::Command
       client = VMC::Client.new(target_url)
       unless client.target_valid?
         if prompt_ok
-          display "Host is not valid: '#{target_url}'".red
-          show_response = ask "Would you like see the response [yN]? "
-          display "\n<<<\n#{client.raw_info}\n>>>\n" if show_response.upcase == 'Y'
+          display "Host is not available or is not valid: '#{target_url}'".red
+          show_response = ask "Would you like see the response?",
+                              :default => false
+          display "\n<<<\n#{client.raw_info}\n>>>\n" if show_response
         end
         exit(false)
       else

data/lib/cli/commands/services.rb

@@ -20,15 +20,15 @@ module VMC::Cli::Command
       unless no_prompt || service
         services = client.services_info
         err 'No services available to provision' if services.empty?
-        choose do |menu|
-          menu.prompt = 'Please select one you wish to provision: '
-          menu.select_by = :index_or_name
-          services.each do |service_type, value|
-            value.each do |vendor, version|
-              menu.choice(vendor.to_s) { service = vendor.to_s }
-            end
-          end
-        end
+        service = ask(
+          "Which service would you like to provision?",
+          { :indexed => true,
+            :choices =>
+              services.values.collect { |type|
+                type.keys.collect(&:to_s)
+              }.flatten
+          }
+        )
       end
       name = @options[:name] unless name
       unless name
@@ -44,13 +44,12 @@ module VMC::Cli::Command
       unless no_prompt || service
         user_services = client.services
         err 'No services available to delete' if user_services.empty?
-        choose do |menu|
-          menu.prompt = 'Please select one you wish to delete: '
-          menu.select_by = :index_or_name
-          user_services.each do |s|
-            menu.choice(s[:name]) { service = s[:name] }
-          end
-        end
+        service = ask(
+          "Which service would you like to delete?",
+          { :indexed => true,
+            :choices => user_services.collect { |s| s[:name] }
+          }
+        )
       end
       err "Service name required." unless service
       display "Deleting service [#{service}]: ", false

data/lib/cli/commands/user.rb

@@ -13,8 +13,12 @@ module VMC::Cli::Command
       email    = @options[:email] unless email
       password = @options[:password]
       tries ||= 0
-      email = ask("Email: ") unless no_prompt || email
-      password = ask("Password: ") {|q| q.echo = '*'} unless no_prompt || password
+
+      unless no_prompt
+        email ||= ask("Email")
+        password ||= ask("Password", :echo => "*")
+      end
+
       err "Need a valid email" unless email
       err "Need a password" unless password
       login_and_save_token(email, password)
@@ -39,8 +43,8 @@ module VMC::Cli::Command
       err "Need to be logged in to change password." unless email
       say "Changing password for '#{email}'\n"
       unless no_prompt
-        password = ask("New Password: ") {|q| q.echo = '*'}
-        password2 = ask("Verify Password: ") {|q| q.echo = '*'}
+        password = ask "New Password", :echo => "*"
+        password2 = ask "Verify Password", :echo => "*"
         err "Passwords did not match, try again" if password != password2
       end
       err "Password required" unless password

data/lib/cli/config.rb

@@ -20,13 +20,12 @@ module VMC::Cli
       attr_accessor :output
       attr_accessor :trace
       attr_accessor :nozip
-      attr_reader   :suggest_url
 
       def target_url
         return @target_url if @target_url
         target_file = File.expand_path(TARGET_FILE)
         if File.exists? target_file
-          @target_url = File.read(target_file).strip!
+          @target_url = lock_and_read(target_file).strip!
           ha = @target_url.split('.')
           ha.shift
           @suggest_url = ha.join('.')
@@ -40,16 +39,20 @@ module VMC::Cli
         @target_url
       end
 
+      def suggest_url
+        target_url
+        @suggest_url
+      end
+
       def store_target(target_host)
         target_file = File.expand_path(TARGET_FILE)
-        File.open(target_file, 'w+') { |f| f.puts target_host }
-        FileUtils.chmod 0600, target_file
+        lock_and_write(target_file, target_host)
       end
 
       def all_tokens
         token_file = File.expand_path(TOKEN_FILE)
         return nil unless File.exists? token_file
-        contents = File.read(token_file).strip
+        contents = lock_and_read(token_file).strip
         JSON.parse(contents)
       end
 
@@ -69,20 +72,19 @@ module VMC::Cli
         tokens = all_tokens || {}
         tokens[target_url] = token
         token_file = File.expand_path(TOKEN_FILE)
-        File.open(token_file, 'w+') { |f| f.write(tokens.to_json) }
-        FileUtils.chmod 0600, token_file
+        lock_and_write(token_file, tokens.to_json)
       end
 
       def instances
         instances_file = File.expand_path(INSTANCES_FILE)
         return nil unless File.exists? instances_file
-        contents = File.read(instances_file).strip
+        contents = lock_and_read(instances_file).strip
         JSON.parse(contents)
       end
 
       def store_instances(instances)
         instances_file = File.expand_path(INSTANCES_FILE)
-        File.open(instances_file, 'w') { |f| f.write(instances.to_json) }
+        lock_and_write(instances_file, instances.to_json)
       end
 
       def aliases
@@ -100,6 +102,25 @@ module VMC::Cli
         File.open(aliases_file, 'wb') {|f| f.write(aliases.to_yaml)}
       end
 
+      def lock_and_read(file)
+        File.open(file, "r") {|f|
+          f.flock(File::LOCK_EX)
+          contents = f.read
+          f.flock(File::LOCK_UN)
+          contents
+        }
+      end
+
+      def lock_and_write(file, contents)
+        File.open(file, File::RDWR | File::CREAT, 0600) {|f|
+          f.flock(File::LOCK_EX)
+          f.rewind
+          f.puts contents
+          f.flush
+          f.truncate(f.pos)
+          f.flock(File::LOCK_UN)
+        }
+      end
     end
 
     def initialize(work_dir = Dir.pwd)

data/lib/cli/core_ext.rb

@@ -38,6 +38,10 @@ module VMCExtensions
     raise VMC::Cli::CliExit, "#{prefix}#{message}"
   end
 
+  def warn(msg)
+    say "#{"[WARNING]".yellow} #{msg}"
+  end
+
   def quit(message = nil)
     raise VMC::Cli::GracefulExit, message
   end
@@ -65,6 +69,333 @@ module VMCExtensions
     return sprintf("%.#{prec}fG", size/(1024.0*1024.0*1024.0))
   end
 
+  # general-purpose interaction
+  #
+  # `question' is the prompt (without ": " at the end)
+  # `options' is a hash containing:
+  #   :input - the input source (defaults to STDIN)
+  #   :default - the default value, also used to attempt type conversion
+  #              of the answer (e.g. numeric/boolean)
+  #   :choices - a list of strings to choose from
+  #   :indexed - whether to allow choosing from `:choices' by their index,
+  #              best for when there are many choices
+  #   :echo - a string to echo when showing the input;
+  #           used for things like censoring password inpt
+  #   :callback - a block used to override certain actions
+  #
+  #               takes 4 arguments:
+  #                 action: the event, e.g. :up or [:key, X] where X is a
+  #                         string containing a single character
+  #                 answer: the current answer to the question; you'll
+  #                         probably mutate this
+  #                 position: the current offset from the start of the
+  #                           answer string, e.g. when typing in the middle
+  #                           of the input, this will be where you insert
+  #                           characters
+  #                 echo: the :echo option above, may be nil
+  #
+  #               the block should return the updated `position', or nil if
+  #               it didn't handle the event
+  def ask(question, options = {})
+    default = options[:default]
+    choices = options[:choices]
+    indexed = options[:indexed]
+    callback = options[:callback]
+    input = options[:input] || STDIN
+    echo = options[:echo]
+
+    if choices
+      VMCExtensions.ask_choices(input, question, default, choices, indexed, echo, &callback)
+    else
+      VMCExtensions.ask_default(input, question, default, echo, &callback)
+    end
+  end
+
+  ESCAPES = {
+    "[A" => :up, "H" => :up,
+    "[B" => :down, "P" => :down,
+    "[C" => :right, "M" => :right,
+    "[D" => :left, "K" => :left,
+    "[3~" => :delete, "S" => :delete,
+    "[H" => :home, "G" => :home,
+    "[F" => :end, "O" => :end
+  }
+
+  def handle_action(which, ans, pos, echo = nil)
+    if block_given?
+      res = yield which, ans, pos, echo
+      return res unless res.nil?
+    end
+
+    case which
+    when :up
+      # nothing
+
+    when :down
+      # nothing
+
+    when :tab
+      # nothing
+
+    when :right
+      unless pos == ans.size
+        display censor(ans[pos .. pos], echo), false
+        return pos + 1
+      end
+
+    when :left
+      unless pos == 0
+        display "\b", false
+        return pos - 1
+      end
+
+    when :delete
+      unless pos == ans.size
+        ans.slice!(pos, 1)
+        if WINDOWS
+          rest = ans[pos .. -1]
+          display(censor(rest, echo) + " \b" + ("\b" * rest.size), false)
+        else
+          display("\e[P", false)
+        end
+      end
+
+    when :home
+      display("\b" * pos, false)
+      return 0
+
+    when :end
+      display(censor(ans[pos .. -1], echo), false)
+      return ans.size
+
+    when :backspace
+      if pos > 0
+        ans.slice!(pos - 1, 1)
+
+        if WINDOWS
+          rest = ans[pos - 1 .. -1]
+          display("\b" + censor(rest, echo) + " \b" + ("\b" * rest.size), false)
+        else
+          display("\b\e[P", false)
+        end
+
+        return pos - 1
+      end
+
+    when :interrupt
+      raise Interrupt.new
+
+    when :eof
+      return false if ans.empty?
+
+    when :kill_word
+      if pos > 0
+        start = /[^\s]*\s*$/ =~ ans[0 .. pos]
+        length = pos - start
+        ans.slice!(start, length)
+        display("\b" * length + " " * length + "\b" * length, false)
+        return start
+      end
+
+    when Array
+      case which[0]
+      when :key
+        c = which[1]
+        rest = ans[pos .. -1]
+
+        ans.insert(pos, c)
+
+        display(censor(c + rest, echo) + ("\b" * rest.size), false)
+
+        return pos + 1
+      end
+    end
+
+    pos
+  end
+
+  def censor(str, with)
+    return str unless with
+    with * str.size
+  end
+
+  # ask a simple question, maybe with a default answer
+  #
+  # reads character-by-character, handling backspaces, and sending each
+  # character to a block if provided
+  def self.ask_default(input, question, default = nil, echo = nil, &callback)
+    while true
+      prompt(question, default)
+
+      ans = ""
+      pos = 0
+      escaped = false
+      escape_seq = ""
+
+      with_char_io(input) do
+        until pos == false or (c = get_character(input)) =~ /[\r\n]/
+          if c == "\e" || c == "\xE0"
+            escaped = true
+          elsif escaped
+            escape_seq << c
+
+            if cmd = ESCAPES[escape_seq]
+              pos = handle_action(cmd, ans, pos, echo, &callback)
+              escaped, escape_seq = false, ""
+            elsif ESCAPES.select { |k, v| k.start_with? escape_seq }.empty?
+              escaped, escape_seq = false, ""
+            end
+          elsif c == "\177" or c == "\b" # backspace
+            pos = handle_action(:backspace, ans, pos, echo, &callback)
+          elsif c == "\x01"
+            pos = handle_action(:home, ans, pos, echo, &callback)
+          elsif c == "\x03"
+            pos = handle_action(:interrupt, ans, pos, echo, &callback)
+          elsif c == "\x04"
+            pos = handle_action(:eof, ans, pos, echo, &callback)
+          elsif c == "\x05"
+            pos = handle_action(:end, ans, pos, echo, &callback)
+          elsif c == "\x17"
+            pos = handle_action(:kill_word, ans, pos, echo, &callback)
+          elsif c == "\t"
+            pos = handle_action(:tab, ans, pos, echo, &callback)
+          elsif c < " "
+            # ignore
+          else
+            pos = handle_action([:key, c], ans, pos, echo, &callback)
+          end
+        end
+      end
+
+      display "\n", false
+
+      if ans.empty?
+        return default unless default.nil?
+      else
+        return match_type(ans, default)
+      end
+    end
+  end
+
+  def self.ask_choices(input, question, default, choices, indexed = false, echo = nil, &callback)
+    msg = question.dup
+
+    if indexed
+      choices.each.with_index do |o, i|
+        say "#{i + 1}: #{o}"
+      end
+    else
+      msg << " (#{choices.collect(&:inspect).join ", "})"
+    end
+
+    while true
+      ans = ask_default(input, msg, default, echo, &callback)
+
+      matches = choices.select { |x| x.start_with? ans }
+
+      if matches.size == 1
+        return matches.first
+      elsif indexed and ans =~ /^\d+$/ and res = choices.to_a[ans.to_i - 1]
+        return res
+      elsif matches.size > 1
+        warn "Please disambiguate: #{matches.join " or "}?"
+      else
+        warn "Unknown answer, please try again!"
+      end
+    end
+  end
+
+  # display a question and show the default value
+  def self.prompt(question, default = nil)
+    msg = question.dup
+
+    case default
+    when true
+      msg << " [Yn]"
+    when false
+      msg << " [yN]"
+    else
+      msg << " [#{default.inspect}]" if default
+    end
+
+    display "#{msg}: ", false
+  end
+
+  # try to make `str' be the same class as `x'
+  def self.match_type(str, x)
+    case x
+    when Integer
+      str.to_i
+    when true, false
+      str.upcase.start_with? "Y"
+    else
+      str
+    end
+  end
+
+  # definitions for reading character-by-character
+  begin
+    require "Win32API"
+
+    def self.with_char_io(input)
+      yield
+    end
+
+    def self.get_character(input)
+      if input == STDIN
+        begin
+          Win32API.new("msvcrt", "_getch", [], "L").call.chr
+        rescue
+          Win32API.new("crtdll", "_getch", [], "L").call.chr
+        end
+      else
+        input.getc.chr
+      end
+    end
+  rescue LoadError
+    begin
+      require "termios"
+
+      def self.with_char_io(input)
+        return yield unless input.tty?
+
+        before = Termios.getattr(input)
+
+        new = before.dup
+        new.c_lflag &= ~(Termios::ECHO | Termios::ICANON)
+        new.c_cc[Termios::VMIN] = 1
+
+        begin
+          Termios.setattr(input, Termios::TCSANOW, new)
+          yield
+        ensure
+          Termios.setattr(input, Termios::TCSANOW, before)
+        end
+      end
+
+      def self.get_character(input)
+        input.getc.chr
+      end
+    rescue LoadError
+      # set tty modes for the duration of a block, restoring them afterward
+      def self.with_char_io(input)
+        return yield unless input.tty?
+
+        begin
+          before = `stty -g`
+          system("stty raw -echo -icanon isig")
+          yield
+        ensure
+          system("stty #{before}")
+        end
+      end
+
+      # this assumes we're wrapped in #with_stty
+      def self.get_character(input)
+        input.getc.chr
+      end
+    end
+  end
 end
 
 module VMCStringExtensions