hammer_cli 0.19.0 → 2.1.1

data/lib/hammer_cli/apipie/command.rb

@@ -65,8 +65,8 @@ module HammerCLI::Apipie
       method_options(options)
     end
 
-    def print_data(data)
-      print_collection(output_definition, data) unless output_definition.empty?
+    def print_data(data, options = {})
+      print_collection(output_definition, data, options) unless output_definition.empty?
       print_success_message(data) unless success_message.nil?
     end
 
@@ -86,6 +86,7 @@ module HammerCLI::Apipie
         declared_options << option
         block ||= option.default_conversion_block
         define_accessors_for(option, &block)
+        completion_type_for(option, opts)
       end
       extend_options_help(option) if option.value_formatter.is_a?(HammerCLI::Options::Normalizers::ListNested)
       option

data/lib/hammer_cli/apipie/option_builder.rb

@@ -41,12 +41,11 @@ module HammerCLI::Apipie
     end
 
     def create_option(param, resource_name_map)
-      option(
-        option_switch(param, resource_name_map),
-        option_type(param, resource_name_map),
-        option_desc(param),
-        option_opts(param)
-      )
+      family = HammerCLI::Options::OptionFamily.new
+      family.parent(option_switch(param, resource_name_map),
+                    option_type(param, resource_name_map),
+                    option_desc(param),
+                    option_opts(param, resource_name_map))
     end
 
     def option_switch(param, resource_name_map)
@@ -61,7 +60,7 @@ module HammerCLI::Apipie
       param.description || " "
     end
 
-    def option_opts(param)
+    def option_opts(param, resource_name_map)
       opts = {}
       opts[:required] = true if (param.required? and require_options?)
       if param.expected_type.to_s == 'array'
@@ -80,19 +79,22 @@ module HammerCLI::Apipie
       end
       opts[:attribute_name] = HammerCLI.option_accessor_name(param.name)
       opts[:referenced_resource] = resource_name(param)
+      opts[:aliased_resource] = aliased_name(resource_name(param), resource_name_map)
 
       return opts
     end
 
+    def aliased_name(name, resource_name_map)
+      return if name.nil?
+
+      resource_name_map[name.to_s] || resource_name_map[name.to_sym] || name
+    end
+
     def aliased(param, resource_name_map)
       resource_name = resource_name(param)
+      return param.name if resource_name.nil?
 
-      if resource_name.nil?
-        return param.name
-      else
-        aliased_name = resource_name_map[resource_name.to_s] || resource_name_map[resource_name.to_sym] || resource_name
-        return param.name.gsub(resource_name, aliased_name.to_s)
-      end
+      param.name.gsub(resource_name, aliased_name(resource_name, resource_name_map).to_s)
     end
 
     def resource_name(param)

data/lib/hammer_cli/apipie/option_definition.rb

@@ -1,21 +1,23 @@
 require File.join(File.dirname(__FILE__), 'options')
 
 module HammerCLI::Apipie
-
   class OptionDefinition < HammerCLI::Options::OptionDefinition
-
-    attr_accessor :referenced_resource
+    attr_accessor :referenced_resource, :aliased_resource, :family
 
     def initialize(switches, type, description, options = {})
-      if options.has_key? :referenced_resource
-        self.referenced_resource = options.delete(:referenced_resource).to_s if options[:referenced_resource]
-      end
+      @referenced_resource = options[:referenced_resource].to_s if options[:referenced_resource]
+      @aliased_resource = options[:aliased_resource].to_s if options[:aliased_resource]
+      @family = options[:family]
       super
       # Apipie currently sends descriptions as escaped HTML once this is changed this should be removed.
       # See #15198 on Redmine.
       @description = CGI::unescapeHTML(description)
     end
 
-  end
+    def child?
+      return unless @family
 
+      @family.children.include?(self)
+    end
+  end
 end

data/lib/hammer_cli/bash.rb

@@ -0,0 +1,2 @@
+require 'hammer_cli/bash/prebuild_command'
+require 'hammer_cli/bash/completion'

data/lib/hammer_cli/bash/completion.rb

@@ -0,0 +1,159 @@
+require 'json'
+
+module HammerCLI
+  module Bash
+    class Completion
+      def initialize(dict)
+        @dict = dict
+      end
+
+      def complete(line)
+        @complete_line = line.end_with?(' ')
+        full_path = line.split(' ')
+        complete_path = @complete_line ? full_path : full_path[0..-2]
+        dict, path = traverse_tree(@dict, complete_path)
+
+        return [] unless path.empty? # lost during traversing
+
+        partial = @complete_line ? '' : full_path.last
+        finish_word(dict, partial)
+      end
+
+      def self.load_description(path)
+        JSON.load(File.open(path))
+      rescue Errno::ENOENT
+        {}
+      end
+
+      private
+
+      def finish_word(dict, incomplete)
+        finish_option_value(dict, incomplete) ||
+          (finish_option_or_subcommand(dict, incomplete) + finish_param(dict, incomplete))
+      end
+
+      def finish_option_or_subcommand(dict, incomplete)
+        dict.keys.select { |k| k.is_a?(String) && k =~ /^#{incomplete}/ }.map { |k| k + ' ' }
+      end
+
+      def complete_value(value_description, partial, is_param)
+        case value_description['type']
+        when 'value'
+          if !partial.empty?
+            []
+          elsif is_param
+            ['--->', 'Add parameter']
+          else
+            ['--->', 'Add option <value>']
+          end
+        when 'directory'
+          directories(partial)
+        when 'file'
+          files(partial, value_description)
+        when 'enum'
+          enum(partial, value_description['values'])
+        when 'multienum'
+          multienum(partial, value_description['values'])
+        when 'schema'
+          schema(value_description['schema'])
+        when 'list'
+          ['--->', 'Add comma-separated list of values']
+        when 'key_value_list'
+          ['--->', 'Add comma-separated list of key=value']
+        end
+      end
+
+      def finish_param(dict, incomplete)
+        if dict['params'] && !dict['params'].empty?
+          complete_value(dict['params'].first, incomplete, true)
+        else
+          []
+        end
+      end
+
+      def finish_option_value(dict, incomplete)
+        complete_value(dict, incomplete, false) if dict.key?('type')
+      end
+
+      def traverse_tree(dict, path)
+        return [dict, []] if path.nil? || path.empty?
+        result = if dict.key?(path.first)
+                   if path.first.start_with?('-')
+                     parse_option(dict, path)
+                   else
+                     parse_subcommand(dict, path)
+                   end
+                 elsif dict['params']
+                   # traverse params one by one
+                   parse_params(dict, path)
+                 else
+                   # not found
+                   [{}, path]
+                 end
+        result
+      end
+
+      def parse_params(dict, path)
+        traverse_tree({ 'params' => dict['params'][1..-1] }, path[1..-1])
+      end
+
+      def parse_subcommand(dict, path)
+        traverse_tree(dict[path.first], path[1..-1])
+      end
+
+      def parse_option(dict, path)
+        if dict[path.first]['type'] == 'flag' # flag
+          traverse_tree(dict, path[1..-1])
+        elsif path.length >= 2 # option with value
+          traverse_tree(dict, path[2..-1])
+        else # option with value missing
+          [dict[path.first], path[1..-1]]
+        end
+      end
+
+      def directories(partial = '')
+        dirs = []
+        dirs += Dir.glob("#{partial}*").select { |f| File.directory?(f) }
+        dirs = dirs.map { |d| d + '/' } if dirs.length == 1
+        dirs
+      end
+
+      def files(partial = '', opts = {})
+        filter = opts.fetch('filter', '.*')
+        file_names = []
+        file_names += Dir.glob("#{partial}*").select do |f|
+          File.directory?(f) || f =~ /#{filter}/
+        end
+        file_names.map { |f| File.directory?(f) ? f + '/' : f + ' ' }
+      end
+
+      def enum(partial = '', values = [])
+        values.select { |v| v.start_with?(partial) }.map { |v| v + ' ' }
+      end
+
+      def multienum(partial = '', values = [])
+        return values if partial.empty?
+
+        parts = partial.split(',')
+        resolved = []
+        to_complete = parts.each_with_object([]) do |part, res|
+          next resolved << part if values.include?(part)
+
+          res << part
+        end
+
+        hints = to_complete.map do |p|
+          values.select { |v| v.start_with?(p) }
+        end.flatten(1).uniq
+        return values - parts if hints.empty?
+        return [(resolved + hints).join(',')] if hints.size == 1
+
+        hints
+      end
+
+      def schema(template = '')
+        ['--->', "Add value by following schema: #{template}"]
+      end
+    end
+  end
+end

data/lib/hammer_cli/bash/prebuild_command.rb

@@ -0,0 +1,21 @@
+module HammerCLI
+  module Bash
+    class PrebuildCompletionCommand < HammerCLI::AbstractCommand
+      def execute
+        map = HammerCLI::MainCommand.completion_map
+        cache_file = HammerCLI::Settings.get(:completion_cache_file)
+        cache_dir = File.dirname(cache_file)
+        FileUtils.mkdir_p(cache_dir) unless File.directory?(cache_dir)
+        File.write(File.expand_path(cache_file), map.to_json)
+
+        HammerCLI::EX_OK
+      end
+    end
+  end
+
+  HammerCLI::MainCommand.subcommand(
+    'prebuild-bash-completion',
+    _('Prepare map of options and subcommands for Bash completion'),
+    HammerCLI::Bash::PrebuildCompletionCommand
+  )
+end

data/lib/hammer_cli/command_extensions.rb

@@ -15,7 +15,7 @@ module HammerCLI
     ALLOWED_EXTENSIONS = %i[
       option command_options before_print data output help request
       request_headers headers request_options options request_params params
-      option_sources predefined_options use_option
+      option_sources predefined_options use_option option_family
     ].freeze
 
     def initialize(options = {})
@@ -86,6 +86,11 @@ module HammerCLI
       @option_sources_block = block
     end
 
+    def self.option_family(options = {}, &block)
+      @option_family_opts = options
+      @option_family_block = block
+    end
+
     # Object
 
     def extend_options(command_class)
@@ -151,6 +156,13 @@ module HammerCLI
       self.class.extend_option_sources(sources, command)
     end
 
+    def extend_option_family(command_class)
+      allowed = @only & %i[option_family]
+      return if allowed.empty? || (allowed & @except).any?
+
+      self.class.extend_option_family(command_class)
+    end
+
     def delegatee(command_class)
       self.class.delegatee = command_class
     end
@@ -234,5 +246,13 @@ module HammerCLI
       @option_sources_block.call(sources, command)
       logger.debug("Called block for #{@delegatee} option sources:\n\t#{@option_sources_block}")
     end
+
+    def self.extend_option_family(command_class)
+      return if @option_family_block.nil?
+
+      @option_family_opts[:creator] = command_class
+      command_class.send(:option_family, @option_family_opts, &@option_family_block)
+      logger.debug("Called option family block for #{command_class}:\n\t#{@option_family_block}")
+    end
   end
 end

data/lib/hammer_cli/connection.rb

@@ -35,6 +35,10 @@ module HammerCLI
       connections[name]
     end
 
+    def available
+      connections.select { |k, v| !v.nil? }.values.first
+    end
+
     private
 
     def connections

data/lib/hammer_cli/exception_handler.rb

@@ -69,7 +69,7 @@ module HammerCLI
 
     def handle_usage_exception(e)
       print_error (_("Error: %{message}") + "\n\n" +
-                   _("See: '%{path} --help'.")) % {:message => e.message, :path => e.command.invocation_path}
+                   _("See: '%{path} --help'.")) % { message: e.message, path: HammerCLI.expand_invocation_path(e.command.invocation_path) }
       log_full_error e
       HammerCLI::EX_USAGE
     end
@@ -138,7 +138,16 @@ module HammerCLI
     end
 
     def handle_apipie_missing_arguments_error(e)
-      message = _("Missing arguments for %s") % "'#{e.params.join("', '")}'"
+      params = e.params.map do |p|
+        param = p[/\[.+\]/]
+        param = if param.nil?
+                  p.tr('_', '-')
+                else
+                  p.scan(/\[[^\[\]]+\]/).first[1...-1].tr('_', '-')
+                end
+        "--#{param}"
+      end
+      message = _("Missing arguments for %s.") % "'#{params.uniq.join("', '")}'"
       print_error message
       log_full_error e, message
       HammerCLI::EX_USAGE

data/lib/hammer_cli/full_help.rb

@@ -6,8 +6,11 @@ module HammerCLI
 
     def execute
       @adapter = option_md? ? MDAdapter.new : TxtAdapter.new
+      HammerCLI.context[:full_help] = true
+      @invocation_paths = {}
       print_heading
       print_help
+      HammerCLI.context[:full_help] = false
       HammerCLI::EX_OK
     end
 
@@ -19,9 +22,13 @@ module HammerCLI
     end
 
     def print_help(name='hammer', command=HammerCLI::MainCommand, desc='')
-      @adapter.print_command(name, desc, command.new(name).help)
+      @invocation_paths[name] ||= []
+      @adapter.print_command(name, desc, command.new(name, path: @invocation_paths[name]).help)
 
       command.recognised_subcommands.each do |sub_cmd|
+        path = "#{name} #{sub_cmd.names.first}"
+        @invocation_paths[path] ||= []
+        @invocation_paths[path] += @invocation_paths[name]
         print_help(@adapter.command_name(name, sub_cmd.names.first), sub_cmd.subcommand_class, sub_cmd.description)
       end
     end

data/lib/hammer_cli/help/builder.rb

@@ -14,7 +14,7 @@ module HammerCLI
       def add_usage(invocation_path, usage_descriptions)
         heading(Clamp.message(:usage_heading))
         usage_descriptions.each do |usage|
-          puts "    #{invocation_path} #{usage}".rstrip
+          puts "    #{HammerCLI.expand_invocation_path(invocation_path)} #{usage}".rstrip
         end
       end
 
@@ -29,12 +29,19 @@ module HammerCLI
 
         label_width = DEFAULT_LABEL_INDENT
         items.each do |item|
-          label, description = item.help
+          label = item.help.first
           label_width = label.size if label.size > label_width
         end
 
         items.each do |item|
-          label, description = item.help
+          if item.respond_to?(:child?) && item.child?
+            next unless HammerCLI.context[:full_help]
+          end
+          label, description = if !HammerCLI.context[:full_help] && item.respond_to?(:family) && item.family
+            [item.family.switch, item.family.description || item.help[1]]
+          else
+            item.help
+          end
           description.gsub(/^(.)/) { Unicode::capitalize($1) }.each_line do |line|
             puts " %-#{label_width}s %s" % [label, line]
             label = ''
@@ -54,6 +61,25 @@ module HammerCLI
         label = HighLine.color(label, :bold) if @richtext
         puts label
       end
+
+      private
+
+      def 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
   end
 end