RubyGems - lean-ruport - Versions diffs - 0.3.8 - Mend

lean-ruport 0.3.8

Potentially problematic release.

This version of lean-ruport might be problematic. Click here for more details.

Files changed (50) hide show

data/ACKNOWLEDGEMENTS +33 -0
data/AUTHORS +19 -0
data/CHANGELOG +206 -0
data/COPYING +340 -0
data/LICENSE +7 -0
data/README +209 -0
data/Rakefile +54 -0
data/TODO +27 -0
data/lib/ruport.rb +58 -0
data/lib/ruport/config.rb +114 -0
data/lib/ruport/data_row.rb +144 -0
data/lib/ruport/data_set.rb +221 -0
data/lib/ruport/format.rb +116 -0
data/lib/ruport/format/builder.rb +89 -0
data/lib/ruport/format/document.rb +77 -0
data/lib/ruport/format/open_node.rb +36 -0
data/lib/ruport/parser.rb +202 -0
data/lib/ruport/query.rb +208 -0
data/lib/ruport/query/sql_split.rb +33 -0
data/lib/ruport/report.rb +116 -0
data/lib/ruport/report/mailer.rb +48 -0
data/test/samples/addressbook.csv +6 -0
data/test/samples/car_ads.txt +505 -0
data/test/samples/data.csv +3 -0
data/test/samples/document.xml +22 -0
data/test/samples/five_lines.txt +5 -0
data/test/samples/five_paragraphs.txt +9 -0
data/test/samples/ross_report.txt +58530 -0
data/test/samples/ruport_test.sql +8 -0
data/test/samples/stonecodeblog.sql +279 -0
data/test/samples/test.sql +2 -0
data/test/samples/test.yaml +3 -0
data/test/tc_builder.rb +116 -0
data/test/tc_config.rb +41 -0
data/test/tc_data_row.rb +36 -0
data/test/tc_data_set.rb +141 -0
data/test/tc_database.rb +25 -0
data/test/tc_document.rb +42 -0
data/test/tc_element.rb +18 -0
data/test/tc_page.rb +42 -0
data/test/tc_query.rb +55 -0
data/test/tc_reading.rb +60 -0
data/test/tc_report.rb +31 -0
data/test/tc_section.rb +45 -0
data/test/tc_sql_split.rb +18 -0
data/test/tc_state.rb +142 -0
data/test/ts_all.rb +9 -0
data/test/ts_format.rb +5 -0
data/test/ts_parser.rb +10 -0
metadata +102 -0

@@ -0,0 +1,89 @@
+module Ruport
+  class Format
+    class Builder
+      def initialize( data_set )
+        @data = data_set
+        @original = data_set.dup
+        @format = nil
+        @range = nil
+        @header = nil
+        @footer = nil
+        @output_type = nil
+      end
+      attr_accessor :format, :range, :header, :footer, :output_type
+      def render
+        @data = @range ? ( @original[@range] ) : ( @original )
+        send("render_#{@format}")
+      end
+      def render_csv
+        csv_klass = defined?(FasterCSV) ? FasterCSV : CSV
+        fields = @original.fields
+        ( @header ? "#{@header}\n\n" : "" ) +
+        @data.inject(csv_klass.generate_line(fields).chomp + "\n" ) { |out,r|
+          out <<  csv_klass.generate_line(fields.map { |f| r[f] }).chomp + "\n"
+        } + ( @footer ? "\n#{@footer}\n" : "" )
+      end
+      def render_html
+        head_text = ( if @header
+            "  <tr>\n    <th colspan=#{@original.fields.length}>#{@header}" +
+            "</th>\n  </tr>\n"
+        end )
+        out = "<table>\n#{head_text}  <tr>\n    <th>"+
+              "#{@original.fields.join('</th><th>')}" +
+              "</th>\n  </tr>\n"
+        @data.inject(out) do |html,row|
+          html << row.inject("  <tr>\n    "){ |row_html, field|
+                    row_html << "<td>#{field}</td>"
+                  } + "\n  </tr>\n"
+        end
+        foot_text = ( if @footer
+            "  <tr>\n    <th colspan=#{@original.fields.length}>#{@footer}" +
+            "</th>\n  </tr>\n"
+        end )
+        out << "#{foot_text}</table>"
+        return out unless @output_type.eql?(:complete)
+        "<html><head><title></title></head><body>\n#{out}</body></html>\n"
+      end
+      def render_text
+        header = @header ? "#{@header}\n" : ""
+        header << "fields: ( #{ @original.fields.join(', ') } )\n"
+        indices = (@range)  ? @range.to_a : (0...@original.to_a.length).to_a
+        @data.inject(header) do |output,row|
+          output << "row#{indices.shift}: ( #{row.to_a.join(', ')} )\n"
+        end + (@footer ? "#{@footer}\n" : "" )
+      end
+      def render_pdf
+        return unless defined? PDF::Writer
+        pdf = PDF::Writer.new
+        pdf.margins_cm(0)
+        @data.each do |page|
+          unless page.eql?(@data.pages.first)
+            pdf.start_new_page
+          end
+          page.each do |section|
+            section.each do |element|
+              pdf.y =  pdf.cm2pts(element.top)
+              pdf.text element.content,
+                          :left  => pdf.cm2pts(element.left),
+                          :right => pdf.cm2pts(element.right),
+                          :justification => element.align || :center
+            end
+          end
+        end
+        pdf.render
+      end
+    end
+  end
+end

data/lib/ruport/format/document.rb ADDED

@@ -0,0 +1,77 @@
+require "ostruct"
+require "rexml/document"
+module Ruport
+  class Format
+    class Document < OpenStruct
+      include Enumerable
+      def initialize(name,options={})
+          super(options)
+          self.name = name
+          self.pages ||= []
+      end
+      def each
+        self.pages.each { |p| yield(p) }
+      end
+      def add_page(name,options={})
+          options[:document] = self
+          self.pages << Format::Page.new(name,options)
+      end
+      def <<(page)
+        page.document = self
+        self.pages << page.dup
+      end
+      def [](page_name)
+        return self.pages[page_name] if page_name.kind_of? Integer
+        self.pages.find { |p| p.name.eql?(page_name) }
+      end
+      def clone
+        cloned = self.clone
+        cloned.pages = self.pages.clone
+        return cloned
+      end
+    end
+    class Page < Format::OpenNode
+      def initialize(name,options={})
+        super(:page,:document,:sections,name,options)
+      end
+      def add_section(name,options={})
+        add_child(Format::Section,name,options)
+      end
+    end
+    class Section < Format::OpenNode
+      def initialize(name, options={})
+        super(:section,:page,:elements,name,options)
+      end
+      def add_element(name,options={})
+        add_child(Format::Element,name,options)
+      end
+    end
+    class Element < OpenStruct
+      def initialize(name,options={})
+        super(options)
+        self.name = name
+      end
+      def to_s
+        self.content
+      end
+    end
+  end
+end

data/lib/ruport/format/open_node.rb ADDED

@@ -0,0 +1,36 @@
+require "ostruct"
+module Ruport
+  class Format
+    class OpenNode < OpenStruct
+      include Enumerable
+      def initialize(my_name, parent_name, children_name, name, options={})
+        @my_children_name = children_name
+        @my_parent_name   = parent_name
+        @my_name          = my_name
+        super(options)
+        self.name = name
+        self.send(@my_children_name) ||
+        self.send("#{@my_children_name}=".to_sym,{})
+      end
+      def each &p
+        self.send(@my_children_name).values.each(&p)
+      end
+      def add_child(klass,name,options={})
+        options[@my_name] = self
+        self << klass.new(name, options)
+      end
+      def <<(child)
+        child.send("#{@my_name}=".to_sym, self)
+        self.send(@my_children_name)[child.name] = child.dup
+      end
+      def [](child_name)
+        self.send(@my_children_name)[child_name]
+      end
+    end
+  end
+end

data/lib/ruport/parser.rb ADDED

@@ -0,0 +1,202 @@
+#!/usr/local/bin/ruby -w
+#  parser.rb,  A tool for parsing arbitrary input
+#   ______________________         _ _
+#  (Here there be dragons!) o    /    \
+#   ----------------------    o | O  O |
+#                               |      |
+#         .----.                \/\/\/\/
+#        | 0  0 |
+#        |      | o   _____________________________
+#        |/\/\/\|  o ( Dude. That phrase is sooo '89)
+#                     ------------------------------
+#
+#   [ but seriously.  be careful in here. ]
+#
+#  This is Free Software, you may freely modify and/or distribute it by the
+#  terms of the GNU General Public License or the Ruby license.
+#
+#  See LICENSE and COPYING for details.
+#
+#  Based on Parse::Input (http://rubyforge.org/projects/input)
+#  Modified version created on 2006.02.20 by Gregory Brown
+#  Copyight (C) 2006, all rights reserved.
+#
+#  Modifications from Parse::Input include:
+#  - Ruport::Parser can handle string input
+#  - Ruport::Parser does not define a top level input() method
+#  - Any and all documentation has been added post-fork
+#  - Ruby Style indentation used
+#
+#  Original application:
+#  Created by James Edward Gray II on 2005-08-14.
+#  Copyright 2005 Gray Productions. All rights reserved.
+require "stringio"
+module Ruport
+# If you're reporting on data, there is a good chance it's going to need some
+# munging.  A 100% compatible modified version of JEG2's Parse::Input, Ruport::Parser
+# can help you do that.
+#
+# This class provides a system that lets you specify regular expressions to
+# identify patterns and extract the data you need from your input.
+#
+# It implements a somewhat straightforward domain specific language to help
+# you scrape and tear up your gnarly input and get something managable.
+#
+# It is a bit of an expert tool, but is indispensible when messy data needs to be
+# parsed. For now, you'll probably want to read the source for this particular
+# class.  There may be dragons.
+#
+# Sample usage:
+#  path = "somefile"
+#  data = Ruport::Parser.new(path, "") do
+#    @state = :skip
+#    stop_skipping_at("Save Ad")
+#    skip(/\A\s*\Z/)
+#
+#    pre { @price = @miles = nil }
+#    read(/\$([\d,]+\d)/) { |price| @price = price.delete(",").to_i }
+#    read(/([\d,]*\d)\s*m/) { |miles| @miles = miles.delete(",").to_i }
+#
+#    read do |ad|
+#      if @price and @price < 20_000 and @miles and @miles < 40_000
+#        (@ads ||= Array.new) << ad.strip
+#      end
+#    end
+#  end
+  class Parser
+    def initialize( path, separator = $/, &init )
+      @path      = path
+      @separator = separator
+      @state     = :read
+      @_pre_readers   = Array.new
+      @_readers       = Array.new
+      @_post_readers  = Array.new
+      @_skip_starters = Array.new
+      @_skip_stoppers = Array.new
+      @_skips         = Array.new
+      @_skip_searches = Array.new
+      @_stops         = Array.new
+      @_origin        = :file
+      instance_eval(&init) unless init.nil?
+      parse
+    end
+    def []( name )
+      variable_name = "@#{name}"
+      if instance_variables.include? variable_name
+        instance_variable_get(variable_name)
+      else
+        nil
+      end
+    end
+    def method_missing( method, *args, &block )
+      variable_name = "@#{method}"
+      if instance_variables.include? variable_name
+        instance_variable_get(variable_name)
+      else
+        super
+      end
+    end
+    private
+    def parse
+      io_klass = (@origin.eql? :string) ? StringIO : File
+      io_klass.open(@path) do |io|
+        while @read = io.gets(@separator)
+          if @_stops.any? { |stop| @read.index(stop) }
+            @state = :stop
+            break
+          end
+          case @state
+          when :skip
+            search(@_skip_searches)
+            if @_skip_stoppers.any? { |stop| @read.index(stop) }
+              @state = :read
+            end
+          when :read
+            if @_skip_starters.any? { |start| @read.index(start) }
+              @state = :skip
+              search(@_skip_searches)
+              next
+            end
+            if @_skips.any? { |skip| @read.index(skip) }
+              search(@_skip_searches)
+              next
+            end
+            @_pre_readers.each { |pre| instance_eval(&pre) }
+            search(@_readers)
+            @_post_readers.each { |post| instance_eval(&post) }
+          end
+          break if @state == :stop
+        end
+      end
+    end
+    def pre( &pre_readers_handler )
+      @_pre_readers << pre_readers_handler
+    end
+    def read( pattern = nil, &handler )
+      @_readers << Array[pattern, handler]
+    end
+    def post( &post_readers_handler )
+      @_post_readers << post_readers_handler
+    end
+    def search( searches )
+      searches.each do |pattern, handler|
+        if pattern.nil?
+          handler[@read]
+        elsif pattern.is_a? Regexp
+          next unless md = @read.match(pattern)
+          captures = md.captures
+          if captures.empty?
+            handler[@read]
+          else
+            handler[*captures]
+          end
+        elsif @read.index(pattern)
+          handler[@read]
+        end
+      end
+    end
+    def find_in_skipped( pattern = nil, &handler )
+      @_skip_searches << Array[pattern, handler]
+    end
+    def skip( pattern )
+      @_skips << pattern
+    end
+    def start_skipping_at( pattern )
+      @_skip_starters << pattern
+    end
+    def stop_skipping_at( pattern )
+      @_skip_stoppers << pattern
+    end
+    def stop_at( pattern )
+      @_stops << pattern
+    end
+    def origin(source=:string)
+      @_origin = :file
+    end
+  end
+end

data/lib/ruport/query.rb ADDED

@@ -0,0 +1,208 @@
+require "generator"
+require "ruport/query/sql_split"
+#this hack looks pointless right now but leaves room to just add more libs
+%w[dbi].each { |lib| begin; require lib;
+  rescue LoadError
+    Ruport.complain "Couldn't find #{lib}!", :level => :log_only
+  end
+}
+module Ruport
+  # Query offers a way to interact with databases via DBI.  It supports
+  # returning result sets in either Ruport's native DataSets, or in their raw
+  # form as DBI::Rows.
+  #
+  # It offers basic caching support, the ability to instantiate a generator for
+  # a result set, and the ability to quickly and easily swap between data
+  # sources.
+  class Query
+    include Enumerable
+    # Queries are initialized with some SQL and a number of options that effect
+    # their operation.  They are NOT executed at initialization.
+    #
+    # This is important to note as they will not query the database until either
+    # Query#result, Query#execute, Query#generator, or an enumerable method is
+    # called on them.
+    #
+    # This kind of laziness is supposed to be A Good Thing, and
+    # as long as you keep it in mind, it should not cause any problems.
+    #
+    # The SQL can be single or multistatement, but the resulting DataSet will
+    # consist only of the result of the last statement which returns something.
+    #
+    # Options:
+    #
+    # <tt>:source</tt>
+    #   A source specified in Ruport::Config.sources, defaults to :default
+    # <tt>:origin</tt>
+    #   query origin, default to :string, but can be
+    #   set to :file, loading the path specified by the sql parameter
+    # <tt>:dsn</tt>
+    #   If specifed, the query object will manually override Ruport::Config
+    # <tt>:user</tt>
+    #   If a DSN is specified, a user can be set by this option
+    # <tt>:password</tt>
+    #   If a DSN is specified, a password can be set by this option
+    # <tt>:raw_data</tt>
+    #   When set to true, DBI::Rows will be returned
+    # <tt>:cache_enabled</tt>
+    #   When set to true, Query will download results only once, and then return
+    #   cached values until cache has been cleared.
+    # Examples:
+    #
+    #   # uses Ruport::Config's default source
+    #   Ruport::Query.new("select * from fo")
+    #
+    #   # uses the Ruport::Config's source labeled :my_source
+    #   Ruport::Query.new("select * from fo", :source => :my_source)
+    #
+    #   # uses a manually entered source
+    #   Ruport::Query.new("select * from fo", :dsn => "dbi:mysql:my_db",
+    #     :user => "greg", :password => "chunky_bacon" )
+    #
+    #   # uses a SQL file stored on disk
+    #   Ruport::Query.new("my_query.sql",:origin => :file)
+    def initialize(sql, options={})
+      options[:source] ||= :default
+      options[:origin] ||= :string
+      @sql = sql
+      @statements = SqlSplit.new(get_query(options[:origin],sql))
+      if options[:dsn]
+        Ruport::Config.source :temp, :dsn      => options[:dsn],
+                                     :user     => options[:user],
+                                     :password => options[:password]
+        options[:source] = :temp
+      end
+      select_source(options[:source])
+      @raw_data = options[:raw_data]
+      @cache_enabled  = options[:cache_enabled]
+      @cached_data = nil
+    end
+    # set to true to get DBI:Rows, false to get Ruport constructs
+    attr_accessor :raw_data
+    # modifying this might be useful for testing, this is the data stored by
+    # ruport when caching
+    attr_accessor :cached_data
+    # this is the original SQL for the Query object
+    attr_reader :sql
+    # This will set the dsn, username, and password to one specified by a label
+    # that corresponds to a source in Ruport::Config
+    def select_source(label)
+      @dsn      = Ruport::Config.sources[label].dsn
+      @user     = Ruport::Config.sources[label].user
+      @password = Ruport::Config.sources[label].password
+    end
+    # Standard each iterator, iterates through result set row by row.
+    def each(&action)
+      Ruport::complain(
+        "no block given!", :status => :fatal, :exception => LocalJumpError
+      ) unless action
+      fetch &action
+    end
+    # Grabs the result set as a DataSet or if in raw_data mode, an array of
+    # DBI:Row objects
+    def result; fetch; end
+    # Runs the query without returning it's results.
+    def execute; fetch; nil; end
+    # clears the contents of the cache
+    def clear_cache
+      @cached_data = nil
+    end
+    # clears the contents of the cache and then runs the query, filling the
+    # cache with the new result
+    def update_cache
+      clear_cache
+      caching_flag,@cache_enabled = @cache_enabled, true
+      fetch; @cache_enabled = caching_flag
+    end
+    # Turns on caching.  New data will not be loaded until cache is clear or
+    # caching is disabled.
+    def enable_caching
+      @cache_enabled = true
+    end
+    # Turns off caching and flushes the cached data
+    def disable_caching
+      @cached_data   = nil
+      @cache_enabled = false
+    end
+    # Returns a DataSet, even if in raw_data mode
+    def to_dataset
+      data_flag, @raw_data = @raw_data, false
+      data = fetch; @raw_data = data_flag; return data
+    end
+    # Returns a csv dump of the query
+    def to_csv
+      to_dataset.to_csv
+    end
+    # Returns a Generator object of the result set
+    def generator
+      Generator.new(fetch)
+    end
+    private
+    def query_data( query_text )
+      data = @raw_data ? [] : DataSet.new
+      DBI.connect(@dsn, @user, @password) do |dbh|
+        dbh.execute(query_text) do |sth|
+            return unless sth.fetchable?
+            results = sth.fetch_all
+            data.fields = sth.column_names unless @raw_data
+            results.each { |row| data << row }
+        end
+      end
+      data
+    rescue
+      nil
+    end
+    def get_query(type,query)
+      case (type)
+      when :string
+         query
+      when :file
+        load_file( query )
+      end
+    end
+    def load_file( query_file )
+      begin; File.read( query_file ).strip ; rescue
+        Ruport::complain "Could not open #{query_file}",
+          :status => :fatal, :exception => LoadError
+      end
+    end
+    def fetch(&action)
+      data = nil
+      if @cache_enabled and @cached_data
+        data = @cached_data
+      else
+        @statements.each { |query_text| data = query_data( query_text ) }
+      end
+      data.each { |r| action.call(r) } if block_given? ; data
+      @cached_data = data if @cache_enabled
+      return data
+    end
+  end
+end