subscribable 0.0.2 → 0.0.3

data/lib/generators/subscribable/templates/sub_relation_migration.rb

@@ -3,7 +3,6 @@ class CreateSubRelation < ActiveRecord::Migration
     create_table :sub_relations do |t|
       t.references :subscription, polymorphic: true
       t.references :subscriber, polymorphic: true
-      t.string     :status
       t.timestamps
     end
 

data/lib/subscribable/relation_assigner.rb

@@ -16,6 +16,14 @@ module Subscribable
       end
     end
 
+    def subscribers_from(*args)
+      subscribers.where(subscriber_type: args)
+    end
+
+    def subscriptions_to(*args)
+      subscriptions.where(subscription_type: args)
+    end
+
     def subscribe_to!(actor)
       sub = subscriptions.new
       sub.subscription = actor
@@ -27,66 +35,12 @@ module Subscribable
       subscription.delete
     end
 
-    def subscription_status_with(actor)
-      subscription = subscription_with(actor)
-      subscription.nil? ? 'no relationship' : subscription.status
-    end
-
-    def update_subscription_status!(actor, status)
-      subscription = subscription_with(actor)
-      subscription.status = status
-      subscription.save
-    end
-
     def subscribed_to?(actor)
       query = actor.subscribers.where(subscriber_id: id, subscriber_type: self.class.name)
       query.empty? ? false : true
     end
 
-    def respond_to?(method_name, include_all=false)
-      class_name = klass_name(method_name)
-      method_name.to_s.match('_subscri') ? class_name.constantize.respond_to?(:subscribable?) : super
-    end
-
-    def method_missing(method_name, *args, &block)
-      class_name = klass_name(method_name)
-      case method_name.to_s
-      when /_subscribers/
-        subscribers_query(method_name, class_name)
-      when /_subscriptions/
-        subscriptions_query(method_name, class_name)
-      else
-        super
-      end
-    end
-
     private
-    def klass_name(value)
-      value = value.to_s.split('_')
-      value.pop
-      value.map{|name| name.capitalize}.join
-    end
-
-    def subscriptions_query(method_name, class_name)
-      self.class.send(:define_method, method_name) do
-        Subscribable::SubRelation.where(
-          subscriber_id:      self.id,
-          subscriber_type:    self.class.name,
-          subscription_type:  class_name )
-      end
-      self.send(method_name)
-    end
-
-    def subscribers_query(method_name, class_name)
-      self.class.send(:define_method, method_name) do
-        Subscribable::SubRelation.where(
-          subscription_type:  self.class.name,
-          subscription_id:    self.id,
-          subscriber_type:    class_name )
-      end
-      self.send(method_name)
-    end
-
     def subscription_with(actor)
       subscriptions.where(subscription_id: actor.id, subscription_type: actor.class.name).first
     end

data/lib/subscribable/version.rb

@@ -1,3 +1,3 @@
 module Subscribable
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/fake_models/{actor.rb → group.rb}

@@ -1,7 +1,7 @@
 require 'active_record'
 require 'subscribable'
 
-class Actor < ActiveRecord::Base
+class Group < ActiveRecord::Base
   include Subscribable::RelationAssigner
   subscribable
 end

data/spec/fake_models/user.rb

@@ -0,0 +1,7 @@
+require 'active_record'
+require 'subscribable'
+
+class User < ActiveRecord::Base
+  include Subscribable::RelationAssigner
+  subscribable
+end

data/spec/relationship_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe 'User - Group Relationship' do
+  let(:user) { User.create(name: 'Marius') }
+  let(:group) { Group.create(name: 'Calculus') }
+
+  it 'group is subscribable' do
+    expect( Group.subscribable? ).to be_true
+  end
+
+  it 'user is subscribable' do
+    expect( User.subscribable? ).to be_true
+  end
+
+  it 'user can subscribe to another user' do
+    user.subscribe_to!(user)
+    expect(user.subscribers.size).to eq(1)
+  end
+
+  it 'group can subscribe to another group' do
+    group.subscribe_to!(group)
+    expect(group.subscribers.size).to eq(1)
+  end
+
+  context 'uniqueness' do
+    it 'allows saving subscribable' do
+      sub = user.subscriptions.new
+      sub.subscriber = group
+      expect{ sub.save}.to_not raise_error
+    end
+
+    it 'does not allow to save duplicate subscribable' do
+      sub = user.subscriptions.new
+      sub.subscription = group
+      sub.save
+
+      sub2 = user.subscriptions.new
+      sub2.subscription = group
+      expect{ sub2.save }.to raise_error(ActiveRecord::RecordNotUnique)
+    end
+  end
+
+  context 'subscribed_to?' do
+    it 'returns true if user is subscribed to group' do
+      sub = user.subscriptions.new
+      sub.subscription = group
+      sub.save
+      expect(user.subscribed_to?(group)).to be_true
+    end
+
+    it 'returns false if user is not subscribed to group' do
+      expect(user.subscribed_to?(group)).to be_false
+    end
+  end
+
+  it 'can delete a subscription to a group' do
+    user.subscribe_to!(group)
+    user.delete_subscription_to!(group)
+    expect(user.subscribed_to?(group)).to be_false
+  end
+
+  context 'subscribers' do
+    it 'can search by type' do
+      group.subscribe_to!(user)
+      user.subscribe_to!(user)
+      expect(user.subscribers_from('Group').size).to eq(1)
+    end
+
+    it 'can search by many types' do
+      group.subscribe_to!(user)
+      user.subscribe_to!(user)
+      expect(user.subscribers_from('User', 'Group').size).to eq(2)
+    end
+  end
+
+  context 'subscriptions' do
+    it 'can search by type' do
+      user.subscribe_to!(group)
+      user.subscribe_to!(user)
+      expect(user.subscriptions_to('Group').size).to eq(1)
+    end
+    it 'can search by many type' do
+      user.subscribe_to!(group)
+      user.subscribe_to!(user)
+      expect(user.subscriptions_to('Group', 'User').size).to eq(2)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,8 @@
 require 'rubygems'
 require 'bundler/setup'
 require 'active_record'
+require 'fake_models/user'
+require 'fake_models/group'
 
 RSpec.configure do |config|
 end
@@ -10,16 +12,19 @@ ActiveRecord::Base.establish_connection(
   :database => ":memory:"
 )
 
-class CreateActors < ActiveRecord::Migration
+class CreateModels < ActiveRecord::Migration
   def self.up
-    create_table :actors do |t|
+    create_table :users do |t|
+      t.string :name
+    end
+
+    create_table :groups do |t|
       t.string :name
     end
 
     create_table :sub_relations do |t|
       t.references :subscription, polymorphic: true
       t.references :subscriber, polymorphic: true
-      t.string     :status
       t.timestamps
     end
 
@@ -30,4 +35,4 @@ class CreateActors < ActiveRecord::Migration
   end
 end
 
-catch_output = CreateActors.up
+catch_output = CreateModels.up

data/subscribable.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["marius@mlpinit.com"]
   spec.description   = %q{ Groups, Users, or other models can subscribe to each other.}
   spec.summary       = %q{ A way models can subscribe to each other.}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/mlpinit/subscribable"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: subscribable
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-15 00:00:00.000000000 Z
+date: 2013-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -78,12 +78,12 @@ files:
 - lib/subscribable/relation_assigner.rb
 - lib/subscribable/sub_relation.rb
 - lib/subscribable/version.rb
-- spec/actor_spec.rb
-- spec/fake_models/actor.rb
-- spec/relation_assigner_spec.rb
+- spec/fake_models/group.rb
+- spec/fake_models/user.rb
+- spec/relationship_spec.rb
 - spec/spec_helper.rb
 - subscribable.gemspec
-homepage: ''
+homepage: https://github.com/mlpinit/subscribable
 licenses:
 - MIT
 post_install_message: 
@@ -109,8 +109,8 @@ signing_key:
 specification_version: 3
 summary: A way models can subscribe to each other.
 test_files:
-- spec/actor_spec.rb
-- spec/fake_models/actor.rb
-- spec/relation_assigner_spec.rb
+- spec/fake_models/group.rb
+- spec/fake_models/user.rb
+- spec/relationship_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/spec/actor_spec.rb

@@ -1,108 +0,0 @@
-require 'spec_helper'
-require 'fake_models/actor'
-
-describe 'Actor' do
-  let(:actor) { Actor.create!(name: 'George') }
-  let(:star) { Actor.create!(name: 'Mike') }
-
-  it 'responds to actor_subscribers' do
-    expect( actor.respond_to?(:actor_subscribers) ).to be_true
-  end
-
-  it 'responds to actor_subscriptions' do
-    expect( actor.respond_to?(:actor_subscriptions) ).to be_true
-  end
-
-  it 'can call actor_subscribers' do
-    expect( actor.actor_subscribers ).to eq([])
-  end
-
-  it 'can call actor_subscriptions' do
-    expect( actor.actor_subscriptions ).to eq([])
-  end
-
-  it 'has subscriptions' do
-    expect{ actor.subscriptions }.to_not raise_error(NoMethodError)
-  end
-
-  it 'has subscribers' do
-    expect{ actor.subscribers }.to_not raise_error(NoMethodError)
-  end
-
-  it 'is subscribable' do
-    expect( Actor.subscribable? ).to be_true
-  end
-
-  it 'subscribe(actor) subscribes to an actor' do
-    star.subscribe_to!(actor)
-    expect(actor.subscribers.size).to eq(1)
-  end
-
-  context 'existance of relationship' do
-    it 'subscribed_to?(actor) returns true' do
-      sub = star.subscriptions.new
-      sub.subscription = actor
-      sub.save
-      expect(star.subscribed_to?(actor)).to be_true
-    end
-
-    it 'subscribed_to?(actor) returns false' do
-      expect(star.subscribed_to?(actor)).to be_false
-    end
- end
-
-  context 'without sub_relations' do
-    it 'can query subscribers from subscribable models' do
-      expect( actor.actor_subscribers ).to eq([])
-    end
-
-    it 'can query subscriptions from subscribable models' do
-      expect( actor.actor_subscriptions ).to eq([])
-    end
-  end
-
-  context 'with sub_relations' do
-    before do
-      sub = actor.subscriptions.new
-      sub.subscription = star
-      sub.save
-    end
-    it 'can query subscriptions from subscribable models' do
-      expect( actor.actor_subscriptions.size ).to eq(1)
-    end
-
-    it 'can query subscribers from subscribable models' do
-      expect( star.actor_subscribers.size ).to eq(1)
-    end
-  end
-
-  context 'relationship status' do
-    it 'has no relationship' do
-      expect( star.subscription_status_with(actor) ).to eq('no relationship')
-    end
-
-    it 'has friendship relationship' do
-      sub = star.subscriptions.new
-      sub.subscription = actor
-      sub.status = 'friendship'
-      sub.save
-      expect( star.subscription_status_with(actor) ).to eq('friendship')
-    end
-  end
-
-  it 'updates subscription status' do
-    sub = star.subscriptions.new
-    sub.subscription = actor
-    sub.status = 'pending'
-    sub.save
-    star.update_subscription_status!(actor, 'friendship')
-    sub = star.subscriptions.where(subscription_id: actor.id, subscription_type: actor.class.name).first
-    expect(sub.status).to eq('friendship')
-  end
-
-  it 'delete subscription to actor' do
-    star.subscribe_to!(actor)
-    star.delete_subscription_to!(actor)
-    expect(star.subscribed_to?(actor)).to be_false
-  end
-end

data/spec/relation_assigner_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'fake_models/actor'
-
-describe 'Relation Assigner' do
-
-  let(:actor) { Actor.create(name: 'Marius') }
-  let(:actor2) { Actor.create(name: 'Quad') }
-
-  it 'allows saving subscribable models' do
-    sub = actor.subscriptions.new
-    sub.subscriber = actor2
-    expect{ sub.save}.to_not raise_error
-  end
-
-  it 'allows saving unique subscribable models only' do
-    sub = actor.subscriptions.new
-    sub.subscription = actor2
-    sub.save
-
-    sub2 = actor.subscriptions.new
-    sub2.subscription = actor2
-    expect{ sub2.save }.to raise_error(ActiveRecord::RecordNotUnique)
-  end
-end