redcrumbs 0.5.0 → 0.5.1

data/lib/redcrumbs/serializable_association.rb

@@ -0,0 +1,193 @@
+require 'dm-core'
+require 'dm-types'
+
+module Redcrumbs
+  module SerializableAssociation
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        include DataMapper::Resource unless self < DataMapper::Resource
+      end
+    end
+
+    module ClassMethods
+      def serializable_association(name)
+        raise ArgumentError unless name and [:creator, :target, :subject].include?(name)
+
+        property "stored_#{name}".to_sym, DataMapper::Property::Json, :lazy => false
+        property "#{name}_id".to_sym, DataMapper::Property::Integer, :index => true, :lazy => false
+        property "#{name}_type".to_sym, DataMapper::Property::String, :index => true, :lazy => false
+
+        define_setter_for(name)
+        define_getter_for(name)
+        define_loader_for(name)
+        define_load_state_getter(name)
+
+        self
+      end
+
+      private
+
+      # Define a setter, e.g. object.creator=
+      #
+      def define_setter_for(name)
+        define_method("#{name}=") do |associated|
+          instance_variable_set("@#{name}".to_sym, associated)
+
+          assign_id_for(name, associated)
+          assign_type_for(name, associated)
+          assign_serialized_attributes(name, associated)
+        end
+      end
+
+
+      # Define a getter, e.g. object.creator
+      #
+      def define_getter_for(name)
+        define_method("#{name}") do
+          instance_variable_get("@#{name}") or
+          instance_variable_set("@#{name}", deserialize(name)) or
+          instance_variable_set("@#{name}", load_associated(name))
+        end
+      end
+
+
+      # Define method to force a load of the association from
+      # the database or return it if already loaded.
+      #
+      def define_loader_for(name)
+        define_method("full_#{name}") do
+          if send("has_loaded_#{name}?")
+            instance_variable_get("@#{name}")
+          else
+            instance_variable_set("@#{name}_load_state", true)
+            instance_variable_set("@#{name}", load_associated(name))
+          end
+        end
+      end
+
+
+      # Define method to check if association has been fully loaded
+      # from the database.
+      #
+      def define_load_state_getter(name)
+        instance_variable_set("@#{name}_load_state", false)
+
+        define_method("has_loaded_#{name}?") do
+          instance_variable_get("@#{name}_load_state")
+        end
+      end
+    end
+
+
+    # Load the association from the database.
+    #
+    def load_associated(name)
+      return nil unless association_id = send("#{name}_id")
+
+      class_name = send("#{name}_type") || config_class_name_for(name)
+      klass = class_name.classify.constantize
+
+      primary_key = config_primary_key_for(name) || klass.primary_key
+
+      klass.where(primary_key => association_id).first
+    end
+
+    private
+
+    # Assign the association id based on default primary key
+    #
+    def assign_id_for(name, associated)
+      id = if associated
+        primary_key = config_primary_key_for(name) or associated.class.primary_key
+        associated[primary_key]
+      end
+
+      send("#{name}_id=", id)
+    end
+
+
+    # Assign the association type based on default primary key
+    #
+    def assign_type_for(name, associated)
+      type = associated ? associated.class.name : nil
+
+      send("#{name}_type=", type)
+    end
+
+
+    # Serialize and assign the association
+    #
+    def assign_serialized_attributes(name, associated)
+      serialized = associated ? serialize(name, associated) : {}
+
+      send("stored_#{name}=", serialized)
+    end
+
+
+    # Get the class name from the config options, e.g.
+    # Redcrumbs.creator_class_sym
+    #
+    def config_class_name_for(name)
+      Redcrumbs.send("#{name}_class_sym").to_s
+    end
+
+
+    # Get the expected primary key for the association from
+    # the config options.
+    #
+    def config_primary_key_for(name)
+      Redcrumbs.send("#{name}_primary_key")
+    rescue NoMethodError
+      nil
+    end
+
+    # Serializes a given object by looking for its configuration options
+    # or calling serialization method.
+    #
+    def serialize(name, associated)
+      if name == :subject
+        associated.serialized_as_redcrumbs_subject
+      else
+        keys = Redcrumbs.send("store_#{name}_attributes").dup
+
+        associated.attributes.select {|k,v| keys.include?(k.to_sym)}
+      end
+    end
+
+
+    # Returns a new instance of the associated object based on the
+    # serialized attributes only.
+    #
+    def deserialize(name)
+      properties = send("stored_#{name}")
+      associated_id = send("#{name}_id")
+
+      return nil unless properties.present? and associated_id
+
+      class_name = send("#{name}_type")
+      class_name ||= config_class_name_for(name) unless name == :subject
+
+      instantiate_with_id(class_name, properties, associated_id)
+    end
+    
+
+    # Return a properties hash that corresponds to the given class's
+    # column names.
+    #
+    def clean_properties(klass, properties)
+      properties.select {|k,v| klass.column_names.include?(k.to_s)}
+    end
+
+
+    def instantiate_with_id(class_name, properties, associated_id)
+      klass = class_name.classify.constantize
+      properties = clean_properties(klass, properties)
+
+      associated = klass.new(properties, :without_protection => true)
+      associated.id = associated_id
+      associated
+    end
+  end
+end

data/lib/redcrumbs/users.rb

@@ -1,45 +1,35 @@
 module Redcrumbs
 # Provides methods for giving user context to crumbs. Retrieves crumbs created by a user (creator) or
 # affecting a user (target)
- module Users
+  module Users
     extend ActiveSupport::Concern
-    
-    module InstanceMethods
-      # Retrieves crumbs related to the user
-      def crumbs_for
-        crumb_or_custom_class.all(:target_id => self[Redcrumbs.target_primary_key], :order => [:created_at.desc])
-      end
 
-      # Retrieves crumbs created by the user
-      def crumbs_by
-        crumb_or_custom_class.all(:creator_id => self[Redcrumbs.creator_primary_key], :order => [:created_at.desc])
-      end
-      
-      # A limitable collection of both crumbs_for and crumbs_by
-      # This is an unforunate hack to get over the redis dm adapter's non-support of addition (OR) queries
-      def crumbs_as_user(opts = {})
-        opts[:limit] ||= 100
-        arr = crumbs_for 
-        arr += crumbs_by
-        arr.all(opts)
-      end
-      
-      # Creator method defines who should be considered the creator when a model is updated. This
-      # can be overridden in the redcrumbed model to define who the creator should be. Defaults
-      # to the current user (or creator class) associated with the model.
-      def creator
-        send(Redcrumbs.creator_class_sym) if respond_to?(Redcrumbs.creator_class_sym)
-      end
-      
-      private
-      
-      def crumb_or_custom_class
-         if self.class.redcrumbs_options[:class_name]
-           self.class.redcrumbs_options[:class_name].to_s.capitalize.constantize
-         else
-           Crumb
-         end
-      end
+    # Retrieves crumbs related to the user
+    #
+    def crumbs_for(opts = {})
+      klass = Redcrumbs.crumb_class
+
+      klass.targetted_by(self).all(opts)
+    end
+
+    # Retrieves crumbs created by the user
+    #
+    def crumbs_by(opts = {})
+      klass = Redcrumbs.crumb_class
+
+      klass.created_by(self).all(opts)
+    end
+
+    # Or queries don't seem to be working with dm-redis-adapter. This
+    # is a temporary workaround.
+    #
+    def crumbs_as_user(opts = {})
+      opts[:limit] ||= 100
+
+      arr = crumbs_by.to_a + crumbs_for.to_a
+      arr.uniq!
+
+      arr.sort_by! {|c| [c.created_at, c.id]}.reverse
     end
   end
 end

data/lib/redcrumbs/version.rb

@@ -1,3 +1,3 @@
 module Redcrumbs
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/redcrumbs.gemspec

@@ -6,20 +6,22 @@ Gem::Specification.new do |s|
   s.name        = "redcrumbs"
   s.version     = Redcrumbs::VERSION
   s.authors     = ["John Hope"]
-  s.email       = ["info@midhirrecords.com"]
-  s.homepage    = "https://github.com/projectzebra/Redcrumbs"
+  s.email       = ["john@shiftdock.com"]
+  s.homepage    = "https://github.com/JonMidhir/Redcrumbs"
   s.summary     = %q{Fast and unobtrusive activity tracking of ActiveRecord models using DataMapper and Redis}
   s.description = %q{Fast and unobtrusive activity tracking of ActiveRecord models using DataMapper and Redis}
+  s.license     = 'MIT'
 
   s.rubyforge_project = "redcrumbs"
+  
+  s.add_dependency 'data_mapper', '>= 1.2.0'
+  s.add_dependency 'redis', '>= 2.2.2'
+  s.add_dependency 'dm-redis-adapter', '>= 0.6.2'
+  s.add_dependency 'redis-namespace', '>= 1.3.0'
+  s.add_dependency 'activerecord', '>= 3.1', '< 5'
+  s.add_dependency 'activesupport', '>= 3.1', '< 5'
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(/^spec/)
   s.require_paths = ["lib"]
-  
-  s.add_dependency 'data_mapper', '>= 1.2.0'
-  s.add_dependency 'dm-redis-adapter', '~> 0.6.2'
-  s.add_dependency 'redis', '~> 2.2.2'
-  s.add_dependency 'redis-namespace', '>= 1.1.0'
 end

data/spec/redcrumbs/config_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Redcrumbs do
+  describe '.creator_class_sym' do
+    subject { Redcrumbs.creator_class_sym }
+
+    context 'when unchanged' do
+      it { is_expected.to eq(:user) }
+    end
+
+    context 'when changed to :game' do
+      before { Redcrumbs.creator_class_sym = :game }
+      after  { Redcrumbs.creator_class_sym = :user }
+
+      it { is_expected.to eq(:game)}
+    end
+  end
+
+
+  describe '.creator_primary_key' do
+    subject { Redcrumbs.creator_primary_key }
+
+    context 'when unchanged' do
+      it { is_expected.to eq('id') }
+    end
+
+    context 'when changed to :name' do
+      before { Redcrumbs.creator_primary_key = :name }
+      after  { Redcrumbs.creator_primary_key = :id }
+
+      it { is_expected.to eq(:name)}
+    end
+  end
+
+
+  describe '.target_class_sym' do
+    subject { Redcrumbs.target_class_sym }
+
+    context 'when unchanged' do
+      it { is_expected.to eq(:user) }
+    end
+
+    context 'when changed to :game' do
+      before { Redcrumbs.target_class_sym = :game }
+      after  { Redcrumbs.target_class_sym = :user }
+
+      it { is_expected.to eq(:game)}
+    end
+  end
+
+
+  describe '.target_primary_key' do
+    subject { Redcrumbs.target_primary_key }
+
+    context 'when unchanged' do
+      it { is_expected.to eq('id') }
+    end
+
+    context 'when changed to :name' do
+      before { Redcrumbs.target_primary_key = :name }
+      after  { Redcrumbs.target_primary_key = :id }
+
+      it { is_expected.to eq(:name)}
+    end
+  end
+
+
+  describe '.store_creator_attributes' do
+    subject { Redcrumbs.store_creator_attributes }
+
+    context 'when unchanged' do
+      it { is_expected.to eq([]) }
+    end
+
+    context 'when given attribute keys' do
+      before { Redcrumbs.store_creator_attributes = [:id, :name] }
+      after  { Redcrumbs.store_creator_attributes = [] }
+
+      it { is_expected.to eq([:id, :name])}
+    end
+  end
+
+
+  describe '.store_target_attributes' do
+    subject { Redcrumbs.store_target_attributes }
+
+    context 'when unchanged' do
+      it { is_expected.to eq([]) }
+    end
+
+    context 'when given attribute keys' do
+      before { Redcrumbs.store_target_attributes = [:id, :name] }
+      after  { Redcrumbs.store_target_attributes = [] }
+
+      it { is_expected.to eq([:id, :name])}
+    end
+  end
+
+
+  describe '.redis' do
+    let!(:default_redis) { Redcrumbs.redis }
+    subject { Redcrumbs.redis }
+
+    context 'when given a URL string with port and scheme' do
+      before { Redcrumbs.redis = 'redis://localhost:6379' }
+      after { Redcrumbs.redis = default_redis }
+
+      it { expect(subject.namespace).to eq(:redcrumbs) }
+      it { expect(subject.client.host).to eq('localhost') }
+      it { expect(subject.client.port).to eq(6379) }
+    end
+
+    context 'when given a URL string without scheme' do
+      before { Redcrumbs.redis = 'localhost:6379' }
+      after { Redcrumbs.redis = default_redis }
+
+      it { expect(subject.namespace).to eq(:redcrumbs) }
+      it { expect(subject.client.host).to eq('localhost') }
+      it { expect(subject.client.port).to eq(6379) }
+    end
+
+    context 'when given a URL string with namespace' do
+      before { Redcrumbs.redis = 'localhost:6379/some_namespace' }
+      after { Redcrumbs.redis = default_redis }
+
+      it { expect(subject.namespace).to eq('some_namespace') }
+    end
+
+    context 'when given an existing redis client' do
+      let(:redis) { Redis.new }
+      before { Redcrumbs.redis = redis }
+      after { Redcrumbs.redis = default_redis }
+
+      it { expect(subject.redis).to eq(redis) }
+    end
+
+    context 'when given an existing redis namespace' do
+      let(:redis) { Redis::Namespace.new('some_namespace') }
+      before { Redcrumbs.redis = redis }
+      after { Redcrumbs.redis = default_redis }
+
+      it { is_expected.to eq(redis) }
+    end
+  end
+
+
+  describe '.crumb_class' do
+    subject { Redcrumbs.crumb_class }
+
+    context 'when class_name unchanged' do
+      it { is_expected.to be(Redcrumbs::Crumb) }
+    end
+
+    context 'when class_name set to unknown class' do
+      before { Redcrumbs.class_name = :foo }
+      after  { Redcrumbs.class_name = nil }
+
+      it { is_expected.to be(Redcrumbs::Crumb) }
+    end
+
+    context 'when class doesnt inherit from Crumb' do
+      before { Redcrumbs.class_name = :game }
+      after  { Redcrumbs.class_name = nil }
+
+      it { expect { subject }.to raise_error(ArgumentError) }
+    end
+  end
+end