notification_manager 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9674349da766261d2b2a5053d705e2bf0e3c4032a90f5d69f545451cb637d001
-  data.tar.gz: 4a3b339281e86d552e1d81c701a125a345a173e8b85fc82561d768a3824e307f
+  metadata.gz: e376c2270a096ff8d19676ce7487dfb9740acc3659ed7a41c789ce32417b3dd3
+  data.tar.gz: 17b18422bc6b2f193e53796d25d9dd5eccb8b5644641bbabb2dda30dde404d49
 SHA512:
-  metadata.gz: abd407fe50688a7c4ba8ad99cb77853e2e28591b5268ece01d757fd37bbd21d67bd51113579fc448517c08c060de346066a864d4a32322a471c43c1d64b2b024
-  data.tar.gz: 4c82dab89081331e12dfa499cb56b4fbf32bdae2bd30c97ba25ea88206d14c7b97060463cec0d26b7bc256cc4711c9976c86536511e0238a3350fc00679de885
+  metadata.gz: '0749cbc681d8526d3f7a593aaf4b9f62323a60cd1880792c269a14b8ff9d6b488fad3a6b665d0b3999752744a3e89412f1c33f2e11494cf95b562cc37d1197ee'
+  data.tar.gz: acb945c0b0a496740a79535e97b315a91df1ff6a795ed6c2427bcf5e5c6414038591d8daa4ed641068b76773e90d3a88c74eba37876c8dcb684dd4646f3aaf4d

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.2
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-03-28
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in notification_manager.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 TODO: Write your name
+
+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,288 @@
+# NotificationManager
+
+A flexible notification management system for Rails applications that automatically triggers notifications based on ActiveRecord model lifecycle events and attribute changes.
+
+## Features
+
+- 🔔 Trigger notifications on model lifecycle events (create, update, destroy)
+- 🎯 Trigger notifications based on attribute status changes
+- 🏷️ Tag-based notification clearing to prevent duplicate notifications
+- 👥 Support for multiple recipients per notification
+- 🔄 Polymorphic notification system supporting any notifiable model
+- ⏭️ Conditional notification skipping
+- 🎨 Extensible architecture with customizable notification managers
+
+## Requirements
+
+- Ruby >= 3.2.0
+- Rails >= 6.1
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'notification_manager'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Usage
+
+### 1. Generate the Notification Model
+
+First, generate the notification model and migration:
+
+```bash
+$ rails generate notification_manager:notifications
+$ rails db:migrate
+```
+
+This creates:
+- `app/models/notification.rb` - The Notification model
+- `db/migrate/[timestamp]_create_notifications.rb` - The database migration
+
+The notifications table includes:
+- `user_id` - Reference to the user receiving the notification
+- `notifiable` - Polymorphic reference to any notifiable model
+- `description` - Notification message
+- `link` - Optional link for the notification
+- `tag` - Tag for grouping/clearing related notifications
+- `opened` - Boolean flag to track read/unread status
+
+### 2. Include the Notifiable Concern
+
+Add the `ActiveRecordNotifiable` concern to any model you want to send notifications from:
+
+```ruby
+class Order < ApplicationRecord
+  include NotificationManager::NotificationSources::ActiveRecordNotifiable
+  
+  # Your model code...
+end
+```
+
+This adds an `after_commit` callback that automatically triggers notifications based on your notification manager configuration.
+
+### 3. Create a Notification Manager
+
+Create a notification manager class for your notifiable model. The class name should follow the pattern `[ModelName]NotificationManager`:
+
+```ruby
+# app/notification_managers/order_notification_manager.rb
+class OrderNotificationManager < NotificationManager::NotificationManagers::Base
+  def notification_steps
+    [
+      order_created_notification,
+      order_shipped_notification,
+      order_delivered_notification
+    ]
+  end
+
+  private
+
+  def order_created_notification
+    NotificationManager::NotificationDefinitions::Base.new(
+      lifecycle_triggers: [:created],
+      status_triggers: [],
+      notification_tags_to_clear: [],
+      notifications_to_send: [
+        {
+          recipients: :seller_recipient,
+          notification: :send_order_created_notification
+        }
+      ]
+    )
+  end
+
+  def order_shipped_notification
+    NotificationManager::NotificationDefinitions::Base.new(
+      lifecycle_triggers: [:updated],
+      status_triggers: [
+        {
+          attr: :status,
+          triggers: -> { ['shipped'] }
+        }
+      ],
+      notification_tags_to_clear: ['order_pending'],
+      notifications_to_send: [
+        {
+          recipients: :buyer_recipient,
+          notification: :send_order_shipped_notification
+        }
+      ]
+    )
+  end
+
+  def order_delivered_notification
+    NotificationManager::NotificationDefinitions::Base.new(
+      lifecycle_triggers: [:updated],
+      status_triggers: [
+        {
+          attr: :status,
+          triggers: -> { ['delivered'] }
+        }
+      ],
+      notification_tags_to_clear: ['order_shipped'],
+      notifications_to_send: [
+        {
+          recipients: :buyer_recipient,
+          notification: :send_order_delivered_notification
+        }
+      ]
+    )
+  end
+
+  # Recipient methods return arrays of users
+  def seller_recipient
+    [notifiable.seller]
+  end
+
+  def buyer_recipient
+    [notifiable.buyer]
+  end
+
+  # Notification sender methods
+  def send_order_created_notification(order, recipient)
+    Notification.create!(
+      user: recipient,
+      notifiable: order,
+      description: "New order ##{order.id} received",
+      link: "/orders/#{order.id}",
+      tag: 'order_created'
+    )
+  end
+
+  def send_order_shipped_notification(order, recipient)
+    Notification.create!(
+      user: recipient,
+      notifiable: order,
+      description: "Your order ##{order.id} has been shipped",
+      link: "/orders/#{order.id}",
+      tag: 'order_shipped'
+    )
+  end
+
+  def send_order_delivered_notification(order, recipient)
+    Notification.create!(
+      user: recipient,
+      notifiable: order,
+      description: "Your order ##{order.id} has been delivered",
+      link: "/orders/#{order.id}",
+      tag: 'order_delivered'
+    )
+  end
+end
+```
+
+### 4. Notification Definition Options
+
+Each notification definition accepts the following options:
+
+#### `lifecycle_triggers` (Array)
+Specifies which lifecycle events should trigger the notification:
+- `:created` - Triggers when the record is created
+- `:updated` - Triggers when the record is updated
+- `:destroyed` - Triggers when the record is destroyed
+
+#### `status_triggers` (Array of Hashes)
+Defines attribute-based conditions for triggering notifications:
+```ruby
+status_triggers: [
+  {
+    attr: :status,           # The attribute to watch
+    triggers: -> { ['value'] }  # Lambda returning array of trigger values
+  }
+]
+```
+
+Use `-> { '*' }` to trigger on any change to the attribute.
+
+#### `notification_tags_to_clear` (Array)
+Array of notification tags to clear before sending new notifications. This prevents duplicate or outdated notifications:
+```ruby
+notification_tags_to_clear: ['order_pending', 'order_processing']
+```
+
+#### `notifications_to_send` (Array of Hashes)
+Defines which notifications to send:
+```ruby
+notifications_to_send: [
+  {
+    recipients: :method_name,      # Method that returns array of users
+    notification: :method_name     # Method that creates the notification
+  }
+]
+```
+
+### 5. Skipping Notifications
+
+You can temporarily skip notifications for a specific operation:
+
+```ruby
+order = Order.new(...)
+order.skip_notifications = true
+order.save
+```
+
+## Advanced Examples
+
+### Multiple Recipients
+
+```ruby
+def admin_recipients
+  User.where(role: 'admin').to_a
+end
+
+def stakeholder_recipients
+  [notifiable.owner, notifiable.manager].compact
+end
+```
+
+### Conditional Status Triggers
+
+```ruby
+status_triggers: [
+  {
+    attr: :priority,
+    triggers: -> { ['high', 'critical'] }
+  },
+  {
+    attr: :assigned_to_id,
+    triggers: -> { '*' }  # Trigger on any assignment change
+  }
+]
+```
+
+### Chaining Notifications
+
+Clear previous notifications when sending new ones to maintain a clean notification state:
+
+```ruby
+NotificationManager::NotificationDefinitions::Base.new(
+  lifecycle_triggers: [:updated],
+  status_triggers: [{ attr: :status, triggers: -> { ['completed'] } }],
+  notification_tags_to_clear: ['task_pending', 'task_in_progress'],
+  notifications_to_send: [
+    { recipients: :task_owner, notification: :send_completion_notification }
+  ]
+)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/CodeTectonics/notification-manager. This project is intended to be a safe, welcoming space for collaboration.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "notification_manager"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/generators/notification_manager/notification/notification_generator.rb

@@ -0,0 +1,34 @@
+require "rails/generators"
+require "rails/generators/named_base"
+require "rails/generators/migration"
+
+module AnalyticsPlane
+  module Generators
+    class NotificationGenerator < Rails::Generators::NamedBase
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("../templates", __dir__)
+
+      desc "Creates a Notification model and migration for NotificationManager"
+
+      def create_model
+        template "notification_model.rb", "app/models/#{file_name}.rb"
+      end
+
+      def create_notification_migration
+        migration_template(
+          "create_notifications.rb",
+          "db/migrate/create_#{file_name.pluralize}.rb"
+        )
+      end
+
+      def self.next_migration_number(dirname)
+        if @next_migration_number
+          @next_migration_number += 1
+        else
+          @next_migration_number = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        end
+      end
+    end
+  end
+end

data/lib/generators/notification_manager/notifications_generator.rb

@@ -0,0 +1,34 @@
+require "rails/generators"
+require "rails/generators/named_base"
+require "rails/generators/migration"
+
+module NotificationManager
+  module Generators
+    class NotificationsGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates the Notification model and miration for use with Notification Managers."
+
+      def create_models
+        template "notification_model.rb", "app/models/notification.rb"
+      end
+
+      def create_migrations
+        migration_template "create_notifications.rb",
+                           "db/migrate/create_notifications.rb"
+      end
+
+      def self.next_migration_number(dirname)
+        if ActiveRecord::Base.timestamped_migrations
+          @@migration_number ||= Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+          @@migration_number += 1
+          @@migration_number.to_s
+        else
+          format("%03d", current_migration_number(dirname) + 1)
+        end
+      end
+    end
+  end
+end

data/lib/generators/notification_manager/templates/create_notifications.rb

@@ -0,0 +1,14 @@
+class CreateNotifications < ActiveRecord::Migration[7.0]
+  def change
+    create_table :notifications do |t|
+      t.references :user, foreign_key: true
+      t.references :notifiable, polymorphic: true
+      t.string :description
+      t.string :link
+      t.string :tag
+      t.boolean :opened, default: false, null: false
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/notification_manager/templates/notification_model.rb

@@ -0,0 +1,6 @@
+class Notification < ApplicationRecord
+  belongs_to :user
+  belongs_to :notifiable, polymorphic: true
+
+  validates :description, presence: true
+end

data/lib/notification_manager/notification_definitions/base.rb

@@ -0,0 +1,64 @@
+module NotificationManager
+  module NotificationDefinitions
+    class Base
+      attr_accessor :lifecycle_triggers, :status_triggers, :notification_tags_to_clear,
+                    :notifications_to_send
+
+      def initialize(options)
+        @lifecycle_triggers = options[:lifecycle_triggers] || []
+        @status_triggers = options[:status_triggers]
+        @notification_tags_to_clear = options[:notification_tags_to_clear] || []
+        @notifications_to_send = options[:notifications_to_send] || []
+      end
+
+      def triggered?(notifiable)
+        lifecycle_event_reached?(notifiable) && status_reached?(notifiable)
+      end
+
+      def lifecycle_event_reached?(notifiable)
+        if notifiable.created_at_previously_changed?
+          lifecycle_triggers.include?(:created)
+        elsif notifiable.updated_at_previously_changed?
+          lifecycle_triggers.include?(:updated)
+        elsif notifiable.destroyed?
+          lifecycle_triggers.include?(:destroyed)
+        end
+      end
+
+      def status_reached?(notifiable)
+        return true if status_triggers.empty?
+
+        status_triggers.each do |event|
+          next unless notifiable.send("#{event[:attr]}_previously_changed?")
+
+          triggers = event[:triggers].yield
+
+          return true if triggers == '*'
+
+          return true if notifiable[event[:attr]].in?(triggers)
+        end
+
+        false
+      end
+
+      def clear_notifications(notifiable)
+        return if notification_tags_to_clear.empty?
+
+        Notification.where(
+          notifiable_id: notifiable.id,
+          notifiable_type: notifiable.class.name,
+          tag: notification_tags_to_clear
+        ).destroy_all
+      end
+
+      def send_notifications(notification_manager, notifiable)
+        notifications_to_send.each do |notification|
+          recipients = notification_manager.send(notification[:recipients])
+          recipients.compact.each do |recipient|
+            notification_manager.send(notification[:notification], notifiable, recipient)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/notification_manager/notification_managers/base.rb

@@ -0,0 +1,24 @@
+module NotificationManager
+  module NotificationManagers
+    class Base
+      attr_accessor :notifiable
+
+      def initialize(notifiable)
+        @notifiable = notifiable
+      end
+
+      def run_notification_flow
+        notification_steps.each do |step|
+          next unless step.triggered?(@notifiable)
+
+          step.clear_notifications(@notifiable)
+          step.send_notifications(self, @notifiable)
+        end
+      end
+
+      def notification_steps
+        raise "Implement in subclass"
+      end
+    end
+  end
+end

data/lib/notification_manager/notification_sources/active_record_notifiable.rb

@@ -0,0 +1,25 @@
+module NotificationManager
+  module NotificationSources
+    module ActiveRecordNotifiable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :skip_notifications
+
+        after_commit :send_notifications
+
+        def send_notifications
+          return if skip_notifications
+          return if notification_manager_class_name.nil?
+
+          notification_manager = notification_manager_class_name.constantize.new(self)
+          notification_manager.run_notification_flow
+        end
+
+        def notification_manager_class_name
+          "#{self.class.name}NotificationManager"
+        end
+      end
+    end
+  end
+end

data/lib/notification_manager/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NotificationManager
+  VERSION = "0.1.2"
+end

data/lib/notification_manager.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "notification_manager/version"
+require_relative "notification_manager/notification_definitions/base"
+require_relative "notification_manager/notification_managers/base"
+require_relative "notification_manager/notification_sources/active_record_notifiable"
+
+module NotificationManager
+  class Error < StandardError; end
+end

data/notification_manager.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "lib/notification_manager/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "notification_manager"
+  spec.version = NotificationManager::VERSION
+  spec.authors = ["Mark Harbison"]
+  spec.email = ["mark@tyne-solutions.com"]
+
+  spec.summary = "Notification manager."
+  spec.description = "Notification manager."
+  spec.homepage = "https://github.com/CodeTectonics/notification-manager"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"]    = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"]   = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- spec/*`.split("\n")
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "rails", ">= 6.1"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/notification_manager.rbs

@@ -0,0 +1,4 @@
+module NotificationManager
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/spec/notification_manager_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe NotificationManager do
+  it "has a version number" do
+    expect(NotificationManager::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "notification_manager"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: notification_manager
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Mark Harbison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-01 00:00:00.000000000 Z
+date: 2026-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -30,7 +30,31 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/generators/notification_manager/notification/notification_generator.rb
+- lib/generators/notification_manager/notifications_generator.rb
+- lib/generators/notification_manager/templates/create_notifications.rb
+- lib/generators/notification_manager/templates/notification_model.rb
+- lib/notification_manager.rb
+- lib/notification_manager/notification_definitions/base.rb
+- lib/notification_manager/notification_managers/base.rb
+- lib/notification_manager/notification_sources/active_record_notifiable.rb
+- lib/notification_manager/version.rb
+- notification_manager.gemspec
+- sig/notification_manager.rbs
+- spec/notification_manager_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/CodeTectonics/notification-manager
 licenses:
 - MIT
@@ -57,4 +81,6 @@ rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Notification manager.
-test_files: []
+test_files:
+- spec/notification_manager_spec.rb
+- spec/spec_helper.rb