trackoid 0.1.2 → 0.1.3

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/lib/trackoid/aggregates.rb

@@ -129,6 +129,10 @@ module Mongoid  #:nodoc:
             TrackerAggregates.new(self, name, args)
           end
 
+          define_method("#{name}_with_track") do |track_field, *args|
+            TrackerAggregates.new(self, name, args, track_field)
+          end
+
           define_method("#{name}=") do
             raise NoMethodError
           end

data/lib/trackoid/tracker.rb

@@ -6,16 +6,29 @@ module Mongoid  #:nodoc:
       
       def initialize(owner, field, aggregate_data)
         @owner, @for = owner, field
-        @data = @owner.read_attribute(@for)
+        @for_data = @owner.internal_track_name(@for)
+        @data = @owner.read_attribute(@for_data)
         
         # The following is needed if the "field" Mongoid definition for our
         # internal tracking field does not include option ":default => {}"
         if @data.nil?
-          @owner.write_attribute(@for, {})
-          @data = @owner.read_attribute(@for)
+          @owner.write_attribute(@for_data, {})
+          @data = @owner.read_attribute(@for_data)
         end
 
-        @aggregate_data = aggregate_data
+        @aggregate_data = aggregate_data.first if aggregate_data.first
+      end
+
+      # Delegate all missing methods to the aggregate accessors. This enables
+      # us to call an aggregation token after the tracking field.
+      #
+      # Example:
+      #
+      #   <tt>@object.visits.browsers ...</tt>
+      #
+      def method_missing(name, *args, &block)
+        super unless @owner.aggregate_fields.member?(name)
+        @owner.send("#{name}_with_track".to_sym, @for, *args, &block)
       end
 
       # Update methods
@@ -30,10 +43,10 @@ module Mongoid  #:nodoc:
         return unless @owner.aggregated?
 
         @owner.aggregate_fields.each do |(k,v)|
-          token = v.call(@aggregate_data)
+          next unless token = v.call(@aggregate_data)
+          
           fk = @owner.class.name.to_s.foreign_key.to_sym
-          selector = { fk => @owner.id, :ns => k, :key => token }
-
+          selector = { fk => @owner.id, :ns => k, :key => token.to_s }
           @owner.aggregate_klass.collection.update( selector,
               { (how_much > 0 ? "$inc" : "$dec") => update_hash(how_much.abs, date) },
               :upsert => true)
@@ -50,6 +63,7 @@ module Mongoid  #:nodoc:
 
       def set(how_much, date = DateTime.now)
         raise Errors::ModelNotSaved, "Can't update a new record" if @owner.new_record?
+
         update_data(how_much, date)
         @owner.collection.update( @owner._selector,
             { "$set" => update_hash(how_much, date) },
@@ -113,7 +127,7 @@ module Mongoid  #:nodoc:
 
       def update_hash(num, date)
         {
-          "#{@for}.#{date_literal(date)}" => num
+          "#{@for_data}.#{date_literal(date)}" => num
         }
       end
 

data/lib/trackoid/tracker_aggregates.rb

@@ -4,23 +4,57 @@ module Mongoid  #:nodoc:
     # This internal class handles all interaction of an aggregation token.
     class TrackerAggregates
 
-      def initialize(owner, token, key_selector)
+      def initialize(owner, token, key_selector, track_field = nil)
         @owner, @token = owner, token
         @key = key_selector
+        @track_field = track_field
 
         @accessor = @owner.class.send(:internal_accessor_name, @token)
         @selector = {:ns => @token}
         @selector.merge!(:key => @key.first) if @key.first
+        @criteria = @owner.send(@accessor).where(@selector)
       end
 
+      # REFACTOR THIS
+      # WE ARE DOING SOMETHING LIKE:
+      #
+      # => browsers("something").visits
+      #
+      # WHILE A BEST APPROACH IS LIKE
+      #
+      # => visits.browsers("something")
+
+      # visits (Tracker) -> browsers (TrackerAggregates) -> count (to Criteria)
+      #                                                  -> today (data)
+
+      # Delegate all missing methods to the underlying Mongoid Criteria
       def method_missing(name, *args, &block)
-        @criteria ||= @owner.send(@accessor).where(@selector)
-        
+        @criteria.send(name)
+
         # Delegate all missing methods to the underlying Mongoid Criteria
-        return @criteria.send(name) unless @owner.tracked_fields.member?(name)
+        # return @criteria.send(name) unless @owner.tracked_fields.member?(name)
+        # super
         
         # Otherwise, it's a track method, so process it
-        @criteria.collect {|x| x.send(name, *args, &block) }
+        # @criteria.collect {|x| x.send(name, *args, &block) }
+      end
+
+      def today
+        @criteria.collect {|c|
+          [c.key, c.send(@track_field).today] if @track_field
+        }
+      end
+
+      def yesterday
+        @criteria.collect {|c|
+          [c.key, c.send(@track_field).yesterday] if @track_field
+        }
+      end
+
+      def last_days(how_much = 7)
+        @criteria.collect {|c|
+          [c.key, c.send(@track_field).last_days(how_much)] if @track_field
+        }
       end
 
     end

data/lib/trackoid/tracking.rb

@@ -25,9 +25,9 @@ module Mongoid #:nodoc:
       # This is necessary so that Mongoid does not "dirty" the field
       # potentially overwriting the original data.
       def track(name)
-        set_tracking_field(name)
-        create_tracking_accessors(name)
-        update_aggregates(name) if aggregated?
+        set_tracking_field(name.to_sym)
+        create_tracking_accessors(name.to_sym)
+        update_aggregates(name.to_sym) if aggregated?
       end
 
       protected
@@ -42,7 +42,7 @@ module Mongoid #:nodoc:
         field internal_track_name(name), :type => Hash    # , :default => {}
         # Should we make an index for this field?
         index internal_track_name(name)
-        tracked_fields << name.to_sym
+        tracked_fields << name
       end
       
       # Creates the tracking field accessor and also disables the original
@@ -50,8 +50,8 @@ module Mongoid #:nodoc:
       # Mongoid fields ensures they doesn't get dirty, so Mongoid does not
       # overwrite old data.
       def create_tracking_accessors(name)
-        define_method("#{name}") do |*aggr|
-          Tracker.new(self, "#{name}_data".to_sym, aggr)
+        define_method(name) do |*aggr|
+          Tracker.new(self, name, aggr)
         end
 
         # Should we just "undef" this methods?

data/spec/aggregates_spec.rb

@@ -10,10 +10,10 @@ class TestModel
   # for testing pourposes. Trackoid does not make any difference in the
   # declaration order of tracking fields and aggregate tokens.
   track :visits
-  aggregate :browsers do; "Mozilla".downcase; end
+  aggregate :browsers do |b| b.split.first.downcase if b; end
 
   track :uniques
-  aggregate :referers do; "GoogleBot".downcase; end
+  aggregate :referers do |r| r.split.last.downcase if r; end
 end
 
 class SecondTestModel
@@ -62,8 +62,8 @@ describe Mongoid::Tracking::Aggregates do
 
   it "should create an array in the class with all aggregate fields even when monkey patching" do
     class TestModel
-      aggregate :quarters do
-        "Q1"
+      aggregate :quarters do |q|
+        "Q1";
       end
     end
     @mock.class.aggregate_fields.keys.to_set.should == [ :browsers, :referers, :quarters ].to_set
@@ -167,7 +167,7 @@ describe Mongoid::Tracking::Aggregates do
     end
 
     it "should increment visits for all aggregated instances" do
-      @mock.visits("Aggregate data").inc
+      @mock.visits("Mozilla Firefox").inc
       @mock.browsers.count.should == 1
       @mock.referers.count.should == 1
       @mock.quarters.count.should == 1
@@ -175,7 +175,7 @@ describe Mongoid::Tracking::Aggregates do
 
     it "should increment visits for specific aggregation keys" do
       @mock.browsers("mozilla").size.should == 1
-      @mock.referers("googlebot").size.should == 1
+      @mock.referers("firefox").size.should == 1
       @mock.quarters("Q1").size.should == 1
     end
 
@@ -185,12 +185,47 @@ describe Mongoid::Tracking::Aggregates do
       @mock.quarters("Q2").size.should == 0
     end
 
-    it "should have 1 in visits" do
-      tt = @mock.browsers.visits.collect {|v| v.last_days(7)}
-      tt.should == [[0, 0, 0, 0, 0, 0, 1]]
+    it "should have 1 visits today" do
+      @mock.visits.browsers.today.should == [["mozilla", 1]]
+      @mock.visits.referers.today.should == [["firefox", 1]]
+    end
+
+    it "should have 0 visits yesterday" do
+      @mock.visits.browsers.today.should == [["mozilla", 1]]
+      @mock.visits.referers.today.should == [["firefox", 1]]
+    end
+
+    it "should have 1 visits last 7 days" do
+      @mock.visits.browsers.last_days(7).should == [["mozilla", [0, 0, 0, 0, 0, 0, 1]]]
+      @mock.visits.referers.last_days(7).should == [["firefox", [0, 0, 0, 0, 0, 0, 1]]]
+    end
+
+    it "should work adding 1 visit with different aggregation data" do
+      @mock.visits("Google Chrome").inc
+      @mock.visits.browsers.today.should == [["mozilla", 1], ["google", 1]]
+      @mock.visits.referers.today.should == [["firefox", 1], ["chrome", 1]]
+      
+      # Just for testing array manipulations
+      @mock.visits.browsers.today.inject(0) {|total, c| total + c.last }.should == 2
+    end
+
+    it "let's chek what happens when sorting the best browser..." do
+      @mock.visits("Google Chrome").inc
+      @mock.visits.browsers.today.should == [["mozilla", 1], ["google", 2]]
+      @mock.visits.browsers.today.max {|a,b| a.second <=> b.second }.should == ["google", 2]
+    end
+
+    it "should work without aggregation information" do
+      @mock.visits.inc
+      @mock.visits.browsers.today.should == [["mozilla", 1], ["google", 2]]
+      @mock.visits.referers.today.should == [["firefox", 1], ["chrome", 2]]
+      
+      # A more throughout test would check totals...
+      visits_today = @mock.visits.today
+      visits_today_with_browser = @mock.visits.browsers.today.inject(0) {|total, c| total + c.last }
+      visits_today.should == visits_today_with_browser + 1
     end
 
-    
   end
 
 

data/trackoid.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{trackoid}
-  s.version = "0.1.2"
+  s.version = "0.1.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jose Miguel Perez"]

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: trackoid
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - Jose Miguel Perez