trackoid_mongoid4 0.1.3

data/lib/mongoid/tracking/core_ext/time.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+class Time
+  # Functions to construct the MongoDB field key for trackers
+  #
+  # to_i_timestamp returns the computed UTC timestamp regardless of the
+  # timezone.
+  #
+  # Examples:
+  #    2011-01-01 00:00:00 UTC  ===> 14975
+  #    2011-01-01 23:59:59 UTC  ===> 14975
+  #    2011-01-02 00:00:00 UTC  ===> 14976
+  # 
+  # to_i_hour returns the hour for the date, again regardless of TZ
+  #
+  #    2011-01-01 00:00:00 UTC  ===> 0
+  #    2011-01-01 23:59:59 UTC  ===> 23
+  #
+  ONEHOUR = 60 * 60
+  ONEDAY = 24 * ONEHOUR
+
+  def to_i_timestamp
+    #Adding a fix for case where the 'quo' is being used instead of Fixnum's '/' operator
+    (self.dup.utc.to_i / ONEDAY).to_i
+  end
+
+  def to_key_timestamp
+    to_i_timestamp.to_s
+  end
+
+  def to_i_hour
+    self.dup.utc.hour
+  end
+
+  def to_key_hour
+    to_i_hour.to_s
+  end
+
+  # Returns an integer to use as MongoDB key
+  def to_key
+    "#{to_i_timestamp}.#{to_i_hour}"
+  end
+
+  def self.from_key(ts, h)
+    Time.at(ts.to_i * ONEDAY + h.to_i * ONEHOUR)
+  end
+
+  # Returns a range to be enumerated using hours for the whole day
+  def whole_day
+    midnight = utc? ? Time.utc(year, month, day) : Time.new(year, month, day, 0, 0, 0, utc_offset)
+    midnight...(midnight + ::Range::DAYS)
+  end
+end

data/lib/mongoid/tracking/core_ext.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+require 'mongoid/tracking/core_ext/time'
+require 'mongoid/tracking/core_ext/range'

data/lib/mongoid/tracking/errors.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Tracking #:nodoc
+    module Errors #:nodoc
+
+      class ClassAlreadyDefined < RuntimeError
+        def initialize(klass)
+          @klass = klass
+        end
+        def message
+          "#{@klass} already defined, can't aggregate!"
+        end
+      end
+
+    class AggregationAlreadyDefined < RuntimeError
+       def initialize(klass, token)
+         @klass = klass
+         @token = token
+       end
+       def message
+         "Aggregation '#{@token}' already defined for model #{@klass}"
+       end
+     end
+
+     class AggregationNameDeprecated < RuntimeError
+       def initialize(token)
+         @token = token
+       end
+       def message
+         "Ussing aggregation name '#{@klass}' is deprecated. Please select another name."
+       end
+      end
+
+      class ModelNotSaved < RuntimeError; end
+
+      class NotMongoid < RuntimeError; end
+
+    end
+  end
+end

data/lib/mongoid/tracking/reader_extender.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+module Mongoid  #:nodoc:
+  module Tracking
+
+    # ReaderExtender is used in cases where we need to return an integer
+    # (class Numeric) while extending their contents. It would allow to
+    # perform advanced calculations in some situations:
+    #
+    # Example:
+    #
+    #   a = visits.today   # Would return a number, but "extended" so that
+    #                      # we can make a.hourly to get a detailed, hourly
+    #                      # array of the visits.
+    #
+    #   b = visits.yesterday
+    #   c = a + b          # Here, in c, normally we would have a FixNum with
+    #                      # the sum of a plus b, but if we extend the sum
+    #                      # operation, we can additionaly sum the hourly
+    #                      # array and return a new ReaderExtender c.
+    #
+    class ReaderExtender
+      def initialize(number, hours)
+        @total = number
+        @hours = hours
+      end
+
+      def hourly
+        @hours
+      end
+
+      def to_s
+        @total.to_s
+      end
+
+      def to_f
+        @total.to_f
+      end
+
+      def to_i
+        @total.to_i
+      end
+
+      def ==(other)
+        @total == other
+      end
+
+      def <=>(other)
+        @total <=> other
+      end
+
+      def <(other)
+        @total < other
+      end
+      def <=(other)
+        @total <= other
+      end
+
+      def >(other)
+        @total > other
+      end
+      
+      def >(other)
+        @total >= other
+      end
+
+      def +(other)
+        return @total + other unless other.is_a?(ReaderExtender)
+        self.class.new(other + @total, @hours.zip(other.hourly).map!(&:sum))
+      end
+
+      def coerce(other)
+        [self.to_i, other]
+      end
+
+      def as_json(options = nil)
+        @total
+      end
+
+      # Solution proposed by Yehuda Katz in the following Stack Overflow:
+      # http://stackoverflow.com/questions/1095789/sub-classing-fixnum-in-ruby
+      #
+      # Basically we override our methods while proxying all missing methods
+      # to the underliying FixNum
+      #
+      def method_missing(name, *args, &blk)
+        ret = @total.send(name, *args, &blk)
+        ret.is_a?(Numeric) ? ReaderExtender.new(ret, @hours) : ret
+      end
+    end
+
+  end
+end

data/lib/mongoid/tracking/readers.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+module Mongoid  #:nodoc:
+  module Tracking
+    # Reader methods (previously known as "accessors")
+    module Readers
+
+
+
+      # Access methods
+      def today
+        whole_data_for(Time.now)
+      end
+
+      def yesterday
+        whole_data_for(Time.now - 1.day)
+      end
+
+      def first_value
+        data_for(first_date)
+      end
+
+      def last_value
+        data_for(last_date)
+      end
+
+      def last_days(how_much = 7)
+        return [today] unless how_much > 0
+        now, hmd = Time.now, (how_much - 1)
+        on( now.ago(hmd.days)..now )
+      end
+
+      def on(date)
+        if date.is_a?(Range)
+          whole_data_for_range(date)
+        else
+          whole_data_for(date)
+        end
+      end
+
+      def all_values
+        on(first_date..last_date) if first_date
+      end
+
+      def all_values_total
+        return all_values.sum.to_i if all_values && !all_values.nil?
+        return 0
+      end
+
+      # Utility methods
+      def first_date
+        date_cleanup
+        return nil unless _ts = @data.keys.min
+        return nil unless _h = @data[_ts].keys.min
+        Time.from_key(_ts, _h)
+      end
+
+      def last_date
+        date_cleanup
+        return nil unless _ts = @data.keys.max
+        return nil unless _h = @data[_ts].keys.max
+        Time.from_key(_ts, _h)
+      end
+
+      # We need the cleanup method only for methods who rely on date indexes
+      # to be valid (well formed) like first/last_date. This is because
+      # Mongo update operations cleans up the last key, which in our case
+      # left the array in an inconsistent state.
+      #
+      # Example:
+      # Before update:
+      #
+      #  { :visits_data => {"14803" => {"22" => 1} } }
+      #
+      # After updating with:  {"$unset"=>{"visits_data.14803.22"=>1}
+      #
+      #  { :visits_data => {"14803" => {} } }
+      #
+      # We can NOT retrieve the first date with visits_data.keys.min
+      #
+      def date_cleanup
+        @data.reject! {|k,v| v.count == 0}
+      end
+    end
+  end
+end

data/lib/mongoid/tracking/tracker.rb

@@ -0,0 +1,243 @@
+# encoding: utf-8
+module Mongoid  #:nodoc:
+  module Tracking
+    # This internal class handles all interaction for a track field.
+    class Tracker
+
+
+      include Readers
+
+      def initialize(owner, field, aggregate_data)
+        @owner, @for = owner, field
+        @for_data = @owner.internal_track_name(@for)
+        @data = @owner.read_attribute(@for_data)
+
+        if @data.nil?
+          @owner.write_attribute(@for_data, {})
+          @data = @owner.read_attribute(@for_data)
+        end
+
+        @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
+      def add(how_much = 1, date = Time.now)
+        raise Errors::ModelNotSaved, "Can't update a new record. Save first!" if @owner.new_record?
+        return if how_much == 0
+
+        # Note that the following #update_data method updates our local data
+        # and the current value might differ from the actual value on the
+        # database. Basically, what we do is update our own copy as a cache
+        # but send the command to atomically update the database: we don't
+        # read the actual value in return so that we save round trip delays.
+        #
+        update_data(data_for(date) + how_much, date)
+        @owner.inc(store_key(date) => how_much.abs)
+
+        return unless @owner.aggregated?
+
+       @owner.aggregate_fields.each do |k, v|
+         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.to_s }
+
+         docs = @owner.aggregate_klass.collection.find(selector)
+         docs.upsert("$inc" => update_hash(how_much.abs, date))
+        end
+      end
+
+      def inc(date = Time.now)
+        add(1, date)
+      end
+
+      def dec(date = Time.now)
+        add(-1, date)
+      end
+
+      def set(how_much, date = Time.now)
+        raise Errors::ModelNotSaved, "Can't update a new record" if @owner.new_record?
+        update_data(how_much, date)
+        #debugger
+        date = normalize_date(date)
+        if @owner.send(@for_data).empty?
+          @owner.set(@for_data => {date.to_key_timestamp => {date.to_key_hour => how_much}})
+        else
+          current_data = @owner.send(@for_data)
+          current_data.merge!({date.to_key_timestamp => {date.to_key_hour => how_much}})
+          @owner.set(@for_data => current_data)
+        end
+        return unless @owner.aggregated?
+
+        @owner.aggregate_fields.each do |(k,v)|
+          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.to_s }
+
+         docs = @owner.aggregate_klass.collection.find(selector)
+         docs.upsert("$set" => update_hash(how_much.abs, date))
+       end
+      end
+
+      def reset(how_much, date = Time.now)
+        return erase(date) if how_much.nil?
+
+        # First, we use the default "set" for the tracking field
+        # This will also update one aggregate but... oh well...
+        set(how_much, date)
+
+        # Need to iterate over all aggregates and send an update or delete
+        # operations over all mongo records for this aggregate field
+         @owner.aggregate_fields.each do |(k,v)|
+          fk = @owner.class.name.to_s.foreign_key.to_sym
+          selector = { fk => @owner.id, ns: k }
+          docs = @owner.aggregate_klass.collection.find(selector)
+          docs.update_all("$set" => update_hash(how_much.abs, date))
+        end
+      end
+
+      def erase(date = Time.now)
+        raise Errors::ModelNotSaved, "Can't update a new record" if @owner.new_record?
+
+        remove_data(date)
+
+        @owner.unset(store_key(date))
+
+        return unless @owner.aggregated?
+
+        # Need to iterate over all aggregates and send an update or delete
+        # operations over all mongo records
+       @owner.aggregate_fields.each do |(k,v)|
+         fk = @owner.class.name.to_s.foreign_key.to_sym
+         selector = { fk => @owner.id, ns: k }
+
+         docs = @owner.aggregate_klass.collection.find(selector)
+         docs.update_all("$unset" => update_hash(1, date))
+       end
+      end
+
+      private
+      def data_for(date)
+        unless date.nil?
+          date = normalize_date(date)
+          @data.try(:[], date.to_i_timestamp.to_s).try(:[], date.to_i_hour.to_s) || 0
+        end
+      end
+
+      def whole_data_for(date)
+        unless date.nil?
+          date = normalize_date(date)
+          if date.utc?
+            d = expand_hash @data[date.to_key_timestamp]
+            ReaderExtender.new(d.sum, d)
+          else
+            r = date.whole_day
+            d1 = expand_hash @data[r.first.to_key_timestamp]
+            d2 = expand_hash @data[r.last.to_key_timestamp]
+            t = d1[r.first.to_i_hour, 24] + d2[0, r.first.to_i_hour]
+            ReaderExtender.new(t.sum, t)
+          end
+        end
+      end
+
+      def whole_data_for_range(date)
+        date = normalize_date(date)
+        if date.first.utc?
+          keys = date.map(&:to_key_timestamp)
+          keys.inject([]) do |r, e|
+            d = expand_hash(@data[e])
+            r << ReaderExtender.new(d.sum, d)
+          end
+        else
+          first = date.first.whole_day.first.to_key_timestamp
+          last  = date.last.whole_day.last.to_key_timestamp
+          pivot = date.first.whole_day.first.to_i_hour
+          acc = expand_hash(@data[first.to_s])
+
+          data = []
+          first.succ.upto(last) do |n|
+            d = expand_hash(@data[n])
+            t = acc[pivot, 24] + d[0, pivot]
+            acc = d
+            data << ReaderExtender.new(t.sum, t)
+          end
+          data
+        end
+      end
+
+      def expand_hash(h)
+        d = Array.new(24, 0)
+        h.inject(d) { |d, e| d[e.first.to_i] = e.last; d } if h
+        d
+      end
+
+      def update_data(value, date)
+        unless date.nil?
+          return remove_data(date) unless value
+          date = normalize_date(date)
+          dk, hk = date.to_i_timestamp.to_s, date.to_i_hour.to_s
+          unless ts = @data[dk]
+            ts = (@data[dk] = {})
+          end
+          ts[hk] = value
+        end
+      end
+
+      def remove_data(date)
+        unless date.nil?
+          date = normalize_date(date)
+          dk, hk = date.to_i_timestamp.to_s, date.to_i_hour.to_s
+          if ts = @data[dk]
+            ts.delete(hk)
+            unless ts.count > 0
+              @data.delete(dk)
+            end
+          end
+        end
+      end
+
+      # Returns a store key for passed date.
+      def store_key(date)
+        "#{@for_data}.#{normalize_date(date).to_key}"
+      end
+
+
+      def update_hash(num, date)
+        { store_key(date) => num }
+      end
+
+      # Allow for dates to be different types.
+      def normalize_date(date)
+        case date
+        when String
+          Time.parse(date)
+        when Date
+          date.to_time
+        when Range
+          normalize_date(date.first)..normalize_date(date.last)
+        else
+          date
+        end
+      end
+
+      # WARNING: This is +only+ for debugging purposes (rspec y tal)
+      def _original_hash
+        @data
+      end
+
+    end
+
+  end
+end

data/lib/mongoid/tracking/tracker_aggregates.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid  #:nodoc:
+  module Tracking
+    # This internal class handles all interaction of an aggregation token.
+    class TrackerAggregates
+
+      def initialize(owner, token, key_selector, track_field = nil)
+        @owner, @token = owner, token
+        @key = key_selector.first
+        @track_field = track_field
+
+        @accessor = @owner.class.send(:internal_accessor_name, @token)
+        @selector = { ns: @token }
+        @selector.merge!(key: @key) if @key
+
+        @criteria = @owner.send(@accessor).where(@selector)
+      end
+
+      # Delegate all missing methods to the underlying Mongoid Criteria
+      def method_missing(name, *args, &block)
+        @criteria.send(name)
+      end
+
+      # Define all readers here. Basically we are delegating to the Track
+      # object for every object in the criteria
+      Readers.instance_methods.each {|name|
+        define_method(name) do |*args|
+          return nil unless @track_field
+          if @key
+            res = @criteria.first
+            res.send(@track_field).send(name, *args) if res
+          else
+            @criteria.collect {|c|
+              [c.key, c.send(@track_field).send(name, *args)]
+            }
+          end
+        end
+      }
+
+    end
+  end
+end

data/lib/mongoid/tracking.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Tracking #:nodoc:
+
+    # Include this module to add analytics tracking into a +root level+ document.
+    # Use "track :field" to add a field named :field and an associated mongoid
+    # field named after :field
+    def self.included(base)
+      base.class_eval do
+        unless self.ancestors.include? Mongoid::Document
+          raise Errors::NotMongoid, "Must be included in a Mongoid::Document"
+        end
+
+        include Aggregates
+        extend ClassMethods
+
+        class_attribute :tracked_fields
+        self.tracked_fields = []
+        delegate :tracked_fields, :internal_track_name, to: "self.class"
+      end
+    end
+
+      def clicks_score
+    (click_percent / 10.0).round
+  end
+
+  def  click_percent
+    return 0 if impressions_count.eql?(0) ||  clicks.eql?(0)
+    if !impressions_count.eql?(0)
+      (( clicks.to_f / impressions_count.to_f) * 100).round
+    end
+  end
+
+  def avg_days
+    if publish_date < Date.today
+      if end_date > Date.today
+        days = (Date.today - publish_date).to_i
+      else
+        days = (end_date - publish_date).to_i
+      end
+      return days
+    else
+      return 0
+    end
+  end
+
+  def avg_daily_clicks
+    return (visits.all_values_total/ avg_days).to_f.round(2) if !avg_days.eql?(0)
+    return 0.0
+  end
+
+  def avg_daily_views
+    return (impressions.all_values_total / avg_days).to_f  if !avg_days.eql?(0)
+    return 0.0
+  end
+
+  def impressions_count
+    return impressions.all_values_total
+  end
+
+
+    module ClassMethods
+      # Adds analytics tracking for +name+. Adds a +'name'_data+ mongoid
+      # field as a Hash for tracking this information. Additionaly, hiddes
+      # the field, so that the user can not mangle with the original one.
+      # This is necessary so that Mongoid does not "dirty" the field
+      # potentially overwriting the original data.
+      def track(name)
+        set_tracking_field(name.to_sym)
+        create_tracking_accessors(name.to_sym)
+        create_tracked_fields(name)
+        update_aggregates(name.to_sym) if aggregated?
+      end
+
+      def create_tracked_fields(name)
+        field "#{name}_data".to_sym, type: Hash, default: {}
+      end
+
+
+      # Returns the internal representation of the tracked field name
+      def internal_track_name(name)
+        "#{name}_data".to_sym
+      end
+
+      # Configures the internal fields for tracking. Additionally also creates
+      # an index for the internal tracking field.
+      def set_tracking_field(name)
+        # DONT make an index for this field. MongoDB indexes have limited
+        # size and seems that this is not a good target for indexing.
+        # index internal_track_name(name)
+        tracked_fields << name
+      end
+
+      # Creates the tracking field accessor and also disables the original
+      # ones from Mongoid. Hidding here the original accessors for the
+      # 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, aggr)
+        end
+      end
+
+      # Updates the aggregated class for it to include a new tracking field
+      def update_aggregates(name)
+        aggregate_klass.track name
+      end
+
+    end
+
+  end
+end

data/lib/trackoid_mongoid4/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Trackoid #:nodoc:
+  VERSION = "0.1.3"
+end

data/lib/trackoid_mongoid4.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'trackoid_mongoid4/version'
+
+require 'mongoid/tracking'
+require 'mongoid/tracking/errors'
+require 'mongoid/tracking/core_ext'
+require 'mongoid/tracking/reader_extender'
+require 'mongoid/tracking/readers'
+require 'mongoid/tracking/tracker'
+require 'mongoid/tracking/aggregates'
+require 'mongoid/tracking/tracker_aggregates'