hammer_cli 0.19.1 → 2.2.0

data/lib/hammer_cli/logger_watch.rb

@@ -1,4 +1,4 @@
-require 'awesome_print'
+require 'amazing_print'
 
 module HammerCLI
   module Logger

data/lib/hammer_cli/main.rb

@@ -47,9 +47,11 @@ module HammerCLI
       :context_target => :interactive
     option ["--no-headers"], :flag, _("Hide headers from output")
     option ["--csv"], :flag, _("Output as CSV (same as --output=csv)")
-    option ["--output"], "ADAPTER", _("Set output format"),
-           format: HammerCLI::Options::Normalizers::Enum.new(HammerCLI::Output::Output.adapters.keys.map(&:to_s)),
-      :context_target => :adapter
+    option ['--output'], 'ADAPTER', _('Set output format'),
+           format: HammerCLI::Options::Normalizers::Enum.new(
+             HammerCLI::Output::Output.adapters.keys.map(&:to_s)
+           ),
+           context_target: :adapter
     option ["--output-file"], "OUTPUT_FILE", _("Path to custom output file") do |filename|
       begin
         context[:output_file] = File.new(filename, 'w')

data/lib/hammer_cli/options/normalizers.rb

@@ -111,10 +111,10 @@ module HammerCLI
 
       class ListNested < AbstractNormalizer
         class Schema < Array
-          def description
+          def description(richtext: true)
             '"' + reduce([]) do |schema, nested_param|
               name = nested_param.name
-              name = HighLine.color(name, :bold) if nested_param.required?
+              name = HighLine.color(name, :bold) if nested_param.required? && richtext
               values = nested_param.validator.scan(/<[^>]+>[\w]+<\/?[^>]+>/)
               value_pattern = if values.empty?
                                 "<#{nested_param.expected_type.downcase}>"
@@ -172,6 +172,9 @@ module HammerCLI
 
 
       class Bool < AbstractNormalizer
+        def allowed_values
+          ['yes', 'no', 'true', 'false', '1', '0']
+        end
 
         def description
           _('One of %s.') % ['true/false', 'yes/no', '1/0'].join(', ')
@@ -189,7 +192,7 @@ module HammerCLI
         end
 
         def complete(value)
-          ["yes ", "no "]
+          allowed_values.map { |v| v + ' ' }
         end
       end
 
@@ -280,6 +283,7 @@ module HammerCLI
       end
 
       class EnumList < AbstractNormalizer
+        attr_reader :allowed_values
 
         def initialize(allowed_values)
           @allowed_values = allowed_values

data/lib/hammer_cli/options/option_definition.rb

@@ -22,14 +22,12 @@ module HammerCLI
 
     class OptionDefinition < Clamp::Option::Definition
 
-      attr_accessor :value_formatter
-      attr_accessor :context_target
-      attr_accessor :deprecated_switches
+      attr_accessor :value_formatter, :context_target, :deprecated_switches
 
       def initialize(switches, type, description, options = {})
-        self.value_formatter = options[:format] || HammerCLI::Options::Normalizers::Default.new
-        self.context_target = options[:context_target]
-        self.deprecated_switches = options[:deprecated]
+        @value_formatter = options[:format] || HammerCLI::Options::Normalizers::Default.new
+        @context_target = options[:context_target]
+        @deprecated_switches = options[:deprecated]
         super
       end
 
@@ -138,6 +136,28 @@ module HammerCLI
         end
       end
 
+      def completion_type(formatter = nil)
+        return { type: :flag } if @type == :flag
+
+        formatter ||= value_formatter
+        completion_type = case formatter
+                          when HammerCLI::Options::Normalizers::Bool,
+                               HammerCLI::Options::Normalizers::Enum
+                            { type: :enum, values: value_formatter.allowed_values }
+                          when HammerCLI::Options::Normalizers::EnumList
+                            { type: :multienum, values: value_formatter.allowed_values }
+                          when HammerCLI::Options::Normalizers::ListNested
+                            { type: :schema, schema: value_formatter.schema.description(richtext: false) }
+                          when HammerCLI::Options::Normalizers::List
+                            { type: :list }
+                          when HammerCLI::Options::Normalizers::KeyValueList
+                            { type: :key_value_list }
+                          when HammerCLI::Options::Normalizers::File
+                            { type: :file }
+                          end
+        completion_type || { type: :value }
+      end
+
       private
 
       def format_deprecation_msg(option_desc, deprecation_msg)

data/lib/hammer_cli/options/option_family.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module HammerCLI
+  module Options
+    class OptionFamily
+      attr_reader :children
+
+      IDS_REGEX = /\s?([Ii][Dd][s]?)\W|([Ii][Dd][s]?\Z)/
+
+      def initialize(options = {})
+        @all = []
+        @children = []
+        @options = options
+        @creator = options[:creator] || Class.new(HammerCLI::Apipie::Command)
+        @prefix = options[:prefix]
+        @description = options[:description]
+        @root = options[:root] || options[:aliased_resource] || options[:referenced_resource]
+      end
+
+      def description
+        types = all.map(&:type).map { |s| s.split('_').last.to_s }
+                   .map(&:capitalize).join('/')
+        @description ||= @parent.help[1].gsub(IDS_REGEX) { |w| w.gsub(/\w+/, types) }
+        if @options[:deprecation].class <= String
+          format_deprecation_msg(@description, _('Deprecated: %{deprecated_msg}') % { deprecated_msg: @options[:deprecation] })
+        elsif @options[:deprecation].class <= Hash
+          full_msg = @options[:deprecation].map do |flag, msg|
+            _('%{flag} is deprecated: %{deprecated_msg}') % { flag: flag, deprecated_msg: msg }
+          end.join(', ')
+          format_deprecation_msg(@description, full_msg)
+        else
+          @description
+        end
+      end
+
+      def switch
+        return if @parent.nil? && @children.empty?
+        return @parent.help_lhs.strip if @children.empty?
+
+        switch_start = main_switch.each_char
+                                  .zip(*all.map(&:switches).flatten.map(&:each_char))
+                                  .select { |a, b| a == b }.transpose.first.join
+        suffixes = all.map do |m|
+          m.switches.map { |s| s.gsub(switch_start, '') }
+        end.flatten.reject(&:empty?).sort { |x, y| x.size <=> y.size }
+        "#{switch_start}[#{suffixes.join('|')}]"
+      end
+
+      def head
+        @parent
+      end
+
+      def all
+        @children + [@parent].compact
+      end
+
+      def parent(switches, type, description, opts = {}, &block)
+        raise StandardError, 'Option family can have only one parent' if @parent
+
+        @parent = new_member(switches, type, description, opts, &block)
+      end
+
+      def child(switches, type, description, opts = {}, &block)
+        child = new_member(switches, type, description, opts, &block)
+        @children << child
+        child
+      end
+
+      def adopt(child)
+        child.family = self
+        @children << child
+      end
+
+      private
+
+      def format_deprecation_msg(option_desc, deprecation_msg)
+        "#{option_desc} (#{deprecation_msg})"
+      end
+
+      def new_member(switches, type, description, opts = {}, &block)
+        opts = opts.merge(@options)
+        opts[:family] = self
+        if opts[:deprecated]
+          handles = [switches].flatten
+          opts[:deprecated] = opts[:deprecated].select do |switch, _msg|
+            handles.include?(switch)
+          end
+        end
+        @creator.instance_eval do
+          option(switches, type, description, opts, &block)
+        end
+      end
+
+      def main_switch
+        root = @root || @parent.aliased_resource || @parent.referenced_resource || common_root
+        "--#{@prefix}#{root}".tr('_', '-')
+      end
+
+      def common_root
+        switches = all.map(&:switches).flatten
+        shortest = switches.min_by(&:length)
+        max_len = shortest.length
+        max_len.downto(0) do |curr_len|
+          0.upto(max_len - curr_len) do |start|
+            root = shortest[start, curr_len]
+            if switches.all? { |switch| switch.include?(root) }
+              return root[2..-1].chomp('-')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hammer_cli/options/predefined.rb

@@ -6,7 +6,7 @@ module HammerCLI
     module Predefined
       OPTIONS = {
         fields: [['--fields'], 'FIELDS',
-                 _('Show specified fileds or predefined filed sets only. (See below)'),
+                 _('Show specified fields or predefined field sets only. (See below)'),
                  format: HammerCLI::Options::Normalizers::List.new,
                  context_target: :fields]
       }.freeze

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

@@ -44,14 +44,10 @@ module HammerCLI::Output::Adapter
       raise NotImplementedError
     end
 
-    def print_collection(fields, collection)
+    def print_collection(fields, collection, options = {})
       raise NotImplementedError
     end
 
-    def reset_context
-      @context.delete(:fields)
-    end
-
     protected
 
     def filter_fields(fields)

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

@@ -14,7 +14,7 @@ module HammerCLI::Output::Adapter
       print_collection(fields, [record].flatten(1))
     end
 
-    def print_collection(fields, collection)
+    def print_collection(fields, collection, options = {})
       collection.each do |data|
         output_stream.puts render_fields(fields, data)
         output_stream.puts

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

@@ -149,7 +149,8 @@ module HammerCLI::Output::Adapter
       print_collection(fields, [record].flatten(1))
     end
 
-    def print_collection(fields, collection)
+    def print_collection(fields, collection, options = {})
+      current_chunk = options[:current_chunk] || :single
       fields = filter_fields(fields).filter_by_classes
                                     .filter_by_sets
                                     .filter_by_data(collection.first,
@@ -161,7 +162,7 @@ module HammerCLI::Output::Adapter
       # or use headers from output definition
       headers ||= default_headers(fields)
       csv_string = generate do |csv|
-        csv << headers if headers && !@context[:no_headers]
+        csv << headers if headers && !@context[:no_headers] && %i[first single].include?(current_chunk)
         rows.each do |row|
           csv << Cell.values(headers, row)
         end

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

@@ -6,9 +6,20 @@ module HammerCLI::Output::Adapter
       output_stream.puts JSON.pretty_generate(result.first)
     end
 
-    def print_collection(fields, collection)
-      result = prepare_collection(fields, collection)
-      output_stream.puts JSON.pretty_generate(result)
+    def print_collection(fields, collection, options = {})
+      current_chunk = options[:current_chunk] || :single
+      prepared = prepare_collection(fields, collection)
+      result = JSON.pretty_generate(prepared)
+      if current_chunk != :single
+        result = if current_chunk == :first
+                   result[0...-2] + ','
+                 elsif current_chunk == :last
+                   result[2..-1]
+                 else
+                   result[2...-2] + ','
+                 end
+      end
+      output_stream.puts result
     end
 
     def print_message(msg, msg_params={})

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

@@ -12,7 +12,7 @@ module HammerCLI::Output::Adapter
     def print_record(fields, record)
     end
 
-    def print_collection(fields, collection)
+    def print_collection(fields, collection, options = {})
     end
 
   end

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

@@ -2,6 +2,11 @@ require File.join(File.dirname(__FILE__), 'wrapper_formatter')
 
 module HammerCLI::Output::Adapter
   class Table < Abstract
+    def initialize(context = {}, formatters = {}, filters = {})
+      super
+      @printed = 0
+    end
+
     def features
       return %i[rich_text serialized inline] if tags.empty?
 
@@ -12,7 +17,8 @@ module HammerCLI::Output::Adapter
       print_collection(fields, [record].flatten(1))
     end
 
-    def print_collection(all_fields, collection)
+    def print_collection(all_fields, collection, options = {})
+      current_chunk = options[:current_chunk] || :single
       fields = filter_fields(all_fields).filter_by_classes
                                         .filter_by_sets
                                         .filter_by_data(collection.first,
@@ -27,13 +33,26 @@ module HammerCLI::Output::Adapter
       table_gen = HammerCLI::Output::Generators::Table.new(
         columns, formatted_collection, no_headers: @context[:no_headers]
       )
-      output_stream.print(table_gen.result)
 
-      if collection.respond_to?(:meta) && collection.meta.pagination_set? &&
-         @context[:verbosity] >= collection.meta.pagination_verbosity &&
-         collection.count < collection.meta.subtotal
-        pages = (collection.meta.subtotal.to_f / collection.meta.per_page).ceil
-        puts _("Page %{page} of %{total} (use --page and --per-page for navigation).") % {:page => collection.meta.page, :total => pages}
+      meta = collection.respond_to?(:meta) ? collection.meta : nil
+
+      output_stream.print(table_gen.header) if %i[first single].include?(current_chunk)
+
+      output_stream.print(table_gen.body)
+
+      @printed += collection.count
+
+      # print closing line only after the last chunk
+      output_stream.print(table_gen.footer) if %i[last single].include?(current_chunk)
+
+      return unless meta && meta.pagination_set?
+
+      leftovers = %i[last single].include?(current_chunk) && @printed < meta.subtotal
+      if @context[:verbosity] >= meta.pagination_verbosity &&
+         collection.count < meta.subtotal &&
+         leftovers
+        pages = (meta.subtotal.to_f / meta.per_page).ceil
+        puts _("Page %{page} of %{total} (use --page and --per-page for navigation).") % {:page => meta.page, :total => pages}
       end
     end
 
@@ -47,7 +66,7 @@ module HammerCLI::Output::Adapter
       collection.collect do |d|
         fields.inject({}) do |row, f|
           formatter = WrapperFormatter.new(@formatters.formatter_for_type(f.class), f.parameters)
-          row.update(f.label => formatter.format(data_for_field(f, d) || "").to_s)
+          row.update(f.label => formatter.format(data_for_field(f, d)).to_s)
         end
       end
     end

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

@@ -6,9 +6,12 @@ module HammerCLI::Output::Adapter
       output_stream.puts YAML.dump(result.first)
     end
 
-    def print_collection(fields, collection)
-      result = prepare_collection(fields, collection)
-      output_stream.puts YAML.dump(result)
+    def print_collection(fields, collection, options = {})
+      current_chunk = options[:current_chunk] || :single
+      prepared = prepare_collection(fields, collection)
+      result = YAML.dump(prepared)
+      result = result[4..-1] unless %i[first single].include?(current_chunk)
+      output_stream.puts result
     end
 
     def print_message(msg, msg_params={})

data/lib/hammer_cli/output/output.rb

@@ -25,15 +25,13 @@ module HammerCLI::Output
 
     def print_record(definition, record)
       adapter.print_record(definition.fields, record) if appropriate_verbosity?(:record)
-      adapter.reset_context
     end
 
-    def print_collection(definition, collection)
+    def print_collection(definition, collection, options = {})
       unless collection.class <= HammerCLI::Output::RecordCollection
         collection = HammerCLI::Output::RecordCollection.new([collection].flatten(1))
       end
-      adapter.print_collection(definition.fields, collection) if appropriate_verbosity?(:collection)
-      adapter.reset_context
+      adapter.print_collection(definition.fields, collection, options) if appropriate_verbosity?(:collection)
     end
 
     def adapter

data/lib/hammer_cli/settings.rb

@@ -66,7 +66,8 @@ module HammerCLI
 
     def self.default_settings
       {
-        :use_defaults => true
+        :use_defaults => true,
+        :completion_cache_file => '~/.cache/hammer_completion.yml'
       }
     end
 

data/lib/hammer_cli/subcommand.rb

@@ -23,6 +23,11 @@ module HammerCLI
         @subcommand_class
       end
 
+      def help
+        names = HammerCLI.context[:full_help] ? @names.join(", ") : @names.first
+        [names, description]
+      end
+
       attr_reader :warning
     end
 
@@ -90,8 +95,27 @@ module HammerCLI
         logger.info "subcommand #{name} (#{subcommand_class_name}) was created."
       end
 
+      def find_subcommand(name, fuzzy: true)
+        subcommand = super(name)
+        if subcommand.nil? && fuzzy
+          find_subcommand_starting_with(name)
+        else
+          subcommand
+        end
+      end
+
+      def find_subcommand_starting_with(name)
+        subcommands = recognised_subcommands.select { |sc| sc.names.any? { |n| n.start_with?(name) } }
+        if subcommands.size > 1
+          raise HammerCLI::CommandConflict, _('Found more than one command.') + "\n\n" +
+                                            _('Did you mean one of these?') + "\n\t" +
+                                            subcommands.collect(&:names).flatten.select { |n| n.start_with?(name) }.join("\n\t")
+        end
+        subcommands.first
+      end
+
       def define_subcommand(name, subcommand_class, definition, &block)
-        existing = find_subcommand(name)
+        existing = find_subcommand(name, fuzzy: false)
         if existing
           raise HammerCLI::CommandConflict, _("Can't replace subcommand %<name>s (%<existing_class>s) with %<name>s (%<new_class>s).") % {
             :name => name,