ruport 0.4.13 → 0.4.15

data/CHANGELOG

@@ -1,4 +1,26 @@
-The current version of Ruby Reports is 0.4.13
+The current version of Ruby Reports is 0.4.15
+
+changes since 0.4.13
+
+- Began building a new data handling system, which is much faster than
+  DataSet/DataRow and takes up less memory.  It is also very young, though.
+  (See Data::Table and Data::Record)
+
+- Added init_plugin hooks
+
+- Added DataSet#rename_columns
+
+- Added taggable mixin
+
+- Added an options accessor to help solve ticket #8
+
+- Alioth now has a powerful hook back into the engine from plugins via helpers
+
+- added action / attribute methods for format engine / plugin via MetaTools
+
+- added accessor style methods to DataRow via method_missing
+
+- added prune method for Table formmatting. 
 
 changes since 0.4.11
 

data/Rakefile

@@ -21,7 +21,7 @@ end
 
 spec = Gem::Specification.new do |spec|
 	spec.name = LEAN ? "lean-ruport" : "ruport"
-	spec.version = "0.4.13"
+	spec.version = "0.4.15"
 	spec.platform = Gem::Platform::RUBY
 	spec.summary = "A generalized Ruby report generation and templating engine."
 	spec.files =  Dir.glob("{examples,lib,test}/**/**/*") +

data/TODO

@@ -6,8 +6,6 @@ Immediate Goals:
 
     - PDF document support + example
 
-    - event system
- 
     - Composite key selection
 
     - Value modification predicate.
@@ -18,6 +16,4 @@ Immediate Goals:
 
     - Document the inner classes of Format
 
-    - make the Fetchable module to abstract data acquisition
-  
     - Calculated fields

data/lib/ruport/data/collection.rb

@@ -0,0 +1,20 @@
+module Ruport::Data
+  class Collection
+    require "forwardable"
+    extend Forwardable
+    include Enumerable
+    include Taggable
+
+    def initialize(data=nil,options={})
+      @data = data.dup if data
+    end
+
+    def as(type)
+      Ruport::Format.table :data => self, :plugin => type
+    end
+    
+    attr_reader :data
+    def_delegators :@data, :each, :length, :[], :empty?
+  end
+end
+

data/lib/ruport/data/record.rb

@@ -0,0 +1,81 @@
+module Ruport::Data
+  class Record
+    require "forwardable"
+    extend Forwardable
+    include Enumerable
+    include Taggable
+
+    def initialize(data,options={})
+      @data = data.dup
+      @attributes = options[:attributes]
+    end
+
+    attr_reader :data
+    def_delegators :@data,:each, :length
+
+  
+    def [](index)
+      if index.kind_of? Integer
+        @data[index]
+      else
+        @data[@attributes.index(index)]
+      end
+    end
+
+    def []=(index, value)
+      if index.kind_of? Integer
+        @data[index] = value
+      else
+        @data[attributes.index(index)] = value
+      end
+    end
+
+    def ==(other)
+      return false if attributes && !other.attributes
+      return false if other.attributes && !attributes
+      (attributes == other.attributes) && (data == other.data)
+    end
+
+    alias_method :eql?, :==
+    
+    def to_a; data.dup; end
+    
+    def to_h; Hash[*attributes.zip(data).flatten] end
+
+    def attributes; @attributes && @attributes.dup; end
+
+    def attributes=(a); @attributes=a; end
+
+    def reorder(*indices)
+      dup.reorder! *indices
+    end
+
+    def reorder!(*indices)
+      @data = indices.map { |i| self[i] }
+      if attributes
+        if indices.all? { |e| e.kind_of? Integer }
+          @attributes = indices.map { |i| @attributes[i] }
+        else
+          @attributes = indices
+        end
+      end; self
+    end
+
+    def dup
+      self.class.new(data,:attributes => attributes)
+    end 
+    
+    #FIXME: This does not take into account frozen / tainted state
+    alias_method :clone, :dup
+
+    def method_missing(id,*args)
+      id = id.to_s.gsub(/=$/,"")
+      if @attributes.include?(id)
+        args.empty? ? self[id] : self[id] = args.first
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/ruport/data/table.rb

@@ -0,0 +1,57 @@
+module Ruport::Data
+  class Table < Collection
+    def initialize(options={})
+      @column_names = options[:column_names].dup if options[:column_names]
+      @data         = []
+      options[:data].each { |e| self << e }  if options[:data]
+    end
+
+    attr_reader :column_names
+    
+    def column_names=(other)
+      @column_names = other.dup
+    end
+
+    def <<(other)
+      case(other)
+      when Array
+        @data << Record.new(other, :attributes => @column_names)
+      when Hash
+        raise unless @column_names
+        arr = @column_names.map { |k| other[k] }
+        @data << Record.new(arr, :attributes => @column_names)
+      when Record
+        @data << Record.reorder(*column_names)
+      end
+    end
+
+    def reorder!(*indices)
+      @column_names = indices
+      @data.each { |r| r.reorder! *indices }; self
+    end
+
+    def reorder(*indices)
+      dup.reorder! *indices
+    end
+
+    def self.load(csv_file, options = {})
+      options = {:has_names => true}.merge(options)
+      require "fastercsv"
+      loaded_data = self.new
+
+      first_line = true
+      FasterCSV.foreach(csv_file) do |row|
+        if first_line && options[:has_names]
+          loaded_data.column_names = row
+          first_line = false
+        elsif !block_given?
+          loaded_data << row
+        else
+          yield(loaded_data,row)
+        end
+      end
+      return loaded_data
+    end 
+
+  end
+end

data/lib/ruport/data/taggable.rb

@@ -0,0 +1,27 @@
+module Ruport::Data
+  
+  module Taggable
+
+    def tag(tag_name)
+      tags << tag_name unless has_tag? tag_name
+    end
+
+    def delete_tag(tag_name)
+      tags.delete tag_name
+    end
+  
+    def has_tag?(tag_name)
+      tags.include? tag_name
+    end
+  
+    def tags
+      @ruport_tags ||= []
+    end
+    
+    def tags=(tags_list)
+      @ruport_tags = tags_list
+    end
+
+  end
+  
+end

data/lib/ruport/data.rb

@@ -0,0 +1 @@
+%w[taggable record collection table].each { |l| require "ruport/data/#{l}" }

data/lib/ruport/data_row.rb

@@ -74,7 +74,7 @@ module Ruport
       
       attr_accessor :fields, :tags
       alias_method  :column_names, :fields
-      
+      alias_method  :attributes, :fields
       # Returns a new DataRow
       def +(other)
         DataRow.new @fields + other.fields, :data => (@data + other.to_a)
@@ -177,5 +177,11 @@ module Ruport
           :status => :fatal, :exception => ArgumentError, :level => :log_only
         end
       end
-    end
+    
+      def method_missing(id,*args)
+        f = id.to_s.gsub(/=$/,'')
+        return super unless fields.include?(f)
+        args.empty? ? self[f] : self[f] = args[0]
+      end
+  end
 end

data/lib/ruport/data_set.rb

@@ -234,6 +234,14 @@ module Ruport
       @fields = d.fields
     end
 
+    def rename_columns(cols)
+      if cols.kind_of?(Array)
+        cols.each_with_index { |c,i| fields[i] = c }
+      else
+        cols.map { |k,v| fields[fields.index(k)] = v }
+      end
+      @data.each { |r| r.fields = fields }
+    end
     # uses Format::Builder to render DataSets in various ready to output
     # formats.  
     #
@@ -249,7 +257,7 @@ module Ruport
     #
     # This will enable <tt>data.as(:my_format_name)</tt>
     def as(format,&action)
-      t = Format.table_object(:data => clone, :plugin => format)
+      t = Format.table_object(:data => self, :plugin => format)
       action.call(t) if block_given?
       t.render
     end
@@ -286,6 +294,7 @@ module Ruport
       f.all? { |e| e.kind_of? Integer } &&
       f.inject([]) { |s,e| s + [@fields[e]] } || f
     end
+
     
   end
 end

data/lib/ruport/format/engine.rb

@@ -1,23 +1,25 @@
 module Ruport
   class Format::Engine
     require "forwardable"
-    
     class << self
 
       include Enumerable
+      include MetaTools
       extend Forwardable
 
-      def_delegator :@data, :each
-      
-      def renderer(&block)
-        block = lambda { data } unless block_given?
-        (class << self; self; end).send(:define_method, :render, &block)
-      end
-
       attr_accessor :engine_klasses
       attr_reader :plugin 
       attr_reader :data
       attr_accessor :klass_binding
+      attr_reader :options
+      
+      def_delegator :@data, :each
+      private :attribute, :attributes, :singleton, :action
+
+      def renderer(&block)
+        block = lambda { data } unless block_given?
+        singleton.send(:define_method, :render,&block)
+      end
       
       def alias_engine(klass,name)
         Format::Engine.engine_klasses ||= {}
@@ -28,10 +30,15 @@ module Ruport
         @data = data
         active_plugin.data = data.dup if active_plugin
       end
+
+      def options=(opts)
+        @options = opts
+        active_plugin.options = options if active_plugin
+      end
       
       def active_plugin
+        return yield(@format_plugins[:current]) if block_given?
         @format_plugins[:current]  
-        #plugin && @format_plugins[plugin]
       end
 
       def plugin=(p)
@@ -49,6 +56,9 @@ module Ruport
         raise "No plugin specified" unless plugin
         raise "No data provided" unless data
         active_plugin.data = data.dup
+        if active_plugin.respond_to? :init_plugin_helper
+          active_plugin.init_plugin_helper(self)
+        end
       end
 
       def flush_data
@@ -73,6 +83,11 @@ module Ruport
         format_plugins.values
       end 
       
+      def method_missing(id)
+        super unless active_plugin.respond_to?("#{id}_helper")
+        return active_plugin.send("#{id}_helper",self)
+      end
+
     end
   end
   
@@ -81,8 +96,8 @@ module Ruport
      renderer do
         super
         active_plugin.rendered_field_names = "" 
-        build_field_names if (data.respond_to?(:fields) && 
-                              data.fields && show_field_names)
+        build_field_names if (data.respond_to?(:column_names) && 
+                              data.column_names && show_field_names)
         a = active_plugin.render_table
       end
 
@@ -96,6 +111,17 @@ module Ruport
         data[0].to_a.length
       end
 
+      def prune(limit=data[0].length)
+        (0...limit).each do |field|
+          last = ""
+          data.each_with_index { |e,i|
+            next if i.zero? || field.nonzero? && data[i][field-1] 
+            last = data[i-1][field] if data[i-1][field]
+            data[i][field] = nil if e[field] == last
+          }
+        end
+      end
+      
       attr_accessor :show_field_names
       
       private
@@ -105,7 +131,7 @@ module Ruport
           active_plugin.rendered_field_names = active_plugin.build_field_names
         end
       end
-      
+
     end  
     
       alias_engine Table, :table_engine

data/lib/ruport/format/plugin.rb

@@ -4,10 +4,17 @@ module Ruport
     class << self
 
       attr_accessor :data
+      attr_accessor :options 
+      
+      include MetaTools
 
-      def plugin_name(name)
-        @name = name
+      def helper(name,&block)
+        singleton.send( :define_method, "#{name}_helper", &block )
       end
+
+      private :singleton, :attribute, :attributes, :action
+     
+      def plugin_name(name=nil); @name ||= name; end
       
       def format_name
         pattern = /Ruport::Format|Plugin/
@@ -18,11 +25,11 @@ module Ruport
       def renderer(render_type,&block)
         m = "render_#{render_type}".to_sym
         block = lambda { data } unless block_given?
-        (class << self; self; end).send(:define_method, m, &block)
+        singleton.send(:define_method, m, &block)
       end
 
       def format_field_names(&block)
-        (class << self; self; end).send(:define_method, :build_field_names, &block)
+        singleton.send( :define_method, :build_field_names, &block)
       end
 
       def register_on(klass)
@@ -39,7 +46,7 @@ module Ruport
         @options.merge!(hash)
         @options.dup
       end
-      
+     
       attr_accessor :rendered_field_names
       attr_accessor :pre, :post
       attr_accessor :header, :footer
@@ -47,14 +54,14 @@ module Ruport
     
     
     class CSVPlugin < Format::Plugin
-       
+      
+      helper(:init_plugin) { require "fastercsv" }
+
       format_field_names do
-        require "fastercsv"
-        FasterCSV.generate { |csv| csv << data.fields }
+        FasterCSV.generate { |csv| csv << data.column_names }
       end
       
       renderer :table do
-        require "fastercsv"
         rendered_field_names +
         FasterCSV.generate { |csv| data.each { |r| csv << r } }
       end
@@ -78,7 +85,7 @@ module Ruport
           }
         }
         
-        a = data.inject(th){ |s,r| 
+        a = data.inject(th){ |s,r|
           s + "| #{r.to_a.join(' | ')} |\n"
         } << hr
 
@@ -88,39 +95,40 @@ module Ruport
            r.gsub!(/\A.{#{width},}/) { |m| m[0,width-2] += ">>" }
         }.join("\n") << "\n"
       end
+      
       format_field_names do
-        data.fields.each_with_index { |f,i| 
-          data.fields[i] = f.to_s.center(max_col_width(i))
+        data.column_names.each_with_index { |f,i| 
+          data.column_names[i] = f.to_s.center(max_col_width(i))
         }
-        "#{hr}| #{data.fields.to_a.join(' | ')} |\n"
+        "#{hr}| #{data.column_names.to_a.join(' | ')} |\n"
       end
 
-      def self.max_col_width(index) 
-        f = data.fields if data.respond_to? :fields
+      action :max_col_width do |index|
+        f = data.column_names if data.respond_to? :column_names
         d = DataSet.new f, :data => data
         
         cw = d.map { |r| r[index].to_s.length }.max
         
-        return cw unless d.fields
+        return cw unless d.column_names
         
-        nw = (index.kind_of?(Integer) ? d.fields[index] : index ).to_s.length
+        nw = (index.kind_of?(Integer) ? d.column_names[index] : index ).to_s.length
         
         [cw,nw].max
       end
 
-      def self.table_width
-        f = data.fields if data.respond_to? :fields
+      action :table_width do
+        f = data.column_names if data.respond_to? :column_names
         d = DataSet.new f, :data => data 
 
-        d[0].fields.inject(0) { |s,e| s + max_col_width(e) }
+        d[0].attributes.inject(0) { |s,e| s + max_col_width(e) }
       end
 
-      def self.hr
+      action :hr do
         len = data[0].to_a.length * 3 + table_width + 1
         "+" + "-"*(len-2) + "+\n"
       end
 
-      class << self; attr_accessor :right_margin; end
+      attribute :right_margin
 
       register_on :table_engine
       register_on :document_engine
@@ -145,7 +153,7 @@ module Ruport
         pdf.render
       end
 
-      format_field_names { data.fields }
+      format_field_names { data.column_names }
 
       register_on :table_engine
     end
@@ -165,7 +173,7 @@ module Ruport
       end
 
       format_field_names do
-        s = "|_." + data.fields.join(" |_.") + "|\n"
+        s = "|_." + data.column_names.join(" |_.") + "|\n"
       end
 
       register_on :table_engine

data/lib/ruport/meta_tools.rb

@@ -0,0 +1,19 @@
+module Ruport
+  module MetaTools
+    def singleton; (class << self; self; end); end
+
+    def attribute(sym,value = nil)
+      singleton.send(:attr_accessor, sym )
+      self.send("#{sym}=",value)
+    end
+
+    def attributes(syms)
+      syms.each { |s| attribute s }
+    end
+
+    def action(name,&block)
+      singleton.send(:define_method, name, &block)
+    end
+  end
+end
+

data/lib/ruport/rails/reportable.rb

@@ -1,8 +1,8 @@
 module Ruport
   module Reportable
-    def formatted_table(type,options={},&block)
+    def formatted_table(type,options={})
       to_ds(:find => options[:find],:columns => options[:columns]).as(type){ |e|
-        block[e] if block_given?
+        yield(e) if block_given?
       }
     end
     def to_ds(options={})

data/lib/ruport/report.rb

@@ -137,7 +137,7 @@ module Ruport
     #  result = query "select * from foo", :as => :pdf
     #
     # See source of this function and methods of Ruport::Query for details.
-    def query(sql, options={}, &action)
+    def query(sql, options={})
       options[:origin] ||= :string
       options[:source] ||= @source
 
@@ -147,7 +147,7 @@ module Ruport
       elsif options[:as]
         Format.table :data => q.result, :plugin => options[:as]
       else
-        block_given? ? action.call(q.result) : q.result
+        block_given? ? yield(q.result) : q.result
       end
     end
     

data/lib/ruport.rb

@@ -14,7 +14,7 @@ module Ruport
   
   begin; require 'rubygems'; rescue LoadError; nil end
   
-  VERSION = "Ruby Reports Version 0.4.13"
+  VERSION = "Ruby Reports Version 0.4.15"
   
   # Ruports logging and error interface.
   # Can generate warnings or raise fatal errors
@@ -57,6 +57,6 @@ module Ruport
 end
 
 
-%w[config report format query data_row data_set].each { |lib|
+%w[config meta_tools report format query data_row data_set data].each { |lib|
   require "ruport/#{lib}" 
 }

data/test/tc_data_row.rb

@@ -21,6 +21,14 @@ class TestDataRow < Test::Unit::TestCase
     assert_equal("[1,2]",@rows[0].to_s)
   end
 
+  def test_accessor_style
+    row = @rows[0]
+    assert_equal 1, row.foo
+    assert_equal 2, row.bar
+    row.bar = 17
+    assert_equal [1,17], row.to_a
+  end
+
   def test_tagging
     @rows[0].tag_as :foo
     assert_equal(true, @rows[0].has_tag?(:foo) )

data/test/tc_data_set.rb

@@ -46,6 +46,23 @@ class TestDataSet < Test::Unit::TestCase
                     @data[2].to_a )
   end
 
+  def test_rename_columns
+    @data.rename_columns "col1" => "Column 1", 
+                         "col2" => "Column 2", 
+                         "col3" => "Column 3"
+    assert_equal %w[Column\ 1 Column\ 2 Column\ 3], @data.fields
+    @data.each do |r|
+      assert_equal %w[Column\ 1 Column\ 2 Column\ 3], r.fields
+    end
+    assert_equal "b", @data[0]["Column 2"]
+    assert_equal "e", @data[1]["Column 3"]
+    @data.rename_columns %w[one two three]
+    assert_equal %w[one two three], @data.fields
+    @data.each do |r|
+      assert_equal %w[one two three], r.fields
+    end
+  end
+
   def test_delete_if
     @data.delete_if { |r| r.any? { |e| e.empty? } }
     assert_equal([%w[a b c]],@data.to_a)