yummi 0.0.2 → 0.0.3

data/examples/list_files.rb

@@ -34,13 +34,12 @@ opt = OptionParser::new
 # sets the title
 @table.title = 'Files in home folder'
 # formats size for easily reading
-@table.format :size, :using => Yummi::Formatter.bytes
+@table.format :size, :using => Yummi::Formatter.unit(:byte)
 
 opt.on '--color TYPE', 'Specify the color type (zebra,file,none)' do |type|
   case type
     when 'zebra'
-      @table.row_colorizer Yummi::IndexedDataColorizer.odd :with => :intense_gray
-      @table.row_colorizer Yummi::IndexedDataColorizer.even :with => :intense_white
+      @table.row_colorizer Yummi::IndexedDataColorizer.zebra :intense_gray, :intense_white
     when 'file'
       @table.row_colorizer do |i, data|
         data[:directory] ? :intense_gray : :intense_white

data/examples/monitor_table.rb

@@ -31,18 +31,18 @@ opt = OptionParser::new
 # sets the title
 @table.title = 'Server Runtime Info'
 # formats memory info for easily reading
-@table.format :max_memory, :using => Yummi::Formatter.bytes
-@table.format :free_memory, :using => Yummi::Formatter.bytes
+@table.format :max_memory, :using => Yummi::Formatter.unit(:byte)
+@table.format :free_memory, :using => Yummi::Formatter.unit(:byte)
 
 # colorizer for memory
-memory_colorizer = Yummi::Colorizer.by_eval do |free_memory, max_memory|
+memory_colorizer = Yummi::Colorizer.by_data_eval do |free_memory, max_memory|
   free_memory.to_f / max_memory
 end
 memory_colorizer.use(:red) { |value| value > 0.1 and value < 0.3 }
 memory_colorizer.use(:intense_red) { |value| value <= 0.1 }
 
 # colorizer for threads
-thread_colorizer = Yummi::Colorizer.by_eval do |max_threads, in_use_threads|
+thread_colorizer = Yummi::Colorizer.by_data_eval do |max_threads, in_use_threads|
   in_use_threads.to_f / max_threads
 end
 thread_colorizer.use(:brown) { |value| value > 0.7 and value < 0.9 }
@@ -51,14 +51,15 @@ thread_colorizer.use(:intense_cyan) { |value| value >= 0.9 }
 opt.on '--color TYPE', 'Specify the color type (zebra,row,cell,none)' do |type|
   case type
     when 'zebra'
-      @table.row_colorizer Yummi::IndexedDataColorizer.odd :with => :brown
-      @table.row_colorizer Yummi::IndexedDataColorizer.even :with => :purple
+      @table.row_colorizer Yummi::Colorizer.by_index.zebra :brown, :purple
     when 'row'
       @table.row_colorizer memory_colorizer
       @table.row_colorizer thread_colorizer
     when 'cell'
-      @table.using_row.colorize :free_memory, :using => memory_colorizer
-      @table.using_row.colorize :in_use_threads, :using => thread_colorizer
+      @table.using_row do
+        @table.colorize :free_memory, :using => memory_colorizer
+        @table.colorize :in_use_threads, :using => thread_colorizer
+      end
     when 'none'
       @table.no_colors
     else

data/examples/table_cash_flow.rb

@@ -47,8 +47,7 @@ opt = OptionParser::new
 opt.on '--color TYPE', 'Specify the color type (zebra,full,none)' do |type|
   case type
     when 'zebra'
-      @table.row_colorizer Yummi::IndexedDataColorizer.odd :with => :brown
-      @table.row_colorizer Yummi::IndexedDataColorizer.even :with => :purple
+      @table.row_colorizer Yummi::Colorizer.by_index.zebra :brown, :purple
     when 'full'
       # colorize all values from the Description column to purple
       @table.colorize :description, :with => :purple

data/lib/yummi/table.rb

@@ -82,8 +82,6 @@ module Yummi
       @no_colors = true
     end
 
-    #
-    # === Description
     #
     # Sets the table header. If no aliases are defined, they will be defined as the texts
     # in lowercase with line breaks and spaces replaced by underscores.
@@ -118,8 +116,6 @@ module Yummi
       @aliases = header.map { |n| n.downcase.gsub(' ', '_').gsub("\n", '_').to_sym } if @aliases.empty?
     end
 
-    #
-    # === Description
     #
     # Sets the align for a column in the table. #Yummi#Aligner should respond to it.
     #
@@ -140,8 +136,6 @@ module Yummi
       @align[index] = type
     end
 
-    #
-    # === Description
     #
     # Adds a component to colorize the entire row (overrides column color).
     # The component must respond to +call+ with the index and the row as the arguments and
@@ -154,32 +148,27 @@ module Yummi
     #   table.row_colorizer { |i, row| :red if row[:value] < 0 }
     #
     def row_colorizer colorizer = nil, &block
-      @row_colorizer ||= Yummi::LinkedBlocks::new
+      @row_colorizer ||= Yummi::GroupedComponent::new
       @row_colorizer << (colorizer or block)
     end
 
-    #
-    # === Description
     #
     # Indicates that the column colorizer (#colorize) should receive the entire row as the
-    # argument instead of just the column value.
-    #
-    # === Return
-    #
-    # +self+
+    # argument instead of just the column value for all definitions inside of the given
+    # block.
     #
     # === Example
     #
-    #   table.using_row.colorize(:value) { |row| :red if row[:value] < row[:average] }
-    #
+    #   table.using_row do
+    #     table.colorize(:value) { |row| :red if row[:value] < row[:average] }
+    #   end
     #
     def using_row
       @using_row = true
-      self
+      yield
+      @using_row = false
     end
 
-    #
-    # === Description
     #
     # Sets a component to colorize a column.
     #
@@ -208,11 +197,8 @@ module Yummi
       @colorizers[index] ||= []
       obj = (params[:using] or block or (proc { |v| params[:with] }))
       @colorizers[index] << {:use_row => @using_row, :component => obj}
-      @using_row = false
     end
 
-    #
-    # === Description
     #
     # Sets a component to format a column.
     #
@@ -255,16 +241,22 @@ module Yummi
       header_color_map, header_output = build_header_output
       data_color_map, data_output = build_data_output
 
-      color_map = header_color_map + data_color_map
-      output = header_output + data_output
-
       string = ""
       string << Color.colorize(@title, @colors[:title]) << $/ if @title
-      output.each_index do |i|
-        row = output[i]
+      string << content(header_color_map + data_color_map,
+                        header_output + data_output)
+    end
+
+    #
+    # Gets the content string for the given color map and content
+    #
+    def content color_map, data
+      string = ""
+      data.each_index do |i|
+        row = data[i]
         row.each_index do |j|
           column = row[j]
-          width = max_width output, j
+          width = max_width data, j
           align = (@align[j] or @default_align)
           color = color_map[i][j]
           value = Aligner.send align, column.to_s, width

data/lib/yummi/version.rb

@@ -21,5 +21,5 @@
 # THE SOFTWARE.
 
 module Yummi
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/yummi.rb

@@ -109,46 +109,90 @@ module Yummi
     end
   end
 
-  module Aligner
-
-    def self.right text, width
-      text.rjust(width)
+  #
+  # A module to handle blocks by dynamically resolving parameters
+  #
+  # see #DataEvalColorizer
+  #
+  module BlockHandler
+
+    #
+    # Calls the block resolving the parameters by getting the parameter name from the
+    # given context.
+    #
+    # === Example
+    #
+    #   context = :max => 10, :curr => 5, ratio => 0.15
+    #   percentage = BlockHandler.call_block(context) { |max,curr| curr.to_f / max }
+    #
+    def block_call context, &block
+      args = []
+      block.parameters.each do |parameter|
+        args << context[parameter[1]]
+      end
+      block.call *args
     end
 
-    def self.left text, width
-      text.ljust(width)
-    end
+    module_function :block_call
 
   end
 
-  module IndexedDataColorizer
+  # A module to align texts based on a reference width
+  module Aligner
 
-    def self.odd params
-      lambda do |index, data|
-        params[:with] if index.odd?
-      end
+    # Aligns the text to the right
+    def self.right text, width
+      text.rjust(width)
     end
 
-    def self.even params
-      lambda do |index, data|
-        params[:with] if index.even?
-      end
+    # Aligns the text to the left
+    def self.left text, width
+      text.ljust(width)
     end
 
   end
 
+  # A module with useful colorizers
   module Colorizer
 
+    # Joins the given colorizers to work as one
     def self.join *colorizers
-      join = Yummi::LinkedBlocks::new
+      join = Yummi::GroupedComponent::new
       colorizers.each { |c| join << c }
       join
     end
 
+    # Returns a new instance of #DataEvalColorizer
+    def self.by_data_eval &block
+      DataEvalColorizer::new &block
+    end
+
+    # Returns a new instance of #EvalColorizer
     def self.by_eval &block
       EvalColorizer::new &block
     end
 
+    # Returns the #IndexedDataColorizer module
+    def self.by_index
+      IndexedDataColorizer
+    end
+
+    #
+    # A colorizer that evaluates a main block and returns a color based on other blocks.
+    #
+    # The main block must be compatible with the colorizing type (receiving a column
+    # value in case of a table column colorizer or the row index and row value in case
+    # of a table row colorizer).
+    #
+    # === Example
+    #
+    #   # assuming that the table has :max and :current aliases
+    #   colorizer = DataEvalColorizer::new { |index, data| data[:current] / data[:max] }
+    #   # the result of the expression above will be passed to this block
+    #   colorizer.use(:red) { |value| value >= 0.9 }
+    #
+    #   table.using_row.colorize :current, :using => colorizer
+    #
     class EvalColorizer
 
       def initialize &block
@@ -157,13 +201,24 @@ module Yummi
         @eval_blocks = []
       end
 
-      def use color, &eval_block
+      #
+      # Uses the given color if the given block returns something when evaluated with the
+      # result of main block.
+      #
+      # An objtect that responds to :call may also be used.
+      #
+      def use color, component = nil, &eval_block
         @colors << color
-        @eval_blocks << eval_block
+        @eval_blocks << (component or eval_block)
+      end
+
+      # Resolves the value using the main block and given arguments
+      def resolve_value *args
+        @block.call *args
       end
 
       def call *args
-        value = Yummi.call_block args.last, &@block # by convention, the last arg is data
+        value = resolve_value *args
         @eval_blocks.each_index do |i|
           return @colors[i] if @eval_blocks[i].call(value)
         end
@@ -172,40 +227,117 @@ module Yummi
 
     end
 
+    #
+    # A colorizer that evaluates a main block and returns a color based on other blocks.
+    #
+    # The main block can receive any parameters and the names must be aliases the current
+    # evaluated data.
+    #
+    # === Example
+    #
+    #   # assuming that the table has :max and :current aliases
+    #   colorizer = DataEvalColorizer::new { |max, current| current / max }
+    #   # the result of the expression above will be passed to this block
+    #   colorizer.use(:red) { |value| value >= 0.9 }
+    #
+    #   table.using_row.colorize :current, :using => colorizer
+    #
+    class DataEvalColorizer < EvalColorizer
+      include Yummi::BlockHandler
+
+      def resolve_value *args
+        block_call args.last, &@block # by convention, the last arg is data
+      end
+
+    end
+
+    # A module with colorizers that uses indexes
+    module IndexedDataColorizer
+
+      # Returns a colorizer that uses the given color in odd indexes
+      def self.odd color
+        lambda do |index, data|
+          color if index.odd?
+        end
+      end
+
+      # Returns a colorizer that uses the given color in even indexes
+      def self.even color
+        lambda do |index, data|
+          color if index.even?
+        end
+      end
+
+      # Returns a colorizer that uses the first color for odd indexes and the second for
+      # even indexes.
+      def self.zebra first_color, second_color
+        Yummi::Colorizer.join odd(first_color), even(second_color)
+      end
+
+    end
+
   end
 
+  # A module with useful formatters
   module Formatter
 
+    # A module for formatting units in a way that makes the value easy to read
+    module Unit
+      # Holds the information about the units that are supported in #format
+      UNITS = {
+        :byte => {:range => %w{B KB MB GB TB}, :step => 1024}
+      }
+
+      #
+      # Formats the value using the given unit.
+      #
+      # === Args
+      #
+      # +unit+::
+      #   A unit defined in #UNITS or a definition
+      # +value+::
+      #   The value to format
+      # +params+::
+      #   Additional parameters:
+      #   * precision: the number of fractional digits to display (defaults to 1)
+      #
+      def self.format unit, value, params = {}
+        unit = UNITS[unit] if unit.is_a? Symbol
+        params[:precision] ||= 1
+        result = value
+        units = unit[:range]
+        units.each_index do |i|
+          minimun = (unit[:step] ** i)
+          result = "%.#{params[:precision]}f #{units[i]}" % (value.to_f / minimun) if value >= minimun
+        end
+        result
+      end
+    end
+
+    # Formats boolean values using 'Yes' or 'No'
     def self.yes_or_no
       lambda do |value|
         value ? "Yes" : "No"
       end
     end
 
+    # Formats a float value by rounding to the given decinal digits
     def self.round precision
       lambda do |value|
         "%.#{precision}f" % value
       end
     end
 
-    def self.unit params
+    # see #Unit#format
+    def self.unit unit, params = {}
       lambda do |value|
-        result = value
-        units = params[:range]
-        units.each_index do |i|
-          minimun = (params[:step] ** i)
-          result = "%.#{params[:precision]}f #{units[i]}" % (value.to_f / minimun) if value >= minimun
-        end
-        result
+        Unit.format unit, value, params
       end
     end
 
-    def self.bytes precision = 1
-      unit :range => %w{B KB MB GB TB}, :step => 1024, :precision => precision
-    end
-
   end
 
+  # A class to expose indexed data by numeric indexes and aliases.
   class IndexedData
 
     def initialize aliases, data
@@ -223,36 +355,45 @@ module Yummi
 
   end
 
-  class LinkedBlocks
-
+  # A class to group components and blocks
+  class GroupedComponent
+
+    #
+    # Creates a new GroupedComponent
+    #
+    # === Args
+    #
+    # +params+::
+    #   Hash parameters:
+    #     - call_all: indicates if all components must be called. For use if the return
+    #     should be ignored
+    #     - message: the message to send. Defaults to :call
+    #
     def initialize params = {}
-      @blocks = []
+      @components = []
       @call_all = params[:call_all]
+      @message = (params[:message] or :call)
     end
 
-    def << block
-      @blocks << block
+    # Adds a new component
+    def << component = nil, &block
+      @components << (component or block)
     end
 
+    #
+    # Calls the added components by sending the configured message and the given args.
+    #
     def call *args
       result = nil
-      @blocks.each do |block|
+      @components.each do |component|
         break if result and not @call_all
-        result = block.call *args
+        result = component.send @message, *args
       end
       result
     end
 
   end
 
-  def self.call_block params, &block
-    args = []
-    block.parameters.each do |parameter|
-      args << params[parameter[1]]
-    end
-    block.call *args
-  end
-
 end
 
 require_relative 'yummi/no_colors' if RUBY_PLATFORM['mingw'] #Windows

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yummi
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-10 00:00:00.000000000Z
+date: 2012-04-15 00:00:00.000000000Z
 dependencies: []
 description: A tool to colorize your console application.
 email: