hammer_cli 0.0.18 → 0.1.0

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

@@ -35,6 +35,26 @@ module HammerCLI::Output::Adapter
       raise NotImplementedError
     end
 
+    protected
+
+    def field_filter
+      HammerCLI::Output::FieldFilter.new
+    end
+
+    def data_for_field(field, record)
+      path = field.path
+
+      path.inject(record) do |record, path_key|
+        if record.has_key? path_key.to_sym
+          record[path_key.to_sym]
+        elsif record.has_key? path_key.to_s
+          record[path_key.to_s]
+        else
+          return nil
+        end
+      end
+    end
+
     private
 
     def filter_formatters(formatters_map)

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

@@ -1,7 +1,7 @@
 module HammerCLI::Output::Adapter
   class Base < Abstract
 
-    GROUP_INDENT = " "*2
+    GROUP_INDENT = " "*4
     LABEL_DIVIDER = ": "
 
     def tags
@@ -13,117 +13,88 @@ module HammerCLI::Output::Adapter
     end
 
     def print_collection(fields, collection)
-      self.fields = fields
-
-      collection.each do |d|
-        fields.collect do |f|
-          render_field(f, d)
-        end
+      collection.each do |data|
+        puts render_fields(fields, data)
         puts
       end
     end
 
     protected
 
-    def render_Field(field, data, indent="")
-      puts indent.to_s+" "+format_value(field, data).to_s
+    def field_filter
+      filtered = []
+      filtered << Fields::Id unless @context[:show_ids]
+      HammerCLI::Output::FieldFilter.new(filtered)
     end
 
-    def render_Label(field, data, indent="")
-      render_label(field, indent)
-      puts
-      indent = indent.to_s + GROUP_INDENT
-
-      field.output_definition.fields.collect do |f|
-        render_field(f, data, indent)
+    def filter_fields(fields, data)
+      field_filter.filter(fields).reject do |field|
+        field_data = data_for_field(field, data)
+        not field.display?(field_data)
       end
     end
 
-    def render_LabeledField(field, data, indent="")
-      render_label(field, indent)
-      puts format_value(field, data).to_s
-    end
+    def render_fields(fields, data)
+      output = ""
 
-    def render_KeyValue(field, data, indent="")
-      render_label(field, indent)
-      params = field.get_value(data) || []
-      print "%{name} => %{value}" % params
-    end
+      fields = filter_fields(fields, data)
 
-    def render_Collection(field, data, indent="")
-      render_label(field, indent)
-      puts
-      indent = indent.to_s + " "*(label_width_for_list(self.fields)+LABEL_DIVIDER.size)
+      label_width = label_width(fields)
 
-      data = field.get_value(data) || []
-      data.each do |d|
-        field.output_definition.fields.collect do |f|
-          render_field(f, d, indent)
-        end
-        puts
+      fields.collect do |field|
+        field_data = data_for_field(field, data)
+
+        next unless field.display?(field_data)
+        output += render_field(field, field_data, label_width)
+        output += "\n"
       end
+      output.rstrip
     end
 
-    def render_Joint(field, data, indent="")
-      render_label(field, indent)
-      data = field.get_value(data)
-      puts field.attributes.collect{|attr| data[attr] }.join(" ")
-    end
+    def render_field(field, data, label_width)
 
-    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
+      if field.is_a? Fields::ContainerField
+        output = ""
+
+        idx = 0
+        data = [data] unless data.is_a? Array
+        data.each do |d|
+          idx += 1
+          fields_output = render_fields(field.fields, d).indent_with(GROUP_INDENT)
+          fields_output = fields_output.sub(/^[ ]{4}/, " %-3s" % "#{idx})") if field.is_a? Fields::Collection
 
-    def render_field(field, data, indent="")
-      renderer = find_renderer(field)
-      renderer.call(field, data, indent)
+          output += fields_output
+          output += "\n"
+        end
+
+        render_label(field, label_width) + "\n" + output.rstrip
+      else
+        render_label(field, label_width) +
+        render_value(field, data)
+      end
     end
 
-    def render_label(field, indent="")
+    def render_label(field, width)
       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)
+        "%-#{width}s" % (field.label.to_s + LABEL_DIVIDER)
       else
-        print indent.to_s
+        ""
       end
     end
 
-    def format_value(field, data)
-      format_method = "format_"+field_type(field.class)
-
-      value = field.get_value(data)
+    def render_value(field, data)
       formatter = @formatters.formatter_for_type(field.class)
-      value = formatter.format(value) if formatter
-      value
-    end
-
-    def field_type(field_class)
-      field_class.name.split("::")[-1]
-    end
-
-    def label_width_for(field)
-      if field.respond_to?(:output_definition)
-        label_width_for_list(field.output_definition.fields)+GROUP_INDENT.size
-      elsif field.respond_to?(:label)
-        field.label.size+LABEL_DIVIDER.size rescue 0
-      else
-        0
-      end
+      data = formatter.format(data) if formatter
+      data.to_s
     end
 
-    def label_width_for_list(fields)
+    def label_width(fields)
       fields.inject(0) do |result, f|
-        width = label_width_for(f)
+        width = f.label.to_s.size + LABEL_DIVIDER.size
         (width > result) ? width : result
       end
     end
 
-    attr_accessor :fields
-
   end
 
   HammerCLI::Output::Output.register_adapter(:base, Base)

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

@@ -28,9 +28,9 @@ module HammerCLI::Output::Adapter
         collection.each do |d|
           csv << fields.inject([]) do |row, f|
             unless f.class <= Fields::Id && !@context[:show_ids]
-              value = (f.get_value(d) || '')
+              value = data_for_field(f, d)
               formatter = @formatters.formatter_for_type(f.class)
-              row << (formatter ? formatter.format(value) : value)
+              row << ((formatter ? formatter.format(value) : value) || '')
             end
             row
           end
@@ -44,16 +44,16 @@ module HammerCLI::Output::Adapter
         id = msg_params["id"] || msg_params[:id]
         name = msg_params["name"] || msg_params[:name]
 
-        labels = ["Message"]
+        labels = [_("Message")]
         data = [msg.format(msg_params)]
 
         if id
-          labels << "Id"
+          labels << _("Id")
           data << id
         end
 
         if name
-          labels << "Name"
+          labels << _("Name")
           data << name
         end
 

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

@@ -4,6 +4,9 @@ module HammerCLI::Output::Adapter
 
   class Table < Abstract
 
+    MAX_COLUMN_WIDTH = 80
+    MIN_COLUMN_WIDTH = 5
+
     def tags
       [:screen, :flat]
     end
@@ -13,25 +16,29 @@ module HammerCLI::Output::Adapter
     end
 
     def print_collection(all_fields, collection)
-
-      fields = all_fields.reject { |f| f.class <= Fields::Id && !@context[:show_ids] }
+      fields = field_filter.filter(all_fields)
 
       rows = collection.collect do |d|
         row = {}
         fields.each do |f|
-          row[f.label.to_sym] = f.get_value(d) || ""
+          row[label_for(f)] = data_for_field(f, d) || ""
         end
         row
       end
 
       options = fields.collect do |f|
-        { f.label.to_sym => { :formatters => Array(@formatters.formatter_for_type(f.class)) } }
+        { label_for(f) => {
+            :formatters => Array(@formatters.formatter_for_type(f.class)),
+            :width => max_width_for(f)
+          }
+        }
       end
 
       sort_order = fields.map { |f| f.label.upcase }
 
       printer = TablePrint::Printer.new(rows, options)
-      TablePrint::Config.max_width = 40
+      TablePrint::Config.max_width = MAX_COLUMN_WIDTH
+      TablePrint::Config.multibyte = true
 
       output = sort_columns(printer.table_print, sort_order)
       dashes = /\n([-|]+)\n/.match(output)
@@ -41,15 +48,39 @@ module HammerCLI::Output::Adapter
       puts dashes[1] if dashes
     end
 
-    def print_heading(heading, size)
-      size = heading.size if heading.size > size
-      puts '-' * size
-      puts ' ' * ((size-heading.size)/2) + heading
-      puts '-' * size
+    protected
+
+    def field_filter
+      filtered = [Fields::ContainerField]
+      filtered << Fields::Id unless @context[:show_ids]
+      HammerCLI::Output::FieldFilter.new(filtered)
     end
 
     private
 
+    def label_for(field)
+      width = width_for(field)
+      if width
+        "%-#{width}s" % field.label.to_s
+      else
+        field.label.to_s
+      end
+    end
+
+    def max_width_for(field)
+      width = width_for(field)
+      width ||= field.parameters[:max_width]
+      width = MIN_COLUMN_WIDTH if width && width < MIN_COLUMN_WIDTH
+      width
+    end
+
+    def width_for(field)
+      width = field.parameters[:width]
+      width = MIN_COLUMN_WIDTH if width && width < MIN_COLUMN_WIDTH
+      width
+    end
+
+
     def sort_columns(output, sort_order)
       return output if sort_order.length == 1 # don't sort one column
       delimiter = ' | '

data/lib/hammer_cli/output/dsl.rb

@@ -22,7 +22,7 @@ module HammerCLI::Output
       options[:path] << key if !key.nil?
 
       options[:label] = label
-      type ||= Fields::DataField
+      type ||= Fields::Field
       custom_field type, options, &block
     end
 

data/lib/hammer_cli/output/field_filter.rb

@@ -0,0 +1,21 @@
+module HammerCLI::Output
+
+  class FieldFilter
+
+    def initialize(field_classes=[])
+      @field_classes = field_classes
+    end
+
+    def filter(fields)
+      fields = fields.clone
+      @field_classes.each do |cls|
+        fields.reject! do |f|
+          f.is_a? cls
+        end
+      end
+      fields
+    end
+
+  end
+
+end

data/lib/hammer_cli/output/fields.rb

@@ -4,93 +4,42 @@ module Fields
 
   class Field
 
-    def initialize(options={})
-    end
-
-    def get_value(data)
-    end
-
-  end
-
-  class LabeledField < Field
-
     attr_reader :label
-
-    def initialize(options={})
-      @label = options[:label]
-    end
-  end
-
-  class DataField < LabeledField
-
     attr_reader :path
 
     def initialize(options={})
+      @hide_blank = options[:hide_blank].nil? ? false : options[:hide_blank]
       @path = options[:path] || []
-      super(options)
-    end
-
-    def get_value(data)
-      follow_path(data, path || [])
+      @label = options[:label]
+      @options = options
     end
 
-    private
-
-    def follow_path(record, path)
-      record = symbolize_hash_keys(record)
-
-      path.inject(record) do |record, path_key|
-        if record.has_key? path_key.to_sym
-          record[path_key.to_sym]
-        else
-          return nil
-        end
-      end
+    def hide_blank?
+      @hide_blank
     end
 
-    def symbolize_hash_keys(h)
-      if h.is_a? Hash
-        return h.inject({}) do |result,(k,v)|
-          # symbolizing empty string fails in ruby 1.8
-          result.update k.to_sym => symbolize_hash_keys(v) unless k.to_s.empty?
-          result
-        end
-      elsif h.is_a? Array
-        return h.collect{|item| symbolize_hash_keys(item)}
+    def display?(value)
+      if not hide_blank?
+        true
+      elsif value.nil?
+        false
       else
-        h
+        true
       end
     end
 
-  end
-
-  class Date < DataField
-  end
-
-  class Id < DataField
-  end
-
-  class List < DataField
-  end
-
-  class KeyValue < DataField
-  end
-
-
-  class Joint < DataField
-    def initialize(options={}, &block)
-      super(options)
-      @attributes = options[:attributes] || []
+    def parameters
+      @options
     end
 
-    attr_reader :attributes
   end
 
-  class Label < LabeledField
+
+  class ContainerField < Field
 
     def initialize(options={}, &block)
       super(options)
-      dsl = HammerCLI::Output::Dsl.new :path => options[:path]
+      dsl = HammerCLI::Output::Dsl.new
       dsl.build &block if block_given?
 
       self.output_definition.append dsl.fields
@@ -101,23 +50,40 @@ module Fields
       @output_definition
     end
 
+    def fields
+      @output_definition.fields
+    end
+
+    def display?(value)
+      if not hide_blank?
+        true
+      elsif value.nil? || value.empty?
+        false
+      else
+        true
+      end
+    end
   end
 
-  class Collection < DataField
+  class Date < Field
+  end
 
-    def initialize(options={}, &block)
-      super(options)
-      dsl = HammerCLI::Output::Dsl.new
-      dsl.build &block if block_given?
+  class Id < Field
+  end
 
-      self.output_definition.append dsl.fields
-    end
+  class List < Field
+  end
 
-    def output_definition
-      @output_definition ||= HammerCLI::Output::Definition.new
-      @output_definition
-    end
+  class LongText < Field
+  end
+
+  class KeyValue < Field
+  end
+
+  class Label < ContainerField
+  end
 
+  class Collection < ContainerField
   end
 
 end