hammer_cli 0.19.0 → 2.1.1

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.rb

@@ -1,9 +1,9 @@
 require File.join(File.dirname(__FILE__), 'output/output')
 require File.join(File.dirname(__FILE__), 'output/fields')
 require File.join(File.dirname(__FILE__), 'output/formatters')
+require File.join(File.dirname(__FILE__), 'output/generators')
 require File.join(File.dirname(__FILE__), 'output/adapter')
 require File.join(File.dirname(__FILE__), 'output/definition')
 require File.join(File.dirname(__FILE__), 'output/dsl')
 require File.join(File.dirname(__FILE__), 'output/record_collection')
 require File.join(File.dirname(__FILE__), 'output/field_filter')
-

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

@@ -1,16 +1,11 @@
 require File.join(File.dirname(__FILE__), 'wrapper_formatter')
-require 'hammer_cli/output/utils'
 
 module HammerCLI::Output::Adapter
-
   class Table < Abstract
-
-    MAX_COLUMN_WIDTH = 80
-    MIN_COLUMN_WIDTH = 5
-
-    HLINE = '-'
-    LINE_SEPARATOR = '-|-'
-    COLUMN_SEPARATOR = ' | '
+    def initialize(context = {}, formatters = {}, filters = {})
+      super
+      @printed = 0
+    end
 
     def features
       return %i[rich_text serialized inline] if tags.empty?
@@ -22,46 +17,42 @@ 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,
                                                         compact_only: true)
                                         .filtered_fields
       formatted_collection = format_values(fields, collection)
-      # calculate hash of column widths (label -> width)
-      widths = calculate_widths(fields, formatted_collection)
-
-      header_bits = []
-      hline_bits = []
-      fields.map do |f|
-        header_bits << normalize_column(widths[f.label], f.label.upcase)
-        hline_bits << HLINE * widths[f.label]
-      end
 
-      line = hline_bits.join(LINE_SEPARATOR)
-      unless @context[:no_headers]
-        output_stream.puts line
-        output_stream.puts header_bits.join(COLUMN_SEPARATOR)
-        output_stream.puts line
+      columns = fields.each_with_object({}) do |field, result|
+        result[field.label] = field.parameters
       end
 
-      formatted_collection.collect do |row|
-        row_bits = fields.map do |f|
-          normalize_column(widths[f.label], row[f.label] || "")
-        end
-        output_stream.puts row_bits.join(COLUMN_SEPARATOR)
-      end
+      table_gen = HammerCLI::Output::Generators::Table.new(
+        columns, formatted_collection, no_headers: @context[:no_headers]
+      )
 
-      # print closing line only when the table isn't empty
-      # and there is no --no-headers option
-      output_stream.puts line unless formatted_collection.empty? || @context[:no_headers]
+      meta = collection.respond_to?(:meta) ? collection.meta : nil
 
-      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}
+      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
 
@@ -71,55 +62,14 @@ module HammerCLI::Output::Adapter
       super << Fields::ContainerField
     end
 
-    def normalize_column(width, value)
-      value = value.to_s
-      padding = width - HammerCLI::Output::Utils.real_length(value)
-      if padding >= 0
-        value += (" " * padding)
-      else
-        value, real_length = HammerCLI::Output::Utils.real_truncate(value, width-3)
-        value += '...'
-        value += ' ' if real_length < (width - 3)
-      end
-      value
-    end
-
     def format_values(fields, collection)
       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
-
-    def calculate_widths(fields, collection)
-      Hash[fields.map { |f| [f.label, calculate_column_width(f, collection)] }]
-    end
-
-    def calculate_column_width(field, collection)
-      if field.parameters[:width]
-        return [field.parameters[:width], MIN_COLUMN_WIDTH].max
-      end
-
-      width = HammerCLI::Output::Utils.real_length(field.label.to_s)
-      max_width = max_width_for(field)
-      collection.each do |item|
-        width = [HammerCLI::Output::Utils.real_length(item[field.label]), width].max
-        return max_width if width >= max_width
-      end
-      width
-    end
-
-    private
-
-    def max_width_for(field)
-      if field.parameters[:max_width]
-        [field.parameters[:max_width], MAX_COLUMN_WIDTH].min
-      else
-        MAX_COLUMN_WIDTH
-      end
-    end
   end
 
   HammerCLI::Output::Output.register_adapter(:table, Table)