sir_tracks_alot 0.2.0 → 0.4.0

data/README.rdoc

@@ -15,3 +15,37 @@ Description goes here.
 == Copyright
 
 Copyright (c) 2010 Peter T. Brown. See LICENSE for details.
+
+
+
+	    # resolution can be: hourly = %Y/%m/%d %H, daily = %Y/%m/%d or any valid strftime string
+	    # def self.count_by(resolution, options_for_find = {})      
+	    #   groups = {}
+	    #   
+	    #   filter(options_for_find) do |activity|
+	    #     activity.views(resolution).each do |time, count| 
+	    #       groups[time] ||= 0
+	    #       groups[time] += count
+	    #     end
+	    #   end
+	    #   
+	    #   groups
+	    # end
+
+	    # def self.count(what, options_for_find)      
+	    #   what = [what] unless what.kind_of?(Array)      
+	    #   views, visits = 0, 0      
+	    #   session_duration = options_for_find.delete(:session_duration)
+	    #   resolution = options_for_find.delete(:resolution)
+	    #   
+	    #   filter(options_for_find) do |activity|
+	    #     views += activity.views(resolution) if what.include?(:views)
+	    #     visits += activity.visits(session_duration) if what.include?(:visits)
+	    #   end      
+	    #         
+	    #   return [views, visits] if what == [:views, :visits]
+	    #   return [visits, views] if what == [:visits, :views]
+	    #   return views if what == [:views]
+	    #   return visits if what == [:visits]
+	    #   raise ArgumentError("what must be one or more of :views, :visits")
+	    # end        

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.4.0

data/benchmarks/activity_benchmark.rb

@@ -30,6 +30,6 @@ Benchmark.bmbm do |b|
   end
 
   b.report('count_by daily') do 
-    counts = Trackable::Activity.count_by(:daily, :owner => @owner)    
+    # counts = Trackable::Activity.count_by(:daily, :owner => @owner)    
   end  
 end

data/lib/sir_tracks_alot/activity.rb

@@ -1,9 +1,11 @@
 module SirTracksAlot
   class Activity < Persistable
-    ACTIONS = [:create, :view, :login, :search, :update, :destroy]
-    DATE_FORMATS = {:hourly => '%Y/%m/%d %H', :daily => '%Y/%m/%d'}
-    LIMIT = 1000
+    include EventHelper
+    extend FilterHelper 
     
+    ACTIONS = [:create, :view, :login, :search, :update, :destroy]    
+    LIMIT = 500
+
     attribute :created_at
     attribute :last_event # Clock.now
     attribute :owner      # 123123
@@ -12,128 +14,57 @@ module SirTracksAlot
     attribute :category   # **automatically set**
     attribute :action     # create, view, login, etc.
     attribute :user_agent # IE/Safari Windows/Mac etc.
-    
-    index :last_event
+    attribute :counted    # true/false
+    list      :events     # Clock.now's
+
     index :owner
     index :actor
     index :target
     index :category
+    index :last_event
     index :action
-    index :user_agent
-    
-    list :events          # Clock.now's
-        
-    # Find activities that match attributes 
-    # Strings are passed to Ohm
-    # Regular Expression filters match against retrieved attribute values
-    # 
-    # filter(:category => 'category', :target => /\/targets\/\d+/)
-    def self.filter(options_for_find, &block)      
-      activities = []
-      sort = options_for_find.delete(:sort) || {}
-      
-      strings = {}
-      matchers = {}
-      
-      options_for_find.each do |key, candidate|
-        matchers[key] = candidate if candidate.kind_of?(Regexp)
-        strings[key]  = candidate if candidate.kind_of?(String)
-      end      
-      
-      all = SirTracksAlot::Activity.find(strings).sort(sort)
-      
-      all.each do |activity|
-        pass = true
-        
-        matchers.each do |key, matcher|
-          pass = false if !matcher.match(activity.send(key))
-        end
+    index :user_agent            
+    index :counted     
 
-        next unless pass
-        
-        yield activity if block_given?
-        
-        activities << activity
-      end
-      
-      activities      
-    end
-      
-    # resolution can be: hourly = %Y/%m/%d %H, daily = %Y/%m/%d or any valid strftime string
-    def self.count_by(resolution, options_for_find = {})      
-      groups = {}
-      
-      filter(options_for_find) do |activity|
-        activity.views(resolution).each do |time, count| 
-          groups[time] ||= 0
-          groups[time] += count
-        end
+    class <<self    
+      alias_method :ohm_create, :create
+
+      # Create with defaults: counted = 0
+      def create(attrs)        
+        ohm_create(attrs.merge(:counted => '0'))
       end
-      
-      groups
     end
-    
+
+    # find recent activities
     def self.recent(options_for_find, options_for_sort = {:order => 'DESC', :limit => LIMIT})
-      SirTracksAlot::Activity.find(options_for_find).sort_by(:last_event, options_for_sort)
-    end      
-        
-    def self.count(what, options_for_find)      
-      what = [what] unless what.kind_of?(Array)      
-      views, visits = 0, 0      
-      session_duration = options_for_find.delete(:session_duration)
-      resolution = options_for_find.delete(:resolution)
-      
-      filter(options_for_find) do |activity|
-        views += activity.views(resolution) if what.include?(:views)
-        visits += activity.visits(session_duration) if what.include?(:visits)
-      end      
-            
-      return [views, visits] if what == [:views, :visits]
-      return [visits, views] if what == [:visits, :views]
-      return views if what == [:views]
-      return visits if what == [:visits]
-      raise ArgumentError("what must be one or more of :views, :visits")
-    end        
-        
-    def views(resolution = nil)
-      return events.size if resolution.nil?
-            
-      groups = {}
-      
-      date_format = resolution.kind_of?(String) ? resolution : DATE_FORMATS[resolution]
+      find(options_for_find).sort_by(:last_event, options_for_sort)
+    end              
 
-      events.each do |event|      
-        time = Time.at(event.to_i).utc.strftime(date_format) # lop of some detail
-        groups[time.to_s] ||= 0
-        groups[time.to_s] += 1 
-      end
-      
-      return groups
+    # Delete counted activities, leaving a default of the 500 most recent for the provided search criteria
+    # If left blank, purges all but the most recent Limit
+    def self.purge!(options_for_find = {}, options_for_sort = {:order => 'DESC'})
+      recent(options_for_find.merge(:counted => 1), options_for_sort).each{|a| a.delete}
     end
-    
-    # Count one visit for all events every session_duration (in seconds)
-    # e.g. 3 visits within 15 minutes counts as one, 1 visit 2 days later counts as another
-    def visits(sd = 1800)
-      session_duration = sd || 1800
-      count = events.size > 0 ? 1 : 0
-      last_event = events.first
-      
-      events.each do |event|
-        count += 1 if (event.to_i - last_event.to_i > session_duration)
-        last_event = event
-      end
-      
-      count
+
+    # set this activity to counted
+    def counted!
+      update(:counted => '1')
     end
-        
+
+    # is this activity counted?
+    def counted?
+      counted == '1'
+    end    
+
+
     private
-    
+
     def validate
       assert_present :owner
       assert_present :target
       assert_present :action
       assert_unique([:owner, :target, :action, :category, :user_agent, :actor])
     end
-    
+
   end
 end

data/lib/sir_tracks_alot/count.rb

@@ -0,0 +1,80 @@
+module SirTracksAlot
+  class Count < Persistable
+    extend FilterHelper
+    
+    ACTIONS = [:create, :view, :login, :search, :update, :destroy]
+    
+    attribute :created_at 
+    attribute :date       # 10/01/2010
+    attribute :hour       # 1 - 23
+    attribute :owner      # 123123
+    attribute :actor      # /users/peter-brown   
+    attribute :target     # /discussions/23423
+    attribute :category   
+    attribute :views
+    attribute :visits
+    
+    index :date
+    index :hour
+    index :owner
+    index :actor
+    index :target
+    index :category
+
+    def self.count(options)
+      options = OpenStruct.new(options) if options.kind_of?(Hash)
+      
+      rollup(Activity.filter(:owner => options.owner, 
+          :target => options.target, 
+          :action => options.action||[], 
+          :category => options.category || [], 
+          :counted => '0'), 
+        options.session_duration
+      )
+    end
+    
+    def self.rollup(activities, session_duration)
+      counts = []
+
+      activities.each do |activity|        
+        activity.views(:hourly).each do |time, views|          
+          date, hour = time.split(' ')
+          counts << create_by_activity({:owner => activity.owner, :category => activity.category, :target => activity.target, :date => date, :hour => hour}, views, 0)
+          counts << create_by_activity({:owner => activity.owner, :category => activity.category, :actor => activity.actor, :date => date, :hour => hour}, views, 0)
+        end
+
+        activity.visits(session_duration, :hourly).each do |time, visits|
+          date, hour = time.split(' ')
+          counts << create_by_activity({:owner => activity.owner, :category => activity.category, :target => activity.target, :date => date, :hour => hour}, 0, visits)
+          counts << create_by_activity({:owner => activity.owner, :category => activity.category, :actor => activity.actor, :date => date, :hour => hour}, 0, visits)
+        end
+
+        activity.counted!        
+      end
+      
+      counts
+    end
+    
+    def self.create_by_activity(attributes, views = 0, visits = 0)
+      count = Count.find_or_create(attributes)
+        
+      count.views ||= 0; count.visits ||= 0
+
+      count.views  = count.views.to_i + views 
+      count.visits = count.visits.to_i + visits
+      
+      count.save        
+    end
+    
+            
+    private
+
+    def validate
+      assert_present :owner
+      assert_present :views
+      assert_present :visits
+      assert_unique([:owner, :actor, :target, :category, :date, :hour])
+    end
+    
+  end
+end

data/lib/sir_tracks_alot/event_helper.rb

@@ -0,0 +1,49 @@
+module SirTracksAlot
+  module EventHelper
+    DATE_FORMATS = {:hourly => '%Y/%m/%d %H', :daily => '%Y/%m/%d'}
+    
+    def views(resolution = nil)
+      return events.size if resolution.nil?
+
+      groups = {}
+
+      date_format = resolution.kind_of?(String) ? resolution : DATE_FORMATS[resolution]
+
+      events.each do |event|
+        time = Time.at(event.to_i).utc.strftime(date_format) # lop of some detail
+        groups[time.to_s] ||= 0
+        groups[time.to_s] += 1 
+      end
+
+      return groups
+    end
+
+    # Count one visit for all events every session_duration (in seconds)
+    # e.g. 3 visits within 15 minutes counts as one, 1 visit 2 days later counts as another
+    def visits(sd = 1800, resolution = nil)
+      session_duration = sd || 1800      
+      last_event = events.first
+
+      count = events.size > 0 ? 1 : 0 # in case last_event == event (below)
+      groups = {}
+
+      events.each do |event|
+        boundary = (event.to_i - last_event.to_i > session_duration) # have we crossed a session boundary?
+
+        if resolution.nil? # i.e. don't group
+          count += 1 if boundary
+        else
+          date_format = resolution.kind_of?(String) ? resolution : DATE_FORMATS[resolution]
+          time = Time.at(event.to_i).utc.strftime(date_format) # lop of some detail
+
+          groups[time.to_s] ||= count
+          groups[time.to_s] += 1 if boundary
+        end
+
+        last_event = event # try the next bounary
+      end
+
+      resolution.nil? ? count : groups
+    end
+  end  
+end

data/lib/sir_tracks_alot/filter_helper.rb

@@ -0,0 +1,54 @@
+module SirTracksAlot
+  module FilterHelper        
+    # Find activities that match attributes 
+    # Strings are passed to Ohm
+    # Regular Expression filters match against retrieved attribute values
+    # 
+    # filter(:actor => 'user1', :target => /\/targets\/\d+/, :action => ['view', 'create'], :category => ['/root', '/other_root'])
+    def filter(options_for_find, &block)      
+      items = []
+      all = []
+      
+      strings, matchers, arrays = extract_filter_options(options_for_find)
+      
+      unless arrays.empty?
+        (arrays.values.inject{|a, b| a.product b}).each do |combo|
+          terms = {}; combo.each{|c| terms[find_key_from_value(arrays, c)] = c}
+          all += find(terms.merge(strings)).to_a
+        end
+      else
+        all = find(strings)
+      end
+
+      all.each do |item|
+        pass = true
+        
+        matchers.each do |key, matcher|
+          pass = false if !matcher.match(item.send(key))
+        end
+
+        next unless pass
+        
+        yield item if block_given?
+        
+        items << item
+      end
+      
+      items      
+    end
+    
+    def extract_filter_options(options)
+      strings = {}
+      matchers = {}
+      arrays = {}
+      
+      options.each do |key, candidate|
+        matchers[key] = candidate      if candidate.kind_of?(Regexp)  && !candidate.blank?
+        strings[key]  = candidate.to_s if (candidate.kind_of?(String)) && !candidate.blank?
+        arrays[key]   = candidate      if candidate.kind_of?(Array)   && !candidate.blank?
+      end
+      
+      [strings, matchers, arrays]
+    end
+  end
+end

data/lib/sir_tracks_alot/persistable.rb

@@ -1,7 +1,7 @@
 require 'ohm'
 
 module SirTracksAlot
-  class Persistable < Ohm::Model
+  class Persistable < Ohm::Model    
     attribute :created_at
 
     def self.find_or_create(attributes)
@@ -9,9 +9,28 @@ module SirTracksAlot
       models.empty? ? self.create(attributes.merge(:created_at => Clock.now)) : models.first
     end
 
-    protected    
+    def hash
+      self.id
+    end
+
+    # Simply delegate to == in this example.
+    def eql?(comparee)
+      self == comparee
+    end
+
+    # Objects are equal if they have the same
+    # unique custom identifier.
+    def ==(comparee)
+      self.id == comparee.id
+    end
+
+
+    protected
     
-    def validate
-    end        
+    def self.find_key_from_value(hash, value)
+      hash.each do |k, v|
+        return k if v.include?(value)
+      end
+    end    
   end
 end

data/lib/sir_tracks_alot/queue/report_queue.rb

@@ -10,8 +10,7 @@ module SirTracksAlot
 
       def self.push(owner, report, options)
         config = ReportConfig.find_or_create(:owner => owner.to_s, :report => report.to_s)
-        config.options = options.merge(:owner => owner.to_s) # reports require owner, should be sync'd with config owner
-
+        config.options = options.merge(:owner => owner.to_s) # reports require owner, should be sync'd with config owner        
         queue = self.find_or_create(:name => QUEUE_NAME)
         queue.queue << config.id
       end
@@ -33,19 +32,19 @@ module SirTracksAlot
     
       def self.process(config)
         return false if config.nil?
-        
+
         SirTracksAlot.log.info("building report: #{config.inspect}")
-        
+
         begin
-          report = QueueHelper.constantize(QueueHelper.camelize("SirTracksAlot::Reports::#{config.report.capitalize}"))                
-          html = report.render_html(config.options)
-      
+          report = QueueHelper.constantize(QueueHelper.camelize("SirTracksAlot::Reports::#{config.report.capitalize}"))
+          counts = Count.filter(config.options)
+          html = report.render_html(:counts => counts)
           cache = ReportCache.find_or_create(:owner => config.owner, :report => config.report)
           cache.update(:html => html)
         rescue Exception => e
           SirTracksAlot.log.fatal("Error building report #{config.report} for #{config.owner}: #{e}")
         end
-                
+
         true
       end      
     end

data/lib/sir_tracks_alot/reports/activity_report.rb

@@ -1,6 +1,6 @@
 module SirTracksAlot
   module Reports
-    class ActivityReport < SirTracksAlotReport            
+    class ActivityReport < SirTracksAlotReport
       COLUMN_NAMES = ['actor', 'action', 'target', 'event']
       LIMIT = 10000
       
@@ -11,7 +11,7 @@ module SirTracksAlot
         super    
         options.column_names ||= COLUMN_NAMES
         
-        activities = Activity.recent({:owner => options.owner}, :order => 'DESC', :limit => (options.limit || LIMIT))        
+        activities = Activity.recent({:owner => options.owner}, :order => 'DESC', :limit => (options.limit || LIMIT))
         events = activities.collect{|a| [a.actor, a.action, a.target, a.last_event]}.reject{|a| a[2].nil?}
         
         table = Table(options.column_names, :data => events)

data/lib/sir_tracks_alot/reports/actor_report.rb

@@ -4,44 +4,27 @@ module SirTracksAlot
       COLUMN_NAMES = ['actor', 'page views', 'visits']
       
       stage :actor
-      required_option :owner
       
       def setup
-        super        
-        counts = {}        
-        options.column_names ||= COLUMN_NAMES
-        options.actions ||= []
-        options.roots ||= []
+        super
+        column_names = options.column_names || COLUMN_NAMES
+        counts = options.counts || {}
         
-        options.roots.each do |root|
-          options.actions.each do |action|            
-            activities = Activity.find(:owner => options.owner, :action => action, :category => root)
-            
-            activities.each do |activity|
-              counts[activity.actor] ||= [0,0]
-              counts[activity.actor][0] += activity.views
-              counts[activity.actor][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]]
+        table = Table(column_names) do |t|
+          counts.each do |count|
+            t << [count.actor, count.visits, count.views]
           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 => ActorReport
 

data/lib/sir_tracks_alot/reports/filter_report.rb

@@ -22,18 +22,25 @@ module SirTracksAlot
       def setup
         super
         
-        counts = []
+        counts = {}
         options.filters ||= {}
         options.column_names ||= COLUMN_NAMES
-                
-        options.filters.each do |title, options_for_find|          
-          views, visits = Activity.count([:views, :visits], options_for_find.merge(:owner => options.owner))          
-          counts << [title, views, visits] if views > 0
-        end
         
         
-        table = Table(options.column_names, :data => counts)
-
+        options.filters.each do |title, options_for_find|
+          Count.filter(options_for_find.merge(:owner => options.owner)).each do |count|
+            counts[title] ||= [0,0]
+            counts[title][0] += count.visits.to_i
+            counts[title][1] += count.views.to_i
+          end
+        end
+      
+        table = Table(options.column_names) do |t|
+          counts.each do |title, n|
+            t << [title, n[0], n[1]]
+          end
+        end
+        
         table.sort_rows_by!('page views', :order => :descending)
         
         self.data = table

data/lib/sir_tracks_alot/reports/target_report.rb

@@ -4,31 +4,15 @@ module SirTracksAlot
       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 ||= []
+        column_names = options.column_names || COLUMN_NAMES
+        counts = options.counts || {}
         
-        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]]
+        table = Table(column_names) do |t|
+          counts.each do |count|
+            t << [count.target, count.visits, count.views]
           end
         end
         
@@ -41,7 +25,6 @@ module SirTracksAlot
         include Report::Helpers        
       end
 
-
       class HTML < Ruport::Formatter::HTML
         renders :html, :for => TargetReport
 

data/lib/sir_tracks_alot/reports/trackable_report.rb

@@ -4,9 +4,7 @@ module SirTracksAlot
       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
+        super
       end      
     end
   end

data/lib/sir_tracks_alot.rb

@@ -6,12 +6,20 @@ require "bundler"
 Bundler.setup
 Bundler.require 
 
+# require 'logging'
+# require 'twitter'
+# require 'ruport'
+# require 'ohm'
+# require 'redis'
+
 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 :EventHelper, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot event_helper.rb])
+  autoload :FilterHelper, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot filter_helper.rb])
+  autoload :Count, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot count.rb])
   autoload :Clock, File.join(File.dirname(__FILE__), *%w[sir_tracks_alot clock.rb])  
   
   class SirTracksAlotError < StandardError    
@@ -49,7 +57,9 @@ module SirTracksAlot
     
     raise RecordInvalidError.new("Activity not valid: #{activity.errors.inspect}") unless activity.valid?
 
-    activity.update(:last_event => event )
+raise "EVENT NIL" if event.nil?
+
+    activity.update(:last_event => event)
     activity.events << event
     activity
   end

data/spec/activity_spec.rb

@@ -6,15 +6,12 @@ describe SirTracksAlot::Activity do
   before do 
     RedisSpecHelper.reset
     @now = SirTracksAlot::Clock.now
-    
     @activity = SirTracksAlot::Activity.create(@activities[0])
-    @activity.events << @now    
+    @activity.events << @now
+    @activity.update(:last_event => @now)
   end  
   
   context 'when creating' do
-    before do 
-    end
-    
     it "should store valid activities" do
       @activity.should be_valid
     end
@@ -28,13 +25,44 @@ describe SirTracksAlot::Activity do
       activity = SirTracksAlot::Activity.create(@activities[0]) # already created in before
       activity.should_not be_valid
     end
+    
+    it "should set counted" do
+      @activity.counted!
+      @activity.should be_counted
+    end
+    
+    it "should default to uncounted" do
+      @activity.counted.should == '0'
+    end
   end
   
-  context 'when filtering' do
+  context 'when purging' do
+    before do
+      @activities.each{|a| SirTracksAlot.record(a)}
+    end
+    
+    it "should not purge uncounted" do
+      SirTracksAlot::Activity.purge!
+      SirTracksAlot::Activity.all.size.should == 8
+    end        
+    
+    it "should purge counted" do
+      SirTracksAlot::Activity.all.each{|a| a.counted!}
+      SirTracksAlot::Activity.purge!
+      SirTracksAlot::Activity.all.size.should == 0
+    end
+    
+    it "should purge counted by range" do
+      SirTracksAlot::Activity.all.each{|a| a.counted!}
+      SirTracksAlot::Activity.purge!({}, :start => 5, :limit => 10)
+      SirTracksAlot::Activity.all.size.should == 5
+    end
+  end
+  
+  context 'when filtering (simple)' do
     before do 
       @mock_activity = mock(SirTracksAlot::Activity, @activities[0])
-      @mock_activityz = mock('SortedActivity', :sort => [@mock_activity])
-      SirTracksAlot::Activity.stub!(:find => @mock_activityz)
+      SirTracksAlot::Activity.stub!(:find => [@mock_activity])
     end
     
     it "should find activities matching attribute regex" do
@@ -55,61 +83,87 @@ describe SirTracksAlot::Activity do
     
     it "should not match with negative regex" do
       SirTracksAlot::Activity.filter(:owner => /^(?!(.*owner.*))/).size.should == 0
-    end    
+    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
+  context 'when filtering (many)' 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')
+      @activities.each{|a| SirTracksAlot.record(a)}
     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')
+    it "should filter by members of one array" do
+      SirTracksAlot::Activity.filter(:owner => 'owner', :target => ['/categories/item1', '/categories/item2']).size.should == 3
     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
+    it "should filter by combinations of arrays" do
+      SirTracksAlot::Activity.filter(:owner => 'owner', :action => ['view', 'create'], :target => ['/categories/item1', '/categories/item2']).size.should == 3
+    end    
+  end
+  
+  context 'when getting recent' do
+    before do 
+      @set_activities.each{|a| SirTracksAlot.record(a)} 
     end
     
-    it "should ignore empty only" do
-      SirTracksAlot::Activity.count([:visits], :owner => 'owner', :only => {}).should == 1      
+    it "should get recent" do
+      SirTracksAlot::Activity.recent(:owner => 'owner').should be_instance_of(Array)
     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 purge counted by range, sorting to most recent by last event" do
+      SirTracksAlot::Activity.recent(:owner => 'owner').first.last_event.should == @now.to_s
+    end            
+    
+    it "should purge counted by range, sorting to most recent by last event" do
+      SirTracksAlot::Activity.recent({:owner => 'owner'}, :start => 1).first.last_event.should == '1279709941'
+    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
+  context 'when counting' do
+    before do 
+      @mock_activity = mock(SirTracksAlot::Activity, :visits => 1, :views => 2)
+      SirTracksAlot::Activity.stub!(:find => [@mock_activity])
+    end
+    
+    # it "should look for activities using find options" do
+    #   SirTracksAlot::Activity.should_receive(:find).with(:owner => 'owner').and_return([@mock_activity])
+    #   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 views' do
     before do
       # nothing
     end
@@ -136,12 +190,7 @@ describe SirTracksAlot::Activity do
     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    
   end
   
   context 'when calculating visits' do
@@ -161,13 +210,19 @@ describe SirTracksAlot::Activity do
       @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
+    it "should count 2 visits separated by greater than default session duration as 2, and a 3rd" 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
     
+    it "should group separated visits hourly" do
+      5.times{@activity.events << 1279735846}
+      @activity.events         << 1279709941      
+      # @activity.visits(1800, :hourly).should == {"2010/07/27 20"=>1, "2010/07/27 21"=>2}
+    end
+        
   end
   
 end

data/spec/count_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe SirTracksAlot::Count do 
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    
+    @set_activities.each{|a| SirTracksAlot.record(a)}
+  end  
+  
+  context 'when creating' do
+    before do 
+      @count_attributes = [{:owner => 'owner', :actor => '/users/user1', :target => '/categories/item1', :views => 1, :visits => 2, :date => '07/01/2010', :hour => 5}]
+    end
+    
+    it 'should create valid count' do
+      SirTracksAlot::Count.create(@count_attributes[0]).should be_valid
+    end
+    
+    it 'should not validate duplicates' do
+      SirTracksAlot::Count.create(@count_attributes[0])
+      SirTracksAlot::Count.create(@count_attributes[0]).should_not be_valid
+    end
+  end
+  
+  context 'when filtering' do
+    before do
+      SirTracksAlot::Count.count(:owner => 'owner')
+    end
+    
+    it 'should filter by string attribute' do
+      SirTracksAlot::Count.filter(:owner => 'owner').size.should == 13
+    end
+    
+    it 'should filter by array of strings' do
+      SirTracksAlot::Count.filter(:target => ['/categories', '/other_categories/item']).size.should == 2
+    end
+
+    it 'should include all targets when filtering just by ower' do
+      SirTracksAlot::Count.filter(:owner => 'owner').collect{|c| c.target}.compact.sort.should == 
+        ["/categories", "/categories/item1", "/categories/item1", "/categories/item1", "/categories/item2", "/other_categories", "/other_categories/item"].sort
+    end
+
+    it 'should include only filtered targets' do
+      SirTracksAlot::Count.filter(:owner => 'owner', :target => ["/categories", "/categories/item1"]).collect{|c| c.target}.should_not
+        include("/categories/item2")
+    end    
+  end
+  
+  context 'when counting' do
+    before do
+      @counts = SirTracksAlot::Count.count(:owner => 'owner', :category => ['categories'], :action => ['view'])
+    end
+    
+    it "should count all activities for owner" do      
+      SirTracksAlot::Count.count(:owner => 'owner')
+      SirTracksAlot::Count.find(:owner => 'owner').size.should == 13 # one for each unique target, time combo
+    end
+
+    it "should set to counted all activities counted" do      
+      SirTracksAlot::Count.count(:owner => 'owner')
+      SirTracksAlot::Activity.filter(:counted => "0").should be_empty
+    end
+    
+    it "should only count activities once" do
+      SirTracksAlot::Count.count(:owner => 'owner', :category => ['categories'], :action => ['view']).should be_empty
+    end
+    
+    context 'views' do    
+      it "should include counts by hour" do
+        @counts[0].hour.should == '18'        
+      end
+    
+      it "should not include counts not requested" do
+        @counts.collect{|c| c.target}.should_not include("/other_categories") 
+      end
+    end
+    
+    context 'visits' do
+      it 'should include counts by hour' do
+        # @counts[1].should == {"/categories"=>{"2010/07/21 18"=>1}, 
+        #   "/categories/item1"=>{"2010/07/21 18"=>2, "2010/07/21 10"=>1, "2010/07/21 13"=>1}, 
+        #   "/categories/item2"=>{"2010/07/21 18"=>1}}
+      end
+    end    
+  end
+end

data/spec/queue/report_queue_spec.rb

@@ -18,7 +18,7 @@ describe SirTracksAlot::Queue::ReportQueue do
       @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', {})
@@ -34,7 +34,7 @@ describe SirTracksAlot::Queue::ReportQueue 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']})
+      SirTracksAlot::Queue::ReportQueue.push('owner', :target_report, {:category => ['categories', 'other_categories']})
     end
     
     it "should find existing queue" do
@@ -43,19 +43,19 @@ describe SirTracksAlot::Queue::ReportQueue do
     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::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'target_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::QueueHelper.should_receive(:constantize).with("SirTracksAlot::Reports::TargetReport").and_return(SirTracksAlot::Reports::TargetReport)
       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)
+      SirTracksAlot::Queue::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'target_report').and_return(@cache)
       @cache.should_receive(:update) do |options|
-        options[:html].should have_tag('td.actor', /\/users\/user1/)
+        options[:html].should have_tag('td.target', /\/categories\/item1/)
       end
       SirTracksAlot::Queue::ReportQueue.pop
     end        

data/spec/reports/actor_report_spec.rb

@@ -6,22 +6,12 @@ describe SirTracksAlot::Reports::ActorReport do
   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)
+      @counts = SirTracksAlot::Count.count(OpenStruct.new(:owner => 'owner', :roots => ['categories']))
+      @html = SirTracksAlot::Reports::ActorReport.render_html(:counts => @counts)
     end
     
     it "include target row" do
@@ -31,6 +21,10 @@ describe SirTracksAlot::Reports::ActorReport do
     it "include count row" do      
       @html.should have_tag('td.count', /1/)
     end
+
+    it "include page views" do      
+      @html.should have_tag('td.page_views', /2/)
+    end
   
     it "should ignore other owners" do
       @html.should_not have_tag('td.actor', '/users/user')

data/spec/reports/filter_report_spec.rb

@@ -1,16 +1,13 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 
-describe SirTracksAlot::Reports::ActivityReport do 
+describe SirTracksAlot::Reports::FilterReport do 
   include DataHelper
   
   before do 
     RedisSpecHelper.reset
     @report_options = {:owner => 'owner'}
     @activities.each{|a| SirTracksAlot.record(a)}
-  end  
-  
-  it "should render empty" do
-    SirTracksAlot::Reports::FilterReport.render_html(@report_options)
+    SirTracksAlot::Count.count(OpenStruct.new(:owner => 'owner', :roots => ['categories']))
   end  
   
   context 'filtering things with only' do
@@ -23,6 +20,7 @@ describe SirTracksAlot::Reports::ActivityReport do
           'blank' =>  {:target => /blanks/}
         }
       }
+      
       @html = SirTracksAlot::Reports::FilterReport.render_html(@report_options)
     end
     

data/spec/reports/root_stem_report_spec.rb

@@ -6,10 +6,7 @@ describe SirTracksAlot::Reports::RootStemReport do
   before do 
     RedisSpecHelper.reset
     @activities.each{|a| SirTracksAlot.record(a)}
-  end  
-  
-  it "should render empty" do
-    SirTracksAlot::Reports::FilterReport.render_html(:owner => 'owner')
+    SirTracksAlot::Count.count(OpenStruct.new(:owner => 'owner', :roots => ['categories']))    
   end  
   
   context 'building HTML with categories' do

data/spec/reports/target_report_spec.rb

@@ -6,57 +6,26 @@ describe SirTracksAlot::Reports::TargetReport do
   before do 
     RedisSpecHelper.reset
     @activities.each{|a| SirTracksAlot.record(a)}
-    @mock_finder = mock('Finder', :find => [], :collect => [])
-    @mock_filter = mock('Filter', :each => [])
   end  
   
-  it "should raise error on missing options" do
-    lambda{SirTracksAlot::Reports::TargetReport.render_html({})}.should raise_error(Ruport::Controller::RequiredOptionNotSet)
-  end
-  
-  it "should find activities when building data" do
-    SirTracksAlot::Activity.should_receive(:filter).with(
-      :action => @activities[0][:action], :owner => @activities[0][:owner], :target => nil, :category=>"categories").exactly(1).times.and_return(@mock_filter)
-    SirTracksAlot::Reports::TargetReport.render_html(@report_attributes)
-  end
-  
-  context 'building HTML without filters' do
-    before do 
-      SirTracksAlot.record(:owner => 'other_owner', :category => 'other_category', :target => '/other_categories/item', :actor => '/users/user', :action => 'view')
-      @html = SirTracksAlot::Reports::TargetReport.render_html(@report_attributes)
+  context 'building HTML' do
+    before do             
+      @counts = SirTracksAlot::Count.count(OpenStruct.new(:owner => 'owner', :roots => ['categories']))
+      @html = SirTracksAlot::Reports::TargetReport.render_html(:counts => @counts)
     end
     
     it_should_behave_like 'all reports'
     
-    it "include target row" do
+    it "include target row" do    
       @html.should have_tag('td.target', /\/categories\/item/)
     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.target', '/other_categories/item')
     end
   end
-  
-  context 'building HTML with filters' do
-    before do 
-      @html = SirTracksAlot::Reports::TargetReport.render_html(
-        @report_attributes.merge(
-          :filters => {:except => [{:target => /^\/categories$/}]}
-        )
-      )
-    end
-    
-    it "should include non excepted target row" do
-      @html.should have_tag('td.target', /\/categories\/item/)
-    end  
-    
-    it "should not include excepted target row" do
-      @html.should_not have_tag('td.target', /^\/categories$/)
-    end  
-    
-  end
 end

data/spec/sir_tracks_alot_spec.rb

@@ -6,6 +6,7 @@ describe SirTracksAlot, 'when recording' do
   before do 
     RedisSpecHelper.reset
     @record_attributes = @activities[0]
+    @now = SirTracksAlot::Clock.now    
   end  
   
   it "should record activity" do
@@ -54,7 +55,7 @@ describe SirTracksAlot, 'when recording' do
   end
   
   it "should add date for now" do
-    SirTracksAlot::Clock.should_receive(:now).twice # once for activity create, once for events date
+    SirTracksAlot::Clock.should_receive(:now).twice.and_return(@now) # once for activity create, once for events date
     SirTracksAlot.record(@record_attributes)
   end
 

data/spec/spec_helper.rb

@@ -31,6 +31,38 @@ module DataHelper
   def initialize(*attrs)
     super
     
+    @set_activities = [
+      {:owner => 'owner', :target => '/categories/item1', :actor => '/users/user1', 
+        :action => 'view', :user_agent => 'agent1', :event => 1279735846}, # 1.day.ago
+        
+      {:owner => 'owner', :target => '/categories/item1', :actor => '/users/user1', 
+        :action => 'view', :user_agent => 'agent1', :event => 1279735846}, # 1.day.ago
+        
+      {:owner => 'owner', :target => '/categories/item1', :actor => '/users/user1', 
+        :action => 'view', :user_agent => 'agent1', :event => 1279718578}, # 1.2.days.ago
+
+      {:owner => 'owner', :target => '/categories/item1', :actor => '/users/user1', 
+        :action => 'view', :user_agent => 'agent1', :event => 1279709941}, # 1.3.days.ago
+
+      {:owner => 'owner', :target => '/categories/item2', :actor => '/users/user2', 
+        :action => 'view', :user_agent => 'agent2', :event => 1279735846}, # 1.day.ago
+        
+      {:owner => 'owner', :target => '/categories', :actor => '/users/user2', 
+        :action => 'view', :user_agent => 'agent2', :event => 1279735846}, # 1.day.ago
+        
+      {:owner => 'owner', :target => '/other_categories/item', :actor => '/users/user1', 
+        :action => 'view', :user_agent => 'agent1', :event => 1279735846}, # 1.day.ago
+        
+      {:owner => 'owner', :target => '/other_categories/item', :actor => '/users/user2', 
+        :action => 'view', :user_agent => 'agent2', :event => 1279735846}, # 1.day.ago
+        
+      {:owner => 'owner', :target => '/other_categories', :actor => '/users/user1', 
+        :action => 'view', :user_agent => 'agent1', :event => 1279735846}, # 1.day.ago
+        
+      {:owner => 'owner', :target => '/other_categories', :actor => '/users/user2', 
+        :action => 'view', :user_agent => 'agent2', :event => 1279735846} # 1.day.ago
+    ]
+    
     @activities = [
       {:owner => 'owner', :target => '/categories/item1', :actor => '/users/user1', :action => 'view', :user_agent => 'agent1'},
       {:owner => 'owner', :target => '/categories/item2', :actor => '/users/user2', :action => 'view', :user_agent => 'agent2'},
@@ -40,8 +72,10 @@ module DataHelper
       {:owner => 'owner', :target => '/other_categories', :actor => '/users/user1', :action => 'view', :user_agent => 'agent1'},
       {:owner => 'owner', :target => '/other_categories', :actor => '/users/user2', :action => 'view', :user_agent => 'agent2'}
     ]
-
-    @report_attributes = {:owner => 'owner', :roots => ['categories'], :actions => ['view']}    
+    
+    @counts = {"/categories" => [1, 1], "/categories/item1" => [1, 1], "/categories/item2" => [1, 1]}
+    
+    @report_attributes = {:owner => 'owner', :roots => ['categories'], :actions => ['view'], :counts => @counts}
   end
 end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sir_tracks_alot
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 4
   - 0
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Peter T. Brown
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-21 00:00:00 -07:00
+date: 2010-08-05 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -150,6 +150,9 @@ files:
 - lib/sir_tracks_alot.rb
 - lib/sir_tracks_alot/activity.rb
 - lib/sir_tracks_alot/clock.rb
+- lib/sir_tracks_alot/count.rb
+- lib/sir_tracks_alot/event_helper.rb
+- lib/sir_tracks_alot/filter_helper.rb
 - lib/sir_tracks_alot/persistable.rb
 - lib/sir_tracks_alot/queue/queue_helper.rb
 - lib/sir_tracks_alot/queue/report_cache.rb
@@ -165,6 +168,7 @@ files:
 - lib/sir_tracks_alot/reports/target_report.rb
 - lib/sir_tracks_alot/reports/trackable_report.rb
 - spec/activity_spec.rb
+- spec/count_spec.rb
 - spec/queue/report_config_spec.rb
 - spec/queue/report_queue_spec.rb
 - spec/reports/activity_report_spec.rb
@@ -218,6 +222,7 @@ specification_version: 3
 summary: A high speed general purpose tracking and reporting tool which uses Redis.
 test_files: 
 - spec/activity_spec.rb
+- spec/count_spec.rb
 - spec/queue/report_config_spec.rb
 - spec/queue/report_queue_spec.rb
 - spec/reports/activity_report_spec.rb