hammer_cli 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 367645958584805f4e59145418616c507fd9144a
-  data.tar.gz: d89c9715a3b0b66dacb21708d878c12e9c542e84
+  metadata.gz: c64a799978261a9f78c6ce7642a7cb82473cbb0a
+  data.tar.gz: 5893a4bfe3980b8794ea988c3895871625f1de47
 SHA512:
-  metadata.gz: 0eb7b32bc92e6d4ebedf52c8e9334ba2acab69808967b02a6e6b92110f936fccc9ede2febfb20e970eaa994c1b05582f83b46b964aef4c2307c2f6f01d4f75d3
-  data.tar.gz: 28164cbd24f5a912b4de8e97e10c917a2690378750ccfd6125f1e4104ff43bea883408f2fca13b70bcbd6abda325f4470b8607b1c4626303b50d7f9bfec0f4d8
+  metadata.gz: 18db270151afec8b1da636d4a3aa9088090c1b4de705102d8ca877c2c5cccbba65acbaa21f12dcbd2abb685f1bb2e684d6324afab555e6172857544c1c704215
+  data.tar.gz: 2c860c0406767e951e0d63d11d2c2e4e5c9d992148710110941982f3a0a9e295a8faf0c2983de1a97b5ba864b5f0aec66c851918e561132f99253c6b83e2edee

data/bin/hammer

@@ -37,6 +37,9 @@ if preparser.verbose?
   root_logger.appenders = root_logger.appenders << ::Logging.appenders.stderr(:layout => HammerCLI::Logger::COLOR_LAYOUT)
 end
 
+hammer_version = Gem.loaded_specs['hammer_cli'].version.to_s
+logger.info "Initialization of Hammer CLI (#{hammer_version}) has started..."
+
 # log which config was loaded (now when we have logging)
 HammerCLI::Settings.path_history.each do |path|
   logger.info "Configuration from the file #{path} has been loaded"
@@ -56,7 +59,8 @@ modules.each do |m|
     handler.handle_exception(e)
     exit HammerCLI::EX_SOFTWARE
   end
-  logger.info "Extension module #{m} loaded"
+  module_version = Gem.loaded_specs[m].version.to_s
+  logger.info "Extension module #{m} (#{module_version}) loaded"
 end
 
 exit HammerCLI::MainCommand.run || HammerCLI::EX_OK

data/lib/hammer_cli/abstract.rb

@@ -1,4 +1,3 @@
-require 'hammer_cli/autocompletion'
 require 'hammer_cli/exception_handler'
 require 'hammer_cli/logger_watch'
 require 'hammer_cli/options/option_definition'
@@ -11,7 +10,6 @@ module HammerCLI
 
   class AbstractCommand < Clamp::Command
 
-    extend Autocompletion
     class << self
       attr_accessor :validation_block
     end
@@ -25,8 +23,6 @@ module HammerCLI
       raise "exit code must be integer" unless exit_code.is_a? Integer
       return exit_code
     rescue => e
-      # do not catch Clamp errors
-      raise if e.class <= Clamp::UsageError || e.class <= Clamp::HelpWanted
       handle_exception e
     end
 
@@ -122,6 +118,34 @@ module HammerCLI
 
     protected
 
+    def interactive?
+      if context[:interactive].nil?
+        return STDOUT.tty? && (HammerCLI::Settings.get(:ui, :interactive) != false)
+      else
+        return context[:interactive]
+      end
+    end
+
+    def ask_username
+      ask("Username: ") if interactive?
+    end
+
+    def ask_password
+      ask("Password for '%s': " % username) {|q| q.echo = false} if interactive?
+    end
+
+    def username(ask_interactively=true)
+      context[:username] ||= ENV['FOREMAN_USERNAME'] || HammerCLI::Settings.get(:foreman, :username)
+      context[:username] ||= ask_username if ask_interactively
+      context[:username]
+    end
+
+    def password(ask_interactively=true)
+      context[:password] ||= ENV['FOREMAN_PASSWORD'] || HammerCLI::Settings.get(:foreman, :password)
+      context[:password] ||= ask_password if ask_interactively
+      context[:password]
+    end
+
     def print_record(definition, record)
       output.print_record(definition, record)
     end
@@ -181,13 +205,25 @@ module HammerCLI
       end
     end
 
+    def self.define_simple_writer_for(attribute, &block)
+      define_method(attribute.write_method) do |value|
+        value = instance_exec(value, &block) if block
+        if attribute.respond_to?(:context_target) && attribute.context_target
+          context[attribute.context_target] = value
+        end
+        attribute.of(self).set(value)
+      end
+    end
+
     def self.option(switches, type, description, opts = {}, &block)
       formatter = opts.delete(:format)
+      context_target = opts.delete(:context_target)
 
       HammerCLI::Options::OptionDefinition.new(switches, type, description, opts).tap do |option|
         declared_options << option
 
         option.value_formatter = formatter
+        option.context_target = context_target
         block ||= option.default_conversion_block
 
         define_accessors_for(option, &block)

data/lib/hammer_cli/apipie/resource.rb

@@ -70,8 +70,8 @@ module HammerCLI::Apipie
     def resource_config
       config = {}
       config[:base_url] = HammerCLI::Settings.get(:foreman, :host)
-      config[:username] = context[:username] || ENV['FOREMAN_USERNAME'] || HammerCLI::Settings.get(:foreman, :username)
-      config[:password] = context[:password] || ENV['FOREMAN_PASSWORD'] || HammerCLI::Settings.get(:foreman, :password)
+      config[:username] = username
+      config[:password] = password
       config
     end
 

data/lib/hammer_cli/completer.rb

@@ -0,0 +1,193 @@
+require 'enumerator'
+
+module HammerCLI
+
+  class CompleterLine < Array
+
+    def initialize(line)
+      @line = line
+      super(line.split)
+    end
+
+    def finished?
+      (@line[-1,1] == " ") || @line.empty?
+    end
+
+  end
+
+  class Completer
+
+    def initialize(cmd_class)
+      @command = cmd_class
+    end
+
+
+    def complete(line)
+      line = CompleterLine.new(line)
+
+      cmd, remaining = find_last_cmd(line)
+
+      opt, value = option_to_complete(cmd, remaining)
+      if opt
+        return complete_attribute(opt, value)
+      else
+        param, value = param_to_complete(cmd, remaining)
+        if param
+          if remaining.finished?
+            return complete_attribute(param, value) + complete_command(cmd, remaining)
+          else
+            return complete_attribute(param, value)
+          end
+        else
+          return complete_command(cmd, remaining)
+        end
+
+      end
+    end
+
+
+    protected
+
+    def complete_attribute(attribute, value)
+      if attribute.respond_to?(:complete)
+        filter(attribute.complete(value), value)
+      else
+        []
+      end
+    end
+
+
+    def param_to_complete(cmd, line)
+      params = cmd.parameters.select do |p|
+        (p.attribute_name != 'subcommand_name') and (p.attribute_name != 'subcommand_arguments')
+      end
+
+      return [nil, nil] if params.empty?
+
+      # select param candidates
+      param_candidates = []
+      line.reverse.each do |word|
+        break if word.start_with?('-')
+        param_candidates.unshift(word)
+      end
+
+      param = nil
+
+      if line.finished?
+        # "--option " or "--option xx " or "xx "
+        value = nil
+        param_index = param_candidates.size
+      else
+        # "--opt" or "--option xx" or "xx yy"
+        value = param_candidates.last
+        param_index = param_candidates.size - 1
+      end
+
+      if param_index >= 0
+        if params.size > param_index
+          param = params[param_index]
+        elsif params.last.multivalued?
+          param = params.last
+        end
+      end
+
+      return [param, value]
+    end
+
+
+    def option_to_complete(cmd, line)
+      return [nil, nil] if line.empty?
+
+      if line.finished?
+        # last word must be option and can't be flag -> we complete the value
+        # "--option " nebo "--option xx "
+        opt = cmd.find_option(line[-1])
+        return [opt, nil] if opt and not opt.flag?
+      else
+        # we complete the value in the second case
+        # "--opt" or "--option xx" or "xx yy"
+        opt = cmd.find_option(line[-2])
+        return [opt, line[-1]] if opt and not opt.flag?
+      end
+      return [nil, nil]
+    end
+
+
+    def find_last_cmd(line)
+      cmd = @command
+      subcommands = sub_command_map(cmd)
+
+      # if the last word is not finished we have to select it's parent
+      # -> shorten the line
+      words = line.dup
+      words.pop unless line.finished?
+
+      cmd_idx = 0
+      words.each_with_index do |word, idx|
+        unless word.start_with?('-')
+          break unless subcommands.has_key? word
+
+          cmd = subcommands[word]
+          cmd_idx = idx+1
+          subcommands = sub_command_map(cmd)
+        end
+      end
+
+      # cut processed part of the line and return remaining
+      remaining = line.dup
+      remaining.shift(cmd_idx) if cmd_idx > 0
+      return [cmd, remaining]
+    end
+
+
+    def complete_command(command, remaining)
+      completions = []
+      completions += sub_command_names(command)
+      completions += command_options(command)
+      completions = Completer::finalize_completions(completions)
+
+      if remaining.finished?
+        return completions
+      else
+        return filter(completions, remaining.last)
+      end
+    end
+
+
+    def filter(completions, last_word)
+      if last_word.to_s != ""
+        completions.select{|name| name.start_with? last_word }
+      else
+        completions
+      end
+    end
+
+
+    def self.finalize_completions(completions)
+      completions.collect{|name| name+' ' }
+    end
+
+
+    def sub_command_map(cmd_class)
+      cmd_class.recognised_subcommands.inject({}) do |cmd_map, cmd|
+        cmd.names.each do |name|
+          cmd_map.update(name => cmd.subcommand_class)
+        end
+        cmd_map
+      end
+    end
+
+
+    def sub_command_names(cmd_class)
+      sub_command_map(cmd_class).keys.flatten
+    end
+
+
+    def command_options(cmd_class)
+      cmd_class.recognised_options.inject([]) do |opt_switches, opt|
+        opt_switches += opt.switches
+      end
+    end
+
+  end
+end

data/lib/hammer_cli/exception_handler.rb

@@ -12,6 +12,8 @@ module HammerCLI
     def mappings
       [
         [Exception, :handle_general_exception], # catch all
+        [Clamp::HelpWanted, :handle_help_wanted],
+        [Clamp::UsageError, :handle_usage_exception],
         [RestClient::ResourceNotFound, :handle_not_found],
         [RestClient::Unauthorized, :handle_unauthorized],
       ]
@@ -41,6 +43,10 @@ module HammerCLI
       end
     end
 
+    def print_message(msg)
+      output.print_message(msg)
+    end
+
     def log_full_error(e)
       backtrace = e.backtrace || []
       @logger.error "\n\n#{e.class} (#{e.message}):\n    " +
@@ -54,6 +60,17 @@ module HammerCLI
       HammerCLI::EX_SOFTWARE
     end
 
+    def handle_usage_exception(e)
+      print_error "Error: %s\n\nSee: '%s --help'" % [e.message, e.command.invocation_path]
+      log_full_error e
+      HammerCLI::EX_USAGE
+    end
+
+    def handle_help_wanted(e)
+      print_message e.command.help
+      HammerCLI::EX_OK
+    end
+
     def handle_not_found(e)
       print_error e.message
       log_full_error e

data/lib/hammer_cli/main.rb

@@ -7,70 +7,48 @@ module HammerCLI
     option ["-v", "--verbose"], :flag, "be verbose"
     option ["-c", "--config"], "CFG_FILE", "path to custom config file"
 
-    option ["-u", "--username"], "USERNAME", "username to access the remote system"
-    option ["-p", "--password"], "PASSWORD", "password to access the remote system"
+    option ["-u", "--username"], "USERNAME", "username to access the remote system",
+      :context_target => :username
+    option ["-p", "--password"], "PASSWORD", "password to access the remote system",
+      :context_target => :password
 
     option "--version", :flag, "show version" do
-      puts "hammer-%s" % HammerCLI.version
+      puts "hammer (%s)" % HammerCLI.version
+      modules = HammerCLI::Settings.get(:modules) || []
+      modules.each do |m|
+        module_version = Gem.loaded_specs[m].version.to_s
+        puts " * #{m} (#{module_version})"
+      end
       exit(HammerCLI::EX_OK)
     end
 
-    option ["--show-ids"], :flag, "Show ids of associated resources"
+    option ["--show-ids"], :flag, "Show ids of associated resources",
+      :context_target => :show_ids
+    option ["--interactive"], "INTERACTIVE", "Explicitly turn interactive mode on/off",
+      :format => HammerCLI::Options::Normalizers::Bool.new,
+      :context_target => :interactive
 
     option ["--csv"], :flag, "Output as CSV (same as --adapter=csv)"
-    option ["--output"], "ADAPTER", "Set output format. One of [%s]" % 
-        HammerCLI::Output::Output.adapters.keys.join(', ')
-    option ["--csv-separator"], "SEPARATOR", "Character to separate the values"
+    option ["--output"], "ADAPTER", "Set output format. One of [%s]" %
+      HammerCLI::Output::Output.adapters.keys.join(', '),
+      :context_target => :adapter
+    option ["--csv-separator"], "SEPARATOR", "Character to separate the values",
+      :context_target => :csv_separator
 
-    option ["-P", "--ask-pass"], :flag, "Ask for password" do 
-      context[:password] = get_password()
-      ''
-    end
 
     option "--autocomplete", "LINE", "Get list of possible endings" do |line|
-      line = line.split
-      line.shift
-      endings = self.class.autocomplete(line).map { |l| l[0] }
-      puts endings.join(' ')
-      exit(HammerCLI::EX_OK)
-    end
-
-    def show_ids=(show_ids)
-      context[:show_ids] = show_ids
-    end
+      # get rid of word 'hammer' on the line
+      line = line.to_s.gsub(/^\S+/, '')
 
-    def run(*args)
-      super
-    end
-
-    def password=(p)
-      @password = p
-      context[:password] = p
+      completer = Completer.new(HammerCLI::MainCommand)
+      puts completer.complete(line).join(" ")
+      exit(HammerCLI::EX_OK)
     end
 
     def csv=(csv)
       context[:adapter] = :csv
     end
 
-    def csv_separator=(separator)
-      context[:csv_separator] = separator
-    end
-
-    def output=(adapter)
-      context[:adapter] = adapter
-    end
-
-    def username=(u)
-      @username = u
-      context[:username] = u
-    end
-
-    private
-
-    def get_password(prompt="Enter Password ")
-      ask(prompt) {|q| q.echo = false}
-    end
-
   end
 
 end

data/lib/hammer_cli/options/normalizers.rb

@@ -11,6 +11,10 @@ module HammerCLI
         def format(val)
           raise NotImplementedError, "Class #{self.class.name} must implement method format."
         end
+
+        def complete(val)
+          []
+        end
       end
 
 
@@ -62,6 +66,10 @@ module HammerCLI
             raise ArgumentError, "value must be one of true/false, yes/no, 1/0"
           end
         end
+
+        def complete(value)
+          ["yes ", "no "]
+        end
       end
 
 
@@ -70,6 +78,16 @@ module HammerCLI
         def format(path)
           ::File.read(::File.expand_path(path))
         end
+
+        def complete(value)
+          Dir[value.to_s+'*'].collect do |file|
+            if ::File.directory?(file)
+              file+'/'
+            else
+              file+' '
+            end
+          end
+        end
       end
 
 
@@ -91,6 +109,10 @@ module HammerCLI
           end
         end
 
+        def complete(value)
+          Completer::finalize_completions(@allowed_values)
+        end
+
         private
 
         def quoted_values

data/lib/hammer_cli/options/option_definition.rb

@@ -6,6 +6,15 @@ module HammerCLI
     class OptionDefinition < Clamp::Option::Definition
 
       attr_accessor :value_formatter
+      attr_accessor :context_target
+
+      def complete(value)
+        if value_formatter.nil?
+          []
+        else
+          value_formatter.complete(value)
+        end
+      end
 
       def help_lhs
         super

data/lib/hammer_cli/output/adapter/table.rb

@@ -12,26 +12,28 @@ module HammerCLI::Output::Adapter
       print_collection(fields, [record].flatten(1))
     end
 
-    def print_collection(fields, collection)
+    def print_collection(all_fields, collection)
+
+      fields = all_fields.reject { |f| f.class <= Fields::Id && !@context[:show_ids] }
 
       rows = collection.collect do |d|
         row = {}
         fields.each do |f|
-
           row[f.label.to_sym] = f.get_value(d) || ""
         end
         row
       end
 
       options = fields.collect do |f|
-        next if f.class <= Fields::Id && !@context[:show_ids]
         { f.label.to_sym => { :formatters => Array(@formatters.formatter_for_type(f.class)) } }
       end
 
+      sort_order = fields.map { |f| f.label.upcase }
+
       printer = TablePrint::Printer.new(rows, options)
       TablePrint::Config.max_width = 40
 
-      output = printer.table_print
+      output = sort_columns(printer.table_print, sort_order)
       dashes = /\n([-|]+)\n/.match(output)
 
       puts dashes[1] if dashes
@@ -46,6 +48,42 @@ module HammerCLI::Output::Adapter
       puts '-' * size
     end
 
+    private
+
+    def sort_columns(output, sort_order)
+      return output if sort_order.length == 1 # don't sort one column
+      delimiter = ' | '
+      lines = output.split("\n")
+      out = []
+
+      headers = lines.first.split(delimiter).map(&:strip)
+
+      # create mapping table for column indexes
+      sort_map = []
+      sort_order.each { |c| sort_map << headers.index(c) }
+
+      lines.each do |line|
+        columns = line.split(delimiter)
+        if columns.length == 1 # dashes
+          columns = columns.first.split('-|-')
+          if columns.length == 1
+            out << columns.first
+          else # new style dashes
+            new_row = []
+            sort_map.each { |i| new_row << columns[i] }
+            out << new_row.join('-|-')
+          end
+        else
+          # reorder row
+          new_row = []
+          sort_map.each { |i| new_row << columns[i] }
+          out << new_row.join(delimiter)
+        end
+      end
+
+      out.join("\n")
+    end
+
   end
 
   HammerCLI::Output::Output.register_adapter(:table, Table)