has_metrics 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test/test.db

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in has_metrics.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Allan Grant
+
+MIT License
+
+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,51 @@
+# HasMetrics
+
+Calculates metrics on ActiveRecord entries and caches them so they can be queried from a database.  The calculated values are stored in another table which gets automatically created and migrated as needed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'has_metrics'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install has_metrics
+
+## Usage
+
+    # Memoize in DB for 24 hours as an integer
+    has_metric :total_offer_count do
+      activities.by_action(:offer).count
+    end
+
+    # Memoize in DB for 1 hour as an integer
+    has_metric :total_share_count, :every => 1.hour do
+      activities.by_action(:share).count
+    end
+
+    # Memoize in DB for 24 hours as a float
+    has_metric :average_shares_per_offer, :type => :float do
+      total_share_count.to_f / total_offer_count
+    end
+
+## TODO
+
+1. Tests
+2. Refactoring
+3. Better readme
+4. Extract related functionality into gem
+    * segments - lets you use has_metrics to segment all records in a table between some set of string values
+    * has_custom_order_by - provides default names scopes for sorting based on metrics & segments by joining the metrics table
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs      << 'lib' << 'test'
+  test.pattern   = 'test/{functional,unit}/**/*_test.rb'
+  test.verbose   = true
+end
+
+task :default => :test

data/has_metrics.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/has_metrics/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Allan Grant"]
+  gem.email         = ["allan@allangrant.net"]
+  gem.description   = %q{Memoization into activerecord.}
+  gem.summary       = %q{Calculate "metrics" (any expensive methods) on ActiveRecord entries and memoize them to an automagical table.}
+  gem.homepage      = "http://github.com/allangrant/has_metrics"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "has_metrics"
+  gem.require_paths = ["lib"]
+  gem.version       = HasMetrics::VERSION
+
+  gem.add_dependency("activerecord")
+  gem.add_development_dependency("rake")
+  gem.add_development_dependency("shoulda")
+  # gem.add_development_dependency("mocha")
+  gem.add_development_dependency("sqlite3")
+end

data/lib/has_metrics/metrics.rb

@@ -0,0 +1,185 @@
+module Metrics
+  def self.included(base)
+    base.extend ClassMethods
+
+    klass_name = "#{base}Metrics"
+    klass = begin
+      Object.const_get(klass_name)
+    rescue
+      Object.const_set(klass_name, Class.new(ActiveRecord::Base))
+    end
+    klass.class_eval do
+      extend Metrics::MetricsClass
+      belongs_to base.to_s.underscore.to_sym, :foreign_key => 'id'
+      @object_class = base
+    end
+    
+    base.class_eval do
+      if klass.table_exists?
+        @metrics_class = klass
+        has_one :metrics, :class_name => klass_name, :foreign_key => 'id', :dependent => :destroy
+      else
+        @object_class = base
+        @metrics_class = base
+        base.extend(Metrics::MetricsClass)
+      end
+      
+      def metrics
+        @metrics ||= self.class.metrics_class.find_or_create_by_id(id)
+      end
+    end
+  end
+
+  module ClassMethods
+    # CLASS METHODS ADDED
+    def metrics_class
+      @metrics_class
+    end
+    def has_metric name, options={}, &block
+      define_method name do |*args|
+        frequency = options[:every] || 20.hours
+        previous_result = metrics.attributes[name.to_s] unless options[:every] == :always
+        datestamp_column = "updated__#{name}__at"
+        datestamp = metrics.attributes[datestamp_column]
+        force = [:force, true].include?(args[0])
+        case
+        when !force && previous_result && options[:once]
+          # Only calculate this metric once.  If it's not nil, reuse the old value.
+          previous_result
+        when !force && frequency.is_a?(Fixnum) && datestamp && datestamp > frequency.ago
+          # The metric was recently calculated and can be reused.
+          previous_result
+        else
+          result = instance_exec(&block)
+          result = nil if result.is_a?(Float) && !result.finite?
+          begin
+            metrics.update_attributes(name => result, datestamp_column => Time.zone.now)
+          rescue NoMethodError
+            # This happens if the migrations haven't run yet.  We should still calculate & return the metric.
+          end
+          result
+        end
+      end
+
+      (@metrics ||= []) << name.to_sym
+
+      if respond_to?(:has_custom_order_by)  # TODO: carve out has_custom_order_by functionality into this gem
+        unless metrics_class == self
+          has_custom_order_by name do |column, order|
+            { :joins => :metrics, :order => "#{reflect_on_association(:metrics).table_name}.#{column} #{order}" }
+          end
+        end
+      end
+      
+      if options[:type] && (options[:type].to_sym == :float)
+        (@float_metrics ||= []) << name.to_sym
+      end
+    end
+
+    def metrics
+      @metrics
+    end
+    
+    def metrics_column_type(column)
+      case
+      when (column.to_s =~ /^by_(.+)$/) && respond_to?(:segment_categories) && segment_categories.include?($1.to_sym) # TODO: carve out segementation functionality into this gem
+        :string
+      when (column.to_s =~ /_at$/)
+        :datetime
+      when @float_metrics && @float_metrics.include?(column)
+        :float
+      else :integer
+      end
+    end
+    
+    def update_all_metrics!(*args)
+      metrics_class.migrate!
+      # start_time = Time.zone.now
+      # total = all.count
+      # if caller.find {|c| c =~ /irb_binding/} # When called from irb
+      #   puts "Updating all metrics on #{name}: #{metrics.join(', ')}"
+      #   puts "Updating #{total} records."
+      #   progress_bar = ProgressBar.new("Progress", total)
+      # end
+      for record in all(:order => "id desc")
+        record.update_metrics!(*args)
+        # progress_bar.inc if progress_bar
+      end
+      # progress_bar.finish if progress_bar
+      # elapsed = Time.zone.now - start_time
+      # Notifier.deliver_simple_message('allan@curebit.com', '[CUREBIT] Metrics computation time', "Finished calculating #{metrics.count} metrics on #{total} #{name.underscore.humanize.downcase.pluralize} in #{elapsed/60} minutes (#{elapsed/total} sec per entry) (#{elapsed/(total*metrics.count)} sec per metric). \n\nMetrics calculated:\n\n#{metrics.join("\n")}")
+      metrics
+    end
+  end
+  ### END CLASS METHODS, START INSTANCE METHODS
+  
+  def update_metrics!(*args)
+    self.class.metrics.each do |metric|
+      send(metric, *args)
+    end
+  end
+  ### END INSTANCE METHODS
+  
+  ### Sets up a class like "SiteMetrics".  These are all CLASS methods:
+  module MetricsClass
+    def object_class
+      @object_class
+    end
+
+    def metrics_updated_at_columns
+      @object_class.metrics.map{|metric| "updated__#{metric}__at"}
+    end
+
+    def required_columns
+        @object_class.metrics.map(&:to_s) + metrics_updated_at_columns
+    end
+
+    def missing_columns
+      reset_column_information
+      required_columns - (columns.map(&:name) - %w(id created_at updated_at))
+    end
+
+    def extra_columns
+      reset_column_information
+      if @object_class == self
+        raise "Cannot determine if there were extra columns for has_metric when using the table itself for storing the metric!  Remove any columns manually"
+        [] # We wont know what columns are excessive if the source changed
+      else
+        (columns.map(&:name) - %w(id created_at updated_at)).map - required_columns   
+      end
+      
+    end
+
+    class Metrics::Migration < ActiveRecord::Migration
+      def self.setup(metrics)
+        @metrics = metrics
+      end
+      def self.up
+        @metrics.missing_columns.each do |column|
+          column_type = @metrics.object_class.metrics_column_type(column)
+          add_column @metrics.table_name, column, column_type, (column_type==:string ? {:null => false, :default => ''} : {})
+        end
+      end
+      def self.down
+        @metrics.extra_columns.each do |column|
+          remove_column @metrics.table_name, column
+        end
+      end
+    end
+
+    def remigrate!
+      old_metrics = @object_class.metrics
+      @object_class.class_eval { @metrics = [] }
+      migrate!
+      @object_class.class_eval { @metrics = old_metrics }      
+      migrate!
+    end
+
+    def migrate!
+      Metrics::Migration.setup(self)
+      Metrics::Migration.down unless @object_class == self || extra_columns.empty?
+      Metrics::Migration.up unless missing_columns.empty?
+      reset_column_information
+    end
+  end
+end

data/lib/has_metrics/version.rb

@@ -0,0 +1,3 @@
+module HasMetrics
+  VERSION = "0.0.1"
+end

data/lib/has_metrics.rb

@@ -0,0 +1,6 @@
+require "has_metrics/version"
+require "has_metrics/metrics"
+
+module HasMetrics
+  
+end

data/test/functional/metrics_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3",
+  :database => File.expand_path(File.dirname(__FILE__) + "/../test.db"))
+
+class CreateTestTables < ActiveRecord::Migration
+  def self.up
+    create_table "users", :force => true do |t|
+      t.string   "name"
+    end
+    create_table "user_metrics", :force => true
+  end
+  
+  def self.down
+    drop_table "users"
+    drop_table "user_metrics"    
+  end
+end
+
+
+class User < ActiveRecord::Base
+  include Metrics
+  has_metric :name_length do
+    name.length
+  end
+end
+
+
+class MetricsTest < Test::Unit::TestCase
+  context "when defining metrics" do
+    setup do
+      root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      
+      CreateTestTables.up
+      User.update_all_metrics!
+      @user_name =
+      @user = User.create(:name => "Fuzz")
+    end
+    
+    should "create rows for the metrics" do
+      assert_equal 3, UserMetrics.columns.count
+      User.has_metric :name_length_squared do
+        name_length * name_length
+      end
+      User.update_all_metrics!
+      assert_equal 5, UserMetrics.columns.count
+      assert_equal 16, @user.name_length_squared
+    end
+
+    should "they should calculate their block when called" do
+      assert_equal "Fuzz", @user.name
+      assert_equal 4, @user.name_length
+      @user.name = "Bib"
+      assert_equal 3, @user.name_length
+      assert_equal 4, User.find_by_name("Fuzz").name_length
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+# Want to test the files here, in lib, not in an installed version of the gem.
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'shoulda'
+# require 'mocha'
+require 'activerecord'
+require 'sqlite3'
+require 'has_metrics/metrics'

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: has_metrics
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Allan Grant
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-07 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  prerelease: false
+  name: activerecord
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id002
+  prerelease: false
+  name: rake
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
+  prerelease: false
+  name: shoulda
+  type: :development
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  prerelease: false
+  name: sqlite3
+  type: :development
+description: Memoization into activerecord.
+email: 
+- allan@allangrant.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- has_metrics.gemspec
+- lib/has_metrics.rb
+- lib/has_metrics/metrics.rb
+- lib/has_metrics/version.rb
+- test/functional/metrics_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/allangrant/has_metrics
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Calculate "metrics" (any expensive methods) on ActiveRecord entries and memoize them to an automagical table.
+test_files: 
+- test/functional/metrics_test.rb
+- test/test_helper.rb