jsanders-ruport 1.7.1

data/AUTHORS

@@ -0,0 +1,48 @@
+= Developers
+
+- {Gregory Brown}[mailto:gregory.t.brown@gmail.com]
+- {Dudley Flanders}[mailto:dudley@misnomer.us]
+- {James Healy}[mailto:jimmy@deefa.com]
+- Dinko Mehinovic
+- {Michael Milner}[mailto:mikem836@gmail.com]
+
+= Contributors / People we've (legally) stolen from:
+
+Iain Broadfoot:
+ - RuportDay 2006 Participant
+
+Eric Pugh:
+ - RuportDay 2006 Participant
+
+James Edward Gray II:
+  - Original inspiration via query.rb
+  - system_extensions.rb
+
+Mathijs Mohlmann:
+ - Performance Enhancement
+     TextPlugin r264-r265
+     HTMLPlugin r266
+
+Francis Hwang:
+ - SQLSplit
+
+Simon Claret:
+ - Initial PDF table support (now deprecated)
+
+Daniel Berger:
+ - we vendored and modified attempt.rb to support it directly in Report.
+   Original website: http://raa.ruby-lang.org/project/attempt/
+
+Marshall T. Vandegrift:
+ - Fixed a bug in Record's struct-like accessors (method_missing)
+ - Provided performance enhancements and tests for query.rb
+ - Improved alignment for Text Tables.
+
+Stefan Mahlitz:
+ - Table#sort_rows_by
+
+Chris Carter
+ - Table#remove_columns (r440)
+
+Dave Nelson
+ - Grouping#sigma (r1131)

data/LICENSE

@@ -0,0 +1,59 @@
+Ruport is copyrighted free software originally produced by Gregory Brown 
+<gregory.t.brown@gmail.com> which now contains a number of community
+contributions and is actively developed by Michael Milner <mikem836@gmail.com>.
+
+See the AUTHORS file for a complete list of contributors.  
+
+Licensing terms follow (License of Ruby 1.8):
+
+You can redistribute Ruport and/or modify it under either the terms of the GPL
+(see COPYING file), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+    modifications to Usenet or an equivalent medium, or by allowing
+    the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+    together with instructions (in the manual page or equivalent)
+    on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+    the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial). 
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README

@@ -0,0 +1,114 @@
+# -----------------------------------------------------------------
+# Contents:
+# 
+#  + What Ruport Is
+#  + Installation
+#  + Resources
+#  + Hacking
+#
+# = What Ruport Is
+#
+# Ruby Reports (Ruport) is an extensible reporting system.
+# 
+# It aims to be as lightweight as possible while still providing core support
+# for data aggregation and manipulation as well as multi-format rendering 
+# of reports.
+#
+# Ruport provides tools for using a number of data sources, including CSV files,
+# ActiveRecord models, and raw SQL connections via RubyDBI (through ruport-util).
+#
+# Data manipulation is easy as there are standard structures that support
+# record, table, and grouping operations.  These all can be extended to
+# implement custom behavior as needed.
+#
+# For common tasks, Ruport provides formatters for CSV, HTML, PDF, and text-
+# based reports.  However, the real power lies in building custom report
+# controllers and formatters.  The base formatting libraries provide a number 
+# of helper functions that will let you build complex reports while maintaining 
+# a DRY and consistent interface.
+#
+# To get a quick feel for what you can accomplish with Ruport, take a look at
+# a few simple examples provided on our web site.
+#
+# http://rubyreports.org/examples.html
+#
+# Since Ruport's core support is intentionally minimalistic, you may be looking
+# for some higher level support for specific needs such as graphing, invoices,
+# report mailing support, etc.  For this, you may wish to take a look at the
+# ruport-util package, which contains some generally useful tools and libraries
+# to extend Ruport's capabilities.
+#
+# = Installation 
+#
+# To install ruport via rubygems:
+#   
+#   sudo gem install ruport 
+#
+# Check to see if it installed properly:
+#
+#   ruby -rubygems -e "require 'ruport'; puts Ruport::VERSION"
+#
+# If you get an error, please let us know on our mailing list. 
+#
+# Dependencies Details:
+#   
+#  -- formatting
+#
+# Ruport relies on PDF::Writer and FasterCSV for its formatting support.
+# If you want to make use of textile helpers, you'll also need RedCloth.
+#
+#  -- database interaction
+#
+# If you wish to use Ruport to report against a rails project, 
+# a camping project, or do standalone acts_as_reportable reports, you'll need
+# ActiveRecord and the acts_as_reportable gem.
+#
+# If you want to use Ruport::Query for raw SQL support, you'll need to 
+# install ruport-util, RubyDBI and whatever database drivers you might need.
+#
+# = Resources              
+#
+# Our developers have published a free-content book about all things
+# Ruport, including complete coverage of acts_as_reportable and some of 
+# ruport-util's features.  This book serves as the definitive guide to 
+# Ruport, so all users should become acquainted with it:
+# 
+#   http://ruportbook.com
+#
+# The next best way to get help and make suggestions is the Ruport mailing list.
+# This software is on the move, so the list is the most reliable way of getting
+# up to date information.
+#
+#  -  You can sign up and/or view the archives here:
+#     http://groups.google.com/group/ruby-reports                                                   
+#
+# If you are looking to dig a little deeper, there are a couple more resources
+# that may be helpful to you.
+#
+#  -  The latest stable API documentation is available at:
+#     http://api.rubyreports.org
+#
+#  -  Our Trac is at: http://code.rubyreports.org/ruport
+#     You may use the username ruport and password blinky to file tickets.
+#
+# = Hacking
+#
+# If you'd like to contribute code to Ruport, please join our development 
+# mailing list, and let us know what you'd like to do!
+#
+#   http://groups.google.com/group/ruport-dev
+# 
+# It also may be worthwhile to join this list if you plan on running edge
+# versions of Ruport, as this is where we make announcements about major 
+# breakage in trunk. 
+#
+# We are very responsive to contributors, and review every patch we receive
+# fairly quickly.  Most contributors who successfully get a patch or two applied
+# are given write access to the repositories and invited to join Ruport's 
+# development team.  Since we view every user as potential contributor, this
+# approach works well for us.
+#
+# So if you want to help out with Ruport, we'll happy accept your efforts!
+
+
+

data/Rakefile

@@ -0,0 +1,93 @@
+require "rake/rdoctask"
+require "rake/testtask"
+
+RUPORT_VERSION = "1.7.0"
+
+begin
+  require "rubygems"
+rescue LoadError
+  nil
+end
+
+task :default => [:test]
+
+Rake::TestTask.new do |test|
+  test.libs << "test"
+  test.test_files = Dir[ "test/*_test.rb" ]
+  test.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.include( "README",
+                           #"CHANGELOG",
+                           "AUTHORS", "COPYING",
+                           "LICENSE", "lib/" )
+  rdoc.main     = "README"
+  rdoc.rdoc_dir = "doc/html"
+  rdoc.title    = "Ruport Documentation"
+end
+
+task :build_archives => [:package,:rcov,:rdoc] do
+  mv "pkg/ruport-#{RUPORT_VERSION}.tgz", "pkg/ruport-#{RUPORT_VERSION}.tar.gz"
+  sh "tar cjvf pkg/ruport_coverage-#{RUPORT_VERSION}.tar.bz2 coverage"
+  sh "tar cjvf pkg/ruport_doc-#{RUPORT_VERSION}.tar.bz2 doc/html"
+  cd "pkg"
+  sh "tar cjvf ruport-#{RUPORT_VERSION}.tar.bz2 ruport-#{RUPORT_VERSION}"
+end
+
+task :run_benchmarks do
+  files = FileList["util/bench/**/**/*.rb"]
+  files.sort!
+  files.uniq!
+  names = files.map { |r| r.sub("util/bench","").split("/").map { |e| e.capitalize } }
+  names.map! { |e| e[1..-2].join("::") + " <BENCH: #{e[-1].sub('Bench_','').sub('.rb','')}>" }
+  start_time = Time.now
+  files.zip(names).each { |f,n|
+    puts "\n#{n}\n\n"
+    sh "ruby -Ilib #{f}"
+    puts "\n"
+  }
+  end_time = Time.now
+  puts "\n** Total Run Time:  #{end_time-start_time}s **"
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.test_files = Dir[ "test/*_test.rb" ]
+  end
+rescue LoadError
+  nil
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "ruport"
+    s.version = RUPORT_VERSION
+    s.platform = Gem::Platform::RUBY
+    s.summary = "A generalized Ruby report generation and templating engine."
+    s.files =  Dir.glob("{examples,lib,test,bin,util/bench}/**/**/*") +
+                        ["Rakefile"]
+    s.require_path = "lib"
+    
+    s.test_files = Dir[ "test/*_test.rb" ]
+    s.has_rdoc = true
+    s.extra_rdoc_files = %w{README LICENSE AUTHORS}
+    s.rdoc_options << '--title' << 'Ruport Documentation' <<
+                         '--main'  << 'README' << '-q'
+    s.add_dependency('fastercsv')
+    s.add_dependency('pdf-writer','= 1.1.8')
+    s.author = "Gregory Brown"
+    s.email = "  gregory.t.brown@gmail.com"
+    s.rubyforge_project = "ruport"
+    s.homepage = "http://rubyreports.org"
+    s.description = <<-END_DESC
+      Ruby Reports is a software library that aims to make the task of reporting
+      less tedious and painful. It provides tools for data acquisition,
+      database interaction, formatting, and parsing/munging.
+    END_DESC
+  end
+rescue LoadError
+  puts 'Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com'
+end

data/examples/anon.rb

@@ -0,0 +1,43 @@
+# Demonstrates building a parent controller which provides additional 'built in'
+# formats, allowing anonymous formatter support to use the simple interface
+# rather than the :format => FormatterClass approach.
+
+require "ruport"
+module FooCorp
+  class Controller < Ruport::Controller
+    def self.built_in_formats
+      super.merge(:xml => FooCorp::Formatter::XML)
+    end
+  end
+
+  class Formatter
+    class XML < Ruport::Formatter
+
+      def xmlify(stuff)
+        output << "Wouldn't you like to see #{stuff} in XML?"
+      end
+    end
+  end
+
+  class MyController < FooCorp::Controller
+    stage :foo
+
+    formatter :xml do
+      build :foo do
+        xmlify "Red Snapper"
+      end
+    end
+
+    formatter :text do
+      build :foo do
+        output << "Red Snapper"
+      end
+    end
+  end
+end
+
+puts "XML:"
+puts FooCorp::MyController.render_xml
+
+puts "Text:"
+puts FooCorp::MyController.render_text

data/examples/btree/commaleon/commaleon.rb

@@ -0,0 +1,263 @@
+# This example is a simplified version of a tool actually used at BTree.
+# It does a very basic task:
+#
+# Given a master CSV file and a key column, it will compare the file
+# to another CSV, and report back what is missing in the second CSV
+# that was in the first, as well as what is changed in the second CSV
+# based on the first.
+#
+# It is not bidirectional, and is mostly meant to compare snapshots
+# of CSV dumps to see what has been removed or altered (we don't care
+# about new records )
+#
+# It's a camping app, but the core of it is a controller/formatter combo. 
+# (Marked by %%%%%%%%%%% below)     
+#
+# You'll need the camping omnibus and the F() ruport plugin to run this app.
+#
+#   gem install camping-omnibus --source http://code.whytheluckystiff.net -y
+#   gem install f --source http://gems.rubyreports.org                                      
+#
+# Once you have them, just run camping commaleon.rb and browse to
+# http://localhost:3301
+#
+# Use ticket_count.csv as your master file and ticket_count2.csv as your
+# comparison file.  Use title as your key.
+#
+# Try out the different outputs, and tweak the app if you'd like to play
+# with it. 
+#
+# If your company has a need for tiny hackish camping/ruport amalgams,
+# you can always ask Gregory if he's looking for work:
+# <gregory.t.brown at gmail.com> 
+#
+require "rubygems"
+require "camping"               
+require "camping/session"   
+require "ruport" 
+require "ruport/extensions"     
+   
+Camping.goes :Commaleon   
+
+module Commaleon
+  include Camping::Session
+end 
+
+def Commaleon.create
+  Camping::Models::Session.create_schema
+end    
+
+module Commaleon::Helpers
+
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+# This is the bulk of the Ruport code in this app
+# (CSVDiffController and CSVDiffFormatter)
+# The rest is just camping.  The interesting thing here is that
+# you could easily define these in another file and just require
+# them here, and use them standalone outside of your web app.      
+# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+  class CSVDiffController < Ruport::Controller
+     stage :diff_report
+     option :key, :mcsv, :ccsv  
+      
+     # This setup() idiom has become the default way of doing some 
+     # manipulations on the data and options before handing off the 
+     # rendering task to the formatters.
+     #   
+     # We're using grouping mainly for the controller support,
+     # and rather than reducing a table, we're building up the
+     # group objects via the helper methods missing_from_compare
+     # and different_from_compare
+     def setup
+        @master_table = Table(:string => mcsv)
+        @compare_table = Table(:string => ccsv)
+        options.diff_report = Grouping(:by => "issue")                            
+        options.diff_report << missing_from_compare            
+        options.diff_report << different_from_compare
+     end                        
+ 
+     # pulls the rows that are present in the master csv but not
+     # in the comparison csv and returns a group.    
+     def missing_from_compare 
+       missing_data = @master_table.rows_with(key) do |k| 
+         missing_keys.include?(k)
+       end        
+       
+       Group("missing from main csv", 
+        :data => missing_data, 
+        :column_names => @master_table.column_names )  
+     end     
+     
+     # pulls the rows that are present in the master csv but match
+     # a row with the same key in the compare csv that do not have
+     # identical attributes.  Returns a group                    
+     def different_from_compare 
+        shared = master_keys & compare_keys  
+        m = @master_table.rows_with(key) do |k|
+          shared.include?(k)
+        end
+                
+        diff = m.reject do |r|   
+          @compare_table.any? { |s| s == r }
+        end    
+        
+        diff.each do |r|
+          comp = @compare_table.rows_with(key => r[key])[0]
+          r.to_hash.each do |k,v| 
+            v << " ## " << comp[k] unless v == comp[k]
+          end
+        end
+        
+        Group("different from main csv", 
+              :data => diff, :column_names => @master_table.column_names)
+     end
+     
+     def missing_keys                
+        master_keys - compare_keys
+     end   
+     
+     def master_keys
+       @master_table.column(key)
+     end
+     
+     def compare_keys
+       @compare_table.column(key)
+     end
+  end   
+  
+  # This is using the F plugin which saves us a line of code and just
+  # looks neat, IMO
+  # 
+  # For more details:
+  #
+  # http://stonecode.svnrepository.com/ruport/trac.cgi/wiki/F
+  #
+  class CSVDiffFormatter < F([:html,:text,:csv,:pdf], :for => CSVDiffController)
+    def build_diff_report        
+     # this is using the selective blocks for formatters that implement
+     # more than one format.  The block below will only be called when this
+     # formatter is rendering HTML
+     html { gussy_up_html }       
+     
+     render_grouping( options.diff_report, 
+                      :style => options.style || :inline )  
+    end   
+   
+    # adds headers to group name to make the output a little prettier 
+    def gussy_up_html
+      options.diff_report.each do |n,g| 
+         g.send(:name=, "<h4>#{n}</h4>")
+      end  
+    end
+  end
+  
+end
+
+module Commaleon::Controllers      
+  
+  class Index < R "/"
+    def get
+      redirect R(CSVDifference)
+    end
+  end
+  
+  class CSVDifference < R '/csv_diff'
+    def get
+      render :get_diff_files
+    end     
+    
+    def post                                   
+      @state.mfile = @input.mfile.tempfile.read
+      @state.cfile = @input.cfile.tempfile.read
+      redirect R(GenerateDiffReport)   
+    end
+  end   
+         
+  class GenerateDiffReport < R '/csv_diff/report'      
+    def get              
+      @id_fields = Table(:string=>@state.mfile).column_names &
+                   Table(:string=>@state.cfile).column_names
+      render :csv_get_id 
+    end                                                        
+    
+    def post
+      @state.key = @input.csv_id  
+      @table = CSVDiffController.render_html(:key =>  @state.key,
+                                           :mcsv => @state.mfile,
+                                           :ccsv => @state.cfile )  
+      render :html_diff   
+    end
+  end
+  
+  class CSVDiffReportFormatted < R '/csv_diff/report.(.*)'        
+     def set_headers(format)
+       types = { "csv" => "application/vnd.ms-excel",
+                 "pdf" => "application/pdf",
+                 "txt" => "text/plain" } 
+       @headers["Content-Type"] = types[format]
+       @headers["Content-Disposition"] = "attachment; filename=diff.#{format}"
+     end   
+     
+     def get(format)         
+       options = { :key  =>  @state.key, 
+                   :mcsv => @state.mfile,
+                   :ccsv => @state.cfile } 
+       
+       set_headers(format)                        
+       case(format)
+       when "csv"
+         text CSVDiffController.render_csv(options)  
+       when "pdf"
+         text CSVDiffController.render_pdf(options.merge(:style => :justified)) 
+       when "txt"
+         text CSVDiffController.render_text(options)
+       else
+         text "no format!"
+       end                                
+     end
+  end  
+                       
+end
+
+module Commaleon::Views
+  def get_diff_files
+    form :action => "?upload_id=#{Time.now.to_f}", :method => 'post',
+         :enctype => 'multipart/form-data' do
+      p do                                
+        label "Master File: ", :for => "mfile"
+        input({:name => "mfile", :type => 'file'})
+      end                                             
+      p do 
+        label "Comparison File: ", :for => "cfile"
+        input({:name => "cfile", :type => 'file'})
+      end
+      p do
+        input.newfile! :type => "submit", :value => "Upload"
+      end
+    end  
+  end  
+  
+  def csv_get_id
+   form :method => "post" do
+      label "ID column: ", :for => "csv_id"  
+      select(:name => "csv_id") do
+        @id_fields.each { |f| option(f) }
+      end      
+      input :type => "submit", :value => "Set ID"
+    end
+  end  
+  
+  def html_diff
+    text @table   
+    hr
+    ul do
+      li { a "New Diff", :href => R(CSVDifference) }
+      li { a "New Key for Diff", :href => R(GenerateDiffReport) }
+      li { a "CSV Download", :href => R(CSVDiffReportFormatted,"csv") } 
+      li { a "Text Download", :href => R(CSVDiffReportFormatted,"txt") }
+      li { a "PDF Download", :href => R(CSVDiffReportFormatted,"pdf") }
+    end
+  end        
+           
+end