ar_to_html_table 0.1.9 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,20 @@
+ar_to_html_table (0.2.0) October 30, 2010
+
+* Table formatter now calls row instance method (DRY's up formatting)
+  and making column formatting stand alone from table formatting.  Next
+  step separate column_formatting into a separate gem.
+
+* Options can now be defined on the column_format call (:options = {})
+  which are passed to the formatter at invocation
+
+* :trend is now a valid totaling method.  Requires ar_results_calculations
+
+* Add dependency for ar_result_calculations
+
+ar_to_html_table (0.1.10) October 24, 2010
+
+* Options can be passed in #format_column
+
 ar_to_html_table (0.1.9) October 24, 2010
 
 * Bar and percentage fixes for when % > 100

data/README.textile

@@ -45,7 +45,7 @@ h2. Column options
 
 |_. Option|_. Description|
 |:order|Positions a column order relative to other columns.  The number isn't important, just its relative value compared to other columns.  Columns are sorted by order and rendered in that order.  The default order is the order in which the columns are defined.|
-|:total|Renders a table footer with a calculation of all the values in the column.  The available totaling methods are **:sum**, **:count** and **:average** (or :avg or :mean)|
+|:total|Renders a table footer with a calculation of all the values in the column.  The available totaling methods are **:sum**, **:count**, **:average** (or :avg or :mean) and **trend** which is a calculated slope from a linear regression of the column|
 |:class|The CSS class for this column.  Note that a **colgroup** is defined for each column and each **colgroup** has as CSS class that is the column name|
 |:formatter|A :symbol representing a method to format the value of each table cell.  There are several predefined formatters but any method with a signature of **method(value, options = {})** will work, including the methods in ActionView::Helpers::NumberHelper. Lastly a lambda can be provided for arbitrary formatting.|
 

data/ar_to_html_table.gemspec

@@ -22,7 +22,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  #s.add_dependency  'builder'
-  #s.add_dependency  'activerecord', '~> 2.3.5'
-  #s.add_dependency  'actionpack', '~> 2.3.5'
+  s.add_dependency  'ar_result_calculations'
+
 end

data/lib/ar_to_html_table/column_formats.rb

@@ -31,8 +31,26 @@ module ArToHtmlTable
       # ====Parameters
       #
       #   column_name:  A column (attribute) on the the model instance 
-      def format_column(column_name)
-        self.class.format_column(column_name, self[column_name])
+      #   options:  Formatter options (passed to the formatter)
+      #
+      # ====Options and where they come from
+      #
+      #   Options provided to a formatter are merged from several sources
+      #   Depending on who is calling the formatter.
+      #
+      #   table_formatter calls with options :cell_type and :column.  :cell_type
+      #   is either :td or :th depending on the type of cell the table formatter i
+      #   populating. :column is the internal column definition used by the table_formatter
+      #   which includes some attributes it uses.
+      #
+      #   instance#format_column (this method) merges in the :row options which is the
+      #   model instance.
+      #
+      #   class#format_column (the class method) merges in the formatter options (defined
+      #   as :options on the column_format definition)
+      def format_column(column_name, options = {})
+        formatter_options = options.merge(:row => self)
+        self.class.format_column(column_name, self[column_name], formatter_options)
       end
       alias :format_attribute :format_column
     end
@@ -62,7 +80,7 @@ module ArToHtmlTable
       #     column_format :revenue,   :total => :sum, :order => 5, :class => 'right'
       #     column_format :age, 	    :total => :avg, :order => 20, :class => 'right', :formatter => :number_with_delimiter
       #   end
-      def column_format(method, options)
+      def column_format(method, options = {})
         options[:formatter] = procify(options[:formatter]) if options[:formatter] && options[:formatter].is_a?(Symbol)
         @attr_formats = (@attr_formats || default_formats).deep_merge({method.to_s => options})
       end
@@ -108,10 +126,16 @@ module ArToHtmlTable
       #
       #   column_name:  A column (attribute) on the the model instance
       #   value: The value to be formatted
-      def format_column(column_name, value)
-        formatter = format_of(column_name)[:formatter]
-        raise "Column #{column_name} has no configured formatter" unless formatter && formatter.is_a?(Proc)
-        formatter.call(value, {})
+      #   options Formatter options
+      def format_column(column_name, value, options = {})
+        format = format_of(column_name)
+        if format && (formatter = format[:formatter])
+          formatter_options = options.merge(:options => format[:options])
+          formatter.call(value, formatter_options)
+        else
+          Rails.logger.debug "[table_formatter] Column #{column_name} has no configured formatter"
+          value.to_s
+        end
       end
       alias :format_attribute :format_column
     

data/lib/ar_to_html_table/model.rb

@@ -19,8 +19,8 @@ module ArToHtmlTable
       # 
       # See ArToHtmlTable::TableFormatter for options.
       def to_table(options = {})
-        @formatter = ArToHtmlTable::TableFormatter.new(self, options)
-        @formatter.to_html
+        @table_formatter = ArToHtmlTable::TableFormatter.new(self, options)
+        @table_formatter.to_html
       end
     end
   

data/lib/ar_to_html_table/table_formatter.rb

@@ -108,7 +108,7 @@ module ArToHtmlTable
       html_options[:class] = (count.even? ? options[:even_row] : options[:odd_row])
       html_options[:id] = row_id(row) if row[klass.primary_key]
       html.tr html_options  do
-        table_columns.each {|column| output_cell(row, column, options) }
+        table_columns.each {|column| output_cell(:td, row, column, options) }
       end
     end
 
@@ -125,32 +125,20 @@ module ArToHtmlTable
           first_column = true
           table_columns.each do |column| 
             value = first_column ? first_column_total(options) : totals[column[:name].to_s]
-            output_cell_value(:th, value, column, options)
+            output_cell(:th, value, column, options)
             first_column = false
           end
         end
       end    
     end
 
-    # Outputs one cell
-    def output_cell(row, column, options = {})
-      output_cell_value(:td, row[column[:name]], column, options)
-    end
-  
-    # Outputs one cells value after invoking its formatter
-    def output_cell_value(cell_type, value, column, options = {})
-      # raise ArgumentError, "Column has no formatter: #{column[:name]}." unless column[:formatter]
-      column_name = column[:name].to_sym
-      column_cache[column_name] = {} unless column_cache.has_key?(column_name)
-
-      if column_cache[column_name].has_key?(value)
-        result = column_cache[column_name][value]
-      elsif column[:formatter]
-        result = column[:formatter].call(value, options.reverse_merge({:cell_type => cell_type, :column => column})) || ''
-        column_cache[column_name][value] = result
+    # Outputs one formatted cell
+    def output_cell(cell_type, row_or_value, column, options = {})
+      formatter_options = options.reverse_merge({:cell_type => cell_type, :column => column})
+      if row_or_value.class.respond_to? :descends_from_active_record?
+        result = row_or_value.format_column(column[:name], formatter_options)
       else
-        result = value.to_s || ''
-        column_cache[column_name][value] = result
+        result = klass.format_column(column[:name], row_or_value, formatter_options)
       end
       html.__send__(cell_type, (column[:class] ? {:class => column[:class]} : {})) do
         html << result.to_s
@@ -190,6 +178,8 @@ module ArToHtmlTable
             totals[column[:name]] = rows.make_numeric(column[:name]).mean(column[:name])
           when :count
             totals[column[:name]] = rows.make_numeric(column[:name]).count(column[:name])
+          when :trend
+            totals[column[:name]] = rows.make_numeric(column[:name]).trend(column[:name])
         end
         totals
       end  
@@ -209,7 +199,6 @@ module ArToHtmlTable
       return {
         :name       => column,
         :label      => klass.human_attribute_name(column),
-        :formatter  => format_options[:formatter],
         :class      => format_options[:class],
         :order      => format_options[:order] || @column_order,
         :total      => format_options[:total]

data/lib/ar_to_html_table/version.rb

@@ -1,3 +1,3 @@
 module ArToHtmlTable
-  VERSION = "0.1.9"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ar_to_html_table
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 9
-  version: 0.1.9
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Kip Cole
@@ -15,10 +15,23 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-24 00:00:00 +08:00
+date: 2010-10-30 00:00:00 +08:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ar_result_calculations
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 description: "    Defines Array#to_table that will render an ActiveRecord result set\n    as an HTML table.\n"
 email: 
 - kipcole9@gmail.com