ruport 0.2.9 → 0.3.8

data/lib/ruport/format/open_node.rb

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

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

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

data/lib/ruport/query/sql_split.rb

@@ -0,0 +1,33 @@
+#--
+# sqlsplit.rb : A tool to properly split SQL input
+#
+# This is Free Software.  You may freely redistribute or modify under the terms
+# of the GNU General Public License or the Ruby License.  See LICENSE and
+# COPYING for details.
+#
+# Created by Francis Hwang, 2005.12.31
+# Copyright (c) 2005, All Rights Reserved.
+#++
+module Ruport
+  class Query 
+    # This class properly splits up multi-statement SQL input for use with
+    # Ruby/DBI
+    class SqlSplit < Array
+			def initialize( sql )
+				super()
+				next_sql = ''
+				sql.each do |line|
+					unless line =~ /^--/ or line =~ %r{^/\*.*\*/;} or line =~ /^\s*$/
+						next_sql << line
+						if line =~ /;$/
+							next_sql.gsub!( /;\s$/, '' )
+							self << next_sql
+							next_sql = ''
+						end
+					end
+				end
+				self << next_sql if next_sql != ''
+			end
+		end
+  end
+end