hammer_cli 0.0.18 → 0.1.0

data/lib/hammer_cli/apipie/command.rb

@@ -28,7 +28,7 @@ module HammerCLI::Apipie
     end
 
     def self.desc(desc=nil)
-      super(desc) || resource.docs_for(action)["apis"][0]["short_description"]
+      super(desc) || resource.action(action).apidoc[:apis][0][:short_description] || " "
     rescue
       " "
     end
@@ -65,9 +65,9 @@ module HammerCLI::Apipie
     private
 
     def self.setup_identifier_options
-      identifier_option(:id, "resource id", declared_identifiers[:id]) if identifier? :id
-      identifier_option(:name, "resource name", declared_identifiers[:name]) if identifier? :name
-      identifier_option(:label, "resource label", declared_identifiers[:label]) if identifier? :label
+      identifier_option(:id, _("resource id"), declared_identifiers[:id]) if identifier? :id
+      identifier_option(:name, _("resource name"), declared_identifiers[:name]) if identifier? :name
+      identifier_option(:label, _("resource label"), declared_identifiers[:label]) if identifier? :label
     end
 
     def self.identifier_option(name, desc, attr_name)
@@ -83,10 +83,16 @@ module HammerCLI::Apipie
     end
 
     def name_to_id(name, option_name, resource)
-      results = resource.call(:index, :search => "#{option_name} = #{name}")[0]
+      results = resource.call(:index, :search => "#{option_name} = #{name}")
       results = HammerCLIForeman.collection_to_common_format(results)
-      raise "#{resource.name} with #{option_name} '#{name}' not found" if results.empty?
-      raise "#{resource.name} with #{option_name} '#{name}' found more than once" if results.count > 1
+
+      msg_opts = {
+        :resource => resource.name,
+        :option => option_name,
+        :value => name
+      }
+      raise _("%{resource} with %{option} '%{value}' not found") % msg_opts if results.empty?
+      raise _("%{resource} with %{option} '%{value}' found more than once") % msg_opts if results.count > 1
       results[0]['id']
     end
 

data/lib/hammer_cli/apipie/options.rb

@@ -7,20 +7,20 @@ module HammerCLI::Apipie
     end
 
     def all_method_options
-      method_options_for_params(resource.docs_for(action)["params"], true)
+      method_options_for_params(resource.action(action).params, true)
     end
 
     def method_options
-      method_options_for_params(resource.docs_for(action)["params"], false)
+      method_options_for_params(resource.action(action).params, false)
     end
 
     def method_options_for_params(params, include_nil=true)
       opts = {}
       params.each do |p|
-        if p["expected_type"] == "hash"
-          opts[p["name"]] = method_options_for_params(p["params"], include_nil)
+        if p.expected_type == :hash
+          opts[p.name] = method_options_for_params(p.params, include_nil)
         else
-          opts[p["name"]] = get_option_value(p["name"])
+          opts[p.name] = get_option_value(p.name)
         end
       end
       opts.reject! {|key, value| value.nil? } unless include_nil
@@ -44,7 +44,7 @@ module HammerCLI::Apipie
           filter = Array(filter)
           filter += declared_identifiers.keys
 
-          options_for_params(resource.docs_for(action)["params"], filter)
+          options_for_params(resource.action(action).params, filter)
         end
       end
 
@@ -52,9 +52,9 @@ module HammerCLI::Apipie
 
       def options_for_params(params, filter)
         params.each do |p|
-          next if filter.include? p["name"].to_s or filter.include? p["name"].to_sym
-          if p["expected_type"] == "hash"
-            options_for_params(p["params"], filter)
+          next if filter.include?(p.name) || filter.include?(p.name.to_sym)
+          if p.expected_type == :hash
+            options_for_params(p.params, filter)
           else
             create_option p
           end
@@ -71,25 +71,23 @@ module HammerCLI::Apipie
       end
 
       def option_switches(param)
-        '--' + param["name"].gsub('_', '-')
+        '--' + param.name.gsub('_', '-')
       end
 
       def option_type(param)
-        param["name"].upcase.gsub('-', '_')
+        param.name.upcase.gsub('-', '_')
       end
 
       def option_desc(param)
-        desc = param["description"].gsub(/<\/?[^>]+?>/, "")
-        return " " if desc.empty?
-        return desc
+        param.description || " "
       end
 
       def option_opts(param)
         opts = {}
-        opts[:required] = true if param["required"]
+        opts[:required] = true if param.required?
         # FIXME: There is a bug in apipie, it does not produce correct expected type for Arrays
         # When it's fixed, we should test param["expected_type"] == "array"
-        opts[:format] = HammerCLI::Options::Normalizers::List.new if param["validator"].include? "Array"
+        opts[:format] = HammerCLI::Options::Normalizers::List.new if param.validator.include? "Array"
         return opts
       end
 

data/lib/hammer_cli/apipie/read_command.rb

@@ -14,7 +14,12 @@ module HammerCLI::Apipie
       protected
       def retrieve_data
         raise "resource or action not defined" unless self.class.resource_defined?
-        resource.call(action, request_params, request_headers)[0]
+        logger.debug request_params.ai
+        if resource && resource.has_action?(action)
+          resource.call(action, request_params, request_headers)
+        else
+          raise HammerCLI::OperationNotSupportedError, "The server does not support such operation."
+        end
       end
 
       def print_data(records)

data/lib/hammer_cli/apipie/resource.rb

@@ -1,64 +1,36 @@
+require 'apipie_bindings'
 module HammerCLI::Apipie
 
-  class ResourceDefinition
+  class AbstractCredentials
 
-    attr_reader :resource_class
-
-    def initialize(resource_class)
-      @resource_class = resource_class
-    end
-
-    def name
-      resource_class.name.split("::")[-1].downcase
+    def to_params
+      {}
     end
 
-    def plural_name
-      irregular_names = {
-        "statistics" => "statistics",
-        "home" => "home",
-        "host_class" => "host_classes",
-        "medium" => "media",
-        "puppetclass" => "puppetclasses",
-        "dashboard" => "dashboard",
-        "smart_proxy" => "smart_proxies",
-        "settings" => "settings",
-        "hostgroup_class" => "hostgroup_classes"
-      }
-      irregular_names[name] || "%ss" % name
-    end
+    private
 
-    def docs_for(method_name)
-      resource_class.doc["methods"].each do |method|
-        return method if method["name"] == method_name.to_s
+    def ask_user(prompt, silent=false)
+      if silent
+        ask(prompt) {|q| q.echo = false}
+      else
+        ask(prompt)
       end
-      raise "No method documentation found for #{resource_class}##{method_name}"
     end
 
   end
 
 
-  class ResourceInstance < ResourceDefinition
+  class ApipieConnector < HammerCLI::AbstractConnector
 
-    def initialize(resource_class, config)
-      super(resource_class)
-      @instance = resource_class.new(config)
-    end
+    attr_reader :api
 
-    def self.from_definition(definition, config)
-      self.new(definition.resource_class, config)
-    end
+    def initialize(params)
+      credentials = params.delete(:credentials)
+      params.merge!(credentials.to_params) if credentials
 
-    def call(method_name, params=nil, headers=nil)
-      Logging.logger[resource_class.name].debug "Calling '#{method_name}' with params #{params.ai}" if HammerCLI::Settings.get(:log_api_calls)
-      result = instance.send(method_name, params, headers)
-      Logging.logger[resource_class.name].debug "Method '#{method_name}' responded with #{result[0].ai}" if HammerCLI::Settings.get(:log_api_calls)
-      result
+      @api = ApipieBindings::API.new(params)
     end
 
-    private
-
-    attr_reader :instance
-
   end
 
 
@@ -69,13 +41,7 @@ module HammerCLI::Apipie
     end
 
     def resource
-      # if the resource definition is not available in this command's class
-      # or its superclass try to look it up in parent command's class
-      if self.class.resource
-        return ResourceInstance.from_definition(self.class.resource, resource_config)
-      else
-        return ResourceInstance.from_definition(self.parent_command.class.resource, resource_config)
-      end
+      self.class.resource || self.parent_command.class.resource
     end
 
     def action
@@ -83,15 +49,29 @@ module HammerCLI::Apipie
     end
 
     def resource_config
-      config = {}
-      config[:base_url] = HammerCLI::Settings.get(:foreman, :host)
-      config[:username] = username
-      config[:password] = password
-      config
+      self.class.resource_config
+    end
+
+    def connection_options
+      self.class.connection_options
     end
 
     module ClassMethods
 
+      def resource_config
+        {}
+      end
+
+      def connection_options
+        {
+          :connector => HammerCLI::Apipie::ApipieConnector
+        }
+      end
+
+      def connection_name(resource_class)
+        :apipie
+      end
+
       def class_resource
         return @api_resource if @api_resource
         return superclass.class_resource if superclass.respond_to? :class_resource
@@ -106,8 +86,18 @@ module HammerCLI::Apipie
         end
       end
 
-      def resource(resource_class=nil, action=nil)
-        @api_resource = ResourceDefinition.new(resource_class) unless resource_class.nil?
+      def resource(resource=nil, action=nil)
+        unless resource.nil?
+          api = HammerCLI::Connection.create(
+            connection_name(resource),
+            resource_config,
+            connection_options).api
+          if api.has_resource?(resource)
+            @api_resource = api.resource(resource)
+          else
+            logger.warn "Resource '#{resource}' does not exist in the API"
+          end
+        end
         @api_action = action unless action.nil?
 
         # if the resource definition is not available in this class

data/lib/hammer_cli/apipie/write_command.rb

@@ -27,7 +27,11 @@ module HammerCLI::Apipie
     end
 
     def send_request
-      resource.call(action, request_params, request_headers)[0]
+      if resource && resource.has_action?(action)
+        resource.call(action, request_params, request_headers)
+      else
+        raise HammerCLI::OperationNotSupportedError, "The server does not support such operation."
+      end
     end
 
     def request_headers

data/lib/hammer_cli/completer.rb

@@ -1,30 +1,77 @@
 require 'enumerator'
 
+
 module HammerCLI
 
+  # Single "word" on a command line to complete.
+  # It contains trailing spaces to recognize whether the word is complete or not.
+  # --param[ ]* or -flag[ ]* or ['"]?word['"]?[ ]*
+  class CompleterWord < String
+
+    def initialize(str)
+      @original = str
+      if quoted?
+        str = str.gsub(/^['"]/, '').gsub(/['"]\s*$/, '')
+      else
+        str = str.strip
+      end
+      super(str)
+    end
+
+    def quoted?
+      quote != ""
+    end
+
+    def quote
+      @original.gsub(/^(['"]?)(.*)$/, '\1')
+    end
+
+    def complete?
+      if quoted?
+        @original.strip.gsub(/^['"].*['"][\s]*$/, '') == ""
+      else
+        @original[-1,1] == " "
+      end
+    end
+
+  end
+
+
+  # Array of command line words for completion.
+  # Splits string line to "words" with trailing spaces.
+  # --param[=]?[ ]* or -flag[ ]* or ['"]word['"]?[ ]*
   class CompleterLine < Array
 
     def initialize(line)
       @line = line
-      super(line.split)
+      super(split_line)
+    end
+
+    def complete?
+      self.empty? || self.last.complete?
     end
 
-    def finished?
-      (@line[-1,1] == " ") || @line.empty?
+    protected
+
+    def split_line
+      @line.scan(/-[\w\-]+=?[\s]*|["][^"]*["]?[\s]*|['][^']*[']?[\s]*|[^\s]+[\s]*/).collect do |word|
+        CompleterWord.new(word.gsub(/=$/, ' '))
+      end
     end
 
   end
 
+
   class Completer
 
     def initialize(cmd_class)
       @command = cmd_class
     end
 
-
     def complete(line)
       line = CompleterLine.new(line)
 
+      # get the last command on the line
       cmd, remaining = find_last_cmd(line)
 
       opt, value = option_to_complete(cmd, remaining)
@@ -33,7 +80,7 @@ module HammerCLI
       else
         param, value = param_to_complete(cmd, remaining)
         if param
-          if remaining.finished?
+          if remaining.complete?
             return complete_attribute(param, value) + complete_command(cmd, remaining)
           else
             return complete_attribute(param, value)
@@ -50,12 +97,25 @@ module HammerCLI
 
     def complete_attribute(attribute, value)
       if attribute.respond_to?(:complete)
-        filter(attribute.complete(value), value)
+        if value != nil and value.quoted?
+          filter(attribute.complete(value), value).map do |completion|
+            quote_value(completion, value.quote)
+          end
+        else
+          filter(attribute.complete(value), value)
+        end
       else
         []
       end
     end
 
+    def quote_value(val, quotes)
+      if val[-1,1] == ' '
+        quotes + val.strip + quotes + ' '
+      else
+        quotes + val
+      end
+    end
 
     def param_to_complete(cmd, line)
       params = cmd.parameters.select do |p|
@@ -73,7 +133,7 @@ module HammerCLI
 
       param = nil
 
-      if line.finished?
+      if line.complete?
         # "--option " or "--option xx " or "xx "
         value = nil
         param_index = param_candidates.size
@@ -94,33 +154,35 @@ module HammerCLI
       return [param, value]
     end
 
-
     def option_to_complete(cmd, line)
       return [nil, nil] if line.empty?
 
-      if line.finished?
+      if line.complete?
         # last word must be option and can't be flag -> we complete the value
-        # "--option " nebo "--option xx "
-        opt = cmd.find_option(line[-1])
+        # "--option " or "--option xx "
+        opt = find_option(cmd, 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])
+        opt = find_option(cmd, line[-2])
         return [opt, line[-1]] if opt and not opt.flag?
       end
       return [nil, nil]
     end
 
+    def find_option(cmd, switch)
+      cmd.find_option(switch) unless switch.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
+      # if the last word is not complete we have to select it's parent
       # -> shorten the line
       words = line.dup
-      words.pop unless line.finished?
+      words.pop unless line.complete?
 
       cmd_idx = 0
       words.each_with_index do |word, idx|
@@ -139,21 +201,19 @@ module HammerCLI
       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?
+      if remaining.complete?
         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 }
@@ -162,12 +222,10 @@ module HammerCLI
       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|
@@ -177,12 +235,10 @@ module HammerCLI
       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