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

lean-ruport 0.3.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

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

@@ -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