hammer_cli 0.0.9 → 0.0.10

data/doc/development_tips.md

@@ -0,0 +1,30 @@
+Development Tips
+----------------
+
+### Local gem modifications
+If you want to modify gems setup for development needs, create a file `Gemfile.local` in the root of your hammer-cli checkout. You can override the setup from `Gemfile` there. This file is git-ignored so you can easily keep your custom tuning.
+
+Typical usage is for linking plugins from local checkouts:
+```ruby
+gem 'hammer_cli_foreman', :path => '../hammer-cli-foreman'
+```
+
+### Debugging with Pry
+[Pry](https://github.com/pry/pry) is a runtime developer console for ruby.
+It allows for debugging when [Pry Debugger](https://github.com/nixme/pry-debugger) is installed alongside.
+
+For basic usage, add following lines to your `Gemfile.local`:
+
+```ruby
+gem 'pry'
+gem 'pry-debugger', :platforms => [:ruby_19]
+```
+
+Then add this line at the place where you want the script to break:
+
+```ruby
+require 'pry'; binding.pry
+```
+
+Pry Debugger supports all expected debugging features.
+See [its documentation](https://github.com/nixme/pry-debugger#pry-debugger-) for details.

data/doc/writing_a_plugin.md

@@ -0,0 +1,90 @@
+Writing your own Hammer plugin
+------------------------------
+
+In this tutorial we will create a simple hello world plugin.
+
+Hammer plugins are nothing but gems. Details on how to build a gem can be found for example at [rubygems.org](http://guides.rubygems.org/make-your-own-gem/).
+In the first part of this tutorial we will briefly guide you through the process of creating a very simple gem. First of all you will need rubygems package installed on your system.
+
+Create the basic gem structure in a project subdirectory of your choice:
+```
+$ cd ./my_first_hammer_plugin/
+$ touch Gemfile
+$ touch hammer_cli_hello.gemspec
+$ mkdir -p lib/hammer_cli_hello
+$ touch lib/hammer_cli_hello.rb
+$ touch lib/hammer_cli_hello/version.rb
+```
+
+Example `Gemfile`:
+```ruby
+source "https://rubygems.org"
+
+gemspec
+```
+
+Example `hammer_cli_hello.gemspec` file:
+```ruby
+$:.unshift File.expand_path("../lib", __FILE__)
+require "hammer_cli_hello/version"
+
+Gem::Specification.new do |s|
+
+  s.name = "hammer_cli_hello"
+  s.authors = ["Me"]
+  s.version = HammerCLIHello.version.dup
+  s.platform = Gem::Platform::RUBY
+  s.summary = %q{Hello world commands for Hammer}
+
+  s.files = Dir['lib/**/*.rb']
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'hammer_cli', '>= 0.0.6'
+end
+```
+More details about the gemspec structure is again at [rubygems.org](http://guides.rubygems.org/specification-reference/).
+
+We'll have to specify the plugins version in `lib/hammer_cli_hello/version.rb`:
+```ruby
+module HammerCLIHello
+  def self.version
+    @version ||= Gem::Version.new '0.0.1'
+  end
+end
+```
+
+This should be enough for creating a minimalist gem. Let's build and install it.
+```
+$ gem build ./hammer_cli_hello.gemspec
+$ gem install hammer_cli_hello-0.0.1.gem
+```
+
+Update the hammer config to enable your plugin.
+```yaml
+:modules:
+  - hammer_cli_hello
+# - hammer_cli_foreman
+# - hammer_cli_katello_bridge
+```
+
+
+Verify the installation by running:
+```
+$ hammer -v > /dev/null
+```
+
+You should see a message saying that your module was loaded (second line in the sample output).
+```
+[ INFO 2013-10-16 11:19:06 Init] Configuration from the file /etc/foreman/cli_config.yml has been loaded
+[ INFO 2013-10-16 11:19:06 Init] Extension module hammer_cli_hello loaded
+[ INFO 2013-10-16 11:19:06 HammerCLI::MainCommand] Called with options: {"verbose"=>true}
+```
+
+Done. Your first hammer plugin is installed. Unfortunatelly it does not contain any commands yet. So let's start adding some to finally enjoy real results.
+
+Optionally you can add a Rakefile and build and install the gem with `rake install`
+```ruby
+# ./Rakefile
+require 'bundler/gem_tasks'
+```
+

data/lib/hammer_cli/abstract.rb

@@ -53,7 +53,7 @@ module HammerCLI
     end
 
     def exception_handler
-      @exception_handler ||= exception_handler_class.new(:context=>context, :adapter=>adapter)
+      @exception_handler ||= exception_handler_class.new(:output => output)
     end
 
     def initialize(*args)
@@ -66,16 +66,21 @@ module HammerCLI
       context[:path][-2]
     end
 
-    def self.subcommand!(name, description, subcommand_class = self, &block)
+    def self.remove_subcommand(name)
       self.recognised_subcommands.delete_if do |sc|
         if sc.is_called?(name)
-          Logging.logger[self].info "subcommand #{name} (#{sc.subcommand_class}) replaced with #{name} (#{subcommand_class})"
+          logger.info "subcommand #{name} (#{sc.subcommand_class}) was removed."
           true
         else
           false
         end
       end
+    end
+
+    def self.subcommand!(name, description, subcommand_class = self, &block)
+      remove_subcommand(name)
       self.subcommand(name, description, subcommand_class, &block)
+      logger.info "subcommand #{name} (#{subcommand_class}) was created."
     end
 
     def self.subcommand(name, description, subcommand_class = self, &block)
@@ -89,37 +94,52 @@ module HammerCLI
     def self.output(definition=nil, &block)
       dsl = HammerCLI::Output::Dsl.new
       dsl.build &block if block_given?
-
       output_definition.append definition.fields unless definition.nil?
       output_definition.append dsl.fields
     end
 
+    def output
+      @output ||= HammerCLI::Output::Output.new(context, :default_adapter => adapter)
+    end
+
     def output_definition
       self.class.output_definition
     end
 
+    def self.inherited_output_definition
+      od = nil
+      if superclass.respond_to? :output_definition
+        od_super = superclass.output_definition
+        od = od_super.dup unless od_super.nil?
+      end
+      od
+    end
+
     def self.output_definition
-      @output_definition ||= HammerCLI::Output::Definition.new
+      @output_definition = @output_definition || inherited_output_definition || HammerCLI::Output::Definition.new
       @output_definition
     end
 
     protected
 
     def print_records(definition, records)
-      HammerCLI::Output::Output.print_records(definition, records, context,
-        :adapter => adapter)
+      output.print_records(definition, records)
     end
 
-    def print_message(msg)
-      HammerCLI::Output::Output.print_message(msg, context, :adapter=>adapter)
+    def print_message(msg, msg_params={})
+      output.print_message(msg, msg_params)
     end
 
-    def logger(name=self.class)
+    def self.logger(name=self)
       logger = Logging.logger[name]
       logger.extend(HammerCLI::Logger::Watch) if not logger.respond_to? :watch
       logger
     end
 
+    def logger(name=self.class)
+      self.class.logger(name)
+    end
+
     def validator
       options = self.class.recognised_options.collect{|opt| opt.of(self)}
       @validator ||= HammerCLI::Validator.new(options)
@@ -147,7 +167,7 @@ module HammerCLI
 
     def self.command_name(name=nil)
       @name = name if name
-      @name
+      @name || (superclass.respond_to?(:command_name) ? superclass.command_name : nil)
     end
 
     def self.autoload_subcommands

data/lib/hammer_cli/apipie/resource.rb

@@ -52,7 +52,7 @@ module HammerCLI::Apipie
 
     def resource
       # if the resource definition is not available in this command's class
-      # try to look it up in parent 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
@@ -74,13 +74,12 @@ module HammerCLI::Apipie
 
     module ClassMethods
 
-      def resource(resource_class=nil, action=nil)
-        @api_resource = ResourceDefinition.new(resource_class) unless resource_class.nil?
-        @api_action = action unless action.nil?
+      def class_resource
         return @api_resource if @api_resource
+        return superclass.class_resource if superclass.respond_to? :class_resource
+      end
 
-        # if the resource definition is not available in this class
-        # try to look it up in it's enclosing module/class
+      def module_resource
         enclosing_module = self.name.split("::")[0..-2].inject(Object) { |mod, cls| mod.const_get cls }
 
         if enclosing_module.respond_to? :resource
@@ -88,6 +87,15 @@ module HammerCLI::Apipie
         end
       end
 
+      def resource(resource_class=nil, action=nil)
+        @api_resource = ResourceDefinition.new(resource_class) unless resource_class.nil?
+        @api_action = action unless action.nil?
+
+        # if the resource definition is not available in this class
+        # try to look it up in it's enclosing module/class
+        return class_resource || module_resource
+      end
+
       def action(action=nil)
         @api_action = action unless action.nil?
         return @api_action if @api_action

data/lib/hammer_cli/apipie/write_command.rb

@@ -7,16 +7,25 @@ module HammerCLI::Apipie
     include HammerCLI::Messages
 
     def execute
-      send_request
-      print_success_message 
+      response = send_request
+      logger.watch "Retrieved data: ", response
+      print_success_message(response)
       return HammerCLI::EX_OK
     end
 
     protected
 
-    def print_success_message
-      msg = success_message
-      print_message(msg) unless msg.nil?
+    def success_message_params(response)
+      response
+    end
+
+    def print_success_message(response)
+      if success_message
+        print_message(
+          success_message,
+          success_message_params(response)
+        )
+      end
     end
 
     def send_request

data/lib/hammer_cli/exception_handler.rb

@@ -6,8 +6,7 @@ module HammerCLI
 
     def initialize(options={})
       @logger = Logging.logger['Exception']
-      @context = options[:context] || {}
-      @adapter = options[:adapter] || :base
+      @output = options[:output]
     end
 
     def mappings
@@ -25,6 +24,10 @@ module HammerCLI
       raise e
     end
 
+    def output
+      @output || HammerCLI::Output::Output.new
+    end
+
     protected
 
     def print_error(error)
@@ -32,9 +35,9 @@ module HammerCLI
       @logger.error error
 
       if @options[:heading]
-        HammerCLI::Output::Output.print_error @options[:heading], error, @context, :adapter => @adapter
+        output.print_error(@options[:heading], error)
       else
-        HammerCLI::Output::Output.print_error error, nil, @context, :adapter => @adapter
+        output.print_error(error)
       end
     end
 

data/lib/hammer_cli/options/normalizers.rb

@@ -53,6 +53,7 @@ module HammerCLI
         end
 
         def format(bool)
+          bool = bool.to_s
           if bool.downcase.match(/^(true|t|yes|y|1)$/i)
             return true
           elsif bool.downcase.match(/^(false|f|no|n|0)$/i)
@@ -71,6 +72,32 @@ module HammerCLI
         end
       end
 
+
+      class Enum < AbstractNormalizer
+
+        def initialize(allowed_values)
+          @allowed_values = allowed_values
+        end
+
+        def description
+          "One of %s" % quoted_values
+        end
+
+        def format(value)
+          if @allowed_values.include? value
+            value
+          else
+            raise ArgumentError, "value must be one of '%s'" % quoted_values
+          end
+        end
+
+        private
+
+        def quoted_values
+          @allowed_values.map { |v| "'#{v}'" }.join(', ')
+        end
+      end
+
     end
   end
 end

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

@@ -11,27 +11,27 @@ module HammerCLI::Output::Adapter
       @formatters = HammerCLI::Output::Formatters::FormatterLibrary.new(filter_formatters(formatters))
     end
 
-    def print_message(msg)
-      puts msg
+    def print_message(msg, msg_params={})
+      puts msg.format(msg_params)
     end
 
-    def print_error(msg, details=nil)
+    def print_error(msg, details=nil, msg_params={})
       details = details.split("\n") if details.kind_of? String
 
       if details
         indent = "  "
-        $stderr.puts msg+":"
-        $stderr.puts indent + details.join("\n"+indent)
-      else
-        $stderr.puts msg
+        msg += ":\n"
+        msg += indent + details.join("\n"+indent)
       end
+
+      $stderr.puts msg.format(msg_params)
     end
 
     def print_records(fields, data)
       raise NotImplementedError
     end
 
-    private 
+    private
 
     def filter_formatters(formatters_map)
       formatters_map ||= {}

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

@@ -17,14 +17,12 @@ module HammerCLI::Output::Adapter
     end
 
     def print_records(fields, data)
-      csv_string = CSV.generate(
-          :col_sep => @context[:csv_separator] || ',', 
-          :encoding => 'utf-8') do |csv|
+      csv_string = generate do |csv|
         # labels
         csv << fields.select{ |f| !(f.class <= Fields::Id) || @context[:show_ids] }.map { |f| f.label }
         # data
         data.each do |d|
-          csv << fields.inject([]) do |row, f| 
+          csv << fields.inject([]) do |row, f|
             unless f.class <= Fields::Id && !@context[:show_ids]
               value = (f.get_value(d) || '')
               formatter = @formatters.formatter_for_type(f.class)
@@ -36,6 +34,41 @@ module HammerCLI::Output::Adapter
       end
       puts csv_string
     end
+
+    def print_message(msg, msg_params={})
+      csv_string = generate do |csv|
+        id = msg_params["id"] || msg_params[:id]
+        name = msg_params["name"] || msg_params[:name]
+
+        labels = ["Message"]
+        data = [msg.format(msg_params)]
+
+        if id
+          labels << "Id"
+          data << id
+        end
+
+        if name
+          labels << "Name"
+          data << name
+        end
+
+        csv << labels
+        csv << data
+      end
+      puts csv_string
+    end
+
+    private
+
+    def generate(&block)
+      CSV.generate(
+        :col_sep => @context[:csv_separator] || ',',
+        :encoding => 'utf-8',
+        &block
+      )
+    end
+
   end
 
   HammerCLI::Output::Output.register_adapter(:csv, CSValues)

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

@@ -3,10 +3,10 @@ module HammerCLI::Output::Adapter
 
   class Silent < Abstract
 
-    def print_message(msg)
+    def print_message(msg, msg_params={})
     end
 
-    def print_error(msg, details=[])
+    def print_error(msg, details=[], msg_params={})
     end
 
     def print_records(fields, data)

data/lib/hammer_cli/output/dsl.rb

@@ -18,7 +18,9 @@ module HammerCLI::Output
     protected
 
     def field(key, label, type=nil, options={}, &block)
-      options[:path] = current_path.clone << key
+      options[:path] = current_path.clone
+      options[:path] << key if !key.nil?
+
       options[:label] = label
       type ||= Fields::DataField
       custom_field type, options, &block

data/lib/hammer_cli/output/output.rb

@@ -1,30 +1,33 @@
 module HammerCLI::Output
   class Output
 
-    def self.print_message(msg, context, options={})
-      adapter(options[:adapter], context).print_message(msg.to_s)
+    def initialize(context={}, options={})
+      self.context = context
+      self.default_adapter = options[:default_adapter]
     end
 
-    def self.print_error(msg, details=nil, context={}, options={})
-      adapter(options[:adapter], context).print_error(msg.to_s, details)
+    attr_accessor :default_adapter
+
+    def print_message(msg, msg_params={})
+      adapter.print_message(msg.to_s, msg_params)
     end
 
-    def self.print_records(definition, records, context, options={})
-      adapter(options[:adapter], context).print_records(definition.fields, [records].flatten(1))
+    def print_error(msg, details=nil, msg_params={})
+      adapter.print_error(msg.to_s, details, msg_params)
     end
 
-    def self.adapter(req_adapter, context)
-      if context[:adapter]
-        adapter_name = context[:adapter].to_sym
-      else
-        adapter_name = req_adapter
-      end
+    def print_records(definition, records)
+      adapter.print_records(definition.fields, [records].flatten(1))
+    end
+
+    def adapter
+      adapter_name = context[:adapter] || default_adapter
 
       begin
-        init_adapter(adapter_name, context)
+        init_adapter(adapter_name.to_sym)
       rescue NameError
-        Logging.logger[self.name].warn("Required adapter '#{adapter_name}' was not found, using 'base' instead")
-        init_adapter(:base, context)
+        Logging.logger[self.class.name].warn("Required adapter '#{adapter_name}' was not found, using 'base' instead")
+        init_adapter(:base)
       end
     end
 
@@ -51,10 +54,12 @@ module HammerCLI::Output
     end
 
     private
-    
-    def self.init_adapter(adapter_name, context)
-      raise NameError unless adapters.has_key? adapter_name
-      adapters[adapter_name].new(context, formatters)
+
+    attr_accessor :context
+
+    def init_adapter(adapter_name)
+      raise NameError unless self.class.adapters.has_key? adapter_name
+      self.class.adapters[adapter_name].new(context, self.class.formatters)
     end
 
   end

data/lib/hammer_cli/utils.rb

@@ -0,0 +1,18 @@
+
+class String
+
+  # string formatting for ruby 1.8
+  def format(params)
+    if params.is_a? Hash
+      array_params = self.scan(/%[<{]([^>}]*)[>}]/).collect do |name|
+        name = name[0]
+        params[name.to_s] || params[name.to_sym]
+      end
+
+      self.gsub(/%[<{]([^>}]*)[>}]/, '%') % array_params
+    else
+      self % params
+    end
+  end
+
+end

data/lib/hammer_cli/version.rb

@@ -1,5 +1,5 @@
 module HammerCLI
   def self.version
-    @version ||= Gem::Version.new '0.0.9'
+    @version ||= Gem::Version.new '0.0.10'
   end
 end

data/lib/hammer_cli.rb

@@ -1,3 +1,4 @@
+require 'hammer_cli/utils'
 require 'hammer_cli/version'
 require 'hammer_cli/exit_codes'
 require 'hammer_cli/settings'