action-store 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8620df9bc8e7e653ee263d433f892c7cdca53033
+  data.tar.gz: 73945fc330e36f657d39e2522e64572edac4a5ad
+SHA512:
+  metadata.gz: 875ca9ea784edc3fbb850bf236aa81ebde12a5609cf184673cae8527c36da1716e45ebe7d8399c951183f2fd3640fcea79b586127a2b12a15b266a1a5905226d
+  data.tar.gz: 0fd1ac9eadc6e0603d149d2b2bd781535b7dede284df05ec7eb7cbd5099a3f222c06cb29f9bedabe845f98cfa3e5933dea0ef7209f1de56c7512cfa4b2a57154

data/CHANGELOG

@@ -0,0 +1,10 @@
+0.2.0
+-----
+
+- New API, define action in User model.
+- Builtin Many-to-Many relations and methods.
+
+0.1.0
+-----
+
+- First release.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Rails Engine
+
+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,178 @@
+ActionStore
+-----------
+
+[![Gem Version](https://badge.fury.io/rb/action-store.svg)](https://badge.fury.io/rb/action-store) [![Build Status](https://travis-ci.org/rails-engine/action-store.svg)](https://travis-ci.org/rails-engine/action-store) [![Code Climate](https://codeclimate.com/github/rails-engine/action-store/badges/gpa.svg)](https://codeclimate.com/github/rails-engine/action-store) [![codecov.io](https://codecov.io/github/rails-engine/action-store/coverage.svg?branch=master)](https://codecov.io/github/rails-engine/action-store?branch=master) [![](http://inch-ci.org/github/rails-engine/action-store.svg?branch=master)](http://inch-ci.org/github/rails-engine/action-store?branch=master)
+
+Store difference kind of actions (Like, Follow, Star, Block ...) in one table via ActiveRecord Polymorphic Association.
+
+- Like Post/Comment/Reply ...
+- Watch/Subscribe Post
+- Follow User
+- Favorite Post
+- Read Notification/Message
+
+And more and more.
+
+## Basic table struct
+
+| Field | Means |
+| ----- | ----- |
+| `action_type` | The type of action [like, watch, follow, star, favorite] |
+| `action_option` | Secondly option for store you custom status, or you can let it null if you don't needs it. |
+| `target_type`, `target_id` | Polymorphic Association for difference `Target` models [User, Post, Comment] |
+
+## Usage
+
+```rb
+gem 'action-store'
+```
+
+and run `bundle install`
+
+### Define Actions
+
+You can use `action_store` to define actions:
+
+app/models/user.rb
+
+```
+class User < ActiveRecord::Base
+  action_store <action_type>, <target>, opts
+end
+```
+
+#### Convention Over Configuration:
+
+| action, target | Target Model | Target `counter_cache_field` | User `counter_cache_field` | Target has_many | User has_many |
+| ------ | ------ | ------ | ------ | ------ | ------ | ------ |
+| `action_store :like, :post` | `Post` | | | `has_many :like_by_user_actions`, `has_many :like_by_users` | `has_many :like_post_actions`, `has_many :like_posts` |
+| `action_store :like, :post, counter_cache: true` | `Post` | `likes_count` |  | `has_many :like_by_user_actions`, `has_many :like_by_users` | `has_many :like_post_actions`, `has_many :like_posts` |
+| `action_store :star, :project, class_name: 'Repository'` | `Repository ` | `stars_count` | `star_projects_count` | `has_many :star_by_user_actions`, `has_many :star_by_users` |
+| `action_store :follow, :user` | `User` | `follows_count` | `follow_users_count` | `has_many :follow_by_user_actions`, `has_many :follow_by_users` | `has_many :follow_user_actions`, `has_many :follow_users` |
+| `action_store :follow, :user, counter_cache: 'followers_count', user_counter_cache: 'following_count'` | `User` | `followers_count ` | `following_count ` | `has_many :follow_by_user_actions`, `has_many :follow_by_users` | `has_many :follow_user_actions`, `has_many :follow_users` |
+
+for example:
+
+```rb
+# app/models/action.rb
+class User < ActiveRecord::Base
+  action_store :like, :post, counter_cache: true
+  action_store :star, :post, counter_cache: true, user_counter_cache: true
+  action_store :follow, :post
+  action_store :like, :comment, counter_cache: true
+  action_store :follow, :user, counter_cache: 'followers_count', user_counter_cache: 'following_count'
+end
+```
+
+### Counter Cache
+
+And you need add counter_cache field to target, user table.
+
+```rb
+add_column :users, :star_posts_count, :integer, default: 0
+add_column :users, :followers_count, :integer, default: 0
+add_column :users, :following_count, :integer, default: 0
+
+add_column :posts, :likes_count, :integer, default: 0
+add_column :posts, :stars_count, :integer, default: 0
+
+add_column :comments, :likes_count, :integer, default: 0
+```
+
+#### Now you can use like this:
+
+@user -> like @post
+
+```rb
+irb> User.create_action(:like, target: @post, user: @user)
+true
+irb> @user.create_action(:like, target: @post)
+true
+irb> @post.reload.likes_count
+1
+```
+
+@user1 -> unlike @user2
+
+```rb
+irb> User.destroy_action(:follow, target: @post, user: @user)
+true
+irb> @user.destroy_action(:like, target: @post)
+true
+irb> @post.reload.likes_count
+0
+```
+
+Check @user1 is liked @post
+
+```rb
+irb> action = User.find_action(:follow, target: @post, user: @user)
+irb> action = @user.find_action(:like, target: @post)
+irb> action.present?
+true
+```
+
+User follow cases:
+
+```rb
+# @user1 -> follow @user2
+@user1.create_action(:follow, target: @user2)
+@user1.reload.following_count => 1
+@user2.reload.followers_count_ => 1
+@user1.follow_user?(@user2) => true
+# @user2 -> follow @user1
+@user2.create_action(:follow, target: @user1)
+@user2.follow_user?(@user1) => true
+# @user1 -> follow @user3
+@user1.create_action(:follow, target: @user3)
+# @user1 -> unfollow @user3
+ @user1.destroy_action(:follow, target: @user3)
+```
+
+## Builtin relations and methods
+
+When you called `action_store`, ActionStore will define Many-to-Many relations for User and Target model.
+
+for example:
+
+```rb
+class User < ActiveRecord::Base
+  action_store :like, :post
+  action_store :block, :user
+end
+```
+
+It will defines Many-to-Many relations:
+
+- For User model will defined: `<action>_<target>s` (like_posts)
+- For Target model will defined: `<action>_by_users` (like_by_users)
+
+```rb
+# for User model
+has_many :like_post_actions
+has_many :like_posts, through: :like_post_actions
+## as user
+has_many :block_user_actions
+has_many :block_users, through: :block_user_actions
+## as target
+has_many :block_by_user_actions
+has_many :block_by_users, through: :block_by_user_actions
+
+# for Target model
+has_many :like_by_user_actions
+has_many :like_by_users, through: :like_user_actions
+```
+
+And `User` model will have methods:
+
+- @user.create_action(:like, target: @post)
+- @user.destroy_action(:like, target: @post)
+- @user.find_action(:like, target: @post)
+- @user.like_post(@post)
+- @user.like_post?(@post)
+- @user.unlike_post(@post)
+- @user.block_user(@user1)
+- @user.unblock_user(@user1)
+- @user.like_post_ids
+- @user.block_user_ids
+- @user.block_by_user_ids

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Actionstore'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/models/action.rb

@@ -0,0 +1,4 @@
+# Auto generate with action-store gem.
+class Action < ActiveRecord::Base
+  include ActionStore::Model
+end

data/config/initializers/action_store.rb

@@ -0,0 +1,3 @@
+# ActionStore Config
+ActionStore.configure do
+end

data/db/migrate/20170204035500_create_actions.rb

@@ -0,0 +1,17 @@
+class CreateActions < ActiveRecord::Migration[5.0]
+  def change
+    create_table :actions do |t|
+      t.string :action_type, null: false
+      t.string :action_option
+      t.string :target_type
+      t.integer :target_id
+      t.string :user_type
+      t.integer :user_id
+
+      t.timestamps
+    end
+
+    add_index :actions, [:user_type, :user_id, :action_type]
+    add_index :actions, [:target_type, :target_id, :action_type]
+  end
+end

data/lib/action-store.rb

@@ -0,0 +1,21 @@
+require "action_store/version"
+require "action_store/configuration"
+require "action_store/engine"
+require "action_store/model"
+require "action_store/mixin"
+
+module ActionStore
+  class << self
+    def config
+      return @config if defined?(@config)
+      @config = Configuration.new
+      @config
+    end
+
+    def configure(&block)
+      config.instance_exec(&block)
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, ActionStore::Mixin)

data/lib/action_store/configuration.rb

@@ -0,0 +1,4 @@
+module ActionStore
+  class Configuration
+  end
+end

data/lib/action_store/engine.rb

@@ -0,0 +1,10 @@
+module ActionStore
+  class Engine < ::Rails::Engine
+    isolate_namespace ActionStore
+
+    initializer "action_store.init_action", after: :load_config_initializers do
+      # Ensure eager_load Action model to init methods
+      require 'action'
+    end
+  end
+end

data/lib/action_store/mixin.rb

@@ -0,0 +1,215 @@
+module ActionStore
+  module Mixin
+    extend ActiveSupport::Concern
+
+    included do
+    end
+
+    def find_action(action_type, opts)
+      opts[:user] = self
+      self.class.find_action(action_type, opts)
+    end
+
+    def create_action(action_type, opts)
+      opts[:user] = self
+      self.class.create_action(action_type, opts)
+    end
+
+    def destroy_action(action_type, opts)
+      opts[:user] = self
+      self.class.destroy_action(action_type, opts)
+    end
+
+    module ClassMethods
+      attr_reader :defined_actions
+
+      def find_defined_action(action_type, name)
+        action_type = action_type.to_s
+        name = name.to_s.singularize.underscore
+        defined_actions.find { |a| a[:action_type] == action_type && a[:action_name] == name }
+      end
+
+      def action_store(action_type, name, opts = {})
+        opts ||= {}
+        klass_name = opts[:class_name] || name
+        target_klass = klass_name.to_s.classify.constantize
+        action_type = action_type.to_s
+        if opts[:counter_cache] == true
+          # @post.stars_count
+          opts[:counter_cache] = "#{action_type.pluralize}_count"
+        end
+        if opts[:user_counter_cache] == true
+          # @user.star_posts_count
+          opts[:user_counter_cache] = "#{action_type}_#{name.to_s.pluralize}_count"
+        end
+
+        @defined_actions ||= []
+        action = {
+          action_name: name.to_s,
+          action_type: action_type,
+          target_klass: target_klass,
+          counter_cache: opts[:counter_cache],
+          user_counter_cache: opts[:user_counter_cache]
+        }
+        @defined_actions << action
+
+        define_relations(action)
+      end
+
+      def find_action(action_type, opts)
+        opts[:action_type] = action_type
+        opts = safe_action_opts(opts)
+        return nil if opts[:user_id].blank? || opts[:user_type].blank?
+        return nil if opts[:target_id].blank? || opts[:target_type].blank?
+
+        defined_action = find_defined_action(opts[:action_type], opts[:target_type])
+        return nil if defined_action.nil?
+
+        Action.find_by(where_opts(opts))
+      end
+
+      def create_action(action_type, opts)
+        opts[:action_type] = action_type
+        opts = safe_action_opts(opts)
+        return false if opts[:user_id].blank? || opts[:user_type].blank?
+        return false if opts[:target_id].blank? || opts[:target_type].blank?
+
+        defined_action = find_defined_action(opts[:action_type], opts[:target_type])
+        return false if defined_action.nil?
+
+        action = Action.find_or_create_by(where_opts(opts))
+        if opts[:action_option]
+          action.update_attribute(:action_option, opts[:action_option])
+        end
+        reset_counter_cache(action, defined_action)
+        true
+      end
+
+      def destroy_action(action_type, opts)
+        opts[:action_type] = action_type
+        opts = safe_action_opts(opts)
+        return false if opts[:user_id].blank? || opts[:user_type].blank?
+        return false if opts[:target_id].blank? || opts[:target_type].blank?
+
+        defined_action = find_defined_action(opts[:action_type], opts[:target_type])
+        return false if defined_action.nil?
+
+        action = Action.where(where_opts(opts)).first
+        return true if !action
+        action.destroy
+        reset_counter_cache(action, defined_action)
+        true
+      end
+
+      def reset_counter_cache(action, defined_action)
+        return false if action.blank?
+        if defined_action[:counter_cache] && action.target.present?
+          target_count = Action.where({ action_type: defined_action[:action_type], target: action.target }).count
+          action.target.update_attribute(defined_action[:counter_cache], target_count)
+        end
+        if defined_action[:user_counter_cache] && action.user.present?
+          user_count = Action.where({ action_type: defined_action[:action_type], user: action.user }).count
+          action.user.update_attribute(defined_action[:user_counter_cache], user_count)
+        end
+      end
+
+      private
+
+      def define_relations(action)
+        target_klass = action[:target_klass]
+        action_type = action[:action_type]
+        action_name = action[:action_name]
+
+        user_klass = self
+
+        # user, person
+        user_name = user_klass.name.underscore.singularize
+
+        # like_topic, follow_user
+        full_action_name = [action_type, action_name].join('_')
+        # like_user, follow_user
+        full_action_name_for_target = [action_type, 'by', user_name].join('_')
+        # unlike_topic, unfollow_user
+        unaction_name = "un#{full_action_name}"
+
+        # @target.like_topic_actions, @target.follow_user_actions
+        has_many_name = [full_action_name, 'actions'].join('_').to_sym
+        # @target.like_topics, @target.follow_users
+        has_many_through_name = full_action_name.pluralize.to_sym
+
+        # @user.like_by_user_actions, @user.follow_by_user_actions
+        has_many_name_for_target = [full_action_name_for_target, 'actions'].join('_').to_sym
+        # @user.like_by_users, @user.follow_by_users
+        has_many_through_name_for_target = full_action_name_for_target.pluralize.to_sym
+
+        has_many_scope = -> {
+          where(action_type: action_type, target_type: target_klass.name, user_type: user_klass.name)
+        }
+
+        # User has_many :like_topic_actions
+        user_klass.send :has_many, has_many_name, has_many_scope, class_name: 'Action'
+        # User has_many :like_topics
+        user_klass.send :has_many, has_many_through_name,
+          through: has_many_name,
+          source: :target,
+          source_type: target_klass.name
+
+        # Topic has_many :like_user_actions
+        target_klass.send :has_many, has_many_name_for_target, has_many_scope,
+          foreign_key: :target_id,
+          class_name: 'Action'
+        # Topic has_many :like_users
+        target_klass.send :has_many, has_many_through_name_for_target,
+          through: has_many_name_for_target,
+          source_type: user_klass.name,
+          source: :user
+
+        # @user.like_topic
+        user_klass.send(:define_method, full_action_name) do |target_or_id|
+          target_id = target_or_id.is_a?(target_klass) ? target_or_id.id : target_or_id
+          result = user_klass.create_action(action_type, target_type: target_klass.name,
+                                                         target_id: target_id,
+                                                         user: self)
+          self.reload
+          result
+        end
+
+        # @user.like_topic?
+        user_klass.send(:define_method, "#{full_action_name}?") do |target_or_id|
+          target_id = target_or_id.is_a?(target_klass) ? target_or_id.id : target_or_id
+          result = user_klass.find_action(action_type, target_type: target_klass.name,
+                                                       target_id: target_id,
+                                                       user: self)
+          result.present?
+        end
+
+        # @user.unlike_topic
+        user_klass.send(:define_method, unaction_name) do |target_or_id|
+          target_id = target_or_id.is_a?(target_klass) ? target_or_id.id : target_or_id
+          result = user_klass.destroy_action(action_type, target_type: target_klass.name,
+                                                          target_id: target_id,
+                                                          user: self)
+          self.reload
+          result
+        end
+      end
+
+      def safe_action_opts(opts)
+        opts ||= {}
+        if opts[:user]
+          opts[:user_id] = opts[:user].id
+          opts[:user_type] = opts[:user].class.name
+        end
+        if opts[:target]
+          opts[:target_type] = opts[:target].class.name
+          opts[:target_id] = opts[:target].id
+        end
+        opts
+      end
+
+      def where_opts(opts)
+        opts.extract!(:action_type, :target_type, :target_id, :user_id, :user_type)
+      end
+    end
+  end
+end

data/lib/action_store/model.rb

@@ -0,0 +1,11 @@
+module ActionStore
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      # puts "Initalize ActionStore::Model"
+      belongs_to :target, polymorphic: true
+      belongs_to :user, polymorphic: true
+    end
+  end
+end

data/lib/action_store/version.rb

@@ -0,0 +1,3 @@
+module ActionStore
+  VERSION = "0.2.0"
+end

data/lib/generators/action_store/install_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+module ActionStore
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Create ActionStore's base files"
+      source_root File.expand_path('../../../../', __FILE__)
+
+      def add_initializer
+        template 'config/initializers/action_store.rb', 'config/initializers/action_store.rb'
+      end
+
+      def add_migrations
+        exec('rake action_store:install:migrations')
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: action-store
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Jason Lee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-04 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
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+description: Store difference kind of actions (Like, Follow, Star, Block ...) in one
+  table via ActiveRecord Polymorphic Association.
+email: huacnlee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG
+- LICENSE
+- README.md
+- Rakefile
+- app/models/action.rb
+- config/initializers/action_store.rb
+- db/migrate/20170204035500_create_actions.rb
+- lib/action-store.rb
+- lib/action_store/configuration.rb
+- lib/action_store/engine.rb
+- lib/action_store/mixin.rb
+- lib/action_store/model.rb
+- lib/action_store/version.rb
+- lib/generators/action_store/install_generator.rb
+homepage: https://github.com/rails-engine/action-store
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Store difference kind of actions (Like, Follow, Star, Block ...) in one table.
+test_files: []