ruport 0.7.2 → 0.8.0

data/lib/ruport/attempt.rb

@@ -1,63 +1,63 @@
 require 'timeout'
 
 class Attempt # :nodoc:
-   VERSION = '0.1.0'
-   
-   # Number of attempts to make before failing.  The default is 3.
-   attr_accessor :tries
-   
-   # Number of seconds to wait between attempts.  The default is 60.
-   attr_accessor :interval
-   
-   # a level which ruport understands.  
-   attr_accessor :log_level
-   
-   # If set, this increments the interval with each failed attempt by that
-   # number of seconds.
-   attr_accessor :increment
-   
-   # If set, the code block is further wrapped in a timeout block.
-   attr_accessor :timeout
-   
-   # Determines which exception level to check when looking for errors to
-   # retry.  The default is 'Exception' (i.e. all errors).
-   attr_accessor :level
-   
-   # :call-seq:
-   #    Attempt.new{ |a| ... }
-   # 
-   # Creates and returns a new +Attempt+ object.  Use a block to set the
-   # accessors.
-   # 
-   def initialize           
-      @tries     = 3         # Reasonable default
-      @interval  = 60        # Reasonable default
-      @increment = nil       # Should be an int, if provided
-      @timeout   = nil       # Wrap the code in a timeout block if provided
-      @level     = Exception # Level of exception to be caught
-      
-      yield self if block_given?
-   end
-   
-   def attempt
-      count = 1
-      begin
-         if @timeout
-            Timeout.timeout(@timeout){ yield }
-         else
-            yield
-         end
-      rescue @level => error
-         @tries -= 1
-         if @tries > 0
-            msg = "Error on attempt # #{count}: #{error}; retrying"
-            count += 1
-            Ruport.log(msg, :level => log_level)
-            @interval += @increment if @increment
-            sleep @interval
-            retry
-         end
-         raise
-      end
-   end
+  VERSION = '0.1.0'
+
+  # Number of attempts to make before failing.  The default is 3.
+  attr_accessor :tries
+
+  # Number of seconds to wait between attempts.  The default is 60.
+  attr_accessor :interval
+
+  # a level which ruport understands.  
+  attr_accessor :log_level
+
+  # If set, this increments the interval with each failed attempt by that
+  # number of seconds.
+  attr_accessor :increment
+
+  # If set, the code block is further wrapped in a timeout block.
+  attr_accessor :timeout
+
+  # Determines which exception level to check when looking for errors to
+  # retry.  The default is 'Exception' (i.e. all errors).
+  attr_accessor :level
+
+  # :call-seq:
+  #    Attempt.new{ |a| ... }
+  # 
+  # Creates and returns a new +Attempt+ object.  Use a block to set the
+  # accessors.
+  # 
+  def initialize           
+    @tries     = 3         # Reasonable default
+    @interval  = 60        # Reasonable default
+    @increment = nil       # Should be an int, if provided
+    @timeout   = nil       # Wrap the code in a timeout block if provided
+    @level     = Exception # Level of exception to be caught
+    
+    yield self if block_given?
+  end
+
+  def attempt
+    count = 1
+    begin
+       if @timeout
+          Timeout.timeout(@timeout){ yield }
+       else
+          yield
+       end
+    rescue @level => error
+       @tries -= 1
+       if @tries > 0
+          msg = "Error on attempt # #{count}: #{error}; retrying"
+          count += 1
+          Ruport.log(msg, :level => log_level)
+          @interval += @increment if @increment
+          sleep @interval
+          retry
+       end
+       raise
+    end
+  end
 end

data/lib/ruport/config.rb

@@ -165,10 +165,10 @@ module Ruport
     # Verifies that you have provided a DSN for your source.
     def check_source(settings,label) # :nodoc:
       unless settings.dsn
-        Ruport.complain( 
+        Ruport.log( 
           "Missing DSN for source #{label}!",
           :status => :fatal, :level => :log_only,
-          :exception => ArgumentError 
+          :raises => ArgumentError 
         )
       end
     end
@@ -176,10 +176,10 @@ module Ruport
     # Verifies that you have provided a host for your mailer.
     def check_mailer(settings, label) # :nodoc:
       unless settings.host
-        Ruport.complain(
+        Ruport.log(
           "Missing host for mailer #{label}",
           :status => :fatal, :level => :log_only,
-          :exception => ArgumentError
+          :raises => ArgumentError
         )
       end
     end
@@ -189,5 +189,16 @@ module Ruport
       @debug_mode = !!something
     end
     
+    # Allows users to set their own accessors on the Config module
+    def method_missing(meth, *args)
+      @config ||= OpenStruct.new
+      
+      if args.empty? || meth.to_s =~ /.*=/
+        @config.send(meth, *args)
+      else
+        @config.send("#{meth}=".to_sym, *args)
+      end
+    end
+    
   end
 end

data/lib/ruport/data.rb

@@ -1,6 +1,4 @@
 require "ruport/data/groupable" 
 require "ruport/data/taggable" 
 require "ruport/data/record" 
-require "ruport/data/collection" 
 require "ruport/data/table" 
-require "ruport/data/set"

data/lib/ruport/data/groupable.rb

@@ -8,6 +8,7 @@ module Ruport::Data
   #
   module Groupable
 
+    #
     # Creates a <tt>Record</tt> made up of <tt>Table</tt>s containing all the
     # records in the original table with the same tag. 
     #
@@ -39,20 +40,23 @@ module Ruport::Data
     #      | clyde  |   4   |
     #      +----------------+
     #
-    def group_by_tag
-      r_tags = map { |r| r.tags }.flatten.uniq
+    def groups
+      #r_tags = map { |r| r.tags }.flatten.uniq
+      r_tags = group_names_intern
       tables_hash = Hash.new { |h,k| h[k] = [].to_table(column_names) }
-      each { |row|
-        row.tags.each { |t| 
-          tables_hash[t].instance_variable_get(:@data) << row
-        }
-      }
-      r = Record.new tables_hash, :attributes => r_tags
-      class << r
-        def each_group; attributes.each { |a| yield(a) }; end
-      end; r
+      r_tags.each { |t| 
+        tables_hash[t.gsub(/^grp_/,"")] = sub_table { |r| r.tags.include? t }}
+      r = Record.new tables_hash, :attributes => group_names
+    end  
+    
+    def group_names
+       group_names_intern.map { |r| r.gsub(/^grp_/,"") }
     end
-
+    
+    def group(tag)
+      sub_table { |r| r.tags.include?("grp_#{tag}") }
+    end
+    #
     # Tags each row of the <tt>Table</tt> for which the <tt>block</tt> is not 
     # false with <tt>label</tt>.
     # 
@@ -72,10 +76,15 @@ module Ruport::Data
     #      | pinky  |   3   |
     #      +----------------+
     #
-    def create_tag_group(label,&block)
-      each { |r| block[r] && r.tag(label) }
-    end
-    alias_method :tag_group, :create_tag_group
+    def create_group(label,&block)
+      each { |r| block[r] && r.tag("grp_#{label}") }
+    end  
+    
+    private
+    
+    def group_names_intern
+       map { |r| r.tags.select { |r| r =~ /^grp_/  } }.flatten.uniq   
+    end    
 
   end
 end

data/lib/ruport/data/record.rb

@@ -5,18 +5,19 @@
 # Copyright 2006 by respective content owners, all rights reserved.
 module Ruport::Data
 
+  #
   # === Overview
   # 
   # Data::Records are the work horse of Ruport's data model. These can behave
   # as Array-like, Hash-like, or Struct-like objects.  They are used as the 
-  # base element in both Tables and Sets.
+  # base element for Data::Table
   #
   class Record
-    require "forwardable"
-    extend Forwardable
-    include Enumerable
-    include Taggable
 
+    include Taggable
+    include Enumerable  
+    
+    # 
     # Creates a new Record object.  If the <tt>:attributes</tt> 
     # keyword is specified, Hash-like and Struct-like 
     # access will be enabled.  Otherwise, Record elements may be 
@@ -44,24 +45,18 @@ module Ruport::Data
     #   b.c    #=> 3
     #
     def initialize(data,options={})
-      if data.kind_of?(Hash)
-        if options[:attributes]
-          @attributes = options[:attributes]
-          @data = options[:attributes].map { |k| data[k] }
-        else
-          @attributes, @data = data.to_a.transpose
-        end
-      else
+      data = data.dup
+      case(data)
+      when Array
+        @attributes = options[:attributes] || (0...data.length).to_a
+        @data = @attributes.inject({}) { |h,a| h.merge(a => data.shift) }
+      when Hash
         @data = data.dup
-        @attributes = options[:attributes] || []
+        @attributes = options[:attributes] || data.keys
       end
-    end
-    
-    # The underlying <tt>data</tt> which is being stored in the record.
-    attr_reader :data
+    end 
     
-    def_delegators :@data,:each, :length
-  
+    #
     # Allows either Array or Hash-like indexing.
     #
     # Examples:
@@ -70,16 +65,15 @@ module Ruport::Data
     #   my_record["foo"]
     #
     def [](index)
-      if index.kind_of? Integer
-        raise "Invalid index" unless index < @data.length
-        @data[index]
+      case(index)
+      when Integer
+        @data[@attributes[index]]
       else
-        index = index.to_s
-        raise "Invalid index" unless attributes.index(index)
-        @data[attributes.index(index)]
+        @data[index]
       end
     end
-
+        
+    # 
     # Allows setting a <tt>value</tt> at an <tt>index</tt>.
     # 
     # Examples:
@@ -87,28 +81,21 @@ module Ruport::Data
     #    my_record[1] = "foo" 
     #    my_record["bar"] = "baz"
     #
-    def []=(index, value)
-      if index.kind_of? Integer
-        raise "Invalid index" unless index < @data.length
-        @data[index] = value
+    def []=(index,value)
+      case(index)
+      when Integer
+        @data[@attributes[index]] = value
       else
-        index = index.to_s
-        raise "Invalid index" unless @attributes.index(index)
-        @data[attributes.index(index)] = value
+        @data[index] = value
       end
     end
 
-    # If <tt>attributes</tt> and <tt>data</tt> are equivalent, then 
-    # <tt>==</tt> evaluates to true. Otherwise, <tt>==</tt> returns false.
-    #
-    def ==(other)
-      return false if @attributes && !other.attributes
-      return false if other.attributes && !@attributes
-      @attributes == other.attributes && @data == other.data
+    def size
+      @data.size
     end
-
-    alias_method :eql?, :==
-   
+    alias_method :length, :size
+    
+    #
     # Converts a Record into an Array.
     #
     # Example:
@@ -116,17 +103,27 @@ module Ruport::Data
     #   a = Data::Record.new([1,2],:attributes => %w[a b])
     #   a.to_a #=> [1,2]
     #
-    def to_a; @data.dup; end
+    # Note: in earlier versions of Ruport, to_a was aliased to data.
+    #       From now on to_a only for array representation! 
+    def to_a
+      @attributes.map { |a| @data[a] }
+    end
+       
+     attr_reader :data
     
-    # Converts a Record into a Hash. This only works if <tt>attributes</tt> 
-    # are specified in the Record.
-    #
-    # Example:
-    #
-    #   a = Data::Record.new([1,2],:attributes => %w[a b])
-    #   a.to_h #=> {"a" => 1, "b" => 2}
-    def to_h; Hash[*@attributes.zip(data).flatten] end
-  
+     #
+     # Converts a Record into a Hash. 
+     #
+     # Example:
+     #
+     #   a = Data::Record.new([1,2],:attributes => %w[a b])
+     #   a.to_h #=> {"a" => 1, "b" => 2}
+    def to_h
+      @data.dup
+    end          
+    
+    #alias_method :data,:to_a
+     
     # Returns a copy of the <tt>attributes</tt> from this Record.
     #
     # Example:
@@ -134,72 +131,79 @@ module Ruport::Data
     #   a = Data::Record.new([1,2],:attributes => %w[a b])
     #   a.attributes #=> ["a","b"]
     #
-    def attributes; @attributes.map { |a| a.to_s }; end
-
-    # Sets the <tt>attribute</tt> list for this Record.
+    def attributes
+      @attributes.dup
+    end
+    
+    #
+    # Sets the <tt>attribute</tt> list for this Record. 
+    # (Dangerous when used within Table objects!)
     #
     # Example:
     #
     #   my_record.attributes = %w[foo bar baz]
     #
     attr_writer :attributes
-
+    
+    #
+    # If <tt>attributes</tt> and <tt>to_a</tt> are equivalent, then 
+    # <tt>==</tt> evaluates to true. Otherwise, <tt>==</tt> returns false.
+    #
+    def ==(other)
+       @attributes.eql?(other.attributes) &&
+       to_a == other.to_a
+    end
+    
+    alias_method :eql?, :==
+    
+    # Yields each element of the Record.  Does not provide attribute names
+    def each 
+      to_a.each { |e| yield(e) }
+    end
+    
+    #
     # Allows you to change the order of or reduce the number of columns in a
     # Record.  
     #
     # Example:
     #
     #   a = Data::Record.new([1,2,3,4],:attributes => %w[a b c d])
-    #   b = a.reorder("a","d","b")
-    #   b.attributes #=> ["a","d","b"]
-    #   b.data #=> [1,4,2]
-    #
+    #   a.reorder("a","d","b")
+    #   a.attributes #=> ["a","d","b"]
+    #   a.data #=> [1,4,2]  
     def reorder(*indices)
-      dup.reorder!(*indices)
-    end
-    
-    # Same as Record#reorder but modifies its reciever in place.
-    def reorder!(*indices)
-      indices = reorder_data!(*indices)
-      if @attributes
-        if indices.all? { |e| e.kind_of? Integer }
-          @attributes = indices.map { |i| @attributes[i] }
-        else
-          @attributes = indices
-        end
-      end; self
-    end
-
-    def reorder_data!(*indices) # :nodoc:
-      indices = indices[0] if indices[0].kind_of?(Array) 
-      indices.each do |i| 
-        self[i] rescue raise ArgumentError, 
-                "you may have specified an invalid column" 
+      indices[0].kind_of?(Array) && indices.flatten!
+      if indices.all? { |i| i.kind_of? Integer } 
+        raise ArgumentError unless indices.all? { |i| @attributes[i] }
+        self.attributes = indices.map { |i| @attributes[i] }
+      else
+        raise ArgumentError unless (indices - @attributes).empty?
+        self.attributes = indices
       end
-      @data = indices.map { |i| self[i] }
-      return indices;
+      self
+    end  
+     
+    # Takes an old name and a new name and renames an attribute.      
+    def rename_attribute(old_name,new_name,update_index=true)
+      @attributes[@attributes.index(old_name)] = new_name if update_index
+      @data[new_name] = @data.delete(old_name)
     end
-
-    
-    # Makes a fresh copy of the Record.
-    def dup
-      copy = self.class.new(@data,:attributes => attributes)
-      copy.tags = self.tags.dup
-      return copy
-    end 
-    
-    #FIXME: This does not take into account frozen / tainted state
-    alias_method :clone, :dup
     
+    #
     # Provides a unique hash value. If a Record contains the same data and
     # attributes as another Record, they will hash to the same value, even if
     # they are not the same object. This is similar to the way Array works, 
     # but different from Hash and other objects.
     #
     def hash
-      (attributes.to_a + data.to_a).hash
+      @attributes.hash + to_a.hash
     end
-
+    
+    # Makes a fresh copy of the Record. 
+    def dup
+      r = Record.new(@data.dup,:attributes => @attributes.dup)
+    end
+        
     # Provides accessor style methods for attribute access.
     #
     # Example:
@@ -207,14 +211,36 @@ module Ruport::Data
     #   my_record.foo = 2
     #   my_record.foo #=> 2
     #
-    def method_missing(mname, *args)
-      id = mname.to_s.gsub(/=$/,"")
-      if attributes.include?(id)
-        args.empty? ? self[id] : self[id] = args.first
+    def method_missing(id,*args)
+      k = id.to_s.gsub(/=$/,"")
+      if(key = @attributes.find { |r| r.to_s.eql?(k) })
+        args[0] ? @data[key] = args[0] : @data[key]
       else
-        super(mname, *args)
+       super
+     end
+    end 
+
+    #indifferentish access that also can call methods
+    def get(name)
+      case name
+      when Symbol
+        send(name)
+      when String
+        self[name]
+      else
+        raise "Whatchu Talkin' Bout, Willis?"
       end
     end
+    
+    private
+    
+    def delete(key)
+      @data.delete(key)
+    end
 
+
+    def reindex(new_attributes)
+      @attributes.replace(new_attributes)
+    end
   end
 end