redcrumbs 0.5.0 → 0.5.1

data/gemfiles/Gemfile.rails-4.0.x

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 4.0'
+gem 'activesupport', '~> 4.0'
+
+gemspec :path => '..'
+
+group :test do
+  gem 'codeclimate-test-reporter', :group => :test, :require => nil
+  gem 'rspec', '~> 3.0'
+  gem 'sqlite3', '~> 1.0'
+end

data/gemfiles/Gemfile.rails-4.1.x

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+gem 'activerecord', '~> 4.1'
+gem 'activesupport', '~> 4.1'
+
+gemspec :path => '..'
+
+group :test do
+  gem 'codeclimate-test-reporter', :group => :test, :require => nil
+  gem 'rspec', '~> 3.0'
+  gem 'sqlite3', '~> 1.0'
+end

data/lib/generators/redcrumbs/templates/initializer.rb

@@ -1,34 +1,17 @@
 Redcrumbs.setup do |config|
-  # When a change is made to a redcrumbed model the user associated with that model will
-  # automatically be stored on the Crumb object. By default Redcrumbs will look for a User
-  # object using 'id' as the primary key but you can override that here.
+  # If your activity feeds are user-based you can store creator and target 
+  # attributes on the crumb object to avoid having to touch your main database
+  # at all. Keep it sensible and evaluate whether the additional space used in 
+  # Redis is really worth the time saving. 
+  # Note: You don't need to store the object id, it is already stored.
   #
-  # config.creator_class_sym = :user
-  # config.creator_primary_key = 'id'
-  # config.target_class_sym = :user
-  # config.target_primary_key = 'id'
-  #
-  #
-  # If you're using the crumbs to report news back to a user you can store creator and target 
-  # attributes on the crumb object to avoid having to touch your main database at all. Keep it 
-  # sensible and evaluate whether the additional space used in Redis is really worth the time saving.
-  #
-  # config.store_creator_attributes = [:id, :name, :email]
-  # config.store_target_attributes = [:id, :name, :email]
+  # config.store_creator_attributes = [:name, :email]
+  # config.store_target_attributes = [:name, :email]
   #
   #
   # Set the mortality to make crumbs automatically expire in time. Default is infinity.
   # config.mortality = 30.days
 end
 
-# Point this to your redis connection. It can be a Redis object or a string.
-Redcrumbs.redis = 'localhost:6379'
-
-# You may want to create a config/redcrumbs.yml file and base your redis setting
-# from that. e.g. (thanks to Resque for this):
-
-# rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
-# rails_env = ENV['RAILS_ENV'] || 'development'
-# 
-# redcrumbs_config = YAML.load_file(rails_root + '/config/redcrumbs.yml')
-# Redcrumbs.redis = redcrumbs_config[rails_env]
+# Point this to your redis connection. It can be a Redis client, namespace or a URL string.
+Redcrumbs.redis = 'localhost:6379'

data/lib/redcrumbs.rb

@@ -1,24 +1,28 @@
+require 'active_support'
+require 'active_support/core_ext'
 require 'active_support/concern'
 require 'active_support/dependencies/autoload'
-require "redcrumbs/version"
-require 'redcrumbs/engine'
+require 'active_record'
+require 'redcrumbs/version'
 require 'redcrumbs/config'
 require 'redis'
 require 'redis-namespace'
 require 'dm-core'
 
-# Redcrumbs implements dirty models to track changes to ActiveRecord models in a way that is fast and
+# Redcrumbs uses `dirty attributes` to track and store changes to ActiveRecord models in a way that is fast and
 # unobtrusive. By storing the data in Redis instead of a SQL database the footprint is greatly reduced, no
 # schema changes are necessary and we can harness all the advantages of a key value store; such as key expiry.
 #
 # Author:: John Hope
-# Copyright:: Copyright (c) 2012 John Hope for Project Zebra
+# Copyright:: Copyright (c) 2014 John Hope for Project Zebra
 # License:: MIT License (http://www.opensource.org/licenses/mit-license.php)
 #
 # To start tracking a model use the 'redcrumbed' method:
 #
 #   class Venue
 #     redcrumbed, :only => [:name, :latlng]
+#
+#     has_one :creator, :class_name => 'User'
 #   end
 #
 #   venue = Venue.last
@@ -38,6 +42,10 @@ module Redcrumbs
   autoload :Options
   autoload :Users
   autoload :Creation
+  autoload :Crumb
+
+  include Options
+  include Users
   
   def self.setup
     yield self
@@ -49,9 +57,6 @@ module Redcrumbs
   
   module ClassMethods
     def redcrumbed(options = {})
-      
-      include Options
-      include Users
       include Creation
       
       prepare_redcrumbed_options(options)

data/lib/redcrumbs/config.rb

@@ -10,14 +10,32 @@ module Redcrumbs
   mattr_accessor :mortality
   mattr_accessor :redis
 
+  mattr_accessor :class_name
+
+
+  # This should only be used to load old crumbs from previous versions
+  # of the gem, in future require an explicit creator/target method to set.
+  #
   @@creator_class_sym ||= :user
   @@creator_primary_key ||= 'id'
-  @@target_class_sym ||= :user
+  @@target_class_sym ||= :user 
   @@target_primary_key ||= 'id'
 
   @@store_creator_attributes ||= []
   @@store_target_attributes ||= []
+
+
+  # Constantises the class_name attribute, falls back to the Crumb default.
+  #
+  def self.crumb_class
+    if @@class_name and @@class_name.length > 0
+      constantize_class_name
+    else
+      Crumb
+    end
+  end
   
+
   # Stolen from resque. Thanks!
   # Accepts:
   #   1. A 'hostname:port' String
@@ -26,6 +44,7 @@ module Redcrumbs
   #   4. A Redis URL String 'redis://host:port'
   #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
   #      or `Redis::Namespace`.
+  #
   def self.redis=(server)
     case server
     when String
@@ -45,12 +64,43 @@ module Redcrumbs
     else
       @@redis = Redis::Namespace.new(:redcrumbs, :redis => server)
     end
+
+    setup_datamapper!
+
     @@redis
   end
 
-  def self.redis
-    return @@redis if @@redis
-    @@redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
-    @@redis
+  private
+
+  # Note: Since it's not possible to access the exact connection the DataMapper adapter
+  # uses we have to use the @@redis module variable and make sure it's consistent.
+  #
+  def self.setup_datamapper!
+    adapter = DataMapper.setup(:default, 
+      { :adapter  => "redis", 
+        :host => self.redis.client.host, 
+        :port => self.redis.client.port, 
+        :password => self.redis.client.password
+      })
+
+    # For supporting namespaces:
+    #
+    adapter.resource_naming_convention = lambda do |value|
+      inflected_value = DataMapper::Inflector.pluralize(DataMapper::Inflector.underscore(value)).gsub('/', '_')
+
+      "#{self.redis.namespace}:#{inflected_value}"
+    end
+  end
+
+  def self.constantize_class_name
+    klass = @@class_name.to_s.classify.constantize
+
+    unless klass < Redcrumbs::Crumb
+      raise ArgumentError, 'Redcrumbs crumb_class must inherit from Redcrumbs::Crumb'
+    end
+
+    klass
+  rescue NameError
+    Crumb
   end
 end

data/lib/redcrumbs/creation.rb

@@ -2,57 +2,70 @@ module Redcrumbs
   module Creation
     extend ActiveSupport::Concern
     
-    module InstanceMethods
-      def crumbs
-        Crumb.all(:subject_type => self.class.to_s, :subject_id => self.id)
-      end
+    def crumbs
+      Redcrumbs.crumb_class.all(
+        :subject_type => self.class.to_s, 
+        :subject_id => self.id
+      )
+    end
 
-      def watched_changes
-        changes.slice(*self.class.redcrumbs_options[:only])
-      end
+    def watched_changes
+      changes.slice(*self.class.redcrumbs_options[:only])
+    end
 
-      def storeable_attributes
-        store = self.class.redcrumbs_options[:store]
-        if store.has_key?(:only)
-          attributes.reject {|k,v| !store[:only].include?(k.to_sym)}
-        elsif store.has_key?(:except)
-          attributes.reject {|k,v| store[:except].include?(k.to_sym)}
-        else
-          {}
-        end
-      end
-      
-      def attributes_from_storeable_methods
-        store = self.class.redcrumbs_options[:store]
-        if store.has_key?(:methods)
-          # get the methods that actually exist on the model
-          methods = methods_from_array(store[:methods])
-          # inject them into a hash with their outcomes as values
-          methods.inject({}) {|h,a| h.merge(a => send(a))}
-        else
-          {}
-        end
-      end
-      
-      def storeable_attributes_and_method_attributes
-        storeable_attributes.merge(attributes_from_storeable_methods)
-      end
+    def storable_attributes_keys
+      store = self.class.redcrumbs_options[:store]
       
-      def create_crumb
-        n = Crumb.build_with_modifications(self)
-        n.save
-      end
-      
-      # This is called after the record is saved to store the changes on the model, including anything done in before_save validations
-      def notify_changes
-        create_crumb unless watched_changes.empty?
-      end
-      
-      private
-      
-      def methods_from_array(array)
-        self.class.instance_methods.select {|method| array.include?(method.to_sym)}
+      store[:only] or 
+      symbolized_attribute_keys(store[:except]) or
+      []
+    end
+
+    def storeable_attributes
+      attributes.slice *storable_attributes_keys.map(&:to_s)
+    end
+
+    def storable_methods_names
+      store = self.class.redcrumbs_options[:store]
+
+      if store[:methods]
+        methods.select {|method| store[:methods].include?(method.to_sym)}
+      else
+        []
       end
     end
+    
+    # Todo: Fix inconsistent naming; storable vs storeable
+    def storable_methods
+      storable_methods_names.inject({}) {|h, n| h.merge(n.to_s => send(n))}
+    end
+    
+    def serialized_as_redcrumbs_subject
+      storeable_attributes.merge(storable_methods)
+    end
+    
+    def create_crumb
+      n = Redcrumbs.crumb_class.build_with_modifications(self)
+      n.save
+      n
+    end
+    
+    # This is called after the record is saved to store the changes on the model, including anything done in before_save validations
+    def notify_changes
+      create_crumb unless watched_changes.empty?
+    end
+    
+    private
+
+    def symbolized_attribute_keys(except = [])
+      return nil unless except
+
+      symbolized_attribute_keys = attributes.dup.symbolize_keys!.keys
+      symbolized_attribute_keys.reject {|key| except.include?(key)}
+    end
+    
+    def methods_from_array(array)
+      self.class.instance_methods.select {|method| array.include?(method.to_sym)}
+    end
   end
 end

data/lib/redcrumbs/crumb.rb

@@ -0,0 +1,100 @@
+require 'dm-core'
+require 'dm-types'
+require 'dm-timestamps'
+require 'dm-redis-adapter'
+require 'redcrumbs/serializable_association'
+
+module Redcrumbs
+  class Crumb
+    
+    include DataMapper::Resource
+    include Redcrumbs::SerializableAssociation
+    
+    property :id, Serial
+    property :modifications, Json, :default => "{}", :lazy => false
+    property :created_at, DateTime
+    property :updated_at, DateTime
+
+    DataMapper.finalize
+
+    after :save, :set_mortality
+
+    serializable_association :creator
+    serializable_association :target
+    serializable_association :subject
+
+    def initialize(params = {})
+      self.subject = params[:subject]
+      self.modifications = params[:modifications]
+    end
+
+    def self.build_with_modifications(subject)
+      return if subject.watched_changes.empty?
+
+      new(:modifications => subject.watched_changes, :subject => subject)
+    end
+
+    def self.created_by(creator)
+      all(:creator_id => creator[Redcrumbs.creator_primary_key]) &
+      all(:creator_type => creator.class.name)
+    end
+
+    def self.targetted_by(target)
+      all(:target_id => target[Redcrumbs.target_primary_key]) &
+      all(:target_type => target.class.name)
+    end
+
+    # Overrides the subject setter created by the SerializableAttributes
+    # module.
+    #
+    def subject=(subject)
+      @subject = subject
+
+      self.stored_subject = subject ? serialize(:subject, subject) : {}
+      self.subject_id = subject ? subject.id : nil
+      assign_type_for(:subject, subject)
+
+      self.target  = subject.target  if subject.respond_to?(:target)
+      self.creator = subject.creator if subject.respond_to?(:creator)
+
+      subject
+    end
+
+    def redis_key
+      "redcrumbs_crumbs:#{id}" if id
+    end
+
+    # Designed to mimic ActiveRecord's count. Probably not performant and only should be used for tests really
+    def self.count
+      Redcrumbs.redis.keys("redcrumbs_crumbs:*").size - 8
+    end
+
+    # Expiry
+
+    def mortal?
+      return false if new?
+
+      time_to_live >= 0
+    end
+    
+    def time_to_live
+      return nil if new?
+
+      @ttl ||= Redcrumbs.redis.ttl(redis_key)
+    end
+
+    def expires_at
+      Time.now + time_to_live if time_to_live
+    end
+    
+    private
+    
+    def set_mortality
+      Redcrumbs.redis.expireat(redis_key, expire_from_now.to_i) if Redcrumbs.mortality
+    end
+
+    def expire_from_now
+      Time.now + Redcrumbs.mortality
+    end
+  end
+end

data/lib/redcrumbs/options.rb

@@ -6,6 +6,8 @@ module Redcrumbs
       # prepare_redcrumbed_options prepares class level options that customise the behaviour of
       # redcrumbed. See documentation for a full explanation of redcrumbed options.
       def prepare_redcrumbed_options(options)
+        options.symbolize_keys!
+
         defaults = {
           :only => [],
           :store => {}
@@ -14,13 +16,16 @@ module Redcrumbs
         options.reverse_merge!(defaults)
         
         options[:only] = Array(options[:only])
-        options[:store] = options[:store]
         
         class_attribute :redcrumbs_options
-        class_attribute :redcrumbs_callback_options
         
         self.redcrumbs_options = options.dup
-        self.redcrumbs_callback_options = options.dup.select {|k,v| [:if, :unless].include?(k.to_sym)}
+
+        options
+      end
+
+      def redcrumbs_callback_options
+        redcrumbs_options.slice(:if, :unless)
       end
     end
   end