google_data_source 0.7.6

data/lib/reporting/reporting_adapter.rb

@@ -0,0 +1,27 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # This connection adapter does the quoting the way our reporting class should generate it
+    # 
+    #
+    class ReportingAdapter < AbstractAdapter
+
+      def initialize
+        super(nil)
+      end
+
+      def quoted_true
+        "'1'"
+      end
+      
+      def quoted_false
+        "'0'"
+      end
+      
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub(/\\/, '\&\&').gsub(/'/, "\\\\'") # ' (for ruby-mode)
+      end
+    end
+  end
+end

data/lib/reporting/reporting_entry.rb

@@ -0,0 +1,147 @@
+# This class represents a single reporting entry.
+# Casting for numerical values and a '+' for the addition of different object
+# is included.
+class ReportingEntry
+  # The raw attributes hash
+  attr_reader :attributes # TODO remove
+
+  # These constants define fields which are casted to integers/float
+  # in the accessor. Also these fields are added when adding two
+  # SuperReportingEntries.
+  #
+  # DON'T USE THIS FOR IDs (e.g. ad_id)
+  SUMMABLE_INT_FIELDS_REGEXP   = /OVERWRITE_THIS_IN_SUBCLASS/
+  SUMMABLE_FLOAT_FIELDS_REGEXP = /OVERWRITE_THIS_IN_SUBCLASS/
+  
+  # Columns listed in this array are explicitely not summable
+  NOT_SUMMABLE_FIELDS          = %w()
+
+  # Standard constructor
+  # takes attributes as hash (like OpenStruct)
+  def initialize(attributes = {})
+    @attributes = HashWithIndifferentAccess.new(attributes)
+  end
+
+  # Offers an +OpenStruct+ like access to the values stored in +@attributes+
+  # Uses the information from +SUMMABLE_*_FIELDS_REGEXP+ to cast to numerical
+  # values.
+  def method_missing(method_id, *args)
+    return self.send("lazy_#{method_id}", *args) if self.respond_to?("lazy_#{method_id}")
+    if @attributes.has_key?(method_id) || method_id.to_s =~ summable_fields_regexp
+      return cast(method_id, @attributes[method_id])
+    end
+    super(method_id, *args)
+  end
+
+  # Add another +SuperReportingEntry+ and returns the resulting entry.
+  # All attributes specified by +SUMMABLE_FIELD_REGEXP+ are summed up.
+  # Further attributes are merged (the own values has priority).
+  def +(other)
+    return self.class.composite([self, other])
+  end
+
+  # Returns a ReportingEntry object with all non addable values set to nil
+  # This is thought be used for sum(mary) rows
+  def to_sum_entry
+    subject = self
+    klass = Class.new(self.class) do
+      # overwrite explicitely not summable columns
+      #
+      subject.send(:not_summable_fields).each do |method_id|
+        define_method(method_id) { nil }
+      end
+      
+      # method missing decides if the columns is displayed or not
+      #
+      define_method(:method_missing) do |method_id, *args|
+        (method_id.to_s =~ summable_fields_regexp) ? subject.send(method_id, *args) : nil
+      end
+
+      # yes, this actually is a sum entry ;-)
+      #
+      def is_sum_entry?
+        return true
+      end
+    end
+    klass.new
+  end
+
+  # Returns a composite element which lazily sums up the summable values of the children
+  def self.composite(entries)
+    public_methods         = self.instance_methods - Object.public_methods
+    summable_methods       = public_methods.select { |method| method.to_s =~ summable_fields_regexp }
+
+    klass = Class.new(self) do
+      define_method(:method_missing) do |method_id, *args|
+        if (method_id.to_s =~ summable_fields_regexp)
+          return entries.inject(0) do |sum, entry|
+            sum + entry.send(method_id, *args)
+          end
+        else
+          return entries.first.send(method_id, *args)
+        end
+      end
+
+      # Delegate all summable method calls to the children
+      # by using the method_missing method
+      summable_methods.each do |method_id|
+        define_method(method_id) do |*args|
+          self.method_missing(method_id, *args)
+        end
+      end
+      
+      # For better debuggability
+      #
+      define_method :inspect do
+        "CompositeReportingEntry [entries: #{entries.inspect} ]"
+      end
+    end
+    klass.new
+  end
+
+  # Returns true if entry is a sum entry (like returned by to_sum_entry)
+  def is_sum_entry?
+    return false
+  end
+
+  protected
+    # Helper function to cast string values to numeric values if +key+
+    # matches either +SUMMABLE_INT_FIELDS_REGEXP+ or +SUMMABLE_FLOAT_FIELDS_REGEXP+
+    def cast(key, value)
+      return value.to_i if key.to_s =~ summable_int_fields_regexp
+      return value.to_f if key.to_s =~ summable_float_fields_regexp
+      value
+    end
+
+    # Returns the union of int and float defining regexps
+    def self.summable_fields_regexp
+      Regexp.union(self::SUMMABLE_INT_FIELDS_REGEXP, self::SUMMABLE_FLOAT_FIELDS_REGEXP)
+    end
+
+    # reader for the regexp defining int fields
+    def summable_int_fields_regexp
+      self.class::SUMMABLE_INT_FIELDS_REGEXP
+    end
+
+    # reader for the regexp defining float fields
+    def summable_float_fields_regexp
+      self.class::SUMMABLE_FLOAT_FIELDS_REGEXP
+    end
+
+    # convenience accessor for summable_fields_regexp
+    def summable_fields_regexp
+      self.class.summable_fields_regexp
+    end
+    
+    # Returns an array of explicitely not summable fields
+    #
+    def not_summable_fields
+      self.class::NOT_SUMMABLE_FIELDS
+    end
+    
+    # For debugging purpose
+    #
+    def inspect
+      "#{self.class.name}: <#{@attributes.inspect}>\n"
+    end
+end

data/lib/reporting/sql_reporting.rb

@@ -0,0 +1,220 @@
+# Subclass of +Reporting+ class
+# Offers a variety of helpers to manage reportings that are generated via pure SQL queries
+#
+class SqlReporting < Reporting
+  attr_reader :columns_used
+  class_attribute :sql_tables, {:instance_reader => false, :instance_writer => false} 
+
+  # Container for columns used by any (select, group by, where) statement.
+  # Used by the joins method to retrieve the joins needed
+  def columns_used
+    @columns_used ||= []
+  end
+
+  # Marks a column as used so the connected joins will be included
+  def mark_as_used(column)
+    columns_used << column.to_sym
+  end
+
+  # Returns the columns string for the select clause
+  def sql_select(additional_columns = [], mapping = {})
+    (map_columns(required_columns, mapping, true) << additional_columns).flatten.join(', ')
+  end
+
+  # Returns the columns string for the group by clause
+  #def sql_group_by(additional_columns = [], mapping = {})
+  def sql_group_by(*args)
+    mapping = args.extract_options! || {}
+    additional_columns = args.first || []
+    result = (map_columns(group_by, mapping) << additional_columns).flatten.join(', ')
+    result.empty? ? nil : result
+  end
+
+  def sql_order_by(mapping = {})
+    return nil if order_by.nil?
+    column    = order_by[0]
+    direction = order_by[1]
+    column    = mapping.has_key?(column) ? mapping[column] : sql_column_name(column)
+    return nil unless column
+    "#{column} #{direction.to_s.upcase}"
+  end
+
+  # TODO make protected?
+  def map_columns(columns, mapping = {}, with_alias = false)
+    mapped = []
+    columns.each do |column|
+      mapped << column if is_sql_column?(column)
+    end
+    mapped.collect do |column|
+      if mapping.has_key?(column)
+        with_alias ? "#{mapping[column]} #{column}" : mapping[column]
+      else
+        sql_column_name(column, :with_alias => with_alias) 
+      end
+    end
+  end
+
+  # Returns the join statements which are needed for the given +columns+
+  def sql_joins(*columns)
+    if columns.empty?
+      columns = columns_used + required_columns
+      columns += where.keys if self.respond_to?(:where)
+    end
+    columns.uniq!
+    columns.flatten!
+
+    # get all tables needed
+    tables = columns.inject([]) do |tables, c|
+      sql = datasource_columns[c.to_s][:sql] if is_sql_column?(c)
+      tables << sql[:table] if sql && sql.is_a?(Hash)
+      tables
+    end.compact.uniq
+
+    # explode dependencies
+    sql_joins = tables.collect do |table|
+      result = [self.class.sql_tables[table]]
+      while result.last.has_key?(:depends)
+        result << self.class.sql_tables[result.last[:depends]]
+      end
+      result.reverse
+    end.flatten.uniq
+
+    sql_joins.collect { |t| t[:join] }.join(' ')
+  end
+
+  # Returns all datasource columns that correcpond to a SQL column
+  def sql_columns
+    datasource_columns.keys.delete_if { |c| !is_sql_column?(c) }.collect(&:to_sym)
+  end
+
+  # Returns +true+ if +column+ is a SQL column
+  def is_sql_column?(column)
+    datasource_columns.has_key?(column.to_s) && datasource_columns[column.to_s][:sql]
+  end
+
+  # Maps the column name using the +:sql+ definitions of the columns
+  #
+  # === options
+  # * +:with_alias+ Returns 'mapped_name name' instead of mapped_name
+  #
+  def sql_column_name(column, options = {})
+    column = column.to_s
+    return false unless is_sql_column?(column)
+    sql = datasource_columns[column][:sql]
+    return column.to_s if sql == true
+
+    parts = []
+    parts << sql[:table] if sql[:table] && !sql[:column].is_a?(String)
+    parts << (sql[:column] || column).to_s
+    sql_name = parts.join('.')
+
+    sql_name << " #{column}" if options[:with_alias]
+    sql_name
+  end
+  
+  # Returns the SQL condition for the given column, depending on the columns type
+  #
+  def sql_condition_for(column_name, value)
+    column_name = column_name.to_s
+    # use the sql column name to be sure the table name is included if an sql column is defined
+    sql_name = is_sql_column?(column_name) ? sql_column_name(column_name) : column_name
+    bind_vars = [ ]
+    condition = ''
+    type = self.class.datasource_filters[column_name][:type].to_sym
+    case type
+      when :boolean then
+        bind_vars = value
+        condition = "(#{sql_name} = ?" + (value == false ? " OR ISNULL(#{sql_name}))" : ')')
+      else
+        bind_vars = value
+        # special handling for zero numbers = allow them to be null too
+        if [ :number, :integer ].include?(type) and not value.kind_of?(Array)
+          condition = "(#{sql_name} = ? #{(value.to_i.zero? ? "OR ISNULL(#{sql_name})" : "")})"
+        else
+          condition = value.kind_of?(Array) ? "(#{sql_name} IN(?))" : "(#{sql_name} = ?)"
+        end
+    end
+    self.class.send(:sanitize_sql_array, [ condition, bind_vars ])
+  end
+  
+  # Returns all key value pairs that will be bound to the query
+  #
+  def sql_bind_variables
+    bind_vars = {}
+    self.class.datasource_filters.each do |column_name, options|
+      # just filter sql columns and nil values
+      if options[:sql] and not attributes[column_name].nil?
+        bind_vars[column_name] = attributes[column_name]
+      end
+    end
+    
+    bind_vars.symbolize_keys
+  end
+  
+  # Concat all where conditions for all bind variables
+  #
+  def sql_conditions
+    sql_bind_variables.collect do |column_name, value|
+      mark_as_used(column_name)
+      sql_condition_for(column_name, value)
+    end.compact.join(' AND ')
+  end
+
+  # Marks all columns used in filters or in the select fields as used
+  # 
+  #
+  def mark_used_columns
+    sql_bind_variables.each { |col, value| mark_as_used(col) unless value.nil? }
+  end
+
+  class << self
+
+    # Defines a SQL table that is not the 'main table'
+    #
+    # === Options
+    # * +join+    Defines the SQL JOIN statement to join this table (mandatory)
+    # * +depends+ Defines a table, this table depends on to join correclty (optional)
+    #
+    def table(name, options = {})
+      self.sql_tables ||= HashWithIndifferentAccess.new.freeze
+      new_entry = HashWithIndifferentAccess.new({name => options}).freeze
+      # frozen, to prevent modifications on class_attribute
+      self.sql_tables = self.sql_tables.merge(new_entry).freeze
+    end
+
+    def add_sql_columns_for(clazz, options = {})
+      except = (options[:except] || []).map(&:to_sym)
+      model_columns = model_columns(clazz)
+      column_names = (options[:columns] || model_columns.keys) # can be used to define column order
+
+      column_names.each do |col_name|
+        next if except.include?(col_name)
+
+        type = model_columns[col_name]
+        groupable = [:string, :date, :boolean].include?(type)
+        use_sql_sum = (type == :number) # SUM() to get correct data with grouping
+        send(:column, col_name.to_sym, 
+                {
+                  :type => type, 
+                  :sql => use_sql_sum ? {:column => "SUM(#{col_name})"} : true,
+                  :grouping => groupable })
+      end
+    end
+
+    def model_columns(clazz)
+      hsh={}
+      clazz.columns_hash.each do |name, col|
+        hsh[name.to_sym] = if col.number?
+          :number
+        elsif col.text?
+          :string
+        else
+          # try to map 1:1
+          col.type
+        end
+      end
+      hsh
+    end
+
+  end
+end

data/test/lib/empty_reporting.rb

@@ -0,0 +1,2 @@
+class EmptyReporting < Reporting
+end

data/test/lib/test_reporting.rb

@@ -0,0 +1,33 @@
+class TestReporting < Reporting
+  attr_reader :aggregate_calls
+  
+  filter :name, 
+    :default => 'foobar'
+    
+    
+  filter :from_date, :type => :date
+  filter :to_date,   :type => :date
+  filter :in_foo
+
+  select_default   %w(name age)
+  group_by_default %w(name)
+
+  column :name,         :type => :string
+  column :age,          :type => :number, :grouping => true
+  column :address,      :type => :string, :grouping => true
+  column :fullname,     :type => :string, :requires => :name
+  column :fullfullname, :type => :string, :requires => :fullname
+  column :circle_a,     :requires => :circle_b
+  column :circle_b,     :requires => :circle_a
+
+  def initialize(*args)
+    #@select = %w(name age)
+    @aggregate_calls = 0
+    super(*args)
+  end
+
+  def aggregate
+    @aggregate_calls += 1
+    []
+  end
+end

data/test/lib/test_reporting_b.rb

@@ -0,0 +1,9 @@
+class TestReportingB < TestReporting
+  filter :name_b
+
+  column :name_b, :type => :string
+  column :age_b,  :type => :number
+
+  select_default %w(name_b)
+  group_by_default %w(age_b)
+end

data/test/lib/test_reporting_c.rb

@@ -0,0 +1,3 @@
+class TestReportingC < TestReporting
+  column :name_c, :type => :string
+end