hammer_cli 0.0.4 → 0.0.5

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

@@ -3,11 +3,16 @@ module HammerCLI::Output::Adapter
 
   class Abstract
 
-    def print_message msg
+    def initialize(context={}, formatters=HammerCLI::Output::Formatters::FormatterLibrary.new)
+      @context = context
+      @formatters = formatters
+    end
+
+    def print_message(msg)
       puts msg
     end
 
-    def print_error msg, details=nil
+    def print_error(msg, details=nil)
       details = details.split("\n") if details.kind_of? String
 
       if details
@@ -19,7 +24,7 @@ module HammerCLI::Output::Adapter
       end
     end
 
-    def print_records fields, data, heading=nil
+    def print_records(fields, data)
       raise NotImplementedError
     end
 

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

@@ -1,17 +1,12 @@
 module HammerCLI::Output::Adapter
   class Base < Abstract
 
-    HEADING_LINE_WIDTH = 80
     GROUP_INDENT = " "*2
     LABEL_DIVIDER = ": "
 
-    def print_records fields, data, heading=nil
+    def print_records(fields, data)
       self.fields = fields
 
-      puts "-"*HEADING_LINE_WIDTH
-      puts "  " + heading.to_s
-      puts "-"*HEADING_LINE_WIDTH
-
       data.each do |d|
         fields.collect do |f|
           render_field(f, d)
@@ -52,7 +47,8 @@ module HammerCLI::Output::Adapter
       puts
       indent = indent.to_s + " "*(label_width_for_list(self.fields)+LABEL_DIVIDER.size)
 
-      field.get_value(data).each do |d|
+      data = field.get_value(data) || []
+      data.each do |d|
         field.output_definition.fields.collect do |f|
           render_field(f, d, indent)
         end
@@ -66,26 +62,14 @@ module HammerCLI::Output::Adapter
       puts field.attributes.collect{|attr| data[attr] }.join(" ")
     end
 
-    def format_Date(string_date)
-      t = DateTime.parse(string_date.to_s)
-      t.strftime("%Y/%m/%d %H:%M:%S")
-    rescue ArgumentError
-      ""
-    end
-
-    def format_List(list)
-      list.join(", ") if list
-    end
-
-    def format_OSName(os)
-      "%{name} %{major}.%{minor}" % os
-    end
-
-    def format_Server(server)
-      "%{name} (%{url})" % server
+    def find_renderer(field)
+      field.class.ancestors.each do |cls|
+        render_method = "render_"+field_type(cls)
+        return method(render_method) if respond_to?(render_method, true)
+      end
+      raise "No renderer found for field %s" % field.class
     end
 
-
     def render_field(field, data, indent="")
       renderer = find_renderer(field)
       renderer.call(field, data, indent)
@@ -94,9 +78,9 @@ module HammerCLI::Output::Adapter
     def render_label(field, indent="")
       if field.label
         w = label_width_for_list(self.fields) - indent.size + 1
-        print indent.to_s+" %#{-w}s" % (field.label.to_s+LABEL_DIVIDER)
+        print indent.to_s+"%#{-w}s" % (field.label.to_s+LABEL_DIVIDER)
       else
-        print indent.to_s+" "
+        print indent.to_s
       end
     end
 
@@ -104,18 +88,11 @@ module HammerCLI::Output::Adapter
       format_method = "format_"+field_type(field.class)
 
       value = field.get_value(data)
-      value = send(format_method, value) if respond_to?(format_method, true)
+      formatter = @formatters.formatter_for_type(field.class)
+      value = formatter.format(value) if formatter
       value
     end
 
-    def find_renderer(field)
-      field.class.ancestors.each do |cls|
-        render_method = "render_"+field_type(cls)
-        return method(render_method) if respond_to?(render_method, true)
-      end
-      raise "No renderer found for field %s" % field.class
-    end
-
     def field_type(field_class)
       field_class.name.split("::")[-1]
     end

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

@@ -3,13 +3,13 @@ module HammerCLI::Output::Adapter
 
   class Silent
 
-    def print_message msg
+    def print_message(msg)
     end
 
-    def print_error msg, details=[]
+    def print_error(msg, details=[])
     end
 
-    def print_records fields, data, heading=nil
+    def print_records(fields, data)
     end
 
   end

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

@@ -2,32 +2,33 @@ require 'table_print'
 
 module HammerCLI::Output::Adapter
 
-  class Table < Base
+  class Table < Abstract
 
-    def print_records fields, data, heading=nil
+    def print_records(fields, data)
 
       rows = data.collect do |d|
         row = {}
         fields.each do |f|
-          row[f.label.to_sym] = f.get_value(d)
+          row[f.label.to_sym] = f.get_value(d) || ""
         end
         row
       end
 
       options = fields.collect do |f|
-        { f.label.to_sym => { 
-            :formatters => [ Formatter.new(self, "format_"+field_type(f.class)) ] } }
+        next if f.class <= Fields::Id && !@context[:show_ids]
+        { f.label.to_sym => { :formatters => Array(@formatters.formatter_for_type(f.class)) } }
       end
 
       printer = TablePrint::Printer.new(rows, options)
       output = printer.table_print
-      dashes = /\n(-+)\n/.match output
-      puts dashes[1]
+      dashes = /\n([-|]+)\n/.match(output)
+
+      puts dashes[1] if dashes
       puts output
-      puts dashes[1]
+      puts dashes[1] if dashes
     end
 
-    def print_heading heading, size
+    def print_heading(heading, size)
       size = heading.size if heading.size > size
       puts '-' * size
       puts ' ' * ((size-heading.size)/2) + heading
@@ -36,18 +37,4 @@ module HammerCLI::Output::Adapter
 
   end
 
-  class Formatter
-    def initialize adapter, method
-      @adapter = adapter
-      @method = method
-    end
-
-    def format value
-      if @adapter.respond_to?(@method, true)
-        value = @adapter.send(@method, value) 
-      end
-      value
-    end
-  end
-
 end

data/lib/hammer_cli/output/dsl.rb

@@ -2,7 +2,7 @@ module HammerCLI::Output
 
   class Dsl
 
-    def initialize options={}
+    def initialize(options={})
       @current_path = options[:path] || []
     end
 
@@ -11,38 +11,38 @@ module HammerCLI::Output
       @fields
     end
 
-    def build &block
+    def build(&block)
       self.instance_eval &block
     end
 
     protected
 
-    def field key, label, type=nil, options={}, &block
+    def field(key, label, type=nil, options={}, &block)
       options[:path] = current_path.clone << key
       options[:label] = label
-      type ||= HammerCLI::Output::DataField
+      type ||= Fields::DataField
       custom_field type, options, &block
     end
 
-    def custom_field type, options={}, &block
+    def custom_field(type, options={}, &block)
       self.fields << type.new(options, &block)
     end
 
-    def label label, &block
+    def label(label, &block)
       options = {}
       options[:path] = current_path.clone
       options[:label] = label
-      custom_field HammerCLI::Output::Fields::Label, options, &block
+      custom_field Fields::Label, options, &block
     end
 
-    def from key
+    def from(key)
       self.current_path.push key
       yield if block_given?
       self.current_path.pop
     end
 
-    def collection key, label, options={}, &block
-      field key, label,  HammerCLI::Output::Fields::Collection, options, &block
+    def collection(key, label, options={}, &block)
+      field key, label, Fields::Collection, options, &block
     end
 
 

data/lib/hammer_cli/output/fields.rb

@@ -1,7 +1,6 @@
 require 'hammer_cli/output/dsl'
 
-module HammerCLI::Output
-
+module Fields
 
   class Field
 
@@ -61,66 +60,58 @@ module HammerCLI::Output
 
   end
 
+  class Date < DataField
+  end
 
-  module Fields
+  class Id < DataField
+  end
 
+  class List < DataField
+  end
 
-    class Date < HammerCLI::Output::DataField
-    end
+  class KeyValue < DataField
+  end
 
-    class OSName < HammerCLI::Output::DataField
-    end
 
-    class List < HammerCLI::Output::DataField
+  class Joint < DataField
+    def initialize(options={}, &block)
+      super(options)
+      @attributes = options[:attributes] || []
     end
 
-    class KeyValue < HammerCLI::Output::DataField
-    end
+    attr_reader :attributes
+  end
 
-    class Server < HammerCLI::Output::DataField
-    end
+  class Label < LabeledField
 
-    class Joint < HammerCLI::Output::DataField
-      def initialize(options={}, &block)
-        super(options)
-        @attributes = options[:attributes] || []
-      end
+    def initialize(options={}, &block)
+      super(options)
+      dsl = HammerCLI::Output::Dsl.new :path => options[:path]
+      dsl.build &block if block_given?
 
-      attr_reader :attributes
+      self.output_definition.append dsl.fields
     end
 
-    class Label < HammerCLI::Output::LabeledField
-
-      def initialize(options={}, &block)
-        super(options)
-        dsl = HammerCLI::Output::Dsl.new :path => options[:path]
-        dsl.build &block if block_given?
-
-        self.output_definition.append dsl.fields
-      end
-
-      def output_definition
-        @output_definition ||= HammerCLI::Output::Definition.new
-        @output_definition
-      end
-
+    def output_definition
+      @output_definition ||= HammerCLI::Output::Definition.new
+      @output_definition
     end
 
-    class Collection < HammerCLI::Output::DataField
+  end
 
-      def initialize(options={}, &block)
-        super(options)
-        dsl = HammerCLI::Output::Dsl.new
-        dsl.build &block if block_given?
+  class Collection < DataField
 
-        self.output_definition.append dsl.fields
-      end
+    def initialize(options={}, &block)
+      super(options)
+      dsl = HammerCLI::Output::Dsl.new
+      dsl.build &block if block_given?
 
-      def output_definition
-        @output_definition ||= HammerCLI::Output::Definition.new
-        @output_definition
-      end
+      self.output_definition.append dsl.fields
+    end
 
+    def output_definition
+      @output_definition ||= HammerCLI::Output::Definition.new
+      @output_definition
     end
 
   end

data/lib/hammer_cli/output/formatters.rb

@@ -0,0 +1,81 @@
+module HammerCLI::Output
+  module Formatters
+
+    # Registry for formatters    
+    class FormatterLibrary
+      def initialize(formatter_map={})
+        @_formatters = {}
+        formatter_map.each do |type, formatters| 
+          register_formatter(type, formatters)
+        end
+      end
+
+      def register_formatter(type, *formatters)
+        if @_formatters[type].nil?
+          @_formatters[type] = FormatterContainer.new *formatters
+        else 
+          formatters.each { |f| @_formatters[type].add_formatter(f) }
+        end
+      end
+
+      def formatter_for_type(type)
+        @_formatters[type.name.split('::').last.to_sym]
+      end
+    end
+
+    # abstract formatter
+    class FieldFormatter
+      def format(data)
+        data
+      end
+    end
+
+    class FormatterContainer < FieldFormatter
+
+      def initialize(*formatters)
+        @formatters = formatters
+      end
+
+      def add_formatter(*formatters)
+        @formatters += formatters
+      end
+
+      def format(data)
+        @formatters.inject(data) { |d,f| f.format(d) }
+      end
+
+    end
+
+    class ColorFormatter
+      def initialize(color)
+        @color = color
+      end
+
+      def format(data)
+        c = HighLine.color(data.to_s, @color)
+      end
+    end
+
+    class DateFormatter < FieldFormatter
+      def format(string_date)
+        t = DateTime.parse(string_date.to_s)
+        t.strftime("%Y/%m/%d %H:%M:%S")
+      rescue ArgumentError
+        ""
+      end
+    end
+
+    class ListFormatter < FieldFormatter
+      def format(list)
+        list.join(", ") if list
+      end
+    end
+
+    DEFAULT_FORMATTERS = FormatterLibrary.new( 
+      :Date => DateFormatter.new, 
+      :List => ListFormatter.new)
+
+  end
+end
+
+

data/lib/hammer_cli/output/output.rb

@@ -4,23 +4,25 @@ module HammerCLI::Output
     attr_accessor :adapter
     attr_reader :definition
 
-    def initialize options={}
-      @adapter = options[:adapter] || HammerCLI::Output::Adapter::Base.new
+    def initialize(options={})
+      @context = options[:context] || {}
+      @adapter = options[:adapter] || HammerCLI::Output::Adapter::Base.new(
+        @context, HammerCLI::Output::Formatters::DEFAULT_FORMATTERS)
       @definition = options[:definition] || HammerCLI::Output::Definition.new
     end
 
-    def print_message msg
+    def print_message(msg)
       adapter.print_message(msg.to_s)
     end
 
-    def print_error msg, details=nil
+    def print_error(msg, details=nil)
       adapter.print_error(msg.to_s, details)
     end
 
-    def print_records records, heading=nil
+    def print_records(records)
       records = [records] unless records.kind_of?(Array)
 
-      adapter.print_records(definition.fields, records, heading)
+      adapter.print_records(definition.fields, records)
     end
 
   end

data/lib/hammer_cli/output.rb

@@ -1,5 +1,6 @@
 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/adapter')
 require File.join(File.dirname(__FILE__), 'output/definition')
 require File.join(File.dirname(__FILE__), 'output/dsl')

data/lib/hammer_cli/settings.rb

@@ -5,11 +5,11 @@ module HammerCLI
 
   class Settings
 
-    def self.[] key
+    def self.[](key)
       settings[key.to_sym]
     end
 
-    def self.load_from_file files
+    def self.load_from_file(files)
       files.reverse.each do |path|
         full_path = File.expand_path path
         if File.exists? full_path
@@ -22,7 +22,7 @@ module HammerCLI
       end
     end
 
-    def self.load settings_hash
+    def self.load(settings_hash)
       settings.merge! settings_hash.inject({}){ |sym_hash,(k,v)| sym_hash[k.to_sym] = v; sym_hash }
     end
 
@@ -33,7 +33,7 @@ module HammerCLI
 
     def self.path_history
       @path_history ||= []
-      @path_history 
+      @path_history
     end
 
     private

data/lib/hammer_cli/version.rb

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