timely_reports 0.9

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjBmYjFjM2I0NDIzZWYxODQyMzczOGY2MjdhYWEyNmUwN2QwOTliZQ==
+  data.tar.gz: !binary |-
+    YzdjNDFhZWYzNjk4OTFkN2QwNWRiNjI3OGExNTcwNmE4NDM2MWM1Mg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    OGRmOTE5NTUxMDMxNGY3NThhODlmOTdiZWI3YzBhZmY4MDc0YzE4M2FlYTdk
+    MzUyOWQ4Zjc1ZjIwOTJmYTA1NTViZjkxMWI3MGZhN2ExNjMxOTc4YmU4N2M5
+    ODFhMjNkYWM0MDQzMDk3MGEwODRjOWZjOGQ4Yjk2MTA1MGEwYTY=
+  data.tar.gz: !binary |-
+    YmI1ZGQ3ZmJhMTQ5NTdjNzk2MDI2YjA3YzNkMDhhYWNhMjVjYmQ0OTA3NDdl
+    ZGFlYTEyYWMzYmJkOGFlNTM2YWQ1YWE3ZDU0ODk5NzgwNmZhYTA0YWZmMTJm
+    OGM3ZTU2Njc0MDU1ZWYyYThiYzVkYzJmZTBhMjQzOGNmYjk4ZWE=

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Nick Ragaz
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,6 @@
+Timely
+============
+
+Create time-based reports about your database records. e.g. # of records per day, month or year.
+
+Requires Rails ~> 3 and Ruby 1.9.2.

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+task :default => :test

data/lib/timely/cell.rb

@@ -0,0 +1,82 @@
+# encoding: UTF-8
+
+module Timely
+  class Cell
+    attr_accessor :report, :row, :column
+
+    def initialize(report, column, row)
+      self.report = report
+      self.column = column
+      self.row    = row
+    end
+
+    def to_s
+      "#<#{self.class.name} row: \"#{row.title}\", starts_at: #{column.starts_at}, ends_at: #{column.ends_at}>"
+    end
+
+    def column_key
+      column.to_i
+    end
+
+    def column_title
+      column.title
+    end
+
+    def row_title
+      row.title
+    end
+
+    def value
+      @value ||= cacheable? ? value_with_caching : value_without_caching
+    end
+
+    def cacheable?
+      row.cacheable? && column.cacheable?
+    end
+
+    def cache_key
+      @cache_key ||= [report.cache_key, row.cache_key, column.cache_key].join(cache_sep)
+    end
+
+    private
+
+    def value_without_caching
+      row.value(column.starts_at, column.ends_at)
+    end
+
+    def value_with_caching
+      Timely.redis ? value_from_redis : value_from_rails_cache
+    end
+
+    def value_from_rails_cache
+      Rails.cache.fetch(cache_key) { value_without_caching }
+    end
+
+    # retrieve a cached value from a redis hash.
+    #
+    # hashes are accessed using the report title and row title. values within
+    # the hash are keyed using the column's start/end timestamps
+    def value_from_redis
+      if val = Timely.redis.hget(redis_hash_key, redis_value_key)
+        val = val.include?(".") ? val.to_f : val.to_i
+      else
+        val = value_without_caching
+        Timely.redis.hset(redis_hash_key, redis_value_key, val)
+      end
+
+      val
+    end
+
+    def redis_hash_key
+      @redis_hash_key ||= [report.cache_key, row.cache_key].join(cache_sep)
+    end
+
+    def redis_value_key
+      @redis_value_key ||= column.cache_key
+    end
+
+    def cache_sep
+      Timely.cache_separator
+    end
+  end
+end

data/lib/timely/column.rb

@@ -0,0 +1,79 @@
+# encoding: UTF-8
+
+class Timely::Column
+  attr_accessor :period, :starts_at, :options
+
+  def initialize(period, starts_at, options={})
+    self.period     = period
+    self.starts_at  = starts_at
+    self.options    = options
+  end
+
+  def inspect
+    "#<#{self.class.name} period: #{period}, starts_at: #{starts_at}, ends_at: #{ends_at}>"
+  end
+
+  # calculate the end time
+  def ends_at
+    @ends_at ||= begin
+      args = period == :quarter ? { months: 3 } : { periods => 1 }
+      starts_at.advance args
+    end
+  end
+
+  # calculate the time between the start and the end. useful as the x value
+  # for bar and line graphs
+  def midpoint
+    @midpoint ||= Time.at((starts_at.to_i + ends_at.to_i) / 2)
+  end
+
+  def title
+    format_time_for_human
+  end
+
+  def to_s
+    format_time_for_group
+  end
+
+  def to_i
+    starts_at.to_i
+  end
+
+  def cache_key
+    [starts_at.to_i, ends_at.to_i].join(Timely.cache_separator)
+  end
+
+  # only cache values when the period is over
+  def cacheable?
+    ends_at < Time.zone.now
+  end
+
+  private
+
+  # :month -> :months, etc.
+  def periods
+    "#{period}s".to_sym
+  end
+
+  def format_time_for_group
+    case period
+    when :year
+      starts_at.strftime("%Y")
+    when :quarter
+      quarter_number = ((starts_at.month - 1) / 3) + 1
+      "#{starts_at.year}#{quarter_number}"
+    when :month
+      starts_at.strftime("%Y%m")
+    when :week
+      starts_at.strftime("%Y%U")
+    when :day
+      starts_at.strftime("%Y%m%d")
+    when :hour
+      starts_at.strftime("%Y%m%d%H")
+    end
+  end
+
+  def format_time_for_human
+    starts_at.strftime Timely.date_formats[period]
+  end
+end

data/lib/timely/configuration_error.rb

@@ -0,0 +1 @@
+class Timely::ConfigurationError < Exception ; end

data/lib/timely/formats/excel.rb

@@ -0,0 +1,86 @@
+# encoding: UTF-8
+
+require 'spreadsheet'
+
+class Timely::Formats::Excel < Timely::Formatter
+  CELL_FORMATS = {
+    title: Spreadsheet::Format.new(bold: true, size: 14),
+    headings: Spreadsheet::Format.new(bold: true, size: 10, align: 'right'),
+    values: Spreadsheet::Format.new(align: 'right')
+  }
+
+  attr_reader :row_idx, :workbook, :worksheet, :path
+
+  def initialize(report, options={})
+    super
+
+    @path       = options[:path] || Tempfile.new('timely-excel').path
+    @row_idx    = 0
+    @workbook   = Spreadsheet::Workbook.new
+    @worksheet  = create_worksheet
+  end
+
+  def output
+    write_title
+    write_columns
+    write_rows
+    write_generated_at
+    save_workbook
+
+    path
+  end
+
+  private
+
+  def row_idx
+    @row_idx
+  end
+
+  def increment_row_idx(by=1)
+    @row_idx += by
+  end
+
+  def create_worksheet
+    worksheet = workbook.create_worksheet
+    worksheet.name = 'Report'
+    worksheet.column(0).width = 24
+    worksheet
+  end
+
+  def write_title(worksheet)
+    worksheet.row(row_idx).default_format = CELL_FORMATS[:titles]
+    worksheet.row(row_idx).push report.title
+    increment_row_idx
+
+    worksheet.row(row_idx).push "#{report.starts_at.to_s(:long)} - #{report.ends_at.to_s(:long)} (by #{report.period})"
+    increment_row_idx 2 # add a blank line
+  end
+
+  def write_columns(worksheet)
+    worksheet.row(row_idx).default_format = CELL_FORMATS[:headings]
+    worksheet.row(row_idx).push ""
+    worksheet.row(row_idx).concat report.columns.map(&:title)
+
+    increment_row_idx
+  end
+
+  def write_rows(worksheet, row_idx)
+    raw = report.raw
+    raw.each do |row, cells|
+      worksheet.row(row_idx).push   row.title.dup
+      worksheet.row(row_idx).concat cells.map(&:value)
+      increment_row_idx
+    end
+  end
+
+  def write_generated_at
+    text = "Generated at #{Time.zone.now.to_formatted_s(:rfc822)}"
+    worksheet.row(row_idx).push text
+
+    increment_row_idx
+  end
+
+  def save_workbook
+    workbook.write path
+  end
+end

data/lib/timely/formats/hash.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+class Timely::Formats::Hash < Timely::Formatter
+  # Turn a report into a simple hash keyed off of the row titles
+  def output
+    {}.tap do |hash|
+      raw = report.raw
+
+      # headings
+      hash[""] = report.columns.map(&:title)
+
+      # data
+      raw.each do |row, cells|
+        hash[row.title] = cells.map(&:value)
+      end
+    end
+  end
+end

data/lib/timely/formats/json.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+require 'json'
+
+class Timely::Formats::Json < Timely::Formatter
+  def output
+    JSON.dump report.to_hash
+  end
+end

data/lib/timely/formatter.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+class Timely::Formatter
+  attr_accessor :report, :options
+
+  def initialize(report, options={})
+    self.report = report
+    self.options = options
+  end
+
+  def to_s
+    "#<#{self.class.name} report: \"#{report.title}\">"
+  end
+end

data/lib/timely/report.rb

@@ -0,0 +1,203 @@
+# encoding: UTF-8
+
+class Timely::Report
+  ## Class Definition ##
+
+  class_attribute :_row_args, :_row_scopes, instance_writer: false
+
+  ## Default Row Settings ##
+
+  class_attribute :default_key
+  self.default_key = :created_at
+
+  class_attribute :default_klass
+  self.default_klass = :total_count
+
+  class << self
+    # Define the report's rows in a subclass:
+    #
+    #   row "Stuff", :created_at, :count do
+    #     objects.where type: 'Stuff'
+    #   end
+    #
+    # When the report is generated, the block is evaluated
+    # in the context of the report, so you can use helper methods
+    # in the report to filter your scopes. For example, you may
+    # want to have a `user` attribute on the report and scope each
+    # row's data to that user's associations.
+    def row(title, key=default_key, klass=default_klass, options={}, &scope)
+      self._row_args   ||= []
+      self._row_scopes ||= []
+
+      klass = symbol_to_row_class klass if klass.is_a?(Symbol)
+
+      self._row_args   << [klass, [title, key, options]]
+      self._row_scopes << scope
+    end
+
+    private
+
+    # :count -> Timely::Rows::Count
+    def symbol_to_row_class(sym)
+      klass = sym.to_s.camelcase
+      Timely::Rows.const_get(klass)
+    rescue
+      raise Timely::ConfigurationError, "No row class defined for #{klass}"
+    end
+  end
+
+  ## Instance Definition ##
+
+  attr_accessor :title, :period, :length, :starts_at, :options
+
+  # This can be overridden to set defaults by calling super(default args)
+  def initialize(options={})
+    options = options.symbolize_keys
+    options.reverse_merge! period: :month
+
+    self.period     = options.delete(:period)
+    self.length     = options.delete(:length)    || default_length
+    self.starts_at  = options.delete(:starts_at) || default_starts_at
+    self.ends_at    = options.delete(:ends_at)   if options.has_key?(:ends_at)
+    self.options    = options
+  end
+
+  def title
+    @title.is_a?(Symbol) ? I18n.t("timely.reports.#{@title}") : @title
+  end
+
+  def to_s
+    "#<#{self.class.name} title: \"#{title}\", period: #{period}, starts_at: #{starts_at}, length: #{length}>"
+  end
+
+  # ensure that period is a valid symbol and not dangerous
+  def period=(val)
+    if Timely.periods.include?(val.to_s)
+      @period = val.to_sym
+    else
+      raise Timely::ConfigurationError, "period must be in the list: #{Timely.periods.join(", ")} (provided #{val})"
+    end
+  end
+
+  # ensure that length is an integer
+  def length=(val)
+    @length = val.to_i
+  end
+
+  # round the given time to the beginning of the period in which the
+  # provided time falls
+  def starts_at=(val)
+    raise Timely::ConfigurationError, "period must be set before setting starts_at" unless period
+
+    if val == :hour
+      @starts_at = val.change(min: 0, sec: 0)
+    else
+      @starts_at = val.send("beginning_of_#{period}")
+    end
+  end
+
+  # recalculate the length so that the report includes the given date
+  def ends_at=(val)
+    raise Timely::ConfigurationError, "starts_at must be set before setting ends_at" unless starts_at
+
+    duration_in_seconds = val - starts_at
+    period_duration = period == :quarter ? 3.months : 1.send(period)
+
+    self.length = (duration_in_seconds.to_f / period_duration).ceil
+  end
+
+  # calculate the end time
+  def ends_at
+    @ends_at ||= begin
+      if period == :quarter
+        starts_at.advance months: length * 3
+      else
+        starts_at.advance periods => length
+      end
+    end
+  end
+
+  # return an array of row objects after evaluating each row's scope in the
+  # context of self
+  def rows
+    @rows ||= _row_args.map.with_index do |row_args, i|
+      klass, args = row_args
+
+      args    = args.dup
+      options = args.extract_options!
+      proc    = _row_scopes[i]
+      scope   = self.instance_eval(&proc)
+
+      klass.new(*args, scope, options)
+    end
+  end
+
+  # return an array of column objects representing each time segment
+  def columns
+    @columns ||= (0..(length-1)).map do |inc|
+      args = period == :quarter ? { months: inc*3 } : { periods => inc }
+      Timely::Column.new period, starts_at.advance(args)
+    end
+  end
+
+  def cells(row)
+    (@cells ||= {})[row.title] ||= columns.map do |col|
+      Timely::Cell.new(self, col, row)
+    end
+  end
+
+  # return a hash where each row is a key pointing to an array of cells
+  def raw
+    @cache ||= Hash[ rows.map { |row| [row, cells(row)] } ]
+  end
+
+  # pass in a custom object that responds to `output`
+  def to_format(formatter_klass, options={})
+    formatter_klass.new(self, options).output
+  end
+
+  # override the cache key to include information about any objects that
+  # affect the scopes passed to each row, e.g. a user
+  def cache_key
+    title.parameterize
+  end
+
+  private
+
+  # handle `to_#{name}` methods by looking up a formatter class defined as
+  # Timely::Formats::#{name.camelcase}
+  def method_missing(method, *args, &block)
+    if method.to_s =~ /\Ato_(.+)\z/
+      to_missing_format $1, args[0]
+    else
+      super
+    end
+  end
+
+  # find the formatter class under Timely::Formats
+  def to_missing_format(formatter_name, options={})
+    formatter_klass = Timely::Formats.const_get(formatter_name.camelcase)
+    to_format formatter_klass, options
+  end
+
+  # :month -> :months, etc.
+  def periods
+    "#{period}s".to_sym
+  end
+
+  def default_length
+    Timely.default_lengths[ period ]
+  end
+
+  def default_starts_at
+    if period == :quarter
+      (length * 3 - 3).months.ago.send("beginning_of_#{period}")
+    elsif period == :hour
+      Time.zone.now.change(mins: 0).advance(hours: -(length-1))
+    elsif period == :day
+      Time.zone.now.change(hours: 0).advance(days: -(length-1))
+    else
+      (length - 1).send("#{period}s").ago.send("beginning_of_#{period}")
+    end
+  end
+end

data/lib/timely/row.rb

@@ -0,0 +1,123 @@
+# encoding: UTF-8
+
+class Timely::Row
+  ## Defaults ##
+
+  class_attribute :default_options, instance_writer: false
+  self.default_options = {}
+
+  ## Instance Definition ##
+
+  attr_accessor :title, :key, :scope, :options
+
+  # Title: string or symbol for I18n lookup
+  # Key: timestamp column name
+  # Scope: (internal) Generated by the report
+  # Options:
+  #    cacheable: if true, cache past values in Redis
+  #    transform: proc to apply to each value (e.g. for rounding), or pass
+  #    `:round` to apply default rounding (two-decimal precision) or `:to_i`
+  #    to round to 0 decimals
+  def initialize(title, key, scope, options={})
+    options.reverse_merge! default_options.reverse_merge(cacheable: true)
+
+    self.title    = title
+    self.key      = key
+    self.scope    = scope
+    self.options  = options
+  end
+
+  def to_s
+    "#<#{self.class.name} title: \"#{title}\", key: #{key}>"
+  end
+
+  def title
+    @title.is_a?(Symbol) ? I18n.t("timely.rows.#{@title}") : @title
+  end
+
+  def cache_key
+    title.parameterize
+  end
+
+  def cacheable?
+    !!options[:cacheable]
+  end
+
+  ## Values ##
+
+  # override value or raw_value in subclasses
+  def value(starts_at, ends_at)
+    transform raw_value_from date_range_scope(starts_at, ends_at)
+  end
+
+  def total(ends_at)
+    transform raw_value_from date_range_scope(nil, ends_at)
+  end
+
+  private
+
+  # override in subclasses to perform a custom calculation
+  def raw_value_from(scope)
+    scope.count
+  end
+
+  private
+
+  ## Helpers ##
+
+  # helper function for rounding non-integer values for nicer output
+  def round(val)
+    val ? val.to_f.round(Timely.default_precision) : 0
+  end
+
+  # transform the given value using either one of the default
+  # transformations (:round or :to_i) or a custom proc
+  def transform(value)
+    transform = options[:transform]
+
+    if transform == :round
+      round value
+    elsif transform == :to_i
+      value.round
+    elsif transform
+      transform.call(value)
+    else
+      value
+    end
+  end
+
+  ## Scopes ##
+
+  # only return records between the reporting dates
+  def date_range_scope(starts_at, ends_at)
+    starts = starts_at && key_is_date? ? starts_at.to_date : starts_at
+    ends = ends_at && key_is_date? ? ends_at.to_date : ends_at
+
+    if starts && ends
+      scope.where("#{key_sql} >= ? AND #{key_sql} < ?", starts, ends)
+    elsif starts
+      scope.where("#{key_sql} >= ?", starts)
+    elsif ends
+      scope.where("#{key_sql} < ?", ends)
+    else
+      scope
+    end
+  end
+
+  ## Column Names ##
+
+  # if the column name does not specify the table, add the table name
+  def disambiguate_column_name(col)
+    col = col.to_s
+    col.include?(".") ? col : "#{scope.table_name}.#{col}"
+  end
+
+  def key_sql
+    @key_sql ||= disambiguate_column_name key
+  end
+
+  # check if a date column's name ends in _on (vs. _at)
+  def key_is_date?
+    @key_is_date ||= (key =~ /_on\z/)
+  end
+end

data/lib/timely/rows/average.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+class Timely::Rows::Average < Timely::Row
+  self.default_options = { transform: :round }
+
+  private
+
+  def raw_value_from(scope)
+    scope.average column_sql
+  end
+
+  def column_sql
+    @column_sql ||= disambiguate_column_name options[:column]
+  end
+end

data/lib/timely/rows/average_days_between.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+class Timely::Rows::AverageDaysBetween < Timely::Row
+  self.default_options = { transform: :round }
+
+  private
+
+  def raw_value_from(scope)
+    scope.average query
+  end
+
+  def query
+    "DATEDIFF(#{to}, #{from})"
+  end
+
+  def from
+    @from ||= disambiguate_column_name column[:from]
+  end
+
+  def to
+    @to ||= disambiguate_column_name column[:to]
+  end
+end

data/lib/timely/rows/average_hours_between.rb

@@ -0,0 +1,23 @@
+# encoding: UTF-8
+
+class Timely::Rows::AverageHoursBetween < Timely::Row
+  self.default_options = { transform: :round }
+
+  private
+
+  def raw_value_from(scope)
+    scope.average query
+  end
+
+  def query
+    "TIMESTAMPDIFF(MINUTE, #{from}, #{to}) / 60"
+  end
+
+  def from
+    @from ||= disambiguate_column_name column[:from]
+  end
+
+  def to
+    @to ||= disambiguate_column_name column[:to]
+  end
+end

data/lib/timely/rows/average_week_hours_between.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+class Timely::Rows::AverageWeekHoursBetween < Timely::Row
+  self.default_options = { transform: :round }
+
+  private
+
+  def raw_value_from(scope)
+    scope.average query
+  end
+
+  # This is equivalent to the following, with substitutions:
+  #
+  #  @old := objects.created_at,
+  #  @new := objects.completed_at,
+  #  @oldWeek := WEEK(@old, 2),
+  #  @newWeek := WEEK(@new, 2),
+  #  @weekends := @newWeek - @oldWeek,
+  #  @weekendSecs := @weekends * 172800,
+  #  @oldWeekSaturday := STR_TO_DATE( CONCAT(DATE_FORMAT(@old, '%X%V'), ' Saturday'), '%X%V %W %h-%i-%s'),
+  #  @extraFirstWeekSecs := TIME_TO_SEC( TIMEDIFF(@old, @oldWeekSaturday) ),
+  #  @extraFirstWeekSecs := (@extraFirstWeekSecs > 0) * @extraFirstWeekSecs,
+  #  @newWeekSaturday := STR_TO_DATE( CONCAT(DATE_FORMAT(@new, '%X%V'), ' Saturday'), '%X%V %W %h-%i-%s'),
+  #  @extraLastWeekSecs := TIME_TO_SEC( TIMEDIFF(@new, @newWeekSaturday) ),
+  #  @extraLastWeekSecs := (@extraLastWeekSecs > 0) * @extraLastWeekSecs,
+  #  @totalSecs := TIME_TO_SEC( TIMEDIFF(@new, @old) ),
+  #  @totalHours := @totalSecs / 3600 as total_hours,
+  #  @avg := (@totalSecs - @weekendSecs + @extraFirstWeekSecs + @extraLastWeekSecs) / 3600 as weekday_hours
+  #
+  # The algorithm is:
+  #
+  #   total time between dates - total time on weekends between dates
+  #
+  # the total weekend time is adjusted to remove any time before or after
+  # the dates themselves (e.g. if the first date is *on* a weekend, then
+  # the hours between the weekend beginning and the first date should not
+  # be counted)
+  def query
+    "((TIME_TO_SEC( TIMEDIFF(#{to}, #{from}) ) - ( ( WEEK(#{to}, 2) - ( WEEK(#{from}, 2) - ( ( YEAR(#{to}) - YEAR(#{from}) ) * 52 ) ) ) * 172800 )) + (( TIME_TO_SEC( TIMEDIFF(#{from}, STR_TO_DATE( CONCAT( DATE_FORMAT(#{from}, '%X%V'), ' Saturday'), '%X%V %W %h-%i-%s' ))) > 0) * TIME_TO_SEC( TIMEDIFF(#{from}, STR_TO_DATE( CONCAT(DATE_FORMAT(#{from}, '%X%V'), ' Saturday'), '%X%V %W %h-%i-%s')) )) + ((TIME_TO_SEC( TIMEDIFF(#{to}, STR_TO_DATE( CONCAT(DATE_FORMAT(#{to}, '%X%V'), ' Saturday'), '%X%V %W %h-%i-%s')) ) > 0) * TIME_TO_SEC( TIMEDIFF(#{to}, STR_TO_DATE( CONCAT(DATE_FORMAT(#{to}, '%X%V'), ' Saturday'), '%X%V %W %h-%i-%s')) )) ) / 3600"
+  end
+
+  def from
+    @from ||= disambiguate_column_name column[:from]
+  end
+
+  def to
+    @to ||= disambiguate_column_name column[:to]
+  end
+end

data/lib/timely/rows/count.rb

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+
+class Timely::Rows::Count < Timely::Row
+  private
+
+  def raw_value_from(scope)
+    scope.count
+  end
+end

data/lib/timely/rows/present.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+class Timely::Rows::Present < Timely::Row
+  private
+
+  def raw_value_from(scope)
+    scope.where(*conditions).count
+  end
+
+  def conditions
+    column_sql = disambiguate_column_name options[:column]
+    ["#{column_sql} IS NOT NULL AND #{column_sql} != ?", ""]
+  end
+end

data/lib/timely/rows/standard_deviation.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+class Timely::Rows::StandardDeviation < Timely::Row
+  self.default_options = { transform: :round }
+
+  private
+
+  def raw_value_from(scope)
+    scope.select(query).first.sd_val
+  end
+
+  def query
+    "STDDEV(#{column}) as sd_val"
+  end
+
+  def column
+    @column ||= disambiguate_column_name options[:column]
+  end
+end

data/lib/timely/rows/sum.rb

@@ -0,0 +1,12 @@
+# encoding: UTF-8
+
+class Timely::Rows::Sum < Timely::Row
+  self.default_options = { transform: :to_i }
+
+  private
+
+  def raw_value_from(scope)
+    column_sql = disambiguate_column_name options[:column]
+    scope.sum column_sql
+  end
+end

data/lib/timely/rows/total_count.rb

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+class Timely::Rows::TotalCount < Timely::Row
+  def value(starts_at, ends_at)
+    total ends_at
+  end
+
+  private
+
+  def raw_value_from(scope)
+    scope.count
+  end
+end

data/lib/timely/rows/total_sum.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+
+class Timely::Rows::TotalSum < Timely::Row
+  self.default_options = { transform: :to_i }
+
+  def value(starts_at, ends_at)
+    total ends_at
+  end
+
+  private
+
+  def raw_value_from(scope)
+    scope.sum disambiguate_column_name(options[:column])
+  end
+end

data/lib/timely.rb

@@ -0,0 +1,111 @@
+require 'active_support/dependencies'
+
+module Timely
+  autoload :Cell,               'timely/cell'
+  autoload :Column,             'timely/column'
+  autoload :ConfigurationError, 'timely/configuration_error'
+  autoload :Formatter,          'timely/formatter'
+  autoload :Report,             'timely/report'
+  autoload :Row,                'timely/row'
+
+  module Formats
+    autoload :Excel,            'timely/formats/excel'
+    autoload :Hash,             'timely/formats/hash'
+    autoload :Json,             'timely/formats/json'
+  end
+
+  module Rows
+    autoload :Average,                 'timely/rows/average'
+    autoload :AverageDaysBetween,      'timely/rows/average_days_between'
+    autoload :AverageHoursBetween,     'timely/rows/average_hours_between'
+    autoload :AverageWeekHoursBetween, 'timely/rows/average_week_hours_between'
+    autoload :Count,                   'timely/rows/count'
+    autoload :Present,                 'timely/rows/present'
+    autoload :StandardDeviation,       'timely/rows/standard_deviation'
+    autoload :Sum,                     'timely/rows/sum'
+    autoload :TotalCount,              'timely/rows/total_count'
+    autoload :TotalSum,                'timely/rows/total_sum'
+  end
+
+  PERIODS = %w( year quarter month week day hour )
+
+  # Customize the rounding precision
+  mattr_accessor :default_precision
+  @@default_precision = 2
+
+  # Customize how column headings are formatted
+  mattr_accessor :date_formats
+  @@date_formats = {
+    year: "%Y",
+    quarter: "%b %Y",
+    month: "%b %Y",
+    week: "%-1d %b",
+    day: "%-1d %b",
+    hour: "%-1I %p (%m/%-1d)"
+  }
+
+  # Customize the # of periods shown by default
+  mattr_accessor :default_lengths
+  @@default_lengths = {
+    year: 3,
+    quarter: 6,
+    month: 6,
+    week: 5,
+    day: 7,
+    hour: 8
+  }
+
+  # Provide a Redis connection for caching. If this is not configured,
+  # the default Rails' cache will be used instead.
+  mattr_accessor :redis
+  @@redis = nil
+
+  # Define the separator for turning cache keys into strings
+  mattr_accessor :cache_separator
+  @@cache_separator = ":"
+
+  # Access the configuration in an initializer like:
+  #
+  #   Timely.setup do |config|
+  #     config.redis = ...
+  #   end
+  def self.setup
+    yield self
+  end
+
+  def self.periods
+    PERIODS
+  end
+
+  def self.redis=(server)
+    case server
+    when String
+      if server =~ /redis\:\/\//
+        redis = Redis.connect(:url => server, :thread_safe => true)
+      else
+        server, namespace = server.split('/', 2)
+        host, port, db = server.split(':')
+        redis = Redis.new(:host => host, :port => port,
+          :thread_safe => true, :db => db)
+      end
+      namespace ||= :resque
+
+      @redis = Redis::Namespace.new(namespace, :redis => redis)
+    when Redis::Namespace
+      @redis = server
+    else
+      @redis = Redis::Namespace.new(:resque, :redis => server)
+    end
+  end
+
+  # Returns the current Redis connection. If none has been created, will
+  # create a new one.
+  def self.redis
+    return @redis if @redis
+    self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
+    self.redis
+  end
+
+  class Engine < Rails::Engine
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: timely_reports
+version: !ruby/object:Gem::Version
+  version: '0.9'
+platform: ruby
+authors:
+- Nick Ragaz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  name: activesupport
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  name: activerecord
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  name: ruby-ole
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  name: spreadsheet
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  name: bundler
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  name: rake
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  name: sqlite3
+description: Create reports about periods of time in your database.
+email: nick.ragaz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/timely/cell.rb
+- lib/timely/column.rb
+- lib/timely/configuration_error.rb
+- lib/timely/formats/excel.rb
+- lib/timely/formats/hash.rb
+- lib/timely/formats/json.rb
+- lib/timely/formatter.rb
+- lib/timely/report.rb
+- lib/timely/row.rb
+- lib/timely/rows/average.rb
+- lib/timely/rows/average_days_between.rb
+- lib/timely/rows/average_hours_between.rb
+- lib/timely/rows/average_week_hours_between.rb
+- lib/timely/rows/count.rb
+- lib/timely/rows/present.rb
+- lib/timely/rows/standard_deviation.rb
+- lib/timely/rows/sum.rb
+- lib/timely/rows/total_count.rb
+- lib/timely/rows/total_sum.rb
+- lib/timely.rb
+- MIT-LICENSE
+- Rakefile
+- README.md
+homepage: http://github.com/nragaz/timely
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Create reports about periods of time in your database.
+test_files: []