tekeya 0.0.1

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc
+*.log
+*.sqlite3
+spec/rails_app/log
+.teamocil

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format nested
+--fail-fast

data/.yardopts

@@ -0,0 +1 @@
+--no-private --protected lib/**/*.rb - README.md LICENSE

data/Gemfile

@@ -0,0 +1,39 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem "rails"     , "~> 3.2.6"
+  gem 'debugger'  , '~> 1.2.0'
+  gem 'yard'      , '~> 0.8.2.1'
+  gem 'bluecloth'
+  gem 'guard-rspec'
+  gem 'ruby_gntp'
+  gem 'guard-bundler'
+  gem 'rb-fsevent', '~> 0.9.1'
+end
+
+group :test do
+  gem 'rspec'             , '~> 2.11.0'
+  gem 'database_cleaner'  , '~> 0.8.0'
+  gem 'fabrication'       , '~> 2.3.0'
+  gem 'faker'             , '~> 1.1.2'
+  gem 'simplecov'         , '~> 0.7.0'
+end
+
+platforms :jruby do
+  gem "activerecord-jdbc-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+  gem "jruby-openssl"
+end
+
+platforms :ruby do
+  gem "sqlite3"
+
+  group :mongoid do
+    gem "mongo", "~> 1.7.0"
+    gem "mongoid", "~> 3.0"
+    gem "bson_ext", "~> 1.7.0"
+    gem 'mongoid-rspec'     , '~> 1.5.4'
+  end
+end

data/Guardfile

@@ -0,0 +1,40 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  watch('lib/tekeya.rb') { "spec/tekeya_spec.rb" }
+  watch('lib/tekeya/configuration.rb') { "spec/tekeya_spec.rb" }
+  watch('lib/tekeya/railtie.rb') { "spec/tekeya_spec.rb" }
+
+  watch('lib/tekeya/entity.rb') { "spec/tekeya/entity_spec.rb" }
+  watch(%r{^lib/tekeya/entity/.+\.rb$}) { "spec/tekeya/entity_spec.rb" }
+
+  watch(%r{^lib/tekeya/feed/.+\.rb$}) { "spec/tekeya/feed_spec.rb" }
+  watch(%r{^lib/tekeya/feed/resque/.+\.rb$}) { "spec/tekeya/feed_spec.rb" }
+end
+
+
+guard 'rspec', :env => {'TEKEYA_ORM' => 'mongoid'} do
+  watch(%r{^spec/.+_spec\.rb$})
+
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  watch('lib/tekeya.rb') { "spec/tekeya_spec.rb" }
+  watch('lib/tekeya/configuration.rb') { "spec/tekeya_spec.rb" }
+  watch('lib/tekeya/railtie.rb') { "spec/tekeya_spec.rb" }
+
+  watch('lib/entity.rb') { "spec/tekeya/entity_spec.rb" }
+  watch(%r{^lib/tekeya/entity/.+\.rb$}) { "spec/tekeya/entity_spec.rb" }
+
+  watch(%r{^lib/tekeya/feed/.+\.rb$}) { "spec/tekeya/feed_spec.rb" }
+  watch(%r{^lib/tekeya/feed/resque/.+\.rb$}) { "spec/tekeya/feed_spec.rb" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Omar Mekky
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Tekeya
+
+**Tekeya** is a social engine for Rails applications based on Redis and RebatDB.
+
+## Objective
+
+We work on social networks all the time and we almost always need to create social graphs, activity feeds and notifications that are efficient, flexible and reliable.
+
+## Name
+
+**Tekeya** is an arabic word the describes a place where people meet and converse.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tekeya'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tekeya
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/TODO.todo

@@ -0,0 +1,8 @@
++ Trim redis feeds
++ Copy feeds when an entity tracks another
++ Delete feeds when entity untracks another
++ Write test scenarios !!!
++ Create a method to handle retrieving the entity's feed (profile and own feed)
++ Delete activity from Redis when deleted from the db
+- test callbacks
+- test notifications

data/app/active_record/tekeya/activity.rb

@@ -0,0 +1,7 @@
+module Tekeya
+  class Activity < ::ActiveRecord::Base
+    include ::Tekeya::Feed::Activity
+
+    # TODO: create migration for basic activity fields
+  end
+end

data/app/active_record/tekeya/attachment.rb

@@ -0,0 +1,5 @@
+module Tekeya
+  class Attachment < ::ActiveRecord::Base
+    include ::Tekeya::Feed::Attachment
+  end
+end

data/app/active_record/tekeya/notification.rb

@@ -0,0 +1,5 @@
+module Tekeya
+  class Notification < ::ActiveRecord::Base
+    include ::Tekeya::Feed::Notification
+  end
+end

data/app/mongoid/tekeya/activity.rb

@@ -0,0 +1,9 @@
+module Tekeya
+  class Activity
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include ::Tekeya::Feed::Activity
+
+    field :activity_type, type: String
+  end
+end

data/app/mongoid/tekeya/attachment.rb

@@ -0,0 +1,6 @@
+module Tekeya
+  class Attachment
+    include Mongoid::Document
+    include ::Tekeya::Feed::Attachment
+  end
+end

data/app/mongoid/tekeya/notification.rb

@@ -0,0 +1,10 @@
+module Tekeya
+  class Notification
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include ::Tekeya::Feed::Notification
+
+    field :notification_type, type: String
+    field :read, type: Boolean
+  end
+end

data/db/migrate/00_create_activities.rb

@@ -0,0 +1,11 @@
+class CreateActivities < ActiveRecord::Migration
+  def change
+    create_table :activities do |t|
+      t.string  :activity_type, null: false
+      t.integer :entity_id, null: false
+      t.string  :entity_type, null: false
+      
+      t.timestamps
+    end
+  end
+end

data/db/migrate/01_create_attachments.rb

@@ -0,0 +1,13 @@
+class CreateAttachments < ActiveRecord::Migration
+  def change
+    create_table :attachments do |t|
+      t.integer   :attache_id, null: false
+      t.string    :attache_type, null: false
+      t.integer   :attachable_id, null: false
+      t.string    :attachable_type, null: false
+      
+      t.timestamps
+    end
+  end
+end
+

data/db/migrate/02_create_notifications.rb

@@ -0,0 +1,14 @@
+class CreateNotifications < ActiveRecord::Migration
+  def change
+    create_table :notifications do |t|
+      t.string    :notification_type, null: false
+      t.integer   :subject_id, null: false
+      t.string    :subject_type, null: false
+      t.integer   :entity_id, null: false
+      t.string    :entity_type, null: false
+      t.boolean   :read, default:false
+      
+      t.timestamps
+    end
+  end
+end

data/lib/tasks/resque_tasks.rake

@@ -0,0 +1,3 @@
+require 'resque/tasks'
+
+task 'resque:setup' => :environment

data/lib/tekeya.rb

@@ -0,0 +1,81 @@
+require "tekeya/version"
+require "tekeya/railtie"
+require "active_support"
+
+module Tekeya
+  extend ActiveSupport::Autoload
+
+  # Dependencies
+  autoload :Redis, 'redis'
+  autoload :Rebat, 'rebat'
+  autoload :Resque, 'resque'
+  # Modules
+  autoload :Configuration
+  autoload :Entity
+
+  module Entity
+    extend ActiveSupport::Autoload
+    
+    autoload :Group
+  end
+
+  module Errors
+    extend ActiveSupport::Autoload
+    
+    autoload :TekeyaError
+    autoload :TekeyaFatal
+    autoload :TekeyaNonEntity
+    autoload :TekeyaNonGroup
+    autoload :TekeyaRelationAlreadyExists
+    autoload :TekeyaRelationNonExistent
+  end
+
+  module Feed
+    extend ActiveSupport::Autoload
+
+    autoload :Activity
+    autoload :Attachable
+    autoload :Attachment
+    autoload :Notification
+
+    module Activity
+      extend ActiveSupport::Autoload
+
+      autoload :FeedItem
+      autoload :Resque
+
+      module Resque
+        extend ActiveSupport::Autoload
+
+        autoload :ActivityFanout
+        autoload :FeedCopy
+        autoload :DeleteActivity
+        autoload :UntrackFeed
+      end
+    end
+  end
+
+
+  # Configure Tekeya
+  #
+  # Example::
+  # 
+  #   Tekeya.configure do |config|
+  #     redis_host = "localhost"
+  #     redis_port = 9200
+  #     flockdb_host = 9200
+  #     flockdb_port = 9200
+  #   end
+  def self.configure(&block)
+    yield Tekeya::Configuration.instance
+    Tekeya::Configuration.instance.setup_databases
+  end
+
+  def self.relations
+    return Tekeya::Configuration.instance.rebat
+  end
+
+  def self.redis
+    return Tekeya::Configuration.instance.redis
+  end
+end

data/lib/tekeya/configuration.rb

@@ -0,0 +1,48 @@
+require 'erb'
+require 'singleton'
+
+module Tekeya
+  # Parses the configuration file and holds important configuration attributes  
+  class Configuration
+    include Singleton
+    
+    attr_reader :redis, :rebat
+    attr_accessor :redis_host, :redis_port, :rebatdb_host, :rebatdb_port, :feed_storage_orm
+    
+    # @private
+    # Initializes a new configuration object
+    def initialize
+      parse_config_file "#{Rails.root}/config/tekeya.yml"
+      
+      # Setup defaults
+      @redis_host       ||= "localhost"
+      @redis_port       ||= "6379"
+      @rebatdb_host     ||= "localhost"
+      @rebatdb_port     ||= "2011"
+      @feed_storage_orm ||= :active_record
+    end
+
+    def setup_databases
+      # Setup redis
+      @redis = Redis.new host: @redis_host, port: @redis_port.to_i
+
+      # Setup resque
+      Resque.redis = @redis
+
+      # Setup rebatdb
+      @rebat = Rebat.new "#{@rebatdb_host}", "#{@rebatdb_port}", { tracks: 1, joins: 2, blocks: 3 }
+    end    
+
+    # Loads the configuration file
+    # @return [nil]
+    def parse_config_file(path)
+      return unless File.exists?(path)
+      
+      conf = YAML::load(ERB.new(IO.read(path)).result)[Rails.env]
+      
+      conf.each do |key,value|
+        self.send("#{key}=", value) if self.respond_to?("#{key}=")
+      end unless conf.nil?
+    end
+  end
+end

data/lib/tekeya/entity.rb

@@ -0,0 +1,432 @@
+module Tekeya
+  # Represents a tekeya entity, the main building block of the engine
+  module Entity
+    extend ActiveSupport::Concern
+
+    included do
+      # Entities are attachable to activities
+      include ::Tekeya::Feed::Attachable
+      # which field should be used as a primary key
+      class_attribute :entity_primary_key
+
+      # default primary key
+      define_tekeya_primary_key :id
+
+      # define the relation with the activity
+      has_many :activities, as: :entity, class_name: "::Tekeya::Activity", dependent: :destroy do
+        # Returns activities dating up to 10 days in the past
+        def recent
+          unless ::Tekeya::Configuration.instance.feed_storage_orm == :mongoid
+            where("created_at > ?", 10.days.ago).order('created_at DESC')
+          else
+            criteria.where(:created_at.gte => 10.days.ago).desc('created_at')
+          end
+        end
+
+        # Any method missing invoked on activities is considered a new activity
+        def method_missing(meth, *args, &block)
+          options = args.extract_options!
+          bool_args = args.map{|arg| arg.respond_to?(:is_tekeya_attachable)}.uniq
+          is_activity = bool_args.length == 1 && bool_args.first == true
+
+          if is_activity
+            attachments = []
+
+            args.each do |attachable|
+              attachments << ::Tekeya::Attachment.new(attachable: attachable)
+            end
+
+            create(activity_type: meth, attachments: attachments, group_with_recent: options[:group].nil? ? true : options[:group])
+          else
+            super
+          end
+        end
+      end
+
+      has_many :notifications, as: :entity, class_name: "::Tekeya::Notification", dependent: :destroy do
+        def unread
+          unless ::Tekeya::Configuration.instance.feed_storage_orm == :mongoid
+            where(read: false).order('created_at DESC')
+          else
+            criteria.where(read: false).desc('created_at')
+          end
+        end
+
+        # Any method missing invoked on activities is considered a new activity
+        def method_missing(meth, *args, &block)
+          options = args.extract_options!
+          bool_args = args.map{|arg| arg.respond_to?(:is_tekeya_attachable)}.uniq
+          is_notification = bool_args.length == 1 && bool_args.first == true
+
+          if is_notification
+            actors = []
+
+            args.each do |attachable|
+              actors << ::Tekeya::Attachment.new(attachable: attachable)
+            end
+
+            subject = @association.nil? ? base : @association.owner
+            create(notification_type: meth, subject: options[:subject].nil? ? subject : options[:subject], actors: actors, group_with_recent: options[:group].nil? ? true : options[:group])
+          else
+            super
+          end
+        end
+      end
+
+      # define some callbacks
+      define_callbacks :track_entity, :untrack_entity, :join_group, :leave_group, :block_entity, :unblock_entity
+    end
+
+    module ClassMethods
+      # Sets an after callback to be run after an entity is tracked
+      #
+      # @param [Symbol, String] callback the method to be run
+      def after_tracking_entity(callback)
+        set_callback :track_entity, :after, callback
+      end
+
+      # Sets an after callback to be run after an entity is untracked
+      #
+      # @param [Symbol, String] callback the method to be run
+      def after_untracking_entity(callback)
+        set_callback :untrack_entity, :after, callback
+      end
+
+      # Sets an after callback to be run after a group is joined
+      #
+      # @param [Symbol, String] callback the method to be run
+      def after_joining_group(callback)
+        set_callback :join_group, :after, callback
+      end
+
+      # Sets an after callback to be run after a group is left
+      #
+      # @param [Symbol, String] callback the method to be run
+      def after_leaving_group(callback)
+        set_callback :leave_group, :after, callback
+      end
+
+      # Sets an after callback to be run after an entity is blocked
+      #
+      # @param [Symbol, String] callback the method to be run
+      def after_blocking_entity(callback)
+        set_callback :block_entity, :after, callback
+      end
+
+      # Sets an after callback to be run after an entity is unblocked
+      #
+      # @param [Symbol, String] callback the method to be run
+      def after_unblocking_entity(callback)
+        set_callback :unblock_entity, :after, callback
+      end
+
+      # Defines the primary key for Tekeya to use in relations
+      #
+      # @param [Symbol] key the field to use as a primary key
+      def define_tekeya_primary_key(key)
+        self.entity_primary_key = key
+      end
+    end
+
+    # Tracks the given entity and copies it's recent feed to the tracker feed
+    #
+    # @param [Entity] entity the entity to track
+    # @param [Boolean] notify determines whether the tracked entity should be notified
+    # @return [Boolean]
+    def track(entity, notify=true)
+      run_callbacks :track_entity do
+        check_if_tekeya_entity(entity)
+        raise ::Tekeya::Errors::TekeyaRelationAlreadyExists.new("Already tracking #{entity}") if self.tracks?(entity)
+
+        ret = add_tekeya_relation(self, entity, :tracks)
+
+        if ret
+          ::Resque.enqueue(::Tekeya::Feed::Activity::Resque::FeedCopy, entity.profile_feed_key, self.feed_key)
+          
+          activity = self.activities.tracked(entity)
+          entity.notifications.tracked_by self if notify
+        end
+
+        return ret
+      end
+    end
+
+    # Return a list of entities being tracked by this entity
+    #
+    # @param  [String] type used to return a certain type of entities being tracked
+    # @return [Array] the entities tracked by this entity
+    def tracking(type = nil)
+      tekeya_relations_of(self, :tracks, type)
+    end
+
+    # Returns a list of entities tracking this entity
+    #
+    # @param  [String] type used to return a certain type of entities being tracked
+    # @return [Array] the entities tracking this entity
+    def trackers(type = nil)
+      tekeya_relations_of(self, :tracks, type, true)
+    end
+
+    # Checks if this entity is tracking the given entity
+    #
+    # @param  [Entity] entity the entity to check
+    # @return [Boolean] true if this entity is tracking the given entity, false otherwise
+    def tracks?(entity)
+      check_if_tekeya_entity(entity)
+      tekeya_relation_exists?(self, entity, :tracks)
+    end
+
+    # Untracks the given entity and deletes recent activities of the untracked entity from this entity's feed
+    #
+    # @param [Entity] entity the entity to untrack
+    # @return [Boolean]
+    def untrack(entity)
+      run_callbacks :untrack_entity do
+        check_if_tekeya_entity(entity)
+        raise ::Tekeya::Errors::TekeyaRelationNonExistent.new("Can't untrack an untracked entity") unless self.tracks?(entity)
+
+        ret = delete_tekeya_relation(self, entity, :tracks)
+        
+        ::Resque.enqueue(::Tekeya::Feed::Activity::Resque::UntrackFeed, entity.profile_feed_key, self.feed_key) if ret
+
+        return ret
+      end
+    end
+
+    # Blocks the given entity and removes any tracking relation between both entities
+    #
+    # @param [Entity] entity the entity to block
+    # @return [Boolean]
+    def block(entity)
+      run_callbacks :block_entity do
+        check_if_tekeya_entity(entity)
+        raise ::Tekeya::Errors::TekeyaRelationAlreadyExists.new("Already blocking #{entity}") if self.blocks?(entity)
+
+        unless entity.is_tekeya_group?
+          self.untrack(entity) if self.tracks?(entity)
+          entity.untrack(self) if entity.tracks?(self)
+        end
+
+        add_tekeya_relation(self, entity, :blocks)
+      end
+    end
+
+    # Returns a list of entities blocked by this entity
+    #
+    # @param  [String] type used to return a certain type of entities blocked
+    # @return [Array] the entities blocked by this entity
+    def blocked(type = nil)
+      tekeya_relations_of(self, :blocks, type)
+    end
+
+    # Checks if this entity is blocking the given entity
+    #
+    # @param  [Entity] entity the entity to check
+    # @return [Boolean] true if this entity is blocking the given entity, false otherwise
+    def blocks?(entity)
+      check_if_tekeya_entity(entity)
+      tekeya_relation_exists?(self, entity, :blocks)
+    end
+
+    # Unblock the given entity
+    #
+    # @param [Entity] entity the entity to unblock
+    # @return [Boolean]
+    def unblock(entity)
+      run_callbacks :unblock_entity do
+        check_if_tekeya_entity(entity)
+        raise ::Tekeya::Errors::TekeyaRelationNonExistent.new("Can't unblock an unblocked entity") unless self.blocks?(entity)
+
+        delete_tekeya_relation(self, entity, :blocks)
+      end
+    end
+
+    # Joins the given group and tracks it
+    #
+    # @note will automatically track the group
+    # @param [Group] group the group to track
+    # @param [Boolean] track_also if set to false automatic tracking is disabled
+    # @param [Boolean] notify determines whether the joined group's owner should be notified
+    # @return [Boolean]
+    def join(group, track_also = true, notify=true)
+      run_callbacks :join_group do
+        check_if_tekeya_group(group)
+        raise ::Tekeya::Errors::TekeyaRelationAlreadyExists.new("Already a member of #{group}") if self.member_of?(group)
+
+        ret = add_tekeya_relation(self, group, :joins)
+        ret &= self.track(group, false) if track_also && !self.tracks?(group) && ret
+        
+        if ret
+          activity = self.activities.joined(group)
+          group.owner.notifications.joined_by self, subject: group if notify
+        end
+
+        return ret
+      end
+    end
+
+    # Return a list of groups joined by this entity
+    #
+    # @param  [String] type used to return a certain type of groups joined
+    # @return [Array] the groups joined by this entity
+    def groups(type = nil)
+      tekeya_relations_of(self, :joins, type)
+    end
+
+    # Checks if this entity is a member of the given group
+    #
+    # @param  [Group] group the group to check
+    # @return [Boolean] true if this entity is a member of the given group, false otherwise
+    def member_of?(group)
+      check_if_tekeya_group(group)
+      tekeya_relation_exists?(self, group, :joins)
+    end
+
+    # Leaves the given group and untracks it
+    #
+    # @param [Group] group the group to untrack
+    # @return [Boolean]
+    def leave(group)
+      run_callbacks :leave_group do
+        check_if_tekeya_group(group)
+        raise ::Tekeya::Errors::TekeyaRelationNonExistent.new("Can't leave an unjoined group") unless self.member_of?(group)
+
+        ret = delete_tekeya_relation(self, group, :joins)
+        ret &= self.untrack(group) if self.tracks?(group) && ret
+
+        return ret
+      end
+    end
+
+    # Returns the entity's recent activities
+    #
+    # @return [Array] the list of recent activities by this entity
+    def profile_feed
+      acts = []
+      pkey = self.profile_feed_key
+      recent_activities_count = ::Tekeya.redis.zcard(pkey)
+
+      # Check if the cache is not empty
+      if recent_activities_count > 0
+        # Retrieve the aggregate keys from redis
+        acts_keys = ::Tekeya.redis.zrange(pkey, 0, -1)
+        # Retrieve the aggregates
+        acts_keys.each do |act_key|
+          acts << ::Tekeya::Feed::Activity::FeedItem.from_redis(act_key, self)
+        end
+      else
+        # Retrieve the activities from the DB
+        db_recent_activities = self.activities.recent
+        db_recent_activities.each do |activity|
+          acts << ::Tekeya::Feed::Activity::FeedItem.from_db(activity, self)
+        end
+      end
+
+      return acts
+    end
+    
+    # Returns the entity's feed
+    #
+    # @return [Array] the list of activities for the entities tracked by this entity
+    def feed
+      acts = []
+      fkey = self.feed_key
+      recent_activities_count = ::Tekeya.redis.zcard(fkey)
+      
+      # Check if the cache is not empty
+      if recent_activities_count > 0
+        # Retrieve the aggregate keys from redis
+        acts_keys = ::Tekeya.redis.zrange(fkey, 0, -1)
+        # Retrieve the aggregates
+        acts_keys.each do |act_key|
+          acts << ::Tekeya::Feed::Activity::FeedItem.from_redis(act_key, self)
+        end
+      else
+        # Retrieve the activities from the DB
+        self.tracking.each do |tracker|
+          db_recent_activities = tracker.activities.recent
+          db_recent_activities.each do |activity|
+            acts << ::Tekeya::Feed::Activity::FeedItem.from_db(activity, tracker)
+          end
+        end
+      end
+
+      return acts
+    end
+
+    # @private
+    # Returns a unique key for the entity's profile feed in redis
+    def profile_feed_key
+      "#{self.class.name}:#{self.send(self.entity_primary_key)}:profile:feed"
+    end
+
+    # @private
+    # Returns a unique key for the entity's feed in redis
+    def feed_key
+      "#{self.class.name}:#{self.send(self.entity_primary_key)}:feed"
+    end
+
+    # A method to identify the entity
+    #
+    # @return [Boolean] true
+    def is_tekeya_entity?
+      return true
+    end
+
+    # A method to identify the entity as a non group
+    #
+    # @return [Boolean] false
+    def is_tekeya_group?
+      return false
+    end
+
+    private
+
+    # @private
+    # Checks if the given argument is an entity and raises an error if its not
+    def check_if_tekeya_entity(entity)
+      raise ::Tekeya::Errors::TekeyaNonEntity.new("Supplied argument is not a Tekeya::Entity") unless entity.present? && entity.is_tekeya_entity?
+    end
+
+    # @private
+    # Checks if the given argument is a group and raises an error if its not
+    def check_if_tekeya_group(group)
+      raise ::Tekeya::Errors::TekeyaNonGroup.new("Supplied argument is not a Tekeya::Entity::Group") unless group.present? && group.is_tekeya_group?
+    end
+
+    # @private
+    # Adds a rebat relation
+    def add_tekeya_relation(from, to, type)
+      ::Tekeya.relations.add(from.send(from.class.entity_primary_key), from.class.name, to.send(to.class.entity_primary_key), to.class.name, 0, type)
+    end
+
+    # @private
+    # Deletes a rebat relation
+    def delete_tekeya_relation(from, to, type)
+      ::Tekeya.relations.delete(from.send(from.class.entity_primary_key), from.class.name, to.send(to.class.entity_primary_key), to.class.name, type)
+    end
+
+    # @private
+    # Retrieves rebat relations
+    def tekeya_relations_of(from, relation_type, entity_type, reverse = false)
+      result_entity_class = entity_type.safe_constantize if entity_type
+      unless reverse
+        ::Tekeya.relations.where(from.send(from.class.entity_primary_key), from.class.name, nil, entity_type, relation_type).entries.map do |entry|
+          result_entity_class ||= entry.toEntityType.safe_constantize
+          result_entity_class.where(:"#{result_entity_class.entity_primary_key}" => entry.toEntityId).first
+        end
+      else
+        ::Tekeya.relations.where(nil, entity_type, from.send(from.class.entity_primary_key), from.class.name, relation_type).entries.map do |entry|
+          result_entity_class ||= entry.fromEntityType.safe_constantize
+          result_entity_class.where(:"#{result_entity_class.entity_primary_key}" => entry.fromEntityId).first
+        end
+      end
+    end
+
+    # @private
+    # Checks if a rebat relation exists
+    def tekeya_relation_exists?(from, to, type)
+      !::Tekeya.relations.where(from.send(from.class.entity_primary_key), from.class.name, to.send(to.class.entity_primary_key), to.class.name, type).entries.empty?
+    end
+  end
+end