ruport-util 0.6.0 → 0.7.0

data/lib/ruport/util/report.rb

@@ -11,71 +11,6 @@ require "forwardable"
 
 module Ruport
 
-  require 'timeout'
-
-  class Attempt # :nodoc:
-    VERSION = '0.1.0 (vendored)'
-
-    # 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
-            @interval += @increment if @increment
-            sleep @interval
-            retry
-         end
-         raise
-      end
-    end
-  end
-
-
-
   # === Overview
   #
   # The Ruport::Report class provides a high level interface to much of Ruport's
@@ -98,41 +33,19 @@ module Ruport
   #     renders_as_grouping(:style => :inline)   
   #
   #     def generate
-  #       table = load_csv "foo.csv"
+  #       table = Table("foo.csv")
   #       Grouping(table, :by => "username")
   #     end  
   #
   #   end   
   #
-  #   report = MyReport.new(:pdf) 
-  #   report.run { |results| results.write("bar.pdf") }
+  #   report = MyReport.new
+  #   report.save_as("bar.pdf")
   #
   class Report   
     extend Forwardable
     include Renderer::Hooks
         
-    # Builds a report instance.  If provided a format parameter, 
-    # this format will be used by default when rendering the report.
-    #
-    def initialize( format=nil )
-      use_source :default
-      @format      = format
-      @report_name = "" 
-      @results     = ""
-      @file        = nil
-    end
-    
-    # By default, this file will be used by Report#write.
-    attr_accessor :file
-
-    # This attribute will get the results of Report#generate when the report is
-    # run.
-    #
-    attr_accessor :results
-     
-    # This attribute defines which format the Report will render in by default.
-    attr_accessor :format
-
     # This is a simplified interface to Ruport::Query.
     #
     # You can use it to read SQL statements from file or string:
@@ -168,9 +81,8 @@ module Ruport
     # See Ruport::Query for details.
     #
     def query(sql, options={})
-      options[:origin] ||= :string
-      options[:source] ||= @source
-      q = options[:query_obj] || Query.new(sql, options)
+      options[:source] ||= :default
+      q = options[:query_obj] || Ruport::Query.new(sql, options)
       if block_given?
         q.each { |r| yield(r) }
       elsif options[:as]
@@ -179,225 +91,47 @@ module Ruport
         q.result
       end
     end
-    
-    # Sets the active source to the Ruport::Query source requested by
-    # <tt>label</tt>. 
-    #
-    # For example, if you have a data source :test, which is defined as such:
-    #
-    #   Ruport::Query.add_source(:test, :dsn => "dbi:mysql:test", 
-    #                                   :user => "root" ) 
-    #
-    #  
-    # The following report would use that data source rather than the
-    # <tt>:default</tt> source:
-    #
-    #   class MyReport < Ruport::Report
-    #
-    #     renders_as_table     
-    #
-    #     def generate
-    #        use_source :test
-    #        query "select * from foo" 
-    #     end             
-    #
-    #   end
-    def use_source(label)
-      @source = label
-    end
-     
-    # Writes the contents of Report#results to file.
-    # If given a string as a second argument, writes that to file, instead.
-    #
-    # Examples:
-    #   
-    #   # write the results of the report to a file
-    #   Report.run { |r| r.write("foo.txt") } 
-    #   
-    #   # write the results in reverse     
-    #   Report.run { |r| r.write("foo.txt",r.results.reverse) }     
-    #    
-    def write(my_file=file,my_results=results)
-      File.open(my_file,"w") { |f| f << my_results }
+
+    def renderable_data #:nodoc:
+      generate
     end
+
+    alias_method :old_as, :as
     
-    # Behaves the same way as Report#write, but will append to a file rather
-    # than create a new file if it already exists.
-    #
-    def append(my_file=file,my_results=results)
-      File.open(my_file,"a") { |f| f << my_results }
+    def as(*args,&block) 
+      prepare if respond_to?(:prepare)
+      output = old_as(*args,&block)
+      cleanup if respond_to?(:cleanup)
+      return output
     end
     
-    # This method passes <tt>self</tt> to Report.run.
-    #
-    # Please see the class method for details.
-    #
-    def run(options={},&block)
-      options[:reports] ||= [self]
-      self.class.run(options,&block)
-    end
-       
-    # Allows you to override the default format.
-    #
-    # Example:
-    #
-    #   my_report.as(:csv) 
-    #
-    def as(format,*args)   
-      self.format,old = format, self.format
-      results = run(*args)  
-      self.format = old 
-      return results
-    end
-                                 
-    # Provides syntactic sugar, allowing to_foo in place of as(:foo)
-    def method_missing(id,*args) 
-      id.to_s =~ /^to_(.*)/
-      $1 ? as($1.to_sym,*args) : super
-    end
-
-    # Loads a CSV in from  a file.
-    #
-    # Example:
-    #
-    #   my_table = load_csv "foo.csv"                 #=> Data::Table
-    #   my_array = load_csv "foo.csv", :as => :array  #=> Array
-    #
-    # See also Ruport::Data::Table.load and Table()
-    #
-    def load_csv(file,options={})
-      case options[:as]
-      when :array
-        a = []
-        Data::Table.load(file,options) { |s,r| a << r } ; a
+    def save_as(filename,options={})
+      formats = { "csv" => ["w",:csv], "txt" => ["w",:text], 
+                  "html" => ["w", :html], "pdf" => ["wb", :pdf ] }
+      
+      fo = filename =~ /.*\.(.*)/ && formats[$1]
+      flags = options.delete(:flags)
+      if fo
+        File.open(filename,flags || fo[0]) { |f| f << as(fo[1],options) }
       else
-        Data::Table.load(file,options)
+        File.open(filename,flags || "w") { |f| f << as($1.to_sym,options) }
       end
     end
 
-    # Executes an erb template.  If a filename is given which matches the
-    # pattern /\.r\w+$/ (eg foo.rhtml, bar.rtxt, etc), 
-    # it will be loaded and evaluated.  Otherwise, the string will be processed
-    # directly.
-    #
-    # Examples:
-    #
-    #  @foo = 'greg'
-    #  erb "My name is <%= @foo %>" #=> "My name is greg"
-    #
-    #  erb "foo.rhtml" #=> contents of evaluated text in foo.rhtml
-    #
-    def erb(s)
-      if s =~ /\.r\w+$/
-        ERB.new(File.read(s)).result(binding)
+    def method_missing(id,*args,&block) 
+      if id.to_s =~ /^to_(.*)/
+        as($1.to_sym,*args,&block)
       else
-        ERB.new(s).result(binding)
+        super
       end
     end
 
-    class << self
-      
-      # Allows you to override the default format.
-      #
-      # Example:
-      #
-      #   my_report.as(:csv) 
-      #
-      def as(format,options={})
-        report = new(format)
-        report.run(rendering_options.merge(options))
-      end 
-      
-      # Provides syntactic sugar, allowing to_foo in place of as(:foo)        
-      def method_missing(id,*args) 
-        id.to_s =~ /^to_(.*)/
-        $1 ? as($1.to_sym,*args) : super
-      end
-
-      # Defines an instance method which will be run before the
-      # <tt>generate</tt> method when Ruport.run is executed.
-      #
-      def prepare(&block); define_method(:prepare,&block) end
-      
-      # Defines an instance method which will be executed by Report.run.
-      #
-      # The return value of this method is assigned to the <tt>results</tt>
-      # attribute.
-      #
-      def generate(&block); define_method(:generate,&block) end
-      
-      # Defines an instance method which will be executed after the object is
-      # yielded in Report.run.
-      #
-      def cleanup(&block); define_method(:cleanup,&block) end
-
-      private :prepare, :generate, :cleanup
-
-      # Runs the reports specified.  If no reports are specified, then it
-      # creates a new instance via <tt>self.new</tt>.
-      #
-      # Hooks called, in order:
-      #    * Report#prepare
-      #    * Report#generate #=> return value stored in @results
-      #    * yields self to block, if given   
-      #    * if a renderer is specified, passes along @results and options
-      #    * Report#cleanup    
-      #
-      # Options: 
-      #   :reports:  A list of reports to run, defaults to a single generic
-      #              instance of the current report (self.new).  
-      # 
-      #   :tries:, :timeout:, :interval:   Wrappers on attempt.rb
-      # 
-      #    all other options will be forwarded to a renderer if one is specified
-      #    via the Renderer::Hooks methods
-      def run(options={})
-        options[:reports] ||= [self.new]
-
-        formatting_options = ( options.keys - 
-                                [:reports,:tries,:timeout,:interval])
-
-        fopts = formatting_options.inject({}) { |s,k|
-          s.merge( k => options[k] )
-        }
-        
-
-        process = lambda do
-          options[:reports].each { |rep|
-            rep.prepare if rep.respond_to? :prepare
-            rep.results = rep.generate
-
-            if renderer
-              rep.results = 
-                renderer.render(rep.format,rendering_options.merge(fopts)) { |r| 
-                r.data = rep.results
-              }
-            end
-
-            yield(rep) if block_given?
-            rep.cleanup if rep.respond_to? :cleanup
-          }
-        end
-
-        if options[:tries] && (options[:interval] || options[:timeout])
-          code = Attempt.new { |a| 
-            a.tries = options[:tries]
-            a.interval = options[:interval] if options[:interval]
-            a.timeout = options[:timeout] if options[:timeout]
-          }
-          code.attempt(&process)
-        else
-          process.call
-        end
+    def add_source(*args) 
+      Ruport::Query.add_source(*args)
+    end
 
-        outs = options[:reports].map { |r| r.results }
-        if outs.length == 1
-          outs.last
-        else
-          outs
-        end
-        
-      end
+    def self.generate
+      yield(new)
     end
   end
 end

data/lib/ruport/util/report_manager.rb

@@ -14,8 +14,7 @@ module Ruport
     #
     # just kidding, use models#find or reports#find
     def self.[](name)     
-      reports.find { |r| r.name.eql?(name) } ||
-      models.find { |m| m.name.eql?(name) }
+      (reports + models).find{|n| n.name == name }
     end
   
     def self.models
@@ -46,4 +45,4 @@ class Ruport::Report
   def self.acts_as_managed_report
     Ruport::ReportManager.add_report(self)
   end
-end
+end

data/lib/ruport/util.rb

@@ -1,8 +1,15 @@
 module Ruport
   module Util
-    VERSION = "0.6.0"
+    VERSION = "0.7.0"
+
+    file = __FILE__
+    file = File.readlink(file) if File.symlink?(file)
+    dir = File.dirname(file)
+    BASEDIR = File.expand_path(File.join(dir, '..', '..'))
+    LIBDIR = File.expand_path(File.join(dir, '..'))
   end
 end
+
 require "ruport/util/report"
 require "ruport/util/graph"
 require "ruport/util/invoice"
@@ -11,3 +18,4 @@ require "ruport/util/mailer"
 require "ruport/util/bench"
 require "ruport/util/generator"
 require "ruport/util/pdf/form"
+require "ruport/util/ods"

data/test/helper/layout.rb

@@ -0,0 +1,55 @@
+require 'test/helper/wrap'
+
+class SpecLayout
+  attr_accessor :base, :layout, :files
+
+  def initialize(base, layout)
+    @base, @layout = base, layout
+  end
+
+  def run
+    SpecWrap.new(@files).run
+  end
+
+  def gather
+    @files = gather_files(@base, @layout)
+  end
+
+  def gather_files(base, layout)
+    files = Set.new
+    base = File.expand_path(base)
+
+    layout.each do |key, value|
+      if value.is_a?(Hash)
+        files += gather_files(base/key, value)
+      else
+        glob = base/key/"#{value}.rb"
+        files += Dir[glob].map{|f| File.expand_path(f)}
+      end
+    end
+
+    files.reject{|f| File.directory?(f)}
+  end
+
+  def clean
+    @files = clean_files(@files, @layout)
+  end
+
+  def clean_files(files, layout)
+    layout.each do |key, value|
+      if value.is_a?(Hash)
+        clean_files(files, value)
+      elsif files
+        files.dup.each do |file|
+          name = File.basename(file, File.extname(file))
+          dir = file.gsub(File.extname(file), '')
+          if name == key and File.directory?(dir)
+            files.delete(file)
+          end
+        end
+      end
+    end
+
+    files
+  end
+end

data/test/helper/wrap.rb

@@ -0,0 +1,190 @@
+require 'pp'
+require 'set'
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+begin
+  require 'systemu'
+rescue LoadError
+  puts "Please install systemu for better-looking results"
+
+  # small drop-in replacement for systemu... far from perfect though, so please
+  # install the library
+
+  def systemu command
+    stdout = `#{command} 2>&1`
+    status, stdout, stderr = $?, stdout, ''
+  end
+end
+
+class String
+  { :red => 31,
+    :green => 32,
+    :yellow => 33,
+  }.each do |key, value|
+    define_method key do
+      "\e[#{value}m" + self + "\e[0m"
+    end
+  end
+
+  def /(str)
+    File.join(self, str.to_s)
+  end
+end
+
+class Array
+  def commonize
+    snips, rest = map{|s| [s[0,1], s[1..-1]]}.transpose
+    unless snips.uniq.size != 1 or rest.any?{|r| File.basename(r) == r}
+      rest.commonize
+    else
+      self.map{|e| e.gsub(/^\//, '')}
+    end
+  end
+
+  def namize
+    commonize.map do |e|
+      dir = File.dirname(e)
+      file = File.basename(e, File.extname(e))
+      ( dir / file ).gsub(/^\.\//, '')
+    end
+  end
+end
+
+$stdout.sync = true
+
+class SpecWrap
+  def initialize(*files)
+    @files = files.flatten
+    @names = @files.namize
+    @specs = Hash[*@files.zip(@names).flatten]
+    @done = Set.new
+  end
+
+  def run
+    @specs.sort_by{|s| s.last}.each do |file, name|
+      spec = SpecFile.new(file, name, term_width)
+      spec.run
+      spec.short_summary
+      @done << spec
+    end
+
+    @done.sort_by{|d| d.name}.each do |spec|
+      puts(spec.long_summary) if spec.failed?
+    end
+
+    summarize
+  end
+
+  def summarize
+    total_passed = @done.inject(0){|s,v| s + v.passed }
+    total_failed = @done.inject(0){|s,v| s + v.failed }
+    total_specs = total_failed + total_passed
+
+    puts "#{total_specs} examples, #{total_failed} failures"
+    puts
+
+    if total_failed.nonzero?
+      failed = @done.select{|d| d.failed.nonzero? or d.passed.zero?}.map{|f| f.name.red }
+      puts "These failed: #{failed.join(', ')}"
+      exit 1
+    else
+      puts("No failing examples, let's add some tests!")
+    end
+  end
+
+  def term_width
+    @names.sort_by{|s| s.size }.last.size
+  end
+end
+
+class SpecFile
+  attr_reader :file, :name, :passed, :failed, :mark_passed
+
+  def initialize file, name, term_width
+    @file, @name, @term_width = file, name, term_width
+    @inc = $:.map{|e| "-I#{e}" }.join(" ")
+  end
+
+  def run
+    init
+    execute
+    parse
+    done
+    self
+  end
+
+  def init
+    print "Running #@name... ".ljust(@term_width + 20)
+  end
+
+  def execute
+    @status, @stdout, @stderr = systemu("ruby #@inc #@file")
+  end
+
+  def done
+    @ran = true
+  end
+
+  def short_summary
+    f = lambda{|n| n.to_s.rjust(3) }
+    total = f[@passed + @failed] rescue nil
+    failed, passed = f[@failed], f[@passed]
+    color = :red
+    width = 22
+
+    if total_failure?
+      text = 'total failure'.center(width)
+    elsif failed?
+      text = "#{total} specs - #{failed} failed".rjust(width)
+      if @stdout =~ /Usually you should not worry about this failure, just install the/
+        lib = @stdout.scan(/^no such file to load -- (.*?)$/).flatten.first
+        text = "needs #{lib}".center(width)
+        @mark_passed = true
+      end
+    elsif (not @mark_passed) and succeeded?
+      color = :green
+      text = "#{total} specs - all passed".rjust(width)
+    end
+
+    puts "[ #{text.send(color)} ]"
+  end
+
+  def long_summary
+    puts "[ #@name ]".center(80, '-'), "ExitStatus:".yellow
+    pp @status
+    puts "StdOut:".yellow, @stdout, "StdErr:".yellow, @stderr
+  end
+
+  def parse
+    @passed = 0
+    @failed = 0
+    found = false
+    @stdout.grep(/(\d+) examples?, (\d+) failures?/)
+    @passed, @failed = $1.to_i, $2.to_i
+  end
+
+  def failed?
+    not succeeded?
+  end
+
+  def total_failure?
+    succeeded? == nil
+  end
+
+  def succeeded?
+    run unless @ran
+    return @mark_passed unless @mark_passed.nil?
+    crits = [
+      [@status.exitstatus.zero?, @stderr.empty?],
+      [@passed, @failed],
+      [@passed.nonzero?, @failed.zero?],
+    ]
+    crits.all?{|c| c.all? }
+  rescue
+    nil
+  end
+end

data/test/helper.rb

@@ -0,0 +1,27 @@
+begin
+  require "rubygems"
+rescue LoadError
+  nil
+end
+
+require "spec"
+require 'ruport'
+this = File.dirname(__FILE__)
+lib = File.expand_path(File.join(this, '..', 'lib'))
+$LOAD_PATH.unshift(lib)
+require "ruport/util"
+
+# Use this to require optional dependencies where tests are expected to fail if
+# a library is not installed, for example Hpricot or Scruffy.
+# It will be parsed by the wrapper and marked.
+
+def testcase_requires(*following)
+  following.each do |file|
+    require(file.to_s)
+  end
+rescue LoadError => ex
+  puts ex
+  puts "Can't run #{$0}: #{ex}"
+  puts "Usually you should not worry about this failure, just install the"
+  puts "library and try again (if you want to use that feature later on)"
+end