hammer_cli 0.19.0 → 2.1.1

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

@@ -59,68 +59,23 @@ module HammerCLI::Output
     end
 
     def sets_table
-      fields_col_size = max_label_length || _('Fields').size
-      fields_col = normalize_column(fields_col_size, _('Fields'), centralize: true)
-      fields_col += ' ' unless (fields_col_size - fields_col.size).zero?
-      header_bits = [fields_col]
-      hline_bits = ['-' * fields_col_size]
-      field_sets.map do |set|
-        header_bits << normalize_column(set.size, set)
-        hline_bits << '-' * set.size
-      end
-      rows_bits = fields_row(@fields, field_sets, fields_col_size)
-      line = "+-#{hline_bits.join('-+-')}-+\n"
-      table = line
-      table += "| #{header_bits.join(' | ')} |\n"
-      table += line
-      table += "#{rows_bits.join("\n")}\n"
-      table += line
-      table
+      columns = field_sets.unshift(_('Fields'))
+      data = fields_data(@fields, columns).flatten
+      table_gen = HammerCLI::Output::Generators::Table.new(columns, data)
+      table_gen.result
     end
 
     private
 
-    def max_label_length
-      field_labels(@fields, full_labels: true).map(&:size).max
-    end
+    def fields_data(fields, sets)
+      fields.each_with_object([]) do |field, data|
+        next data << fields_data(field.fields, sets) if field.respond_to?(:fields)
 
-    def normalize_column(width, col, centralize: false)
-      padding = width - HammerCLI::Output::Utils.real_length(col)
-      if padding >= 0
-        if centralize
-          padding /= 2
-          col.prepend(' ' * padding)
+        data << sets.each_with_object({}) do |set, res|
+          mark = field.sets.include?(set) ? 'x' : ''
+          value = set == sets.first ? field.full_label : mark
+          res.update(set => value)
         end
-        col += (' ' * padding)
-      else
-        col, real_len = HammerCLI::Output::Utils.real_truncate(col, width - 3)
-        col += '...'
-        col += ' ' if real_len < (width - 3)
-      end
-      col
-    end
-
-    def fields_row(fields, sets, fields_col_size)
-      fields.each_with_object([]) do |field, rows|
-        next rows << fields_row(field.fields, sets, fields_col_size) if field.respond_to?(:fields)
-
-        row = [normalize_column(fields_col_size, field.full_label)]
-        sets.each do |set|
-          mark = field.sets.include?(set) ? 'x' : ' '
-          column = normalize_column(set.size, mark, centralize: true)
-          column += ' ' unless (set.size - column.size).zero?
-          row << column
-        end
-        rows << "| #{row.join(' | ')} |"
-      end
-    end
-
-    def field_labels(fields, full_labels: false)
-      fields.each_with_object([]) do |field, labels|
-        label = full_labels ? field.full_label : field.label
-        next labels << label unless field.respond_to?(:fields)
-
-        labels.concat(field_labels(field.fields, full_labels: full_labels))
       end
     end
 

data/lib/hammer_cli/output/generators.rb

@@ -0,0 +1 @@
+require 'hammer_cli/output/generators/table'

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

@@ -0,0 +1,121 @@
+require 'hammer_cli/output/utils'
+
+module HammerCLI
+  module Output
+    module Generators
+      class Table
+        class Column
+          attr_reader :label, :params
+
+          def initialize(label, params = nil)
+            @label = label.to_s
+            @params = params || {}
+          end
+        end
+
+        MAX_COLUMN_WIDTH = 80
+        MIN_COLUMN_WIDTH = 5
+
+        HLINE = '-'
+        LINE_SEPARATOR = '-|-'
+        COLUMN_SEPARATOR = ' | '
+
+        attr_reader :header, :body, :footer, :result
+
+        def initialize(columns, data, options = {})
+          @columns = columns.map { |label, params| Column.new(label, params) }
+          @data = data
+          @options = options
+          create_table
+        end
+
+        private
+
+        def create_header(header_bits, line)
+          result = StringIO.new
+          unless @options[:no_headers]
+            result.puts(line)
+            result.puts(header_bits.join(COLUMN_SEPARATOR))
+            result.puts(line)
+          end
+          result.string
+        end
+
+        def create_body(widths)
+          result = StringIO.new
+          @data.collect do |row|
+            row_bits = @columns.map do |col|
+              normalize_column(widths[col.label], row[col.label] || '')
+            end
+            result.puts(row_bits.join(COLUMN_SEPARATOR))
+          end
+          result.string
+        end
+
+        def create_footer(line)
+          result = StringIO.new
+          result.puts(line) unless @data.empty? || @options[:no_headers]
+          result.string
+        end
+
+        def create_result
+          result = StringIO.new
+          result.print(@header, @body, @footer)
+          result.string
+        end
+
+        def create_table
+          widths = calculate_widths(@columns, @data)
+          header_bits = []
+          hline_bits = []
+          @columns.map do |col|
+            header_bits << normalize_column(widths[col.label], col.label.upcase)
+            hline_bits << HLINE * widths[col.label]
+          end
+          line = hline_bits.join(LINE_SEPARATOR)
+          @header = create_header(header_bits, line)
+          @body = create_body(widths)
+          @footer = create_footer(line)
+          @result = create_result
+        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 calculate_widths(columns, data)
+          Hash[columns.map { |c| [c.label, calculate_column_width(c, data)] }]
+        end
+
+        def calculate_column_width(column, data)
+          if column.params[:width]
+            return [column.params[:width], MIN_COLUMN_WIDTH].max
+          end
+
+          width = HammerCLI::Output::Utils.real_length(column.label)
+          max_width = max_width_for(column)
+          data.each do |item|
+            width = [HammerCLI::Output::Utils.real_length(item[column.label]), width].max
+            return max_width if width >= max_width
+          end
+          width
+        end
+
+        def max_width_for(column)
+          return MAX_COLUMN_WIDTH unless column.params[:max_width]
+
+          column.params[:max_width]
+        end
+      end
+    end
+  end
+end

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,

data/lib/hammer_cli/testing/command_assertions.rb

@@ -71,13 +71,13 @@ module HammerCLI
         if heading.nil?
           ["Error: #{message}",
            "",
-           "See: '#{command} --help'.",
+           "See: '#{HammerCLI.expand_invocation_path(command)} --help'.",
            ""].join("\n")
         else
           ["#{heading}:",
            "  Error: #{message}",
            "  ",
-           "  See: '#{command} --help'.",
+           "  See: '#{HammerCLI.expand_invocation_path(command)} --help'.",
            ""].join("\n")
         end
       end

data/lib/hammer_cli/utils.rb

@@ -60,6 +60,11 @@ module HammerCLI
     STDOUT.tty?
   end
 
+  def self.clear_cache
+    cache_file = File.expand_path(HammerCLI::Settings.get(:completion_cache_file))
+    File.delete(cache_file) if File.exist?(cache_file)
+  end
+
   def self.interactive?
     return HammerCLI::Settings.get(:_params, :interactive) unless HammerCLI::Settings.get(:_params, :interactive).nil?
     HammerCLI::Settings.get(:ui, :interactive) != false
@@ -111,4 +116,21 @@ module HammerCLI
 
     array.insert(idx, *new_items)
   end
+
+  def self.expand_invocation_path(path)
+    bits = path.split(' ')
+    parent_command = HammerCLI::MainCommand
+    new_path = (bits[1..-1] || []).each_with_object([]) do |bit, names|
+      subcommand = parent_command.find_subcommand(bit)
+      next if subcommand.nil?
+
+      names << if subcommand.names.size > 1
+                 "<#{subcommand.names.join('|')}>"
+               else
+                 subcommand.names.first
+               end
+      parent_command = subcommand.subcommand_class
+    end
+    new_path.unshift(bits.first).join(' ')
+  end
 end

data/lib/hammer_cli/version.rb

@@ -1,5 +1,5 @@
 module HammerCLI
   def self.version
-    @version ||= Gem::Version.new "0.19.0"
+    @version ||= Gem::Version.new "2.1.1"
   end
 end

data/test/unit/abstract_test.rb

@@ -262,6 +262,27 @@ describe HammerCLI::AbstractCommand do
       end
 
     end
+
+    describe 'find_subcommand' do
+      it 'should find by full name' do
+        main_cmd.find_subcommand('some_command').wont_be_nil
+      end
+
+      it 'should find by partial name' do
+        main_cmd.find_subcommand('some_').wont_be_nil
+      end
+
+      it 'should not find by wrong name' do
+        main_cmd.find_subcommand('not_existing').must_be_nil
+      end
+
+      it 'should raise if more than one were found' do
+        main_cmd.subcommand('pong', 'description', Subcommand2)
+        proc do
+          main_cmd.find_subcommand('p')
+        end.must_raise HammerCLI::CommandConflict
+      end
+    end
   end
 
   describe "options" do
@@ -413,7 +434,7 @@ describe HammerCLI::AbstractCommand do
     class CmdName2 < CmdName1
     end
 
-    CmdName2.command_name.must_equal 'cmd'
+    CmdName2.command_name.must_equal ['cmd']
   end
 
   it "should inherit output definition" do
@@ -525,7 +546,7 @@ describe HammerCLI::AbstractCommand do
       opt = cmd.find_option('--flag')
       opt.is_a?(HammerCLI::Options::OptionDefinition).must_equal true
       cmd.output_definition.empty?.must_equal false
-      cmd.new({}).help.must_match(/.*text.*/)
+      cmd.new('', {}).help.must_match(/.*text.*/)
     end
 
     it 'should store more than one extension' do

data/test/unit/apipie/api_connection_test.rb

@@ -30,6 +30,7 @@ describe HammerCLI::Apipie::ApiConnection do
       it "logs message when logger is available" do
         logger = stub()
         logger.expects(:debug).with('Apipie cache was cleared')
+        logger.expects(:debug).with('Completion cache was cleared')
 
         api_stub.expects(:clean_cache)
         HammerCLI::Apipie::ApiConnection.new(empty_params, :reload_cache => true, :logger => logger)

data/test/unit/apipie/option_builder_test.rb

@@ -37,6 +37,14 @@ describe HammerCLI::Apipie::OptionBuilder do
     it "should set description with html tags stripped" do
       options[0].description.must_equal 'filter results'
     end
+
+    it "should build option with default family" do
+      options[0].family.wont_be_nil
+    end
+
+    it "should build parent option within default family" do
+      options[0].child?.must_equal false
+    end
   end