rails-persona 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 151d4c30715f7f5cf797f1f6924aa286446a57bdc50b4d7b37b9a269cad539ce
+  data.tar.gz: 26210723fafa5b8f2039d658657793603a7c331f1290bf61c13cccd06d3de47e
+SHA512:
+  metadata.gz: f104c0ef798b1db64ecea07ebc75609981be6f34239bb3e471d9f10122399c5e8847f969797163da05f260255cfecd7937cfc84b7ffd87cba55608ecc5c6b754
+  data.tar.gz: 4707c46dd121ca57529b24418f03b51d5266c4e381d373edc1d9287b77cbc83014dd362521fd76bc9e957da1fa336d69aa0839c82643a9cfcab3e848dbfb19d6

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## [0.1.0] - 2024-05-31
+
+### Added
+- `Persona::Trackable` concern with DSL (`persona do track :action end`)
+- `track!` instance method with optional metadata
+- Full query API: `action_count`, `most_frequent_action`, `least_frequent_action`,
+  `last_action`, `last_active_at`, `inactive_since?`, `ever_did?`,
+  `persona_summary`, `actions_between`, `activity_log`
+- `Persona::Configuration` with `inactivity_threshold_days` and `max_events_per_record`
+- `UntrackedActionError` for safety when tracking undeclared actions
+- Database migration with polymorphic `persona_events` table
+- Railtie for automatic migration path injection

data/LICENSE

@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2024 Syed M. Ghani
+
+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.

data/README.md

@@ -0,0 +1,270 @@
+# rails-persona 🎭
+
+> Model-level behavioral analytics for Rails — own your data, zero external services.
+
+[![Gem Version](https://badge.fury.io/rb/rails-persona.svg)](https://badge.fury.io/rb/rails-persona)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+**rails-persona** is a lightweight Rails gem that adds first-class behavioral tracking directly to your ActiveRecord models. Unlike [ahoy](https://github.com/ankane/ahoy), which is focused on HTTP visit and page-view tracking, rails-persona is built for **model-level action tracking** — understanding *what your users actually do* in your app, not just what pages they visit.
+
+---
+
+## Why rails-persona over ahoy?
+
+| | ahoy | rails-persona |
+|---|---|---|
+| Focus | HTTP visits + page views | Model actions + user behavior |
+| Setup | Controllers + JS snippet | Pure Ruby — one concern |
+| Async | Manual Sidekiq setup | Built-in (`async: true`) |
+| Bulk tracking | ❌ | ✅ `bulk_track!` with `insert_all!` |
+| Class-level analytics | ❌ | ✅ Leaderboards, class summaries |
+| Open tracking mode | ❌ | ✅ No whitelist required |
+| Streak / pattern queries | ❌ | ✅ `daily_activity`, `peak_hour` |
+| Cookies / sessions | Required | Never needed |
+| Works on non-User models | Awkward | First-class |
+
+---
+
+## Installation
+
+```ruby
+gem "rails-persona"
+```
+
+```bash
+bundle install
+rails db:migrate
+```
+
+---
+
+## Quick start
+
+### 1. Include in any model
+
+```ruby
+class User < ApplicationRecord
+  include Persona::Trackable
+
+  persona do
+    track :login
+    track :export_report
+    track :view_dashboard
+    track :upgrade_plan
+  end
+end
+```
+
+### 2. Track actions in your app
+
+```ruby
+# In a controller, service, or job:
+current_user.track!(:login)
+current_user.track!(:upgrade_plan, metadata: { plan: "pro", amount: 49 })
+```
+
+### 3. Query behavior
+
+```ruby
+user.action_count(:login)          # => 42
+user.most_frequent_action          # => :login
+user.least_frequent_action         # => :upgrade_plan
+user.top_actions(3)                # => { login: 42, view_dashboard: 18, export_report: 5 }
+user.last_action                   # => :export_report
+user.last_active_at                # => 2024-05-30 14:22 UTC
+user.first_action                  # => :login
+user.first_active_at               # => 2023-01-10 08:00 UTC
+user.inactive_since?               # => false  (default threshold: 30 days)
+user.inactive_since?(7)            # => false  (custom: 7 days)
+user.days_since_last_activity      # => 2
+user.ever_did?(:export_report)     # => true
+user.never_did?(:upgrade_plan)     # => false
+user.action_share(:login)          # => 64.6  (% of all events)
+user.total_events                  # => 65
+
+user.persona_summary
+# => { login: 42, view_dashboard: 18, export_report: 5, upgrade_plan: 1 }
+
+user.actions_between(1.week.ago, Time.current)
+# => { login: 7, view_dashboard: 3 }
+
+user.activity_log(5)
+# => [
+#      { action: :export_report, at: 2024-05-30 14:22:00, metadata: {} },
+#      { action: :login,         at: 2024-05-30 09:01:00, metadata: {} },
+#    ]
+
+user.daily_activity(30)
+# => { "2024-05-28" => 4, "2024-05-29" => 7, "2024-05-30" => 2 }
+
+user.peak_hour
+# => 14  (2pm is when this user is most active)
+```
+
+---
+
+## Class-level analytics
+
+```ruby
+# Top 10 most active users
+User.persona_leaderboard(limit: 10)
+# => [
+#      { record: #<User id=4>, total_events: 128 },
+#      { record: #<User id=9>, total_events: 97 },
+#    ]
+
+# App-wide breakdown of all user actions
+User.persona_class_summary
+# => { login: 8420, view_dashboard: 5210, export_report: 820 }
+```
+
+---
+
+## Bulk tracking (high-performance)
+
+Uses `insert_all!` — no N+1, no per-row callbacks:
+
+```ruby
+user.bulk_track!([:login, :view_dashboard, :export_report])
+user.bulk_track!([:login, :login, :login])  # track repeated actions
+```
+
+---
+
+## Async tracking (Sidekiq)
+
+```ruby
+# config/initializers/persona.rb
+Persona.configure do |config|
+  config.async = true   # fires a Sidekiq job instead of writing inline
+end
+```
+
+Requires the `sidekiq` gem. Falls back to synchronous if Sidekiq is not available.
+
+---
+
+## Open tracking (no whitelist)
+
+If you want to track arbitrary actions without declaring them:
+
+```ruby
+class Post < ApplicationRecord
+  include Persona::Trackable
+
+  persona do
+    open_tracking!  # any string is valid — no UntrackedActionError raised
+  end
+end
+
+post.track!("custom_#{SecureRandom.hex(4)}")  # works fine
+```
+
+---
+
+## Works on any model
+
+```ruby
+class Post < ApplicationRecord
+  include Persona::Trackable
+
+  persona do
+    track :viewed
+    track :shared
+    track :bookmarked
+  end
+end
+
+post.track!(:viewed)
+post.action_count(:viewed)     # => 128
+post.most_frequent_action      # => :viewed
+Post.persona_class_summary     # => { viewed: 50_420, shared: 890, bookmarked: 210 }
+```
+
+---
+
+## Configuration
+
+```ruby
+# config/initializers/persona.rb
+Persona.configure do |config|
+  config.inactivity_threshold_days = 14     # default: 30
+  config.max_events_per_record     = 500    # default: nil (unlimited)
+  config.async                     = true   # default: false
+  config.auto_prune_after_days     = 90     # default: nil (no auto-prune)
+end
+```
+
+---
+
+## Manual pruning
+
+```ruby
+# Delete events older than 60 days for all records
+Persona::Pruner.prune_older_than(60)
+```
+
+Add to a scheduled job (e.g. `whenever` or Sidekiq-Cron):
+
+```ruby
+# lib/tasks/persona.rake
+namespace :persona do
+  desc "Prune old persona events"
+  task prune: :environment do
+    Persona::Pruner.prune_older_than(Persona.configuration.auto_prune_after_days || 90)
+    puts "Pruned old persona events"
+  end
+end
+```
+
+---
+
+## Comparison with other gems
+
+| Gem | Tracks | rails-persona advantage |
+|---|---|---|
+| **ahoy** | HTTP visits, JS events | Model actions, no JS needed, async built-in |
+| **paper_trail** | Model attribute changes | Behavioral patterns, not diffs |
+| **audited** | CRUD audit logs | Who *acted*, not what *changed* |
+| **mixpanel-ruby** | Remote SaaS events | Your DB, no 3rd party, no cost |
+
+---
+
+## API reference
+
+| Method | Description |
+|--------|-------------|
+| `track!(action, metadata: {})` | Record an action (sync or async) |
+| `bulk_track!(actions)` | Record multiple actions via `insert_all!` |
+| `reset_persona!` | Delete all events for this record |
+| `action_count(action)` | Count of a specific action |
+| `total_events` | Total event count |
+| `most_frequent_action` | Most-performed action |
+| `least_frequent_action` | Least-performed action |
+| `top_actions(n)` | Top N actions by count |
+| `last_action` | Most recent action symbol |
+| `last_active_at` | Timestamp of last action |
+| `first_action` | Earliest action symbol |
+| `first_active_at` | Timestamp of first action |
+| `inactive_since?(days)` | True if no action in N days |
+| `days_since_last_activity` | Integer days since last event |
+| `ever_did?(action)` | True if action occurred |
+| `never_did?(action)` | True if action never occurred |
+| `action_share(action)` | % of all events this action represents |
+| `persona_summary` | Full action → count hash |
+| `actions_between(from, to)` | Actions in a time window |
+| `activity_log(limit)` | Recent events as array of hashes |
+| `daily_activity(days)` | Events grouped by day |
+| `peak_hour` | Hour (0-23) with most activity |
+| `User.persona_leaderboard(limit:)` | Top N most active records |
+| `User.persona_class_summary` | App-wide action breakdown |
+
+---
+
+## Contributing
+
+Bug reports and pull requests welcome at https://github.com/sghani001/rails-persona.
+
+## License
+
+MIT — © Syed M. Ghani

data/app/models/persona_event.rb

@@ -0,0 +1,23 @@
+class PersonaEvent < ActiveRecord::Base
+  belongs_to :trackable, polymorphic: true
+
+  validates :action, presence: true
+
+  # ---- Scopes ---------------------------------------------------------------
+  scope :for_action,  ->(action) { where(action: action.to_s) }
+  scope :recent,      ->(n = 10) { order(created_at: :desc).limit(n) }
+  scope :oldest,      ->         { order(created_at: :asc) }
+  scope :since,       ->(time)   { where("created_at >= ?", time) }
+  scope :before,      ->(time)   { where("created_at < ?", time) }
+  scope :on_day,      ->(date)   { where(created_at: date.all_day) }
+  scope :this_week,   ->         { since(1.week.ago) }
+  scope :this_month,  ->         { since(1.month.ago) }
+
+  # ---- Serialization --------------------------------------------------------
+  def metadata
+    val = super
+    val.is_a?(String) ? JSON.parse(val) : val
+  rescue JSON::ParserError
+    {}
+  end
+end

data/db/migrate/20240101000000_create_persona_events.rb

@@ -0,0 +1,16 @@
+class CreatePersonaEvents < ActiveRecord::Migration[7.0]
+  def change
+    create_table :persona_events do |t|
+      t.references :trackable, polymorphic: true, null: false, index: true
+      t.string     :action,    null: false
+      t.jsonb      :metadata,  null: false, default: {}
+
+      t.timestamps
+    end
+
+    add_index :persona_events, :action
+    add_index :persona_events, :created_at
+    add_index :persona_events, [:trackable_type, :trackable_id, :action],
+              name: "index_persona_events_on_trackable_and_action"
+  end
+end

data/lib/persona/async_tracker.rb

@@ -0,0 +1,26 @@
+module Persona
+  class AsyncTracker
+    include Sidekiq::Worker if defined?(Sidekiq)
+
+    def self.track(trackable_type, trackable_id, action, metadata)
+      if defined?(Sidekiq)
+        perform_async(trackable_type, trackable_id, action, metadata)
+      else
+        perform(trackable_type, trackable_id, action, metadata)
+      end
+    end
+
+    def self.perform(trackable_type, trackable_id, action, metadata)
+      record = trackable_type.constantize.find(trackable_id)
+      PersonaEvent.create!(
+        trackable: record,
+        action:    action,
+        metadata:  metadata
+      )
+    end
+
+    def perform(trackable_type, trackable_id, action, metadata)
+      self.class.perform(trackable_type, trackable_id, action, metadata)
+    end
+  end
+end

data/lib/persona/configuration.rb

@@ -0,0 +1,22 @@
+module Persona
+  class Configuration
+    # Max events stored per trackable record (nil = unlimited)
+    attr_accessor :max_events_per_record
+
+    # Days of inactivity before inactive_since? returns true
+    attr_accessor :inactivity_threshold_days
+
+    # Use Sidekiq for async tracking (requires sidekiq gem)
+    attr_accessor :async
+
+    # Auto-prune events older than N days on each track! call (nil = off)
+    attr_accessor :auto_prune_after_days
+
+    def initialize
+      @max_events_per_record     = nil
+      @inactivity_threshold_days = 30
+      @async                     = false
+      @auto_prune_after_days     = nil
+    end
+  end
+end

data/lib/persona/pruner.rb

@@ -0,0 +1,23 @@
+module Persona
+  class Pruner
+    # Prune events older than N days globally
+    def self.prune_older_than(days)
+      PersonaEvent.where("created_at < ?", days.days.ago).delete_all
+    end
+
+    # Prune per-record if max_events_per_record is set
+    def self.enforce_cap_for(record)
+      cap = Persona.configuration.max_events_per_record
+      return unless cap
+
+      count = record.persona_events.count
+      return unless count > cap
+
+      oldest_ids = record.persona_events
+                         .order(created_at: :asc)
+                         .limit(count - cap)
+                         .pluck(:id)
+      PersonaEvent.where(id: oldest_ids).delete_all
+    end
+  end
+end

data/lib/persona/query.rb

@@ -0,0 +1,129 @@
+module Persona
+  module Query
+    # ---- Counts ---------------------------------------------------------------
+
+    def action_count(action)
+      persona_events.for_action(action).count
+    end
+
+    def total_events
+      persona_events.count
+    end
+
+    # ---- Frequency ------------------------------------------------------------
+
+    def most_frequent_action
+      persona_events.group(:action).order("count_all DESC").count.keys.first&.to_sym
+    end
+
+    def least_frequent_action
+      persona_events.group(:action).order("count_all ASC").count.keys.first&.to_sym
+    end
+
+    def top_actions(limit = 3)
+      persona_events.group(:action).order("count_all DESC").limit(limit).count
+                    .transform_keys(&:to_sym)
+    end
+
+    # ---- Recency --------------------------------------------------------------
+
+    def last_action
+      persona_events.recent(1).first&.action&.to_sym
+    end
+
+    def last_active_at
+      persona_events.recent(1).first&.created_at
+    end
+
+    def first_action
+      persona_events.oldest.first&.action&.to_sym
+    end
+
+    def first_active_at
+      persona_events.oldest.first&.created_at
+    end
+
+    # ---- Inactivity -----------------------------------------------------------
+
+    def inactive_since?(days = Persona.configuration.inactivity_threshold_days)
+      return true if last_active_at.nil?
+      last_active_at < days.days.ago
+    end
+
+    def days_since_last_activity
+      return nil if last_active_at.nil?
+      ((Time.current - last_active_at) / 1.day).to_i
+    end
+
+    # ---- Presence -------------------------------------------------------------
+
+    def ever_did?(action)
+      persona_events.for_action(action).exists?
+    end
+
+    def never_did?(action)
+      !ever_did?(action)
+    end
+
+    # ---- Summaries ------------------------------------------------------------
+
+    def persona_summary
+      persona_events.group(:action).order("count_all DESC").count
+                    .transform_keys(&:to_sym)
+    end
+
+    def actions_between(from, to)
+      persona_events.since(from).before(to).group(:action).count
+                    .transform_keys(&:to_sym)
+    end
+
+    def activity_log(limit = 10)
+      persona_events.recent(limit).map do |e|
+        { action: e.action.to_sym, at: e.created_at, metadata: e.metadata }
+      end
+    end
+
+    # ---- Streaks / Patterns ---------------------------------------------------
+
+    # Actions grouped by day for the last N days
+    def daily_activity(days = 30)
+      persona_events
+        .since(days.days.ago)
+        .group("DATE(created_at)")
+        .order("DATE(created_at) ASC")
+        .count
+    end
+
+    # Peak hour (0-23) when this record is most active
+    def peak_hour
+      persona_events
+        .group("EXTRACT(HOUR FROM created_at)::int")
+        .order("count_all DESC")
+        .count
+        .keys
+        .first
+    end
+
+    # What % of activity is a specific action?
+    def action_share(action)
+      total = total_events
+      return 0.0 if total.zero?
+      (action_count(action).to_f / total * 100).round(1)
+    end
+
+    # ---- Class-level helpers (call on the class, not an instance) ------------
+    module ClassMethods
+      def persona_leaderboard(limit: 10)
+        Persona::Summary.leaderboard(self, limit: limit)
+      end
+
+      def persona_class_summary
+        Persona::Summary.class_summary(self)
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/persona/railtie.rb

@@ -0,0 +1,21 @@
+require "rails"
+
+module Persona
+  class Railtie < Rails::Railtie
+    initializer "persona.load_app_instance_data" do |app|
+      Persona::Railtie.instance_variable_set(:@app, app)
+    end
+
+    initializer "persona.append_migrations" do |app|
+      unless app.root.to_s == File.expand_path("../..", __dir__)
+        config.paths["db/migrate"].expanded.each do |path|
+          app.config.paths["db/migrate"] << path
+        end
+      end
+    end
+
+    rake_tasks do
+      load "tasks/persona_tasks.rake"
+    end
+  end
+end

data/lib/persona/summary.rb

@@ -0,0 +1,38 @@
+module Persona
+  module Summary
+    # Compare two records side by side
+    def self.compare(record_a, record_b)
+      actions = (record_a.persona_summary.keys + record_b.persona_summary.keys).uniq
+
+      actions.each_with_object({}) do |action, hash|
+        hash[action] = {
+          record_a.class.name.downcase + "_#{record_a.id}" => record_a.action_count(action),
+          record_b.class.name.downcase + "_#{record_b.id}" => record_b.action_count(action)
+        }
+      end
+    end
+
+    # Top N most active records of a given class
+    def self.leaderboard(klass, limit: 10)
+      PersonaEvent
+        .where(trackable_type: klass.name)
+        .group(:trackable_id)
+        .order("count_all DESC")
+        .limit(limit)
+        .count
+        .map do |id, count|
+          { record: klass.find(id), total_events: count }
+        end
+    end
+
+    # Class-wide action breakdown
+    def self.class_summary(klass)
+      PersonaEvent
+        .where(trackable_type: klass.name)
+        .group(:action)
+        .order("count_all DESC")
+        .count
+        .transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/persona/trackable.rb

@@ -0,0 +1,105 @@
+require "active_support/concern"
+
+module Persona
+  module Trackable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :persona_events, as: :trackable, dependent: :destroy
+      include Persona::Query
+
+      class_attribute :_persona_tracked_actions, default: []
+      class_attribute :_persona_open_tracking,   default: false
+    end
+
+    class_methods do
+      # DSL: define which actions are trackable
+      #
+      #   persona do
+      #     track :login
+      #     track :export
+      #     open_tracking!   # allow any action (no whitelist)
+      #   end
+      def persona(&block)
+        builder = PersonaBuilder.new(self)
+        builder.instance_eval(&block)
+      end
+    end
+
+    # Track an action on this record.
+    #
+    #   user.track!(:login)
+    #   user.track!(:purchase, metadata: { plan: "pro" })
+    #   user.track!(:purchase, metadata: { plan: "pro" }, skip_cap: true)
+    #
+    def track!(action, metadata: {}, skip_cap: false)
+      action = action.to_s
+
+      unless self.class._persona_open_tracking
+        if self.class._persona_tracked_actions.any? &&
+           !self.class._persona_tracked_actions.include?(action.to_sym)
+          raise Persona::UntrackedActionError,
+                "'#{action}' is not declared on #{self.class.name}. " \
+                "Add `track :#{action}` in your persona block, or call `open_tracking!`."
+        end
+      end
+
+      if Persona.configuration.async && defined?(Sidekiq)
+        Persona::AsyncTracker.track(self.class.name, id, action, metadata)
+      else
+        PersonaEvent.create!(
+          trackable: self,
+          action:    action,
+          metadata:  metadata
+        )
+        Persona::Pruner.enforce_cap_for(self) unless skip_cap
+      end
+    end
+
+    # Bulk track multiple actions at once (no cap enforcement between each)
+    #
+    #   user.bulk_track!([:login, :view_dashboard, :export_report])
+    #
+    def bulk_track!(actions, metadata: {})
+      now = Time.current
+      rows = actions.map do |action|
+        {
+          trackable_type: self.class.name,
+          trackable_id:   id,
+          action:         action.to_s,
+          metadata:       metadata,
+          created_at:     now,
+          updated_at:     now
+        }
+      end
+      PersonaEvent.insert_all!(rows)
+      Persona::Pruner.enforce_cap_for(self)
+    end
+
+    # Reset all events for this record
+    def reset_persona!
+      persona_events.delete_all
+    end
+
+    # -------------------------------------------------------------------------
+    # Inner DSL builder
+    # -------------------------------------------------------------------------
+    class PersonaBuilder
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def track(action)
+        @klass._persona_tracked_actions =
+          (@klass._persona_tracked_actions + [action.to_sym]).uniq
+      end
+
+      # Skip whitelist enforcement — any string is valid
+      def open_tracking!
+        @klass._persona_open_tracking = true
+      end
+    end
+  end
+
+  class UntrackedActionError < StandardError; end
+end

data/lib/persona/version.rb

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

data/lib/persona.rb

@@ -0,0 +1,20 @@
+require "persona/version"
+require "persona/configuration"
+require "persona/railtie" if defined?(Rails)
+require "persona/pruner"
+require "persona/async_tracker"
+require "persona/summary"
+require "persona/query"
+require "persona/trackable"
+
+module Persona
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: rails-persona
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Syed M. Ghani
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: |
+  rails-persona lets you track, query, and understand how users interact with
+  your app directly from your Rails models. Define trackable actions with a
+  clean DSL, then query frequency, recency, inactivity, and full activity logs
+  — all stored in your own database.
+email:
+- syedghani001@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- app/models/persona_event.rb
+- db/migrate/20240101000000_create_persona_events.rb
+- lib/persona.rb
+- lib/persona/async_tracker.rb
+- lib/persona/configuration.rb
+- lib/persona/pruner.rb
+- lib/persona/query.rb
+- lib/persona/railtie.rb
+- lib/persona/summary.rb
+- lib/persona/trackable.rb
+- lib/persona/version.rb
+homepage: https://github.com/sghani001/rails-persona
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.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: Attach behavioral analytics to any Rails model — no external tools needed.
+test_files: []