rails_interactable 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a5ec34551df901686b4d9b3ce19380f91e8eda188a0c1f07d178a086bf2e26a7
+  data.tar.gz: d01ef574f2271418dece99138aa68d293a0cbdfc9fcfc99289ee7d14ef09a7c9
+SHA512:
+  metadata.gz: 791979c3e82e8756551e4bb90cd8580def1fe4ac1948d69db7817dbfa3f594989e1995f37d1d788261d0ad857639029f940434df2fcce951a0cc39797a3ff23d
+  data.tar.gz: 50f22c6c4ac2680f886e910c58766242b01c381edec4dedf36516c2a6dcff475da4b56b08b6a527114bed90c6693ec10faa9e79bb2f64766ddbac826f83786c3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright aric.zheng
+
+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,92 @@
+# RailsInteractable
+> Add like/favorite interactions to Rails models.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "rails_interactable"
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install rails_interactable
+```
+
+## Usage
+
+1.  **Generate Migration and Initializer**: Run the generator to create the necessary database migration and configuration initializer.
+    ```sh
+    rails generate rails_interactable:install
+    ```
+    This command creates:
+    *   A migration file (`db/migrate/xxx_create_interactions.rb`) for the `interactions` table.
+    *   An initializer file (`config/initializers/rails_interactable.rb`) to configure interaction types.
+
+2.  **Run the Migration**: Execute the generated migration to create the `interactions` table in your database.
+    ```sh
+    rails db:migrate
+    ```
+
+3.  **Configure Interaction Types**: Edit `config/initializers/rails_interactable.rb` to define the types of interactions your application supports. You can also define aliases for convenience.
+    ```ruby
+    # config/initializers/rails_interactable.rb
+    RailsInteractable.interaction_types = {
+      like: { alias: :liked_by? },
+      favorite: { alias: :favorited_by? }
+      # Add more types as needed, e.g.:
+      # bookmark: { alias: :bookmarked_by? }
+    }
+    ```
+
+4.  **Make Models Interactable (as Target)**: Add `acts_as_interactable` to the models that can receive interactions (e.g., `Post`, `Video`).
+    ```ruby
+    # app/models/post.rb
+    class Post < ApplicationRecord
+      belongs_to :user
+      acts_as_interactable # Generates methods like post.likes, post.add_like(user), etc.
+    end
+    ```
+
+5.  **Make Models an Operator**: Add `acts_as_operator` to the models that perform interactions (e.g., `User`).
+    ```ruby
+    # app/models/user.rb
+    class User < ApplicationRecord
+      has_many :posts, dependent: :destroy
+      acts_as_operator # Generates methods like user.liked, user.liked_of(Post), user.liked?(post), etc.
+    end
+    ```
+
+## API
+
+### On Interactable Models (e.g., `Post`)
+
+*   **Check Interaction**: `post.interacted_by_like?(user)` / `post.liked_by?(user)` (if alias configured)
+*   **Get Interactors**: `post.likes` (list of users who liked), `post.like_ids` (list of user IDs)
+*   **Get Count**: `post.like_count`
+*   **Add Interaction**: `post.add_like(user)`
+*   **Remove Interaction**: `post.remove_like(user)`
+*   **Toggle Interaction**: `post.toggle_like(user)`
+*   **Generic Check**: `post.interacted_by?(user, 'like')`
+*   **Generic Add/Remove/Toggle**: `post.add_interaction(user, 'like')`, `post.remove_interaction(user, 'like')`, `post.toggle_interaction(user, 'like')`
+
+### On Operator Models (e.g., `User`)
+
+*   **Check Interaction**: `user.liked?(post)` / `user.favorited?(post)`
+*   **Get Interacted Targets**: `user.liked` (all liked items), `user.favorited` (all favorited items)
+*   **Get Interacted Target IDs**: `user.liked_ids` (IDs of all liked items), `user.favorited_ids` (IDs of all favorited items)
+*   **Get Interacted Targets of Specific Type and Model**: `user.liked_of(Post)` (all Posts liked by user), `user.favorited_of(Post)` (all Posts favorited by user)
+*   **Get Interacted Target IDs of Specific Type and Model**: `user.liked_ids_of(Post)` (IDs of Posts liked by user), `user.favorited_ids_of(Post)` (IDs of Posts favorited by user)
+*   **Get Interaction Records**: `user.like_interactions`, `user.favorite_interactions`
+
+## Resources
+- https://chat.qwen.ai/c/4d8b4f97-785b-4aa0-87db-29e7671aa3c5
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+require "bundler/gem_tasks"

data/app/assets/stylesheets/rails_interactable/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/rails_interactable/application_controller.rb

@@ -0,0 +1,4 @@
+module RailsInteractable
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/rails_interactable/application_helper.rb

@@ -0,0 +1,4 @@
+module RailsInteractable
+  module ApplicationHelper
+  end
+end

data/app/jobs/rails_interactable/application_job.rb

@@ -0,0 +1,4 @@
+module RailsInteractable
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/rails_interactable/application_mailer.rb

@@ -0,0 +1,6 @@
+module RailsInteractable
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/rails_interactable/application_record.rb

@@ -0,0 +1,5 @@
+module RailsInteractable
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/rails_interactable/interaction.rb

@@ -0,0 +1,15 @@
+# app/models/rails_interactable/interaction.rb
+module RailsInteractable
+  class Interaction < ApplicationRecord
+    self.table_name = 'rails_interactions'
+
+    belongs_to :operator, polymorphic: true
+    belongs_to :target, polymorphic: true
+
+    validates :interaction_type, presence: true
+    validates :operator, presence: true
+    validates :target, presence: true
+    validates :operator_type, :operator_id, :target_type, :target_id, :interaction_type, presence: true
+    validates :operator_id, uniqueness: { scope: [:operator_type, :target_type, :target_id, :interaction_type] }
+  end
+end

data/app/views/layouts/rails_interactable/application.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Rails interactable</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag    "rails_interactable/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+RailsInteractable::Engine.routes.draw do
+end

data/lib/generators/rails_interactable/install_generator.rb

@@ -0,0 +1,32 @@
+# lib/generators/rails_interactable/install_generator.rb
+require 'rails/generators'
+require 'rails/generators/migration'
+
+module RailsInteractable
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_root File.join(File.dirname(__FILE__), 'templates')
+
+    def copy_initializer
+      template 'initializer.rb', 'config/initializers/rails_interactable.rb'
+    end
+
+    # lib/generators/rails_interactable/install_generator.rb
+    def copy_migration
+      migration_template 'create_interactions.rb.tt', 'db/migrate/create_interactions.rb'
+    end
+
+    private
+
+    def migration_timestamp
+      Time.current.strftime("%Y%m%d%H%M%S")
+    end
+
+    # ActiveRecord::Generators::Base 会自动提供这个方法，但 Base 需要自己实现
+    def self.next_migration_number(dirname)
+      next_migration_number = current_migration_number(dirname) + 1
+      ActiveRecord::Migration.next_migration_number(next_migration_number)
+    end
+  end
+end

data/lib/generators/rails_interactable/templates/create_interactions.rb.tt

@@ -0,0 +1,15 @@
+# lib/generators/rails_interactable/templates/create_interactions.rb.tt
+class CreateInteractions < ActiveRecord::Migration[<%= ActiveRecord::VERSION::MAJOR %>.<%= ActiveRecord::VERSION::MINOR %>]
+  def change
+    create_table :rails_interactions do |t|
+      # 使用 interaction_type 而不是 type
+      t.string :interaction_type, null: false
+      t.references :operator, polymorphic: true, null: false, index: { name: 'index_interactions_on_op_type_and_op_id' }
+      t.references :target, polymorphic: true, null: false, index: { name: 'index_interactions_on_tgt_type_and_tgt_id' }
+
+      t.timestamps
+    end
+
+    add_index :interactions, [:operator_type, :operator_id, :interaction_type, :target_type, :target_id], unique: true, name: 'index_unique_interaction'
+  end
+end

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

@@ -0,0 +1,8 @@
+# lib/generators/rails_interactable/templates/initializer.rb
+RailsInteractable.interaction_types = {
+  like: { alias: :liked_by? },
+  favorite: { alias: :favorited_by? }
+  # 可以添加更多类型
+  # comment: {},
+  # share: { alias: :shared_by? }
+}

data/lib/rails_interactable/engine.rb

@@ -0,0 +1,33 @@
+# lib/rails_interactable/engine.rb
+require 'rails'
+require_relative '../rails_interactable'
+
+module RailsInteractable
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsInteractable
+
+    # 加载插件内部的迁移
+    initializer "rails_interactable.load_migrations" do
+      config.paths["db/migrate"].expanded.each do |expanded_path|
+        Rails.application.config.paths["db/migrate"] << expanded_path
+      end
+    end
+
+    # 配置初始化
+    # 注意：如果配置在插件内部初始化，可能在 dummy app 中被覆盖
+    # 更好的方式是让使用者在 config/initializers 中配置
+    # initializer "rails_interactable.configure" do |app|
+    #   RailsInteractable.interaction_types = {
+    #     like: { alias: :liked_by? },
+    #     favorite: { alias: :favorited_by? }
+    #   }
+    # end
+
+    # 混入模块
+    initializer "rails_interactable.active_record" do
+      ActiveSupport.on_load :active_record do
+        include RailsInteractable
+      end
+    end
+  end
+end

data/lib/rails_interactable/version.rb

@@ -0,0 +1,3 @@
+module RailsInteractable
+  VERSION = "1.0.1"
+end

data/lib/rails_interactable.rb

@@ -0,0 +1,279 @@
+# lib/rails_interactable.rb
+require "rails_interactable/engine"
+
+module RailsInteractable
+  # 存储全局配置
+  mattr_accessor :interaction_types, default: {}
+
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # 模型只需声明自己是可互动的 (作为 target)
+    def acts_as_interactable
+      include InstanceMethods
+      # 在模型类被加载时，根据全局配置动态定义方法
+      RailsInteractable.interaction_types.each do |type, config|
+        define_interaction_methods_for_type(type, config)
+      end
+    end
+
+    # 模型声明自己是互动的操作者 (operator)
+    def acts_as_operator
+      include OperatorInstanceMethods
+      # 在模型类被加载时，根据全局配置动态定义方法 (operator 角度)
+      RailsInteractable.interaction_types.each do |type, config|
+        define_operator_interaction_methods_for_type(type, config)
+      end
+    end
+
+    private
+
+    # 动态定义与特定互动类型相关的方法 (target 角度)
+    def define_interaction_methods_for_type(type, config)
+      type_sym = type.to_sym
+      type_str = type.to_s
+
+      # 1. 检查互动状态: interacted_by_TYPE?(operator)
+      define_method "interacted_by_#{type_sym}?" do |operator|
+        RailsInteractable::Interaction.where(
+          target: self,
+          operator: operator,
+          interaction_type: type_str
+        ).exists?
+      end
+
+      # 2. 获取互动者列表: TYPEers
+      define_method "#{type_sym}s" do
+        # 重用 interactors 方法的逻辑
+        interactors(type_str)
+      end
+
+      # 2.5. 获取互动者ID列表: TYPE_ids
+      define_method "#{type_sym}_ids" do
+        # 重用 interactors_ids 方法的逻辑
+        interactors_ids(type_str)
+      end
+
+      # 3. 获取互动计数: TYPE_count
+      define_method "#{type_sym}_count" do
+        RailsInteractable::Interaction.where(target: self, interaction_type: type_str).count
+      end
+
+      # 4. 添加互动: add_TYPE(operator)
+      define_method "add_#{type_sym}" do |operator|
+        unless RailsInteractable::Interaction.where(
+          target: self,
+          operator: operator,
+          interaction_type: type_str
+        ).exists?
+          RailsInteractable::Interaction.create!(
+            target: self,
+            operator: operator,
+            interaction_type: type_str
+          )
+        end
+      end
+
+      # 5. 移除互动: remove_TYPE(operator)
+      define_method "remove_#{type_sym}" do |operator|
+        interaction = RailsInteractable::Interaction.where(
+          target: self,
+          operator: operator,
+          interaction_type: type_str
+        ).first
+        interaction&.destroy
+      end
+
+      # 6. 切换互动: toggle_TYPE(operator)
+      define_method "toggle_#{type_sym}" do |operator|
+        if send("interacted_by_#{type_sym}?", operator)
+          send("remove_#{type_sym}", operator)
+        else
+          send("add_#{type_sym}", operator)
+        end
+      end
+
+      # 7. 根据配置添加别名等
+      if config && config[:alias]
+        alias_method config[:alias], "interacted_by_#{type_sym}?"
+      end
+    end
+
+    # 动态定义与特定互动类型相关的方法 (operator 角度)
+    def define_operator_interaction_methods_for_type(type, config)
+      type_sym = type.to_sym
+      type_str = type.to_s
+
+      # 1. 获取操作者发起的特定类型互动的目标对象: TYPEd (e.g., user.liked, user.favorited)
+      define_method "#{type_sym}d" do
+        targets_of_type(type_str)
+      end
+
+      # 1.5. 获取操作者发起的特定类型、特定目标模型的互动对象: TYPEd_of(TargetModel) (e.g., user.liked_of(Post), user.favorited_of(Post))
+      define_method "#{type_sym}d_of" do |target_class|
+        targets_of_type_and_class(type_str, target_class)
+      end
+
+      # 2. 获取操作者发起的特定类型互动的目标对象ID: TYPEd_ids (e.g., user.liked_ids, user.favorited_ids)
+      define_method "#{type_sym}_ids" do
+        target_ids_of_type(type_str)
+      end
+
+      # 2.5. 获取操作者发起的特定类型、特定目标模型的互动对象ID: TYPEd_ids_of(TargetModel) (e.g., user.liked_ids_of(Post), user.favorited_ids_of(Post))
+      define_method "#{type_sym}_ids_of" do |target_class|
+        target_ids_of_type_and_class(type_str, target_class)
+      end
+
+      # 3. 检查操作者是否对某个目标执行了特定类型互动: TYPEd?(target) (e.g., user.liked?(post), user.favorited?(post))
+      define_method "#{type_sym}d?" do |target|
+        interacted_with?(target, type_str)
+      end
+
+      # 4. 获取操作者发起的特定类型互动记录: TYPE_interactions (e.g., user.like_interactions, user.favorite_interactions)
+      define_method "#{type_sym}_interactions" do
+        interactions_of_type(type_str)
+      end
+    end
+  end
+
+  module InstanceMethods
+    # 通用方法 - 使用 interaction_type
+    def interacted_by?(operator, type)
+      RailsInteractable::Interaction.where(
+        target: self,
+        operator: operator,
+        interaction_type: type.to_s
+      ).exists?
+    end
+
+    # 修改 interactors 方法，移除 joins，避免多态关联加载错误
+    def interactors(type)
+      # 首先获取所有相关交互的 operator_type 和 operator_id
+      operator_data = RailsInteractable::Interaction
+                         .where(target: self, interaction_type: type.to_s)
+                         .pluck(:operator_type, :operator_id)
+
+      # 按 operator_type 分组
+      operators_by_type = operator_data.group_by(&:first).transform_values { |group| group.map(&:last).uniq }
+
+      # 为每种类型批量查询对应的模型实例
+      results = []
+      operators_by_type.each do |operator_type, operator_ids|
+        operator_class = operator_type.constantize
+        instances = operator_class.where(id: operator_ids)
+        results.concat(instances)
+      end
+
+      results
+    end
+
+    # 新增：获取互动者ID列表
+    def interactors_ids(type)
+      RailsInteractable::Interaction
+        .where(target: self, interaction_type: type.to_s)
+        .pluck(:operator_id)
+        .uniq
+    end
+
+    def interaction_count(type)
+      RailsInteractable::Interaction.where(target: self, interaction_type: type.to_s).count
+    end
+
+    # 通用方法
+    def add_interaction(operator, type)
+      unless RailsInteractable::Interaction.where(
+        target: self,
+        operator: operator,
+        interaction_type: type.to_s
+      ).exists?
+        RailsInteractable::Interaction.create!(
+          target: self,
+          operator: operator,
+          interaction_type: type.to_s
+        )
+      end
+    end
+
+    def remove_interaction(operator, type)
+      interaction = RailsInteractable::Interaction.where(
+        target: self,
+        operator: operator,
+        interaction_type: type.to_s
+      ).first
+      interaction&.destroy
+    end
+
+    def toggle_interaction(operator, type)
+      if interacted_by?(operator, type)
+        remove_interaction(operator, type)
+      else
+        add_interaction(operator, type)
+      end
+    end
+  end
+
+  # 新增：Operator 相关的实例方法
+  module OperatorInstanceMethods
+    # 通用方法：获取操作者发起的特定类型互动
+    def interactions_of_type(type)
+      RailsInteractable::Interaction.where(
+        operator: self,
+        interaction_type: type.to_s
+      )
+    end
+
+    # 通用方法：获取操作者发起的特定类型互动的目标对象
+    def targets_of_type(type)
+      interaction_targets = RailsInteractable::Interaction
+                               .where(operator: self, interaction_type: type.to_s)
+                               .pluck(:target_type, :target_id)
+
+      targets_by_type = interaction_targets.group_by(&:first).transform_values { |group| group.map(&:last).uniq }
+
+      results = []
+      targets_by_type.each do |target_type, target_ids|
+        target_class = target_type.constantize
+        instances = target_class.where(id: target_ids)
+        results.concat(instances)
+      end
+
+      results
+    end
+
+    # 新增：获取操作者发起的特定类型、特定目标模型的互动对象
+    def targets_of_type_and_class(type, target_class)
+      target_class_name = target_class.name
+      interaction_target_ids = RailsInteractable::Interaction
+                                  .where(operator: self, interaction_type: type.to_s, target_type: target_class_name)
+                                  .pluck(:target_id)
+
+      target_class.where(id: interaction_target_ids)
+    end
+
+    # 通用方法：获取操作者发起的特定类型互动的目标对象ID
+    def target_ids_of_type(type)
+      RailsInteractable::Interaction
+        .where(operator: self, interaction_type: type.to_s)
+        .pluck(:target_id)
+        .uniq
+    end
+
+    # 新增：获取操作者发起的特定类型、特定目标模型的互动对象ID
+    def target_ids_of_type_and_class(type, target_class)
+      target_class_name = target_class.name
+      RailsInteractable::Interaction
+        .where(operator: self, interaction_type: type.to_s, target_type: target_class_name)
+        .pluck(:target_id)
+        .uniq
+    end
+
+    # 通用方法：检查操作者是否对某个目标执行了特定类型互动
+    def interacted_with?(target, type)
+      RailsInteractable::Interaction.where(
+        operator: self,
+        target: target,
+        interaction_type: type.to_s
+      ).exists?
+    end
+  end
+end

data/lib/tasks/rails_interactable_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rails_interactable do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: rails_interactable
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- aric.zheng
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.1.1
+description: A Rails gem for adding like, favorite, and other interaction features
+  to models via dynamic method generation.
+email:
+- 1290657123@qq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/stylesheets/rails_interactable/application.css
+- app/controllers/rails_interactable/application_controller.rb
+- app/helpers/rails_interactable/application_helper.rb
+- app/jobs/rails_interactable/application_job.rb
+- app/mailers/rails_interactable/application_mailer.rb
+- app/models/rails_interactable/application_record.rb
+- app/models/rails_interactable/interaction.rb
+- app/views/layouts/rails_interactable/application.html.erb
+- config/routes.rb
+- lib/generators/rails_interactable/install_generator.rb
+- lib/generators/rails_interactable/templates/create_interactions.rb.tt
+- lib/generators/rails_interactable/templates/initializer.rb
+- lib/rails_interactable.rb
+- lib/rails_interactable/engine.rb
+- lib/rails_interactable/version.rb
+- lib/tasks/rails_interactable_tasks.rake
+homepage: https://github.com/afeiship/rails_interactable
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/afeiship/rails_interactable
+  source_code_uri: https://github.com/afeiship/rails_interactable
+  changelog_uri: https://github.com/afeiship/rails_interactable/blob/main/CHANGELOG.md
+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: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Add like/favorite interactions to Rails models.
+test_files: []