report_cat 0.2.0

data/lib/report_cat/core/chart.rb

@@ -0,0 +1,50 @@
+module ReportCat
+  module Core
+    class Chart
+
+      attr_reader :name, :type, :label, :values, :options
+
+      def initialize( attributes = {} )
+        @name = attributes[ :name ]
+        @type = attributes[ :type ]
+        @label = attributes[ :label ]
+        @values = attributes[ :values ] || []
+        @options = attributes[ :options ] || {}
+
+        @values = [ @values ] unless @values.is_a?( Array )
+       end
+
+      # Returns columns as JSON for the Google Visualization API
+
+      def columns( report )
+        columns = []
+        columns << [ 'string', @label ]
+        @values.each { |name| columns << [ 'number', name  ] }
+
+        return columns.to_json
+      end
+
+       # Returns rows as JSON for the Google Visualization API
+
+      def data( report )
+        table = []
+
+        label_index = report.column_index( @label )
+        raise "Bad label index: #{@label}" unless label_index
+
+        value_indexes = @values.map { |name| report.column_index( name ) }
+
+        report.rows.each do |row|
+          data = [ row[ label_index ].to_s ]
+          value_indexes.each do |value_index|
+            data << ( value_index ? row[ value_index ] : nil )
+          end
+          table << data
+        end
+
+        return table.to_json
+      end
+
+    end
+  end
+end

data/lib/report_cat/core/column.rb

@@ -0,0 +1,70 @@
+module ReportCat
+  module Core
+    class Column
+
+      attr_reader :name, :type, :options
+
+      def initialize( attributes = {} )
+        @name = attributes[ :name ]
+        @type = attributes[ :type ]
+        @options = attributes[ :options ] || {}
+      end
+
+      def format( value )
+        return nil if value.nil?
+
+        case @type
+          when :float          then return ("%.2f" % value).to_f
+          when :integer        then return value.to_i
+          when :moving_average then return ("%.2f" % value).to_f
+          when :ratio          then return ("%.2f" % value).to_f
+          else return value
+        end
+      end
+
+      def post_process( report )
+        case @type
+          when :moving_average then post_process_moving_average( report )
+          when :ratio          then post_process_ratio( report )
+        end
+      end
+
+      def post_process_moving_average( report )
+        i_moving_average = report.column_index( name )
+        i_target = report.column_index( @options[ :target ] )
+
+        interval = @options[ :interval ]
+        interval_max = interval - 1
+        n_rows = report.rows.length - 1
+
+        (interval_max..n_rows).each do |row|
+          sum = 0.0
+          (0..interval_max).each { |i| sum += report.rows[ row - i ][ i_target ] }
+          value = sum / interval
+          report.rows[ row ][ i_moving_average ] = format( value )
+        end
+      end
+
+      def post_process_ratio( report )
+        i_ratio = report.column_index( name )
+        i_numerator = report.column_index( @options[ :numerator ] )
+        i_denominator = report.column_index( @options[ :denominator ] )
+
+        report.rows.each do |row|
+          numerator = row[ i_numerator ].to_f
+          denominator = row[ i_denominator ].to_f
+          value = ( denominator == 0.0 ) ? 0.0 : ( numerator / denominator )
+          row[ i_ratio ] = format( value )
+        end
+      end
+
+      def to_sql
+        sql = @options[ :sql ]
+        return "#{sql} as #{name}" if sql
+        return "0 as #{name}" if @type == :ratio || @type == :moving_average
+        return @name
+      end
+
+    end
+  end
+end

data/lib/report_cat/core/param.rb

@@ -0,0 +1,35 @@
+module ReportCat
+  module Core
+    class Param
+
+      attr_reader :name, :type, :value, :options
+
+      def initialize( attributes = {} )
+        @name = attributes[ :name ]
+        @type = attributes[ :type ]
+        @value = attributes[ :value ]
+        @options = attributes[ :options ] || {}
+      end
+
+      def value=( value )
+        @value = case @type
+          when :check_box then ( value == '1' || value == true || value == 'true' )
+          when :date
+            if value.kind_of?( Hash )
+              Date.new( value[:year].to_i, value[:month].to_i, value[:day].to_i )
+            elsif value.kind_of?( String )
+              Date.parse( value )
+            else
+              value
+            end
+          else value
+        end
+      end
+
+      def hide
+        @options[ :hidden ] = true
+      end
+
+    end
+  end
+end

data/lib/report_cat/core/report.rb

@@ -0,0 +1,127 @@
+# This is the most basic report, a simple wrapped around an SQL generator
+
+require 'csv'
+
+module ReportCat
+  module Core
+    class Report
+      extend ActiveSupport::DescendantsTracker
+
+      attr_reader :name, :params, :columns, :rows, :charts
+      attr_reader :from, :joins, :where, :group_by, :order_by, :limit
+      attr_accessor :back
+      attr_reader :abstract
+
+      def initialize( attributes = {} )
+        @name = attributes[ :name ]
+        @from = accept_array( attributes[ :from ], ',' )
+        @joins = accept_array( attributes[ :joins ], ' ' )
+        @where = accept_array( attributes[ :where ], ' and ' )
+        @group_by = accept_array( attributes[ :group_by ], ',' )
+        @order_by = accept_array( attributes[ :order_by ], ',' )
+        @limit = attributes[ :limit ]
+
+        @back = attributes[ :back ]
+
+        @params = []
+        @columns = []
+        @rows = []
+        @charts = []
+      end
+
+      def accept_array( array, separator )
+        return array unless array.is_a?( Array )
+        return array.join( separator )
+      end
+
+      def add_chart( name, type, label, values, options = {} )
+        chart = Chart.new(
+            :name => name,
+            :type => type,
+            :label => label,
+            :values => values,
+            :options => options )
+
+        charts << chart
+        return chart
+      end
+
+      def add_column( name, type, options = {} )
+        columns << ( column = Column.new( :name => name, :type => type, :options => options ) )
+        return column
+      end
+
+      def add_param( name, type, value = nil, options = {} )
+        params << ( param = Param.new( :name => name, :type => type, :value => value, :options => options ) )
+        return param
+      end
+
+      def attributes
+        hash = { :id => name, :name => name }
+        hash[ :back ] = @back if @back
+        @params.each { |param| hash[ param.name ] = param.value }
+        return hash
+      end
+
+      def column( name )
+        if index = columns.index { |c| c.name.to_s == name.to_s }
+          return columns[ index ]
+        end
+        return nil
+      end
+
+      def column_index( name )
+        @columns.each_index { |index| return index if columns[ index ].name == name }
+        return nil
+      end
+
+      def generate( options = {} )
+        @params.each { |param| param.value = options[ param.name ] if options[ param.name ] }
+        query
+      end
+
+      def param( name )
+        if index = @params.index { |p| p.name.to_s == name.to_s }
+          return @params[ index ]
+        end
+        return nil
+      end
+
+      def to_csv
+        CSV.generate( :force_quotes => true ) do |csv|
+          csv << @columns.map { |column| column.name }
+          @rows.each { |row| csv << row }
+        end
+      end
+
+    protected
+
+      def query
+        @rows = []
+        return unless results = ActiveRecord::Base.connection.execute( to_sql )
+
+        results.each do |row|
+          row = columns.map { |c| row[ c.name.to_s ] } if row.is_a?( Hash )
+          row.each_index { |i| row[ i ] = columns[ i ].format( row[ i ] ) }
+          @rows << row
+        end
+
+        @columns.each { |c| c.post_process( self ) }
+      end
+
+      def to_sql
+        select = @columns.map { |c| c.to_sql }.compact.join( ',' )
+
+        sql = "select #{select} from #{from}"
+        sql << " #{joins}" if joins
+        sql << " where #{where}" if where
+        sql << " group by #{group_by}" if group_by
+        sql << " order by #{order_by}" if order_by
+        sql << " limit #{limit}" if limit
+
+        return sql
+      end
+
+    end
+  end
+end

data/lib/report_cat/engine.rb

@@ -0,0 +1,11 @@
+module ReportCat
+  class Engine < ::Rails::Engine
+    isolate_namespace ReportCat
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.integration_tool :rspec
+    end
+
+  end
+end

data/lib/report_cat/matchers/have_chart.rb

@@ -0,0 +1,58 @@
+RSpec::Matchers.define :have_chart do |name|
+
+  description do
+    "have a chart named #{name}"
+  end
+
+  chain :with_type do |type|
+    @type = type
+  end
+
+  chain :with_label do |label|
+    @label = label
+  end
+
+  chain :with_values do |values|
+    @values = values
+  end
+
+  chain :with_options do |options|
+    @options = options
+  end
+
+  match do |report|
+    chart = report.charts.select{ |chart| chart.name == name }.first
+
+    @has_chart = !chart.nil?
+    @has_chart = ( chart.type == @type ) if @type && @has_chart
+    @has_chart = ( chart.label == @label ) if @label && @has_chart
+    @has_chart = ( chart.values == @values ) if @values && @has_chart
+    @has_chart = ( chart.options == @options ) if @options && @has_chart
+
+    @has_chart
+  end
+
+  failure_message do |report|
+    message = "expected that report would have a chart named #{name}"
+
+    chart = report.charts.select{ |chart| chart.name == name }.first
+    message << " with type #{@type} but got #{chart.type}" if chart && chart.type != @type
+    message << " with label #{@label} but got #{chart.label}" if chart && chart.label != @value
+    message << " with options #{@values} but got #{chart.values}" if chart && chart.values != @values
+    message << " with options #{@options} but got #{chart.options}" if chart && chart.options != @options
+
+    message
+  end
+
+  failure_message_when_negated do |report|
+    message = "expected that report would not chart a param named #{name}"
+
+    chart = report.charts.select{ |chart| chart.name == name }.first
+    message << " with type #{@type} but got #{chart.type}" if chart && chart.type != @type
+    message << " with label #{@label} but got #{chart.label}" if chart && chart.label != @value
+    message << " with options #{@values} but got #{chart.values}" if chart && chart.values != @values
+    message << " with options #{@options} but got #{chart.options}" if chart && chart.options != @options
+
+    message
+  end
+end

data/lib/report_cat/matchers/have_column.rb

@@ -0,0 +1,45 @@
+RSpec::Matchers.define :have_column do |name|
+
+  description do
+    "have a column named #{name}"
+  end
+
+  chain :with_type do |type|
+    @type = type
+  end
+
+  chain :with_options do |options|
+    @options = options
+  end
+
+  match do |report|
+    column = report.columns.select{ |column| column.name == name }.first
+
+    @has_column = !column.nil?
+    @has_column = ( column.type == @type ) if @type && @has_column
+    @has_column = ( column.options == @options ) if @options && @has_column
+
+    @has_column
+  end
+
+  failure_message do |report|
+    message = "expected that report would have a column named #{name}"
+
+    column = report.columns.select{ |column| column.name == name }.first
+    message << " with type #{@type} but got #{column.type}" if column && column.type != @type
+    message << " with options #{@options} but got #{column.options}" if column && column.options != @options
+
+    message
+  end
+
+  failure_message_when_negated do |report|
+    message = "expected that report would not have a column named #{name}"
+
+    column = report.columns.select{ |column| column.name == name }.first
+    message << " with type #{@type} but got #{column.type}" if column && column.type != @type
+    message << " with options #{@options} but got #{column.options}" if column && column.options != @options
+
+    message
+  end
+
+end

data/lib/report_cat/matchers/have_param.rb

@@ -0,0 +1,52 @@
+RSpec::Matchers.define :have_param do |name|
+
+  description do
+    "have a param named #{name}"
+  end
+
+  chain :with_type do |type|
+    @type = type
+  end
+
+  chain :with_value do |value|
+    @value = value
+  end
+
+  chain :with_options do |options|
+    @options = options
+  end
+
+  match do |report|
+    param = report.params.select{ |param| param.name == name }.first
+
+    @has_param = !param.nil?
+    @has_param = ( param.type == @type ) if @type && @has_param
+    @has_param = ( param.value == @value ) if @value && @has_param
+    @has_param = ( param.options == @options ) if @options && @has_param
+
+    @has_param
+  end
+
+  failure_message do |report|
+    message = "expected that report would have a param named #{name}"
+
+    param = report.params.select{ |param| param.name == name }.first
+    message << " with type #{@type} but got #{param.type}" if param && param.type != @type
+    message << " with value #{@value} but got #{param.value}" if param && param.value != @value
+    message << " with options #{@options} but got #{param.options}" if param && param.options != @options
+
+    message
+  end
+
+  failure_message_when_negated do |report|
+    message = "expected that report would not have a param named #{name}"
+
+    param = report.params.select{ |param| param.name == name }.first
+    message << " with type #{@type} but got #{param.type}" if param && param.type != @type
+    message << " with value #{@value} but got #{param.value}" if param && param.value != @value
+    message << " with options #{@options} but got #{param.options}" if param && param.options != @options
+
+    message
+  end
+
+end

data/lib/report_cat/reports/cohort_report.rb

@@ -0,0 +1,113 @@
+module ReportCat
+  module Reports
+    include ReportCat::Core
+
+    class CohortReport < DateRangeReport
+
+      attr_reader :cohort
+      attr_reader :cohort_column
+
+      def initialize( attributes = {} )
+        defaults = { :name => :cohort_report }
+        super( defaults.merge( attributes ) )
+
+        @cohort_column = attributes[ :cohort_column ] || :total
+
+        add_column( :total, :integer )
+
+        # Assume any params the child report has
+
+        if @cohort = attributes[ :cohort ]
+          @cohort.params.each { |p| @params << p unless param( p.name ) }
+        end
+       end
+
+      def query
+        @rows = []
+
+        period = param( :period ).value.to_sym
+        start_date = param( :start_date ).value
+        stop_date = param( :stop_date ).value
+        name = param( :period ).value.to_s.chop.chop
+
+        DateRange.generate( period, start_date, stop_date )
+        range = DateRange.range( period, start_date, stop_date )
+
+        range.each_index { |i| add_column( "#{name}_#{i+1}", :float ) }
+        range.each { |r| @rows << add_row( r, range ) }
+
+        columns = @columns[ 3, @columns.length - 3 ].map { |c| c.name }
+        add_chart( :cohort_line, :line, :start_date, columns )
+
+        add_link_column
+      end
+
+      def add_row( date_range, column_range )
+        return [] unless cohort
+
+        generate_cohort( date_range )
+
+        i_total = cohort.column_index( :total )
+        total = cohort.rows.empty? ? 0 : cohort.rows[ 0 ][ i_total ]
+        row = [ date_range.start_date, date_range.stop_date, total ]
+
+        column_range.each_index do |i|
+          if i >= cohort.rows.size
+            row << nil
+          else
+            row << process_cohort( cohort.rows[ i ] )
+          end
+        end
+
+        return row
+      end
+
+      def generate_cohort( date_range )
+        cohort.param( :period ).value = date_range.period.to_sym
+        cohort.param( :start_date ).value = date_range.start_date
+        cohort.param( :stop_date ).value = param( :stop_date ).value
+        cohort.generate
+      end
+
+      def process_cohort( row )
+        return raw_cohort( row )
+      end
+
+      def raw_cohort( row )
+        i_total = cohort.column_index( cohort_column )
+        value = row[ i_total ].to_f
+        return ("%.2f" % value).to_f
+      end
+
+      def fractional_cohort( row )
+        i_total = cohort.column_index( cohort_column )
+        total = cohort.rows.empty? ? 0 : cohort.rows[ 0 ][ i_total ]
+
+        value = row[ i_total ].to_f
+        value = ( total == 0 ? 0.0 : value / total )
+        return ("%.2f" % value).to_f
+      end
+
+      def add_link_column
+        i_start = cohort.column_index( :start_date )
+        add_column( :link, :report )
+
+        rows.each do |row|
+          start_date = row[ i_start ]
+          row << cohort_link( start_date )
+        end
+      end
+
+      def cohort_link( start_date, link_attributes = {} )
+        @cohort.param( :start_date ).value = start_date
+        @cohort.param( :stop_date ).value = param( :stop_date ).value
+        @cohort.param( :period ).value = param( :period ).value
+        @cohort.back = attributes
+
+        return @cohort.attributes.merge( link_attributes )
+      end
+
+    end
+
+  end
+end

data/lib/report_cat/reports/date_range_report.rb

@@ -0,0 +1,66 @@
+module ReportCat
+  module Reports
+    include ReportCat::Core
+
+    class DateRangeReport < Report
+
+      PERIODS = [ :daily, :weekly, :monthly, :quarterly, :yearly ].freeze
+
+      def defaults
+        table_name = ReportCat::DateRange.table_name
+
+        return {
+            :name => :date_range_report,
+            :from => table_name,
+            :order_by => "#{table_name}.start_date asc",
+            :group_by => "#{table_name}.start_date, #{table_name}.stop_date"
+        }
+      end
+
+      def initialize( attributes = {} )
+        super( defaults.merge( attributes ) )
+
+        add_param( :start_date, :date, Date.today - 7 )
+        add_param( :stop_date, :date, Date.today )
+        add_param( :period, :select, :weekly, :values => PERIODS )
+
+        table_name = ReportCat::DateRange.table_name
+        add_column( :start_date, :date, :sql => "#{table_name}.start_date" )
+        add_column( :stop_date, :date, :sql => "#{table_name}.stop_date" )
+      end
+
+      def query
+        DateRange.generate( period, start_date, stop_date )
+        super
+      end
+
+      def where
+        return [
+            super,
+            DateRange.sql_intersect( start_date, stop_date ),
+            DateRange.sql_period( period )
+        ].compact.join( ' and ' )
+      end
+
+      # Accessors
+
+      def period
+        param( :period ).value.to_sym
+      end
+
+      def start_date
+        param( :start_date ).value
+      end
+
+      def stop_date
+        param( :stop_date ).value
+      end
+
+      def first_period
+        ReportCat::DateRange.range( period, start_date, stop_date ).first
+      end
+
+    end
+
+  end
+end

data/lib/report_cat/version.rb

@@ -0,0 +1,3 @@
+module ReportCat
+  VERSION = '0.2.0'
+end

data/lib/report_cat.rb

@@ -0,0 +1,39 @@
+require "report_cat/engine"
+require "report_cat/config"
+
+require 'report_cat/core/chart'
+require 'report_cat/core/column'
+require 'report_cat/core/param'
+require 'report_cat/core/report'
+
+require 'report_cat/reports/date_range_report'
+require 'report_cat/reports/cohort_report'
+
+if defined?( RSpec )
+  require 'report_cat/matchers/have_chart'
+  require 'report_cat/matchers/have_column'
+  require 'report_cat/matchers/have_param'
+end
+
+module ReportCat
+
+  def self.config
+    return ReportCat::Config.instance
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.reports
+    reports = HashWithIndifferentAccess.new
+
+    ReportCat::Core::Report.descendants.map do |klass|
+      report = klass.new
+      reports[ report.name.to_sym ] = report
+    end
+
+    return reports
+  end
+
+end

data/lib/tasks/report_cat.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :report_cat do
+#   # Task goes here
+# end