vmc 0.3.23 → 0.4.0.beta.1

data/vmc-ng/lib/vmc/cli/better_help.rb

@@ -0,0 +1,193 @@
+module VMC
+  module BetterHelp
+    @@groups = []
+    @@tree = {}
+
+    def nothing_printable?(group, all = false)
+      group[:members].reject { |_, _, opts| !all && opts[:hidden] }.empty? &&
+        group[:children].all? { |g| nothing_printable?(g) }
+    end
+
+    def print_help_group(group, all = false, indent = 0)
+      return if nothing_printable?(group, all)
+
+      members = group[:members]
+
+      unless all
+        members = members.reject do |_, _, opts|
+          opts[:hidden]
+        end
+      end
+
+      members = members.collect do |cls, name, opts|
+        [cls, cls.tasks[name]]
+      end
+
+      i = "  " * indent
+
+      print i
+      puts group[:description]
+
+      width = 0
+      members.each do |cls, t|
+        sub = find_subcommand_name(cls)
+        len = (sub ? sub.size + 1 : 0) + t.usage.size
+        if len > width
+          width = len
+        end
+      end
+
+      members.each do |cls, t|
+        sub = find_subcommand_name(cls)
+
+        print "#{i}  "
+
+        label = sub ? "#{sub} " : ""
+        label << t.usage
+
+        print "#{label.ljust(width)}\t#{t.description}"
+
+        puts ""
+      end
+
+      puts "" unless members.empty?
+
+      group[:children].each do |group|
+        print_help_group(group, all, indent + 1)
+      end
+    end
+
+    def groups(*tree)
+      tree.each do |*args|
+        add_group(@@groups, @@tree, *args.first)
+      end
+    end
+
+    def add_group(groups, tree, name, desc, *subs)
+      members = []
+
+      meta = {:members => members, :children => []}
+      groups << meta
+
+      tree[name] = {:members => members, :children => {}}
+
+      meta[:description] = desc
+
+      subs.each do |*args|
+        add_group(meta[:children], tree[name][:children], *args.first)
+      end
+    end
+
+    def group(*names)
+      options =
+        if names.last.is_a? Hash
+          names.pop
+        else
+          {}
+        end
+
+      where = @@tree
+      top = true
+      names.each do |n|
+        where = where[:children] unless top
+
+        unless where
+          raise "unknown group: #{names.join("/")}"
+        end
+
+        where = where[n]
+
+        top = false
+      end
+
+      where[:members] << [self, @usage.split.first, options]
+    end
+
+    def subcommand_classes
+      @subcommand_classes ||= {}
+    end
+
+    def subcommand_names
+      @subcommand_names ||= {}
+    end
+
+    def subcommand(name, cls)
+      subcommand_classes[name] = cls
+      subcommand_names[cls] = name
+      super
+    end
+
+    def find_subcommand_name(cls)
+      found = subcommand_names[cls]
+      return found if found
+
+      if superclass.respond_to?(:find_subcommand_name) &&
+          found = superclass.find_subcommand_name(cls)
+        return found
+      end
+
+      subcommand_classes.each do |name, sub|
+        if found = sub.find_subcommand_name(cls)
+          return name + " " + found
+        end
+      end
+
+      nil
+    end
+
+    def find_subcommand(name)
+      found = subcommand_classes[name]
+      return found if found
+
+      if superclass.respond_to? :find_subcommand
+        superclass.find_subcommand(name)
+      else
+        nil
+      end
+    end
+
+    def task_help(shell, task_name)
+      if sub = find_subcommand(task_name)
+        sub.help(shell, true)
+      elsif t = all_tasks[task_name]
+        puts t.description
+        puts ""
+        puts "Usage: #{t.usage}"
+        puts ""
+        class_options_help(shell, nil => t.options.map { |_, o| o })
+      else
+        super
+      end
+    end
+
+    def help(shell, subcommand = false)
+      puts "Tasks:"
+
+      width = 0
+      @tasks.each do |_, t|
+        len = t.usage.size
+        if len > width
+          width = len
+        end
+      end
+
+      @tasks.each do |_, t|
+        print "  "
+
+        print "#{t.usage.ljust(width)}\t#{t.description}"
+
+        puts ""
+      end
+
+      puts ""
+
+      class_options_help(shell)
+    end
+
+    def print_help_groups(all = false)
+      @@groups.each do |commands|
+        print_help_group(commands, all)
+      end
+    end
+  end
+end

data/vmc-ng/lib/vmc/cli/command.rb

@@ -0,0 +1,523 @@
+require "thor"
+require "interact"
+require "yaml"
+
+require "cfoundry"
+
+require "vmc/constants"
+require "vmc/errors"
+require "vmc/cli/dots"
+require "vmc/cli/better_help"
+
+
+module VMC
+  module Interactive
+    include ::Interactive::Rewindable
+    include Dots
+
+    class InteractiveDefault
+      attr_reader :method
+
+      def initialize(query, cls, cmd, flag)
+        # here be dragons
+        #
+        # MRI has no Proc -> Lambda, so this is kind of the only way to work
+        # around Proc's "convenient" argument handling while keeping the
+        # blocks evaluated on the Command instance
+
+        @method = :"__interact_#{cmd}_#{flag}__"
+        cls.queries.send(:define_method, @method, &query)
+      end
+
+      def to_s
+        "(interaction)"
+      end
+    end
+
+    def force?
+      false
+    end
+
+    def ask(question, options = {})
+      if force? and options.key?(:default)
+        options[:default]
+      else
+        super
+      end
+    end
+
+    def list_choices(choices, options)
+      choices.each_with_index do |o, i|
+        puts "#{c(i + 1, :green)}: #{o}"
+      end
+    end
+
+    def input_state(options)
+      CFState.new(options)
+    end
+
+    def prompt(question, options)
+      value =
+        case options[:default]
+        when true
+          "y"
+        when false
+          "n"
+        when nil
+          ""
+        else
+          options[:default].to_s
+        end
+
+      print "#{question}"
+      print c("> ", :blue)
+
+      unless value.empty?
+        print "#{c(value, :black) + "\b" * value.size}"
+      end
+    end
+
+    def handler(which, state)
+      ans = state.answer
+      pos = state.position
+
+      if state.default?
+        if which.is_a?(Array) and which[0] == :key
+          # initial non-movement keypress clears default answer
+          clear_input(state)
+        else
+          # wipe away any coloring
+          redraw_input(state)
+        end
+
+        state.clear_default!
+      end
+
+      super
+
+      print "\n" if which == :enter
+    end
+
+    class CFState < Interactive::InputState
+      def initialize(options = {}, answer = nil, position = 0)
+        @options = options
+
+        if answer
+          @answer = answer
+        elsif options[:default]
+          case options[:default]
+          when true
+            @answer = "y"
+          when false
+            @answer = "n"
+          else
+            @answer = options[:default].to_s
+          end
+
+          @default = true
+        else
+          @answer = ""
+        end
+
+        @position = position
+        @done = false
+      end
+
+      def clear_default!
+        @default = false
+      end
+
+      def default?
+        @default
+      end
+    end
+  end
+
+  class Command < Thor
+    include Interactive
+    extend BetterHelp
+
+    class_option :proxy, :aliases => "-u", :desc => "Proxy user"
+
+    class_option :verbose,
+      :type => :boolean, :aliases => "-v", :desc => "Verbose"
+
+    class_option :force,
+      :type => :boolean, :aliases => "-f", :desc => "Force (no interaction)"
+
+    class_option :simple_output,
+      :type => :boolean, :desc => "Simplified output format."
+
+    class_option :script, :type => :boolean, :aliases => "-s",
+      :desc => "--simple-output and --force"
+
+    class_option :trace, :type => :boolean, :aliases => "-t",
+      :desc => "Show API requests and responses"
+
+    class_option :color, :type => :boolean, :desc => "Colored output"
+
+    def self.queries
+      return @queries if @queries
+
+      @queries = Module.new
+      include @queries
+
+      @queries
+    end
+
+    def self.flag(name, options = {}, &query)
+      if query
+        options[:default] ||=
+          InteractiveDefault.new(query, self, @usage.split.first, name)
+      end
+
+      method_option(name, options)
+    end
+
+    def self.callbacks_for(name)
+      cs = callbacks[name]
+      if superclass.respond_to? :callbacks
+        cs.merge superclass.callbacks_for(name)
+      else
+        cs
+      end
+    end
+
+    def self.callbacks
+      @callbacks ||= Hash.new do |h, name|
+        h[name] = Hash.new do |h, task|
+          h[task] = []
+        end
+      end
+    end
+
+    def self.add_callback(name, task, callback)
+      callbacks[name][task] << callback
+    end
+
+    def self.before(task, &callback)
+      add_callback(:before, task, callback)
+    end
+
+    def self.after(task, &callback)
+      add_callback(:after, task, callback)
+    end
+
+    def self.ensuring(task, &callback)
+      add_callback(:ensuring, task, callback)
+    end
+
+    def self.around(task, &callback)
+      add_callback(:around, task, callback)
+    end
+
+    private
+
+    def callbacks_for(what)
+      self.class.callbacks_for(what)
+    end
+
+    def passed_value(flag)
+      if (val = options[flag]) && \
+          !val.is_a?(VMC::Interactive::InteractiveDefault)
+        val
+      end
+    end
+
+    def inputs
+      @inputs ||= {}
+    end
+
+    def input(name, *args)
+      return inputs[name] if inputs.key?(name)
+
+      val = options[name]
+      inputs[name] =
+        if val.is_a?(VMC::Interactive::InteractiveDefault)
+          send(val.method, *args)
+        elsif val.respond_to? :to_proc
+          instance_exec(*args, &options[name])
+        else
+          options[name]
+        end
+    end
+
+    def forget(name)
+      @inputs.delete name
+    end
+
+    def script?
+      if options.key?("script")
+        options["script"]
+      else
+        !$stdout.tty?
+      end
+    end
+
+    def force?
+      if options.key?("force")
+        options["force"]
+      else
+        script?
+      end
+    end
+
+    def verbose?
+      options["verbose"]
+    end
+
+    def simple_output?
+      if options.key?("simple_output")
+        options["simple_output"]
+      else
+        script?
+      end
+    end
+
+    def color?
+      if options.key?("color")
+        options["color"]
+      else
+        !simple_output?
+      end
+    end
+
+    def err(msg, exit_status = 1)
+      if script?
+        $stderr.puts(msg)
+      else
+        puts c(msg, :red)
+      end
+
+      $exit_status = 1
+    end
+
+    def with_inputs(new)
+      return yield if !new || new.empty?
+
+      begin
+        orig = {}
+        new.each do |k, v|
+          orig[k] = inputs[k]
+          inputs[k] = v
+        end
+
+        yield
+      ensure
+        orig.each do |k, v|
+          if v.nil?
+            inputs.delete(k)
+          else
+            inputs[k] = v
+          end
+        end
+      end
+    end
+
+    def fail(msg)
+      raise UserError, msg
+    end
+
+    def invoke_task(task, args)
+      callbacks_for(:before)[task.name.to_sym].each do |c|
+        c.call
+      end
+
+      action = proc do |*given_args|
+        if inputs = given_args.first
+          with_inputs(inputs) do
+            task.run(self, args)
+          end
+        else
+          task.run(self, args)
+        end
+      end
+
+      callbacks_for(:around)[task.name.to_sym].each do |a|
+        before = action
+        action = proc do |*given_args|
+          if inputs = given_args.first
+            with_inputs(inputs) do
+              instance_exec(before, args, &a)
+            end
+          else
+            instance_exec(before, args, &a)
+          end
+        end
+      end
+
+      res = instance_exec(args, &action)
+
+      callbacks_for(:after)[task.name.to_sym].each do |c|
+        c.call
+      end
+
+      res
+    rescue Interrupt
+      $exit_status = 130
+    rescue Thor::Error
+      raise
+    rescue UserError => e
+      err e.message
+    rescue Exception => e
+      msg = e.class.name
+      msg << ": #{e}" unless e.to_s.empty?
+      err msg
+
+      ensure_config_dir
+
+      File.open(File.expand_path(VMC::CRASH_FILE), "w") do |f|
+        f.print "Time of crash:\n  "
+        f.puts Time.now
+        f.puts ""
+        f.puts msg
+        f.puts ""
+
+        e.backtrace.each do |loc|
+          if loc =~ /\/gems\//
+            f.puts loc.sub(/.*\/gems\//, "")
+          else
+            f.puts loc.sub(File.expand_path("../../../..", __FILE__) + "/", "")
+          end
+        end
+      end
+    ensure
+      callbacks_for(:ensuring)[task.name.to_sym].each do |c|
+        c.call
+      end
+    end
+    public :invoke_task
+
+    def sane_target_url(url)
+      unless url =~ /^https?:\/\//
+        url = "http://#{url}"
+      end
+
+      url.gsub(/\/$/, "")
+    end
+
+    def target_file
+      one_of(VMC::TARGET_FILE, VMC::OLD_TARGET_FILE)
+    end
+
+    def tokens_file
+      one_of(VMC::TOKENS_FILE, VMC::OLD_TOKENS_FILE)
+    end
+
+    def one_of(*paths)
+      paths.each do |p|
+        exp = File.expand_path(p)
+        return exp if File.exist? exp
+      end
+
+      paths.first
+    end
+
+    def client_target
+      File.read(target_file).chomp
+    end
+
+    def ensure_config_dir
+      config = File.expand_path(VMC::CONFIG_DIR)
+      Dir.mkdir(config) unless File.exist? config
+    end
+
+    def set_target(url)
+      ensure_config_dir
+
+      File.open(File.expand_path(VMC::TARGET_FILE), "w") do |f|
+        f.write(sane_target_url(url))
+      end
+
+      @client = nil
+    end
+
+    def tokens
+      new_toks = File.expand_path(VMC::TOKENS_FILE)
+      old_toks = File.expand_path(VMC::OLD_TOKENS_FILE)
+
+      if File.exist? new_toks
+        YAML.load_file(new_toks)
+      elsif File.exist? old_toks
+        JSON.load(File.read(old_toks))
+      else
+        {}
+      end
+    end
+
+    def client_token
+      tokens[client_target]
+    end
+
+    def save_tokens(ts)
+      ensure_config_dir
+
+      File.open(File.expand_path(VMC::TOKENS_FILE), "w") do |io|
+        YAML.dump(ts, io)
+      end
+    end
+
+    def save_token(token)
+      ts = tokens
+      ts[client_target] = token
+      save_tokens(ts)
+    end
+
+    def remove_token
+      ts = tokens
+      ts.delete client_target
+      save_tokens(ts)
+    end
+
+    def client
+      return @client if @client
+
+      @client = CFoundry::Client.new(client_target, client_token)
+      @client.proxy = options[:proxy]
+      @client.trace = options[:trace]
+      @client
+    end
+
+    def usage(used, limit)
+      "#{b(human_size(used))} of #{b(human_size(limit, 0))}"
+    end
+
+    def percentage(num, low = 50, mid = 70)
+      color =
+        if num <= low
+          :green
+        elsif num <= mid
+          :yellow
+        else
+          :red
+        end
+
+      c(format("%.1f\%", num), color)
+    end
+
+    def megabytes(str)
+      if str =~ /T$/i
+        str.to_i * 1024 * 1024
+      elsif str =~ /G$/i
+        str.to_i * 1024
+      elsif str =~ /M$/i
+        str.to_i
+      elsif str =~ /K$/i
+        str.to_i / 1024
+      end
+    end
+
+    def human_size(num, precision = 1)
+      sizes = ["G", "M", "K"]
+      sizes.each.with_index do |suf, i|
+        pow = sizes.size - i
+        unit = 1024 ** pow
+        if num >= unit
+          return format("%.#{precision}f%s", num / unit, suf)
+        end
+      end
+
+      format("%.#{precision}fB", num)
+    end
+  end
+end