acts_in_relation 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92a9c127a3f1fb388603b635643e90c4069639bf
-  data.tar.gz: 67a69244746409b35ada1c5a6e0aed846753f660
+  metadata.gz: 98631806c248ec6a232438391598ca3c3b6d1429
+  data.tar.gz: 15a8894cde8f8da9d753d647be4220c4c373d0f6
 SHA512:
-  metadata.gz: 4d42116922125188f848c9a50abc955bffc5840381b9686f35bd4701ce3bbc1144e2e50f2117d8d69fdfbd9928807fcbfda13282a46523d2f719fe36cc12d96c
-  data.tar.gz: 1c31f8d090a83f85241becd3878518ed4bd645b8764c78cac3170f90417937c15be2fd6e1804914d4fd4ceb248c8914d876ee01df969327d219143937ec4cd63
+  metadata.gz: cab9fb68c574f05868c3abc17c5cd26638ab901041f6008cc8996e231398bc8087d3002201ead3e2f9ba60cbfd98e9d87e4ab6b965ec040c523233f97f8cf297
+  data.tar.gz: 2b754e9fb4eacba5be95acbdb2dc7eff4adf15220ab32afd96bd87008b90ba4110356b404db0564727cc30d5c5611d359ea722bd992bd2991dff94b76c0f9ce3

data/.gitignore

@@ -0,0 +1,9 @@
+.bundle/
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/db/*.sqlite3-journal
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.sass-cache
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,151 @@
+# acts_in_relation
+
+[![Build Status](https://travis-ci.org/kami30k/acts_in_relation.svg)](https://travis-ci.org/kami30k/acts_in_relation)
+[![Gem Version](https://badge.fury.io/rb/acts_in_relation.svg)](http://badge.fury.io/rb/acts_in_relation)
+
+acts_in_relation adds relational feature to Rails application, such as follow, block, like and so on.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'acts_in_relation'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Usage
+
+acts_in_relation supports two way to add relational feature.
+
+1. Add feature to oneself
+2. Add feature to between two models
+
+Following example shows about User model, however, you can apply to any models.
+
+### 1. Add follow feature to User
+
+This case adds follow feature to User model.
+
+At first, generate User and Follow model:
+
+```
+$ bin/rails g model User
+$ bin/rails g model Follow user_id:integer target_user_id:integer
+```
+
+Then migrate:
+
+```
+$ bin/rake db:migrate
+```
+
+At last, add `acts_in_relation` method to each models:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_in_relation role: :self, action: :follow
+end
+
+class Follow < ActiveRecord::Base
+  acts_in_relation role: :action, self: :user
+end
+```
+
+That's it.
+User instance has been added following methods:
+
+- user.follow(other_user)
+- user.unfollow(other_user)
+- user.following?(other_user)
+- user.following
+- other_user.followed_by?(user)
+- other_user.followers
+
+Example:
+
+```ruby
+user       = User.create
+other_user = User.create
+
+# Follow
+user.follow other_user
+user.following?(other_user)   #=> true
+user.following                #=> <ActiveRecord::Associations::CollectionProxy [#<User id: 2, created_at: "2015-01-10 01:57:52", updated_at: "2015-01-10 01:57:52">]>
+other_user.followed_by?(user) #=> true
+other_user.followers          #=> <ActiveRecord::Associations::CollectionProxy [#<User id: 1, created_at: "2015-01-10 01:57:42", updated_at: "2015-01-10 01:57:42">]>
+
+# Unfollow
+user.unfollow other_user
+user.following?(other_user)   #=> false
+user.following                #=> <ActiveRecord::Associations::CollectionProxy []>
+other_user.followed_by?(user) #=> false
+other_user.followers          #=> <ActiveRecord::Associations::CollectionProxy []>
+```
+
+At the same time, `:action` is able to be passed some actions:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_in_relation role: :self, action: [:follow, :block, :mute]
+end
+```
+
+### 2. Add like feature to User and Post
+
+This case adds like feature to User and Post model.
+
+```ruby
+class User < ActiveRecord::Base
+  acts_in_relation role: :source, target: :post, action: :like
+end
+
+class Post < ActiveRecord::Base
+  acts_in_relation role: :target, source: :user, action: :like
+end
+
+class Like < ActiveRecord::Base
+  acts_in_relation role: :action, source: :user, target: :post
+end
+```
+
+User and Post instance has been added following methods:
+
+- user.like(post)
+- user.unlike(post)
+- user.liking?(post)
+- user.liking
+- post.liked_by?(user)
+- post.likers
+
+At the same time, some `acts_in_relation` methods are able to be defined:
+
+```ruby
+class User < ActiveRecord::Base
+  acts_in_relation role: :self, action: :follow
+  acts_in_relation role: :source, target: :post, action: :like
+end
+```
+
+## Roles
+
+acts_in_relation has three roles: source, target and action.
+
+| Role | Outline | (1) | (2) |
+| --- | --- | --- | --- |
+| source | The model that performs the action. | User | User |
+| target | The model that receives the action. | User | Post |
+| action | The action performs between two models. | Follow | Like |
+
+## Contributing
+
+1. Fork it ( https://github.com/kami30k/acts_in_relation/fork )
+2. Create your feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push to the branch (git push origin my-new-feature)
+5. Create a new Pull Request

data/Rakefile

@@ -1,21 +1,7 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
-
-require 'rdoc/task'
+require 'bundler'
+require 'rspec/core/rake_task'
 
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'ActsInRelation'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+Bundler::GemHelper.install_tasks
 
-require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 task default: :spec
-
-Bundler::GemHelper.install_tasks

data/acts_in_relation.gemspec

@@ -0,0 +1,24 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+
+require 'acts_in_relation/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'acts_in_relation'
+  s.version     = ActsInRelation::VERSION
+  s.authors     = 'kami'
+  s.email       = 'kami30k@gmail.com'
+
+  s.summary     = 'Add relational feature to Rails (e.g. follow, block and like).'
+  s.description = 'Add relational feature to Rails (e.g. follow, block and like).'
+  s.homepage    = 'https://github.com/kami30k/acts_in_relation'
+  s.license     = 'MIT'
+
+  s.files = `git ls-files -z`.split("\x0")
+
+  s.add_dependency 'rails'
+  s.add_dependency 'verbs'
+  s.add_dependency 'caller_class'
+
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'rspec-rails'
+end

data/lib/acts_in_relation.rb

@@ -1,14 +1,29 @@
 require 'acts_in_relation/version'
+require 'acts_in_relation/railtie' if defined?(Rails)
 
 module ActsInRelation
-  autoload :Core,   'acts_in_relation/core'
-  autoload :Source, 'acts_in_relation/source'
-  autoload :Target, 'acts_in_relation/target'
-  autoload :Action, 'acts_in_relation/action'
+  class MissingRoleError < StandardError; end
+
+  class UnknownRoleError < StandardError
+    def initialize(role)
+      @role = role
+    end
+
+    def to_s
+      ":role should be one of :source, :target, :action or :self (#{@role} is passed)"
+    end
+  end
+
+  autoload :Core, 'acts_in_relation/core'
+
+  module Roles
+    autoload :Base,   'acts_in_relation/roles/base'
+    autoload :Source, 'acts_in_relation/roles/source'
+    autoload :Target, 'acts_in_relation/roles/target'
+    autoload :Action, 'acts_in_relation/roles/action'
+  end
 
   module Supports
     autoload :Verb, 'acts_in_relation/supports/verb'
   end
-
-  require 'acts_in_relation/railtie' if defined?(Rails)
 end

data/lib/acts_in_relation/core.rb

@@ -1,54 +1,73 @@
-require 'caller_class'
-
 module ActsInRelation
   module Core
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      include CallerClass
-
-      def acts_in_relation(position = :self, params)
-        relation = Relation.new(position, params, caller_class.downcase)
-        relation.define
+    class << self
+      def included(base)
+        base.extend ClassMethods
       end
     end
 
-    class Relation
-      def initialize(position, params, class_name)
-        @position   = position
-        @params     = params
-        @class_name = class_name
-      end
+    module ClassMethods
+      # DSL called to a subclass of ActiveRecord::Base
+      #
+      # @param [Hash] args Define relation with :role, :action, :source, :target or :self.
+      #
+      # @example Define self relation
+      #   class User < ActiveRecord::Base
+      #     acts_in_relation role: :self, action: [:follow, :block]
+      #   end
+      #
+      #   class Follow < ActiveRecord::Base
+      #     acts_in_relation role: :action, self: :user
+      #   end
+      #
+      #   class Block < ActiveRecord::Base
+      #     acts_in_relation role: :action, self: :user
+      #   end
+      #
+      # @example Define relation of each models
+      #   class User < ActiveRecord::Base
+      #     acts_in_relation role: :source, target: :post, action: :like
+      #   end
+      #
+      #   class Post < ActiveRecord::Base
+      #     acts_in_relation role: :target, source: :user, action: :like
+      #   end
+      #
+      #   class Like < ActiveRecord::Base
+      #     acts_in_relation role: :action, source: :user, target: :post
+      #   end
+      def acts_in_relation(**args)
+        @args = args
 
-      def define
-        positions = (@position == :self) ? [:source, :target] : [@position]
-        positions.each do |position|
-          extend "ActsInRelation::#{position.capitalize}".constantize
-          define
+        case @args[:role]
+        when nil
+          raise ActsInRelation::MissingRoleError
+        when :source
+          define_source
+        when :target
+          define_target
+        when :action
+          define_action
+        when :self
+          define_source
+          define_target
+        else
+          raise ActsInRelation::UnknownRoleError, @args[:role]
         end
       end
 
       private
 
-      def source
-        @source ||= @params[:source] || @class_name
-      end
-
-      def target
-        @target ||= @params[:target] || @class_name
+      def define_source
+        ActsInRelation::Roles::Source.new(@args).define
       end
 
-      # TODO: Return instance if exists
-      def with
-        with = @params[:with]
-        with = with.kind_of?(Array) ? with : [with]
-        with.map(&:to_s)
+      def define_target
+        ActsInRelation::Roles::Target.new(@args).define
       end
 
-      def class_object
-        @class_object ||= @class_name.to_s.capitalize.constantize
+      def define_action
+        ActsInRelation::Roles::Action.new(@args).define
       end
     end
   end

data/lib/acts_in_relation/railtie.rb

@@ -1,8 +1,6 @@
-require 'rails'
-
 module ActsInRelation
   class Railtie < Rails::Railtie
-    initializer 'acts_in_relation' do |app|
+    initializer 'acts_in_relation' do
       ActiveSupport.on_load :active_record do
         include ActsInRelation::Core
       end

data/lib/acts_in_relation/roles/action.rb

@@ -0,0 +1,15 @@
+module ActsInRelation
+  module Roles
+    class Action < Base
+      def define
+        @class.class_eval <<-RUBY
+          belongs_to :"#{source}"
+
+          belongs_to :"target_#{target}",
+            class_name: "#{target.capitalize}",
+            foreign_key: :"target_#{target}_id"
+        RUBY
+      end
+    end
+  end
+end

data/lib/acts_in_relation/roles/base.rb

@@ -0,0 +1,46 @@
+require 'caller_class'
+
+module ActsInRelation
+  module Roles
+    class Base
+      include CallerClass
+      include ActsInRelation::Supports::Verb
+
+      def initialize(args)
+        @class = caller_class.constantize
+        @args = recursive_to_s(args)
+      end
+
+      def source
+        @source ||= @args[:source] || @args[:self] || @class.to_s.downcase
+      end
+
+      def target
+        @target ||= @args[:target] || @args[:self] || @class.to_s.downcase
+      end
+
+      def actions
+        @actions ||= [@args[:action]].flatten
+      end
+
+      def define
+        raise NotImplementedError
+      end
+
+      private
+
+      def recursive_to_s(object)
+        case object
+        when Hash
+          object.each do |k, v|
+            object[k] = recursive_to_s(v)
+          end
+        when Array
+          object.map { |o| recursive_to_s(o) }
+        else
+          object.to_s unless object.nil?
+        end
+      end
+    end
+  end
+end

data/lib/acts_in_relation/roles/source.rb

@@ -0,0 +1,35 @@
+module ActsInRelation
+  module Roles
+    class Source < Base
+      def define
+        actions.each do |action|
+          @class.class_eval <<-RUBY
+            has_many :"#{action.pluralize}",
+              foreign_key: :"#{source}_id",
+              dependent: :destroy
+
+            has_many :"#{progressize(action)}",
+              through: :"#{action.pluralize}",
+              source: :"target_#{target}"
+
+            def #{action}(target)
+              return if #{progressize(action)}?(target) || (self == target)
+
+              #{action.pluralize}.create(target_#{target}_id: target.id)
+            end
+
+            def un#{action}(target)
+              return unless #{progressize(action)}?(target)
+
+              #{action.pluralize}.find_by(target_#{target}_id: target.id).destroy
+            end
+
+            def #{progressize(action)}?(target)
+              #{action.pluralize}.exists?(target_#{target}_id: target.id)
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/acts_in_relation/roles/target.rb

@@ -0,0 +1,24 @@
+module ActsInRelation
+  module Roles
+    class Target < Base
+      def define
+        actions.each do |action|
+          @class.class_eval <<-RUBY
+            has_many :"#{action.pluralize}_as_target",
+              foreign_key: :"target_#{target}_id",
+              class_name: action.capitalize,
+              dependent: :destroy
+
+            has_many :"#{peoplize(action)}",
+              through: :"#{action.pluralize}_as_target",
+              source: :"#{source}"
+
+            def #{pastize(action)}_by?(source)
+              source.#{action.pluralize}.exists?(#{source}_id: source.id)
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/acts_in_relation/supports/verb.rb

@@ -7,20 +7,19 @@ module ActsInRelation
         'follow' => 'following'
       }
 
-      def pastize
-        verb.conjugate(tense: :past).split(' ').last
+      def pastize(object)
+        object.verb.conjugate(tense: :past).split(' ').last
       end
 
-      def progressize
-        return PATCHES[self] if PATCHES.has_key?(self)
+      def progressize(object)
+        return PATCHES[object] if PATCHES.has_key?(object)
 
-        verb.conjugate(aspect: :progressive).split(' ').last
+        object.verb.conjugate(aspect: :progressive).split(' ').last
       end
 
-      # TODO: Implement this method more logically
-      def peoplize
-        action = (last == 'e') ? chop : self
-        action + 'ers'
+      # @todo Implement more logically
+      def peoplize(object)
+        (object.last == 'e' ? object.chop : object) + 'ers'
       end
     end
   end

data/lib/acts_in_relation/version.rb

@@ -1,3 +1,3 @@
 module ActsInRelation
-  VERSION = "0.1.1"
+  VERSION = '0.2.0'
 end

data/spec/dummy/application.rb

@@ -0,0 +1,86 @@
+require 'action_controller/railtie'
+require 'active_record'
+
+require 'acts_in_relation'
+
+module Dummy
+  class Application < Rails::Application
+    config.secret_token = 'abcdefghijklmnopqrstuvwxyz0123456789'
+    config.session_store :cookie_store, key: '_dummy_session'
+    config.eager_load = false
+    config.active_support.deprecation = :log
+  end
+end
+
+Dummy::Application.initialize!
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+#
+# Models
+#
+
+class User < ActiveRecord::Base
+  acts_in_relation role: :self, action: [:follow, :block, :mute]
+
+  acts_in_relation role: :source, target: :post, action: :like
+end
+
+class Post < ActiveRecord::Base
+  acts_in_relation role: :target, source: :user, action: :like
+end
+
+class Follow < ActiveRecord::Base
+  acts_in_relation role: :action, self: :user
+end
+
+class Like < ActiveRecord::Base
+  acts_in_relation role: :action, source: :user, target: :post
+end
+
+#
+# Migrates
+#
+
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :users do |t|
+      t.timestamps null: false
+    end
+  end
+end
+
+class CreatePosts < ActiveRecord::Migration
+  def change
+    create_table :posts do |t|
+      t.timestamps null: false
+    end
+  end
+end
+
+class CreateFollows < ActiveRecord::Migration
+  def change
+    create_table :follows do |t|
+      t.integer :user_id
+      t.integer :target_user_id
+
+      t.timestamps null: false
+    end
+  end
+end
+
+class CreateLikes < ActiveRecord::Migration
+  def change
+    create_table :likes do |t|
+      t.integer :user_id
+      t.integer :target_post_id
+
+      t.timestamps null: false
+    end
+  end
+end
+
+CreateUsers.new.change
+CreatePosts.new.change
+CreateFollows.new.change
+CreateLikes.new.change

data/spec/dummy/bin/rails

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+APP_PATH = File.expand_path('../../application', __FILE__)
+
+require 'rails/commands'

data/spec/dummy/config.ru

@@ -0,0 +1 @@
+run Rails.application

data/spec/models/post_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Post, type: :model do
+  let(:user) { User.create }
+  let(:post) { Post.create }
+
+  describe 'instance methods' do
+    it 'should be defined' do
+      # source: :user, action: :like
+      expect(post).not_to respond_to(:like)
+      expect(post).not_to respond_to(:unlike)
+      expect(post).not_to respond_to(:liking?)
+      expect(post).not_to respond_to(:liking)
+      expect(post).to respond_to(:liked_by?)
+      expect(post).to respond_to(:likers)
+    end
+  end
+
+  describe '#liked_by?' do
+    before { user.like post }
+
+    it 'should be liked by user' do
+      expect(post).to be_liked_by(user)
+    end
+  end
+
+  describe '#likers' do
+    before { user.like post }
+
+    it 'should be included user' do
+      expect(post.likers).to be_exists(id: user.id)
+    end
+  end
+end

data/spec/models/user_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe User, type: :model do
+  let(:user)       { User.create }
+  let(:other_user) { User.create }
+
+  describe 'instance methods' do
+    it 'should be defined' do
+      # action: :follow
+      expect(user).to respond_to(:follow)
+      expect(user).to respond_to(:unfollow)
+      expect(user).to respond_to(:following?)
+      expect(user).to respond_to(:following)
+      expect(user).to respond_to(:followed_by?)
+      expect(user).to respond_to(:followers)
+
+      # action: :block
+      expect(user).to respond_to(:block)
+      expect(user).to respond_to(:unblock)
+      expect(user).to respond_to(:blocking?)
+      expect(user).to respond_to(:blocking)
+      expect(user).to respond_to(:blocked_by?)
+      expect(user).to respond_to(:blockers)
+
+      # action: :mute
+      expect(user).to respond_to(:mute)
+      expect(user).to respond_to(:unmute)
+      expect(user).to respond_to(:muting?)
+      expect(user).to respond_to(:muting)
+      expect(user).to respond_to(:muted_by?)
+      expect(user).to respond_to(:muters)
+
+      # target: :post, action: :like
+      expect(user).to respond_to(:like)
+      expect(user).to respond_to(:unlike)
+      expect(user).to respond_to(:liking?)
+      expect(user).to respond_to(:liking)
+      expect(user).not_to respond_to(:liked_by?)
+      expect(user).not_to respond_to(:likers)
+    end
+  end
+
+  describe '#follow' do
+    context 'unfollow user' do
+      before { user.follow other_user }
+
+      it 'should be followed' do
+        expect(user.follows).to be_exists(target_user_id: other_user.id)
+      end
+    end
+
+    context 'following user' do
+      before do
+        user.follow other_user
+        user.follow other_user
+      end
+
+      it 'should be followed only once' do
+        expect(user.follows.count).to eq(1)
+      end
+    end
+
+    context 'user-self' do
+      before { user.follow user }
+
+      it 'should not be followed' do
+        expect(user.follows).not_to be_exists(target_user_id: user.id)
+      end
+    end
+  end
+
+  describe '#unfollow' do
+    context 'following user' do
+      before do
+        user.follow   other_user
+        user.unfollow other_user
+      end
+
+      it 'should be unfollowed' do
+        expect(user.follows).not_to be_exists(target_user_id: other_user.id)
+      end
+    end
+
+    context 'unfollow user' do
+      it 'should not raise error' do
+        expect { user.unfollow other_user }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#following?' do
+    before { user.follow other_user }
+
+    it 'should be followed' do
+      expect(user).to be_following(other_user)
+    end
+  end
+
+  describe '#following' do
+    before { user.follow other_user }
+
+    it 'should be included other user' do
+      expect(user.following).to be_exists(other_user.id)
+    end
+  end
+
+  describe '#followed_by?' do
+    before { other_user.follow user }
+
+    it 'should be followed by other user' do
+      expect(user).to be_followed_by(other_user)
+    end
+  end
+
+  describe '#followers' do
+    before { other_user.follow user }
+
+    it 'should be included other user' do
+      expect(user.followers).to be_exists(other_user.id)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'dummy/application'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: acts_in_relation
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - kami
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-20 00:00:00.000000000 Z
+date: 2015-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: verbs
   requirement: !ruby/object:Gem::Requirement
@@ -80,24 +80,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Rails plugin that adds a relational feature to Model, such as follow,
-  block, mute, or like and so on.
-email:
-- kami30k@gmail.com
+description: Add relational feature to Rails (e.g. follow, block and like).
+email: kami30k@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
 - MIT-LICENSE
+- README.md
 - Rakefile
+- acts_in_relation.gemspec
 - lib/acts_in_relation.rb
-- lib/acts_in_relation/action.rb
 - lib/acts_in_relation/core.rb
 - lib/acts_in_relation/railtie.rb
-- lib/acts_in_relation/source.rb
+- lib/acts_in_relation/roles/action.rb
+- lib/acts_in_relation/roles/base.rb
+- lib/acts_in_relation/roles/source.rb
+- lib/acts_in_relation/roles/target.rb
 - lib/acts_in_relation/supports/verb.rb
-- lib/acts_in_relation/target.rb
 - lib/acts_in_relation/version.rb
+- spec/dummy/application.rb
+- spec/dummy/bin/rails
+- spec/dummy/config.ru
+- spec/models/post_spec.rb
+- spec/models/user_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/kami30k/acts_in_relation
 licenses:
 - MIT
@@ -118,9 +128,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
-summary: Rails plugin that adds a relational feature to Model, such as follow, block,
-  mute, or like and so on.
+summary: Add relational feature to Rails (e.g. follow, block and like).
 test_files: []

data/lib/acts_in_relation/action.rb

@@ -1,10 +0,0 @@
-module ActsInRelation
-  module Action
-    def define
-      class_object.class_eval <<-RUBY
-        belongs_to :"#{source}"
-        belongs_to :"target_#{target}", class_name: "#{target.capitalize}", foreign_key: :"target_#{target}_id"
-      RUBY
-    end
-  end
-end

data/lib/acts_in_relation/source.rb

@@ -1,35 +0,0 @@
-module ActsInRelation
-  module Source
-    def define
-      with.each do |action|
-        action.extend ActsInRelation::Supports::Verb
-
-        class_object.class_eval <<-RUBY
-          has_many :"#{action.pluralize}",
-            foreign_key: :"#{source}_id",
-            dependent: :destroy
-
-          has_many :"#{action.progressize}",
-            through: :"#{action.pluralize}",
-            source: :"target_#{target}"
-
-          def #{action}(target)
-            return if #{action.progressize}?(target) || (self == target)
-
-            #{action.pluralize}.create(target_#{target}_id: target.id)
-          end
-
-          def un#{action}(target)
-            return unless #{action.progressize}?(target)
-
-            #{action.pluralize}.find_by(target_#{target}_id: target.id).destroy
-          end
-
-          def #{action.progressize}?(target)
-            #{action.pluralize}.exists?(target_#{target}_id: target.id)
-          end
-        RUBY
-      end
-    end
-  end
-end

data/lib/acts_in_relation/target.rb

@@ -1,24 +0,0 @@
-module ActsInRelation
-  module Target
-    def define
-      with.each do |action|
-        action.extend ActsInRelation::Supports::Verb
-
-        class_object.class_eval <<-RUBY
-          has_many :"#{action.pluralize}_as_target",
-            foreign_key: :"target_#{target}_id",
-            class_name: action.capitalize,
-            dependent: :destroy
-
-          has_many :"#{action.peoplize}",
-            through: :"#{action.pluralize}_as_target",
-            source: :"#{source}"
-
-          def #{action.pastize}_by?(source)
-            source.#{action.pluralize}.exists?(#{source}_id: source.id)
-          end
-        RUBY
-      end
-    end
-  end
-end