kbaum-munger 0.1.4

data/lib/munger/item.rb

@@ -0,0 +1,50 @@
+module Munger #:nodoc:
+  
+  class Item
+    
+    attr_reader :data
+    
+    def initialize(data)
+      @data = data
+    end
+    
+    def [](key)
+      return @data[key] if @data[key]
+      if key.is_a? Symbol
+        return @data[key.to_s] if @data[key.to_s]
+      elsif key.is_a? String
+        return @data[key.to_sym] if @data[key.to_sym]
+      end
+    end
+    
+    def []=(key, value)
+      @data[key] = value
+    end
+    
+    def method_missing( id, *args )
+      if @data[id].nil?
+        m = id.to_s
+        if /=$/ =~ m
+    		  @data[m.chomp!] = (args.length < 2 ? args[0] : args)
+    	  else
+    		  @data[m]
+    	  end
+      else
+        @data[id]
+      end
+    end
+    
+    def self.ensure(item)
+      if item.is_a? Munger::Item
+        return item
+      else
+        return Item.new(item)
+      end
+    end
+    
+    def to_hash
+      @data
+    end
+    
+  end
+end

data/lib/munger/render.rb

@@ -0,0 +1,22 @@
+# Munger::Render.to_html(report)
+  
+module Munger #:nodoc:
+  module Render
+        
+    def self.to_html(report, options = {})
+      Html::new(report, options).render
+    end
+
+    def self.to_sortable_html(report, options ={})
+      SortableHtml::new(report, options).render
+    end
+    
+    def self.to_text(report)
+      Text::new(report).render
+    end
+    
+    def self.to_csv(report)
+      CSV::new(report).render
+    end
+  end
+end

data/lib/munger/render/csv.rb

@@ -0,0 +1,31 @@
+module Munger #:nodoc:
+  module Render #:nodoc:
+    class CSV #:nodoc:
+    
+      attr_reader :report
+      
+      def initialize(report)
+        @report = report
+      end
+      
+      def render
+        output = []
+
+        # header
+        output << @report.columns.collect { |col| @report.column_title(col).to_s }.join(',')
+        
+        # body
+        @report.process_data.each do |row|
+          output << @report.columns.collect { |col| row[:data][col].to_s }.join(',')
+        end
+        
+        output.join("\n")
+      end
+      
+      def valid?
+        @report.is_a? Munger::Report
+      end
+    
+    end
+  end
+end

data/lib/munger/render/html.rb

@@ -0,0 +1,89 @@
+begin
+  require 'builder'
+rescue LoadError
+  require 'rubygems'
+  require 'builder'
+end
+
+module Munger #:nodoc:
+  module Render #:nodoc:
+    class Html
+    
+      attr_reader :report, :classes
+      
+      def initialize(report, options = {})
+        @report = report
+        set_classes(options[:classes])
+      end
+      
+      def set_classes(options = nil)
+        options = {} if !options
+        default = {:table => 'report-table'}
+        @classes = default.merge(options)
+      end
+      
+      def render
+        x = Builder::XmlMarkup.new
+        
+        x.table(:class => @classes[:table]) do
+          
+          x.tr do
+            @report.columns.each do |column|
+              x.th(:class => 'columnTitle') { x << @report.column_title(column) }
+            end
+          end
+          
+          @report.process_data.each do |row|
+            
+            classes = []
+            classes << row[:meta][:row_styles]
+            classes << 'group' + row[:meta][:group].to_s if row[:meta][:group]
+            classes << cycle('even', 'odd')
+            classes.compact!
+
+            if row[:meta][:group_header]
+              classes << 'groupHeader' + row[:meta][:group_header].to_s 
+            end
+            
+            row_attrib = {}
+            row_attrib = {:class => classes.join(' ')} if classes.size > 0
+            
+            x.tr(row_attrib) do
+              if row[:meta][:group_header]
+                header = row[:meta][:group_value].to_s
+                x.th(:colspan => @report.columns.size) { x << header }
+              else 
+                @report.columns.each do |column|
+                
+                  cell_attrib = {}
+                  if cst = row[:meta][:cell_styles]
+                    cst = Item.ensure(cst)
+                    if cell_styles = cst[column]
+                      cell_attrib = {:class => cell_styles.join(' ')}
+                    end
+                  end
+                
+                  x.td(cell_attrib) { x << row[:data][column].to_s }
+                end
+              end
+            end
+          end
+          
+        end
+      end
+      
+      def cycle(one, two)
+        if @current == one
+          @current = two
+        else
+          @current = one
+        end
+      end
+      
+      def valid?
+        @report.is_a? Munger::Report
+      end
+    
+    end
+  end
+end

data/lib/munger/render/sortable_html.rb

@@ -0,0 +1,133 @@
+require 'builder'
+module Munger #:nodoc:
+  module Render #:nodoc:
+    # Render a table that lets the user sort the columns
+    class SortableHtml
+    
+      attr_reader :report, :classes
+      
+      # options:
+      # :url => /some/url/for/link  # link to put on column
+      # :params => {:url_params}    # parameters from url if any
+      # :sort => 'column'           # column that is currently sorted
+      # :order => 'asc' || 'desc'   # order of the currently sorted field
+      def initialize(report, options = {})
+        @report = report
+        @options = options
+        # default url and params options
+        @options[:url] ||= '/'
+        @options[:params] ||= {}
+        set_classes(options[:classes])
+      end
+      
+      def set_classes(options = nil)
+        options = {} if !options
+        default = {:table => 'report-table'}
+        @classes = default.merge(options)
+      end
+      
+      def render
+        x = Builder::XmlMarkup.new
+        
+        x.table(:class => @classes[:table]) do
+          
+          x.tr do
+            @report.columns.each do |column|
+              # TODO: Should be able to see if a column is 'sortable'
+              # Assume all columns are sortable here - for now.
+              sorted_state = 'unsorted'
+              direction = 'asc'
+              if [column.to_s, @report.column_data_field(column)].include?(@options[:sort])
+                sorted_state = "sorted"
+                direction = @options[:order] == 'asc' ? 'desc' : 'asc'
+                direction_class = "sorted-#{direction}"
+              end
+              new_params = @options[:params].merge({'sort' => @report.column_data_field(column),'order' => direction})
+              x.th(:class => "columnTitle #{sorted_state} #{direction_class}" ) do 
+                 # x << @report.column_title(column) 
+                 x << "<a href=\"#{@options[:url]}?#{create_querystring(new_params)}\">#{@report.column_title(column)}</a>"
+               end
+            end
+          end
+          
+          @report.process_data.each do |row|
+            
+            classes = []
+            classes << row[:meta][:row_styles]
+            classes << 'group' + row[:meta][:group].to_s if row[:meta][:group]
+            classes << cycle('even', 'odd')
+            classes.compact!
+
+            if row[:meta][:group_header]
+              classes << 'groupHeader' + row[:meta][:group_header].to_s 
+            end
+            
+            row_attrib = {}
+            row_attrib = {:class => classes.join(' ')} if classes.size > 0
+            
+            x.tr(row_attrib) do
+              if row[:meta][:group_header]
+                header = @report.column_title(row[:meta][:group_name]) + ' : ' + row[:meta][:group_value].to_s
+                x.th(:colspan => @report.columns.size) { x << header }
+              else 
+                @report.columns.each do |column|
+                
+                  cell_attrib = {}
+                  if cst = row[:meta][:cell_styles]
+                    cst = Item.ensure(cst)
+                    if cell_styles = cst[column]
+                      cell_attrib = {:class => cell_styles.join(' ')}
+                    end
+                  end
+                  # TODO: Clean this up, I don't like it but it's working
+                  # output the cell
+                  # x.td(cell_attrib) { x << row[:data][column].to_s }
+                  x.td(cell_attrib) do
+                    formatter,*args = *@report.column_formatter(column)
+                    col_data = row[:data] #[column]
+                    if formatter && col_data[column]
+                      formatted = if formatter.class == Proc
+                        formatter.call(col_data.data)
+                      elsif col_data[column].respond_to? formatter
+                        col_data[column].send(formatter, *args)
+                      elsif
+                        col_data[column].to_s
+                      end
+                    else
+                      formatted = col_data[column].to_s
+                    end
+                    x << formatted.to_s
+                  end
+                 
+                end
+              end
+            end
+          end
+          
+        end
+      end
+      
+      def cycle(one, two)
+        if @current == one
+          @current = two
+        else
+          @current = one
+        end
+      end
+      
+      def valid?
+        @report.is_a? Munger::Report
+      end
+    
+      private
+      def create_querystring(params={})
+        qs = []
+        params.each do |k,v|
+          qs << "#{k}=#{v}"
+        end
+        qs.join("&")
+      end
+      
+    end
+  end
+end

data/lib/munger/render/text.rb

@@ -0,0 +1,54 @@
+module Munger #:nodoc:
+  module Render #:nodoc:
+    class Text
+    
+      attr_reader :report
+      
+      def initialize(report)
+        @report = report
+      end
+      
+      def render
+        output = ''
+        depth = {}
+        
+        # find depth
+        @report.process_data.each do |row|
+          @report.columns.each do |column|
+            i = row[:data][column].to_s.size
+            depth[column] ||= @report.column_title(column).to_s.size
+            depth[column] = (depth[column] < i) ? i : depth[column]
+          end
+        end
+
+        # header
+        output += '|'
+        @report.columns.each do |column|
+          output += @report.column_title(column).to_s.ljust(depth[column] + 1) + '| '
+        end
+        output += "\n"
+
+        total = depth.values.inject { |sum, i| sum + i } + (depth.size * 3)
+        0.upto(total) { |i| output += '-' }
+        output += "\n" 
+
+        # body
+        @report.process_data.each do |row|
+          (row[:meta][:group]) ? sep = ':' : sep = '|'
+          output += sep
+          @report.columns.each do |column|
+            output += row[:data][column].to_s.ljust(depth[column] + 1) + sep + ' '
+          end
+          output += "\n"
+        end
+        
+        output
+      end
+      
+      def valid?
+        @report.is_a? Munger::Report
+      end
+    
+    end
+  end
+end

data/lib/munger/report.rb

@@ -0,0 +1,349 @@
+module Munger #:nodoc:
+  
+  class Report
+    
+    attr_writer :data, :sort, :columns, :subgroup, :subgroup_options, :aggregate
+    attr_accessor :column_titles, :column_data_fields, :column_formatters
+    attr_reader :process_data, :grouping_level
+    
+    # r = Munger::Report.new ( :data => data, 
+    #   :columns => [:collect_date, :spot_name, :airings, :display_name],
+    #   :sort => [:collect_date, :spot_name]
+    #   :subgroup => @group_list,
+    #   :aggregate => {:sum => new_columns} )
+    # report = r.highlight
+    def initialize(options = {})
+      @grouping_level = 0
+      @column_titles = {}
+      @column_data_fields = {}
+      @column_formatters = {}
+      set_options(options)
+    end
+    
+    def self.from_data(data)
+      Report.new(:data => data)
+    end
+    
+    def set_options(options)
+      if d = options[:data]
+        if d.is_a? Munger::Data
+          @data = d
+        else
+          @data = Munger::Data.new(:data => d)
+        end
+      end
+      self.sort(options[:sort]) if options[:sort]
+      self.columns(options[:columns]) if options[:columns]
+      self.subgroup(options[:subgroup]) if options[:subgroup]
+      self.aggregate(options[:aggregate]) if options[:aggregate]
+    end
+    
+    def processed?
+      if @process_data
+        true
+      else
+        false
+      end
+    end
+    
+    # returns ReportTable
+    def process(options = {})
+      set_options(options)
+            
+      # sorts and fills NativeReport 
+      @report = translate_native(do_field_sort(@data.data))
+      
+      do_add_groupings
+      do_add_aggregate_rows
+      
+      self
+    end
+    
+    def sort(values = nil)
+      if values
+        @sort = values 
+        self
+      else
+        @sort
+      end
+    end
+    
+    def subgroup(values = nil, options = {})
+      if values
+        @subgroup = values 
+        @subgroup_options = options
+        self
+      else
+        @subgroup
+      end
+    end
+    
+    def columns(values = nil)
+      if values
+        if values.is_a? Hash
+          @columns = values.keys
+          @column_titles = values
+        else
+          @columns = Data.array(values)
+        end
+        self
+      else
+        @columns ||= @data.columns
+      end
+    end
+
+    def column_title(column)
+      if c = @column_titles[column]
+        return c.to_s
+      else
+        return column.to_s
+      end
+    end
+    
+    def column_data_field(column)
+      @column_data_fields[column] || column.to_s
+    end
+    
+    def column_formatter(column)
+      @column_formatters[column]
+    end
+    
+    def aggregate(values = nil)
+      if values
+        @aggregate = values 
+        self
+      else
+        @aggregate
+      end
+    end
+    
+    def rows
+      @process_data.size
+    end
+    
+    def valid?
+      (@data.is_a? Munger::Data) && (@data.valid?)
+    end
+
+    # @report.style_cells('highlight') { |cell, row| cell > 32 }
+    def style_cells(style, options = {})
+      @process_data.each_with_index do |row, index|
+        
+        # filter columns to look at
+        if options[:only]
+          cols = Data.array(options[:only])
+        elsif options [:except]
+          cols = columns - Data.array(options[:except])
+        else
+          cols = columns
+        end
+
+        if options[:no_groups] && row[:meta][:group]
+          next
+        end
+          
+        cols.each do |col|
+          if yield(row[:data][col], row[:data])
+            @process_data[index][:meta][:cell_styles] ||= {}
+            @process_data[index][:meta][:cell_styles][col] ||= []
+            @process_data[index][:meta][:cell_styles][col] << style
+          end
+        end
+      end
+    end
+    
+    # @report.style_rows('highlight') { |row| row.age > 32 }
+    def style_rows(style, options = {})
+      @process_data.each_with_index do |row, index|
+        if yield(row[:data])
+          @process_data[index][:meta][:row_styles] ||= []
+          @process_data[index][:meta][:row_styles] << style
+        end
+      end
+    end
+
+    # post-processing calls
+
+    def get_subgroup_rows(group_level = nil)
+      data = @process_data.select { |r| r[:meta][:group] }
+      data = data.select { |r| r[:meta][:group] == group_level } if group_level
+      data
+    end
+    
+    def to_s
+      pp @process_data
+    end
+    
+    private 
+      
+      def translate_native(array_of_hashes)
+        @process_data = []
+        array_of_hashes.each do |row|
+          @process_data << {:data => Item.ensure(row), :meta => {:data => true}}
+        end
+      end
+      
+      def do_add_aggregate_rows
+        return false if !@aggregate
+        return false if !@aggregate.is_a? Hash
+        
+        totals = {}        
+        
+        @process_data.each_with_index do |row, index|
+          if row[:meta][:data]
+            @aggregate.each do |type, columns|
+              Data.array(columns).each do |column|
+                value = row[:data][column]
+                @grouping_level.downto(0) do |level|
+                  totals[column] ||= {}
+                  totals[column][level] ||= []
+                  totals[column][level] << value
+                end
+              end
+            end
+          elsif level = row[:meta][:group] 
+            # write the totals and reset level
+            @aggregate.each do |type, columns|
+              Data.array(columns).each do |column|
+                data = totals[column][level]
+                @process_data[index][:data][column] = calculate_aggregate(type, data)
+                totals[column][level] = []
+              end
+            end
+          end
+        end
+              
+        total_row = {:data => {}, :meta => {:group => 0}}
+        # write one row at the end with the totals
+        @aggregate.each do |type, columns|
+          Data.array(columns).each do |column|
+            data = totals[column][0]
+            total_row[:data][column] = calculate_aggregate(type, data)
+          end
+        end
+        @process_data << total_row
+        
+      end
+      
+      def calculate_aggregate(type, data)
+        return 0 if !data
+        if type.is_a? Proc
+          type.call(data)
+        else
+          case type
+          when :count
+            data.size
+          when :average
+            sum = data.inject {|sum, n| sum + n }
+            (sum / data.size) rescue 0
+          else
+            data.inject {|sum, n| sum + n }
+          end
+        end
+      end
+      
+      def do_add_groupings
+        return false if !@subgroup
+        sub = Data.array(@subgroup)
+        @grouping_level = sub.size
+        
+        current = {}
+        new_data = []
+        
+        first_row = @process_data.first
+        sub.reverse.each do |group|
+          current[group] = first_row[:data][group]
+        end
+        prev_row = {:data => {}}
+        
+        @process_data.each_with_index do |row, index|
+          # insert header title rows
+          next_row = @process_data[index + 1]
+          
+          if next_row
+            
+            # insert header rows
+            if @subgroup_options[:with_headers]
+              level = 1
+              sub.each do |group|
+                if (prev_row[:data][group] != current[group]) && current[group]
+                  group_row = {:data => {}, :meta => {:group_header => level, 
+                              :group_name => group, :group_value => row[:data][group]}}
+                  new_data << group_row
+                end
+                level += 1
+              end
+            end
+            
+            # insert current row
+            new_data << row
+
+
+            # insert footer rows
+            level = @grouping_level
+            sub.reverse.each do |group|
+              if (next_row[:data][group] != current[group]) && current[group]
+                group_row = {:data => {}, :meta => {:group => level, :group_name => group}}
+                new_data << group_row
+              end
+              current[group] = next_row[:data][group]
+              level -= 1
+            end 
+            
+            prev_row = row
+            
+          else  # last row
+            level = @grouping_level
+            
+            # insert header rows
+            sub.each do |group|
+              if (prev_row[:data][group] != current[group]) && current[group]
+                group_row = {:data => {}, :meta => {:group_header => level, 
+                            :group_name => group, :group_value => row[:data][group]}}
+                new_data << group_row
+              end
+            end
+            
+            new_data << row
+            
+            sub.reverse.each do |group|
+              group_row = {:data => {}, :meta => {:group => level, :group_name => group}}
+              new_data << group_row
+              level -= 1
+            end
+          end
+        end
+
+        @process_data = new_data
+      end
+      
+      def do_field_sort(data)
+        data.sort do |a, b|
+          compare = 0
+          a = Item.ensure(a)
+          b = Item.ensure(b)
+      
+          Data.array(@sort).each do |sorting|
+            if sorting.is_a?(String) || sorting.is_a?(Symbol)
+              compare = a[sorting.to_s] <=> b[sorting.to_s] rescue 0
+              break if compare != 0
+            elsif sorting.is_a? Array
+              key = sorting[0]
+              func = sorting[1]
+              if func == :asc
+                compare = a[key] <=> b[key]
+              elsif func == :desc
+                compare = b[key] <=> a[key]
+              elsif func.is_a? Proc
+                compare = func.call(a[key], b[key])
+              end
+              break if compare != 0
+            end
+          end
+          compare
+        end
+      end
+    
+  end
+  
+end