vmc 0.4.0.beta.12 → 0.4.0.beta.13

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

@@ -1,23 +1,37 @@
-require "vmc/cli/command"
+require "vmc/cli"
 
 module VMC
-  class User < Command
-    desc "create [EMAIL]", "Create a user"
+  class User < CLI
+    desc "List all users"
+    group :admin, :hidden => true
+    def users(input)
+      users =
+        with_progress("Getting users") do
+          client.users
+        end
+
+      users.each do |u|
+        display_user(u)
+      end
+    end
+
+
+    desc "Create a user"
     group :admin, :user, :hidden => true
-    flag(:email) {
+    input(:email, :argument => true, :desc => "User email") {
       ask("Email")
     }
-    flag(:password) {
+    input(:password, :desc => "User password") {
       ask("Password", :echo => "*", :forget => true)
     }
-    flag(:verify) {
+    input(:verify, :desc => "Repeat password") {
       ask("Verify Password", :echo => "*", :forget => true)
     }
-    def create(email = nil)
-      email ||= input(:email)
-      password = input(:password)
+    def create_user(input)
+      email = input[:email]
+      password = input[:password]
 
-      if !force? && password != input(:verify)
+      if !force? && password != input[:verify]
         fail "Passwords don't match."
       end
 
@@ -26,36 +40,39 @@ module VMC
       end
     end
 
-    desc "delete [EMAIL]", "Delete a user"
+    alias_command :create_user, :add_user
+
+
+    desc "Delete a user"
     group :admin, :user, :hidden => true
-    flag(:really) { |email|
+    input :email, :argument => true, :desc => "User to delete"
+    input(:really, :type => :boolean) { |email|
       force? || ask("Really delete user #{c(email, :name)}?", :default => false)
     }
-    def delete(email)
-      return unless input(:really, email)
+    def delete_user(input)
+      return unless input[:really, email]
 
       with_progress("Deleting #{c(email, :name)}") do
         client.user(email).delete!
       end
-    ensure
-      forget(:really)
     end
 
-    desc "passwd [EMAIL]", "Update a user's password"
+
+    desc "Update a user's password"
     group :admin, :user, :hidden => true
-    flag(:email) {
+    input(:email, :argument => true, :desc => "User to update") {
       ask("Email")
     }
-    flag(:password) {
+    input(:password, :desc => "New password") {
       ask("Password", :echo => "*", :forget => true)
     }
-    flag(:verify) {
+    input(:verify, :desc => "Repeat new password") {
       ask("Verify Password", :echo => "*", :forget => true)
     }
-    def passwd(email = nil)
-      email ||= input(:email)
-      password = input(:password)
-      verify = input(:verify)
+    def passwd(input)
+      email = input[:email]
+      password = input[:password]
+      verify = input[:verify]
 
       if password != verify
         fail "Passwords don't match."
@@ -67,5 +84,17 @@ module VMC
         user.update!
       end
     end
+
+    private
+
+    def display_user(u)
+      if quiet?
+        puts u.email
+      else
+        puts ""
+        puts "#{c(u.email, :name)}:"
+        puts "  admin?: #{c(u.admin?, u.admin? ? :yes : :no)}"
+      end
+    end
   end
 end

data/vmc-ng/lib/vmc/plugin.rb

@@ -32,9 +32,4 @@ module VMC
       end
     end
   end
-
-  def self.Plugin(target = CLI, &blk)
-    # SUPER FANCY PLUGIN SYSTEM
-    target.class_eval &blk
-  end
 end

data/vmc-ng/lib/vmc/version.rb

@@ -1,3 +1,3 @@
 module VMC
-  VERSION = "0.4.0.beta.12"
+  VERSION = "0.4.0.beta.13"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: vmc
 version: !ruby/object:Gem::Version 
-  hash: 62196475
+  hash: 62196473
   prerelease: 6
   segments: 
   - 0
   - 4
   - 0
   - beta
-  - 12
-  version: 0.4.0.beta.12
+  - 13
+  version: 0.4.0.beta.13
 platform: ruby
 authors: 
 - VMware
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-06-27 00:00:00 Z
+date: 2012-07-03 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: json_pure
@@ -258,19 +258,19 @@ dependencies:
   type: :runtime
   version_requirements: *id014
 - !ruby/object:Gem::Dependency 
-  name: thor
+  name: mothership
   prerelease: false
   requirement: &id015 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 43
+        hash: 29
         segments: 
         - 0
-        - 14
-        - 6
-        version: 0.14.6
+        - 0
+        - 1
+        version: 0.0.1
   type: :runtime
   version_requirements: *id015
 - !ruby/object:Gem::Dependency 
@@ -281,12 +281,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 31
+        hash: 19
         segments: 
         - 0
-        - 2
-        - 4
-        version: 0.2.4
+        - 3
+        - 0
+        version: 0.3.0
   type: :runtime
   version_requirements: *id016
 description: 
@@ -343,10 +343,10 @@ files:
 - vmc-ng/LICENSE
 - vmc-ng/Rakefile
 - vmc-ng/lib/vmc/cli/app.rb
-- vmc-ng/lib/vmc/cli/better_help.rb
-- vmc-ng/lib/vmc/cli/command.rb
-- vmc-ng/lib/vmc/cli/dots.rb
+- vmc-ng/lib/vmc/cli/help.rb
+- vmc-ng/lib/vmc/cli/interactive.rb
 - vmc-ng/lib/vmc/cli/service.rb
+- vmc-ng/lib/vmc/cli/start.rb
 - vmc-ng/lib/vmc/cli/user.rb
 - vmc-ng/lib/vmc/cli.rb
 - vmc-ng/lib/vmc/constants.rb

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

@@ -1,193 +0,0 @@
-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

@@ -1,567 +0,0 @@
-require "thor"
-require "interact"
-require "yaml"
-
-require "cfoundry"
-
-require "vmc/constants"
-require "vmc/errors"
-require "vmc/cli/dots"
-require "vmc/cli/better_help"
-
-
-$vmc_asked_auth = false
-
-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, :number)}: #{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("> ", :prompt)
-
-      unless value.empty?
-        print "#{c(value, :default) + "\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 :version,
-      :type => :boolean, :aliases => "-v", :desc => "Print version number"
-
-    class_option :verbose, :type => :boolean, :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
-
-    def self.filter(task, &callback)
-      add_callback(:filter, task, callback)
-    end
-
-    private
-
-    def callbacks_for(what)
-      self.class.callbacks_for(what)
-    end
-
-    def passed_value(flag)
-      if (val = inputs[flag] || 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, :error)
-      end
-
-      $exit_status = 1
-    end
-
-    def with_filters(new)
-      new.each do |task, callback|
-        self.class.callbacks[:filter][task] << callback
-      end
-
-      yield
-    ensure
-      new.each do |task, _|
-        self.class.callbacks[:filter][task].pop
-      end
-    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 filter(name, val)
-      callbacks_for(:filter)[name].each do |f|
-        val = f.call val
-      end
-
-      val
-    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 CFoundry::Denied => e
-      if !$vmc_asked_auth && e.error_code == 200
-        $vmc_asked_auth = true
-
-        puts ""
-        puts c("Not authenticated! Try logging in:", :warning)
-
-        invoke :login
-        @client = nil
-
-        retry
-      end
-
-      err "Denied: #{e.description}"
-    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
-          :good
-        elsif num <= mid
-          :warning
-        else
-          :bad
-        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
-      else # assume megabytes
-        str.to_i
-      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