sir_tracks_alot 0.2.0

data/lib/sir_tracks_alot/reports/report.rb

@@ -0,0 +1,35 @@
+module SirTracksAlot
+  module Reports
+    class Report < Ruport::Controller
+      attr_accessor :all
+      
+      def setup
+        self.data = []        
+        options.report_class ||= ''
+        options.report_title ||= 'Report'
+      end
+      
+      module Helpers
+        def self.handle(name, &block)
+          @@handlers ||= {}
+          name = [name] unless name.kind_of?(Array)
+
+          name.each do |n|
+            @@handlers[n] = block          
+          end
+        end
+        
+        def to_dom_class(words)
+          (words||'').gsub(/[^a-z0-9]/, '_')
+        end
+        
+        def render_data(name, value)
+          @@handlers ||= {}          
+          return value if !@@handlers.include?(name)
+          @@handlers[name].call(value)
+        end        
+        
+      end      
+    end
+  end
+end

data/lib/sir_tracks_alot/reports/root_stem_report.rb

@@ -0,0 +1,44 @@
+module SirTracksAlot
+  module Reports
+    class RootStemReport < FilterReport
+      stage :base
+      
+      required_option :owner      
+      
+      # Build up reports by filtering things as follows:
+      # actions = []
+      # roots = {}
+      def setup        
+        options.actions ||= Activity::ACTIONS
+        options.filters ||= {}
+        
+        options.actions.each do |action|
+          options.roots.each do |root|
+            cat, target = root.kind_of?(Array) ? root : [root, root]
+            
+            begin
+              options.filters["#{cat||target} index"] = {:category => cat, :target => /^\/#{target}$/, :action => action}
+              options.filters["#{cat||target} pages"] = {:category => cat, :target => /^\/#{target}\/.+$/, :action => action}
+            rescue RegexpError
+              # swallow
+            end
+          end
+        end
+        
+        super
+      end
+            
+      module Helpers
+        include Report::Helpers
+      end
+
+      class HTML < Ruport::Formatter::HTML    
+        renders :html, :for => RootStemReport
+
+        build :base do
+          output << erb(options.template || TRACKABLE_ROOT+"/views/reports/table.html.erb", :binding => binding)
+        end    
+      end      
+    end
+  end
+end

data/lib/sir_tracks_alot/reports/target_report.rb

@@ -0,0 +1,54 @@
+module SirTracksAlot
+  module Reports
+    class TargetReport < SirTracksAlotReport
+      COLUMN_NAMES = ['target', 'page views', 'visits']
+      
+      stage :target      
+      required_option :owner, :actions
+      
+      def setup
+        super
+        counts = {}
+        options.filters ||= false
+        options.column_names ||= COLUMN_NAMES
+        options.actions ||= []
+        options.roots ||= []
+        
+        options.roots.each do |root|
+          options.actions.each do |action|
+            activities = Activity.filter(:owner => options.owner, :target => options.target, :action => action, :category => root)
+
+            activities.each do |activity|              
+              counts[activity.target] ||= [0,0]
+              counts[activity.target][0] += activity.views
+              counts[activity.target][1] += activity.visits(options.session_duration)
+            end                      
+          end
+        end
+        
+        table = Table(options.column_names) do |t|
+          counts.each do |target, count|
+            t << [target, count[0], count[1]]
+          end
+        end
+        
+        table.sort_rows_by!('page views', :order => :descending)
+        
+        self.data = table
+      end  
+                  
+      module Helpers
+        include Report::Helpers        
+      end
+
+
+      class HTML < Ruport::Formatter::HTML
+        renders :html, :for => TargetReport
+
+        build :target do
+          output << erb((options.template || TRACKABLE_ROOT+"/views/reports/table.html.erb"), :binding => binding)
+        end    
+      end                  
+    end
+  end
+end

data/lib/sir_tracks_alot/reports/trackable_report.rb

@@ -0,0 +1,13 @@
+module SirTracksAlot
+  module Reports
+    class SirTracksAlotReport < Report
+      attr_accessor :all
+      
+      def setup
+        super        
+        options.categories = options.categories  #|| all.collect{|a| a.category}.uniq
+        options.actions = options.actions #|| all.collect{|a| a.action}.uniq
+      end      
+    end
+  end
+end

data/lib/sir_tracks_alot.rb

@@ -0,0 +1,129 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "rubygems"
+require "bundler"
+Bundler.setup
+Bundler.require 
+
+module SirTracksAlot
+  TRACKABLE_ROOT = "#{File.dirname(__FILE__)}/.."
+  
+  autoload :Persistable, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot persistable.rb])
+  autoload :Rollup, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot rollup.rb])
+  autoload :Activity, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot activity.rb])
+  autoload :Clock, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot clock.rb])  
+  
+  class SirTracksAlotError < StandardError    
+  end
+
+  class RecordInvalidError < SirTracksAlotError    
+  end
+    
+  # Creates new activity with attribues: 
+  #   :owner    => string to roll up all activities by e.g. /site/1
+  #   :actor    => string representing who done it e.g. /profiles/peter-brown
+  #   :target   => string representing where they done it e.g. /messages/some-subject
+  #   :action   => what they done e.g. view or create
+  #   :event    => Time.utc.to_i of when the action activity, defaults to now 
+  def self.record(attributes)
+    # event defaults to now unless overwritten
+    event = (attributes.delete(:event) || Clock.now)
+    request = attributes.delete(:request)
+    
+    # try to convert to trackable paths if possible
+    [:target, :actor, :owner].each {|key| attributes[key] = attributes[key].respond_to?(:to_trackable_id) ? 
+      attributes[key].to_trackable_id : 
+      attributes[key].to_s}
+    
+    # automatically extract the root, assign to "category"
+    attributes[:category] = attributes[:target].split('/')[1]
+    
+    # assign the user_agent from the request unless overritten 
+    attributes[:user_agent] ||= (request.nil? ? nil : request.try(:user_agent))
+    
+    return if exclude?(attributes)
+    
+    # find or create
+    activity = Activity.find_or_create(attributes)
+    
+    raise RecordInvalidError.new("Activity not valid: #{activity.errors.inspect}") unless activity.valid?
+
+    activity.update(:last_event => event )
+    activity.events << event
+    activity
+  end
+  
+  # add a hash of attribute/filter pairs to ignore when recording activities
+  # e.g. {:user_agent => /google/}, {:target => '/hidden', :actor => 'spy'}
+  def self.exclude(row)
+    @@filters ||= []
+    @@filters << row
+  end
+  
+  def self.exclude?(attributes)
+    @@filters ||= []
+    
+    return false if @@filters.empty? || attributes.nil?
+    
+    @@filters.each do |filter|
+      filter.each do |key, matcher|
+        matcher = /#{matcher}/ if matcher.kind_of?(String)
+        return true if attributes[key] =~ matcher
+      end
+    end
+    
+    false
+  end
+  
+  def self.clear!
+    @@filters = []
+  end
+  
+  def log
+    return @log if @log
+    
+    @log = Logging::Logger[self]
+    @log.level = :debug
+    @log
+  end  
+  
+  module_function :log
+  
+  module Helper    
+    def to_trackable_id
+      '/'+[self.class.name.underscore.pluralize, self.to_param].join('/')
+    end
+    
+    def find_by_trackable_id(trackable_id)
+      parts = trackable_id.split('/')
+      return unless parts.size == 3
+      return part[1].constantize.find(parts[2])
+    end    
+  end
+  
+  module Queue
+    autoload :ReportQueue, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot queue report_queue.rb])
+    autoload :ReportCache, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot queue report_cache.rb])
+    autoload :ReportConfig, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot queue report_config.rb])
+    autoload :QueueHelper, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot queue queue_helper.rb])
+  end
+  
+  module Reports
+    autoload :Report, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports report.rb])
+    autoload :BasicReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports basic_report.rb])
+    autoload :SirTracksAlotReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports trackable_report.rb])
+    autoload :TargetReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports target_report.rb])
+    autoload :ActorReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports actor_report.rb])    
+    autoload :ActorActivityReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports actor_activity_report.rb])    
+    autoload :ActivityReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports activity_report.rb])    
+    autoload :FilterReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports filter_report.rb])    
+    autoload :RootStemReport, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot reports root_stem_report.rb])        
+  end
+end
+
+# Set it all up.
+if Object.const_defined?("ActiveRecord")
+  ActiveRecord::Base.send(:include, SirTracksAlot::Helper)
+end
+

data/spec/activity_spec.rb

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe SirTracksAlot::Activity do 
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    @now = SirTracksAlot::Clock.now
+    
+    @activity = SirTracksAlot::Activity.create(@activities[0])
+    @activity.events << @now    
+  end  
+  
+  context 'when creating' do
+    before do 
+    end
+    
+    it "should store valid activities" do
+      @activity.should be_valid
+    end
+
+    it "should not store invalid activities" do
+      activity = SirTracksAlot::Activity.create({})
+      activity.should_not be_valid
+    end
+    
+    it "should not validate duplicates" do
+      activity = SirTracksAlot::Activity.create(@activities[0]) # already created in before
+      activity.should_not be_valid
+    end
+  end
+  
+  context 'when filtering' do
+    before do 
+      @mock_activity = mock(SirTracksAlot::Activity, @activities[0])
+      @mock_activityz = mock('SortedActivity', :sort => [@mock_activity])
+      SirTracksAlot::Activity.stub!(:find => @mock_activityz)
+    end
+    
+    it "should find activities matching attribute regex" do
+      SirTracksAlot::Activity.filter(:owner => 'owner', :target => /categories/).size.should == 1
+    end
+
+    it "should find activities matching attribute string" do
+      SirTracksAlot::Activity.filter(:owner => 'owner', :category => 'category').size.should == 1
+    end
+
+    it "should find activities matching attribute string and attribute regex" do
+      SirTracksAlot::Activity.filter(:owner => 'owner', :category => 'category', :target => /categories/).size.should == 1
+    end
+
+    it "should not find activities matching attribute string but not attribute regex" do
+      SirTracksAlot::Activity.filter(:owner => 'owner', :category => 'category', :target => /not_there/).size.should == 0
+    end
+    
+    it "should not match with negative regex" do
+      SirTracksAlot::Activity.filter(:owner => /^(?!(.*owner.*))/).size.should == 0
+    end    
+  end
+  
+  context 'when getting recent' do
+    it "should get recent" do
+      SirTracksAlot::Activity.recent(:owner => 'owner').should be_instance_of(Array)
+    end
+  end
+  
+  context 'when counting' do
+    before do 
+      @mock_activity = mock(SirTracksAlot::Activity, :visits => 1, :views => 2)
+      @mock_activityz = mock('SortedActivity', :sort => [@mock_activity])            
+      SirTracksAlot::Activity.stub!(:find => @mock_activityz)
+    end
+    
+    it "should look for activities using find options" do
+      SirTracksAlot::Activity.should_receive(:find).with(:owner => 'owner').and_return(@mock_activityz)
+      SirTracksAlot::Activity.count(:views, :owner => 'owner')
+    end
+    
+    it "should look for views when counting views" do
+      @mock_activity.should_receive(:views).once.and_return(1)
+      SirTracksAlot::Activity.count(:views, :owner => 'owner')
+    end    
+    
+    it "should not look for views when counting visits" do
+      @mock_activity.should_receive(:views).never
+      SirTracksAlot::Activity.count(:visits, :owner => 'owner')
+    end
+
+    it "should return views and visits" do            
+      SirTracksAlot::Activity.count([:visits, :views], :owner => 'owner').should == [1,2]
+    end
+
+    it "should return visits" do    
+      SirTracksAlot::Activity.count([:visits], :owner => 'owner').should == 1
+    end
+    
+    it "should ignore empty only" do
+      SirTracksAlot::Activity.count([:visits], :owner => 'owner', :only => {}).should == 1      
+    end
+    
+    it "should filter by category" do
+      @mock_activity.should_receive(:category).once.and_return('category')
+      SirTracksAlot::Activity.count([:visits], :owner => 'owner', :category => /category/)
+    end
+    
+    it "should filter by category and match returning correct count" do
+      @mock_activity.stub!(:category => 'category')
+      SirTracksAlot::Activity.count([:visits], :owner => 'owner', :category => /category/).should == 1      
+    end
+  end
+  
+  context 'when counting groups' do
+    before do
+      # nothing
+    end
+    
+    it "should try to parse event time" do      
+      time = Time.at(@now)
+      Time.should_receive(:at).with(@now).and_return(time)
+      @activity.views(:daily)
+    end
+    
+    it "should return grouped counts" do
+      @activity.views(:daily).should be_kind_of(Hash)      
+    end
+
+    it "should return count as hash value" do
+      @activity.views(:daily).values.should == [1]
+    end
+
+    it "should return count key'd by date" do
+      key = Time.at(@now).utc.strftime(SirTracksAlot::Activity::DATE_FORMATS[:daily])
+      @activity.views(:daily).keys.should == [key]
+    end    
+    
+    it "should return count multiple for single group" do
+      SirTracksAlot::Activity.all.first.events << @now
+      @activity.views(:daily).values.should == [2]
+    end
+    
+    it "should return count multiple for single group" do
+      # SirTracksAlot::Activity.count_by(:daily).should == ''
+    end
+    
+  end
+  
+  context 'when calculating visits' do
+    it "should count 2 visits within the duration as one visit" do
+      2.times{@activity.events << SirTracksAlot::Clock.now}
+      @activity.visits.should == 1
+    end
+    
+    it "should count 200 visits within the duration as one visit" do
+      200.times{@activity.events << SirTracksAlot::Clock.now}
+      @activity.visits.should == 1
+    end
+
+    it "should count 2 visits separated by greater than default session duration as 2 visits" do
+      @activity.events << SirTracksAlot::Clock.now 
+      @activity.events << SirTracksAlot::Clock.now + 2000
+      @activity.visits.should == 2
+    end
+
+    it "should count 2 visits separated by greater than default session duration as 2 visits but not by not" do
+      5.times{@activity.events << SirTracksAlot::Clock.now}
+      @activity.events << SirTracksAlot::Clock.now + 2000
+      @activity.events << SirTracksAlot::Clock.now + 4000
+      @activity.visits.should == 3
+    end
+    
+  end
+  
+end
+

data/spec/queue/report_config_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe SirTracksAlot::Queue::ReportConfig do
+  before do 
+    RedisSpecHelper.reset
+    @config = SirTracksAlot::Queue::ReportConfig.find_or_create(:owner => 'owner')
+  end
+  
+  it "should build" do
+    @config.should be_instance_of(SirTracksAlot::Queue::ReportConfig)
+  end  
+  
+  it "should have default options" do
+    @config.options.should be_instance_of(Hash)
+  end
+  
+  it "should store options" do
+    @config.options = {:this => 'that'}
+    @config.options.should == {:this => 'that'}
+  end
+end

data/spec/queue/report_queue_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe SirTracksAlot::Queue::ReportQueue do
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    @queue = SirTracksAlot::Queue::ReportQueue.find_or_create(:name => 'queue')
+  end
+  
+  it "should build" do
+    @queue.should be_instance_of(SirTracksAlot::Queue::ReportQueue)
+  end    
+  
+  context 'when pushing' do  
+    before do
+      @config = mock(SirTracksAlot::Queue::ReportConfig, :options => {}, :options= => true, :id => 1)
+      @activities.each{|a| SirTracksAlot.record(a)}
+      SirTracksAlot::Queue::ReportQueue.push('owner', :actor_report, {})      
+    end
+
+    it "should create a new queue" do      
+      SirTracksAlot::Queue::ReportQueue.should_receive(:find_or_create).with(:name => SirTracksAlot::Queue::ReportQueue::QUEUE_NAME).and_return(@queue)
+      SirTracksAlot::Queue::ReportQueue.push('owner', 'report', {})
+    end    
+    
+    it "should create report config" do
+      SirTracksAlot::Queue::ReportConfig.should_receive(:find_or_create).with(:owner => 'owner', :report => 'report').once.and_return(@config)
+      SirTracksAlot::Queue::ReportQueue.push('owner', 'report', {})
+    end    
+  end
+  
+  context 'when popping' do
+    before do      
+      @cache = mock(SirTracksAlot::Queue::ReportCache, :update => true)      
+      @activities.each{|a| SirTracksAlot.record(a)}
+      SirTracksAlot::Queue::ReportQueue.push('owner', :actor_report, {:roots => ['categories', 'other_categories'], :actions => ['view']})
+    end
+    
+    it "should find existing queue" do
+      SirTracksAlot::Queue::ReportQueue.should_receive(:find).with(:name => SirTracksAlot::Queue::ReportQueue::QUEUE_NAME).and_return(nil)
+      SirTracksAlot::Queue::ReportQueue.pop      
+    end
+    
+    it "should create report cache" do
+      SirTracksAlot::Queue::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'actor_report').and_return(@cache)
+      SirTracksAlot::Queue::ReportQueue.pop      
+    end
+    
+    it "should constantize report by name" do
+      SirTracksAlot::Queue::QueueHelper.should_receive(:constantize).with("SirTracksAlot::Reports::ActorReport").and_return(SirTracksAlot::Reports::ActorReport)
+      SirTracksAlot::Queue::ReportQueue.pop
+    end        
+    
+    it "should build report HTML" do      
+      SirTracksAlot::Queue::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'actor_report').and_return(@cache)
+      @cache.should_receive(:update) do |options|
+        options[:html].should have_tag('td.actor', /\/users\/user1/)
+      end
+      SirTracksAlot::Queue::ReportQueue.pop
+    end        
+    
+  end
+  
+  context 'when contantizing' do
+    it "should support mixed" do
+      # not sure why constantize has trouble with the be_instance_of matcher
+      SirTracksAlot::Queue::QueueHelper.constantize('SirTracksAlot::Reports::ActorReport').to_s.should == 'SirTracksAlot::Reports::ActorReport'
+    end
+  end
+end

data/spec/reports/activity_report_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe SirTracksAlot::Reports::ActivityReport do 
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    @report_options = {:owner => 'owner', :actor => 'actor'}
+  end  
+  
+  it "should render empty" do
+    SirTracksAlot::Reports::ActivityReport.render_html(@report_options)
+  end  
+  
+  context 'building HTML' do
+    before do 
+      @activities.each{|a| SirTracksAlot.record(a)}
+      @html = SirTracksAlot::Reports::ActivityReport.render_html(@report_attributes)
+    end
+    
+    it "include target row" do
+      @html.should have_tag('td.target', /\/categories\/item/)
+    end
+
+    it "include count row" do      
+      @html.should have_tag('td.event', :count => @activities.size)
+    end
+  end
+  
+end

data/spec/reports/actor_activity_report_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe SirTracksAlot::Reports::ActorActivityReport do 
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    @activities.each{|a| SirTracksAlot.record(a)}    
+  end  
+  
+  context 'building HTML' do
+    before do       
+      @html = SirTracksAlot::Reports::ActorActivityReport.render_html(:owner => @activities[0][:owner], :actor => @activities[0][:actor])
+    end
+    
+    it "should so and so" do
+      @html.should have_tag('td', /\/categories\/item1/)
+    end
+  end
+  
+end

data/spec/reports/actor_report_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe SirTracksAlot::Reports::ActorReport do 
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    @activities.each{|a| SirTracksAlot.record(a)}
+    @mock_finder = mock('Finder', :find => [], :collect => [], :each => [])
+  end  
+  
+  it "should raise error on mission options" do
+    lambda{SirTracksAlot::Reports::ActorReport.render_html({})}.should raise_error(Ruport::Controller::RequiredOptionNotSet)
+  end
+  
+  it "should find activities when building data" do
+    SirTracksAlot::Activity.should_receive(:find).exactly(1).times.and_return(@mock_finder)
+    SirTracksAlot::Reports::ActorReport.render_html(@report_attributes)
+  end
+  
+  context 'building HTML' do
+    before do 
+      SirTracksAlot.record(:owner => 'other_owner', :target => '/other_categories/item', :actor => '/users/user', :action => 'view')
+      @html = SirTracksAlot::Reports::ActorReport.render_html(@report_attributes)
+    end
+    
+    it "include target row" do
+      @html.should have_tag('td.actor',/\/users\/user1/)
+    end
+
+    it "include count row" do      
+      @html.should have_tag('td.count', /1/)
+    end
+  
+    it "should ignore other owners" do
+      @html.should_not have_tag('td.actor', '/users/user')
+    end
+  end
+end