notification-handler 2.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2cdb58ba8f4da880b60d9443747199aac809a9fc881c52ea6d6521b02ebb1c6
-  data.tar.gz: 2b22c562259da40608261bd742224fc6302ba678e2536ece9c01a01a01c51d82
+  metadata.gz: c20f9c7a594694c319f373377455d5acfa641e83f761c4af1026eb0373b61393
+  data.tar.gz: a8e467f20f1a34ae3cfd544179354f7dc826feb05e17937ae3854a7441b54265
 SHA512:
-  metadata.gz: a6eb0d2c4cc82ca45ca54d08bc4bf75aaa531d793a31109c0644345e2e00d392f84bf145b414863b835225e52a2249d64ff12df872b2698657ba6ce0b7401693
-  data.tar.gz: cac446fcf48614af0346f947a181be5bfbb5a2fe9f54dd3aebd7e0b231d2550d73f851fad439cf3a07565e8daa9f7278ccc9c5ddd59395b8ee82a1d8e9d50aea
+  metadata.gz: 4368450b8c8bbdc11defc79f74a46bc3338c414e493419c46e5e37e041c81e968b7264cc365d34be3ad24170fa6440bac471df571cc745db6fb2ec311a5034ba
+  data.tar.gz: 75e5ab81337e515b9ae86234f9290335fe6bc58c7929c3b849c31749a9adfe429460279f3836f0a10f3dca5a14c22012d681bbea0d32e978a95187d57bf2ee58

data/README.md

@@ -1,228 +1,84 @@
-# NotificationHandler
+# notifications-rails
 
-[![Gem Version](https://badge.fury.io/rb/notification-handler.svg)](https://badge.fury.io/rb/notification-handler) ![Travis](https://travis-ci.com/jonhue/notifications-rails.svg?branch=master)
+A flexible notification library supporting the delivery to external services, rendering in various environments, and user configuration by category.
 
-Create and modify your notifications through a simple API.
+## Philosophy
 
----
+notifications-rails has been built with modularity in mind. It currently consists of four components each of which bringing one essential functionality to the integration of notifications in your Rails app.
 
-## Table of Contents
+**[notification-handler](notification-handler):** Create and modify your notifications through a simple API.
 
-* [Installation](#installation)
-* [Usage](#usage)
-  * [`Notification` API](#notification-api)
-  * [`notification_target`](#notification_target)
-  * [`notification_object`](#notification_object)
-  * [Groups](#groups)
-    * [Defining a group](#defining-a-group)
-    * [Using a group](#using-a-group)
-  * [Caching](#caching)
-* [Configuration](#configuration)
-* [To Do](#to-do)
-* [Contributing](#contributing)
-  * [Semantic versioning](#semantic-versioning)
+**[notification-renderer](notification-renderer):** Render your notifications in various contexts.
 
----
+**[notification-pusher](notification-pusher):** Deliver your notifications to various services, including [Email](notification-pusher/notification-pusher-actionmailer) and [OneSignal](notification-pusher/notification-pusher-onesignal).
 
-## Installation
-
-NotificationHandler works with Rails 5 onwards. You can add it to your `Gemfile` with:
-
-```ruby
-gem 'notification-handler'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install notification-handler
-
-Now run the generator:
-
-    $ rails g notification_handler:install
-
-To wrap things up, migrate the changes to your database:
-
-    $ rails db:migrate
-
----
-
-## Usage
-
-### `Notification` API
-
-You can use all the ActiveRecord methods you know and love on your `Notification` class. So creating a new notification is dead simple:
-
-```ruby
-notification = Notification.new
-```
-
-Every `Notification` object has a `target` record. This target record is the object, that this notification belongs to (or targets). Usually it's a user, but it can be a record of any class:
-
-```ruby
-notification.target = User.first
-```
-
-To store information in your `Notification` record you can use the `metadata` attribute that gets serialized as a `Hash`:
-
-```ruby
-notification.metadata = {
-  title: 'My first notification',
-  content: "It looks great, doesn't it?"
-}
-```
-
-Another form of adding information is by associating an object to the notification. This can be a record of any class you like:
-
-```ruby
-notification.object = Recipe.first
-```
-
-The `read` attribute determines whether a notification has been seen or not:
-
-```ruby
-notification.read = true
-notification.read? # true
-notification.unread? # false
-```
-
-You can use scopes to filter for read or unread notifications:
-
-```ruby
-# Return all read notifications
-Notification.read
-
-# Return all unread notifications
-Notification.unread
-
-# Number of unread notifications
-Notification.unread.count
-```
-
-### `notification_target`
-
-To use records of an ActiveRecord class as notification targets, add the following to your class:
-
-```ruby
-class User < ApplicationRecord
-  notification_target
-end
-```
-
-Now belonging notifications are easy to access:
-
-```ruby
-notifications = User.first.notifications
-```
-
-You can create a notification from a `target`:
-
-```ruby
-User.first.notify(object: Recipe.first)
-```
-
-...
-
-### `notification_object`
-
-When using records of an ActiveRecord class as notification objects, add this to your class:
+**[notification-settings](notification-settings):** Integrates with your authentication solution to craft a personalized user notification platform.
 
-```ruby
-class Recipe < ApplicationRecord
-  notification_object
-end
-```
-
-Now associated notifications are easy to access:
-
-```ruby
-notifications = Recipe.first.belonging_notifications
-```
-
-...
-
-### Groups
+You may just use the components you actually need, or instead use this gem to bundle everything for a complete notification solution.
 
-Groups are a powerful way to bulk-create notifications for multiple objects that don't necessarily have a common class.
-
-#### Defining a group
+## Installation
 
-You define groups in your `NotificationHandler` configuration:
+You can add notifications-rails to your `Gemfile` with:
 
 ```ruby
-NotificationHandler.configure do |config|
-  config.define_group :subscribers, -> { User.where(subscriber: true) }
-end
+gem 'notifications-rails'
 ```
 
-When creating a notification for the group `:subscribers`, one notification will be added for every target that fulfills this scope: `User.where(subscriber: true)`. You can also target objects from different classes:
+And then run:
 
-```ruby
-NotificationHandler.configure do |config|
-  config.define_group :subscribers,     -> { User.where(subscriber: true) + Admin.all }
-  config.define_group :company_members, lambda { |company_id|
-    User.with_role(:member, Company.find(company_id)
-  }
-end
-```
+    $ bundle install
 
-The only requirement is that the result of evaluating the proc be Enumerable.
+Or install it yourself as:
 
-#### Using a group
+    $ gem install notifications-rails
 
-Bulk-creation of notifications for a certain group is fairly simple:
+If you always want to be up to date fetch the latest from GitHub in your `Gemfile`:
 
 ```ruby
-notification = Notification.create(object: Recipe.first, group: :subscribers)
-notification = Notification.create(object: Recipe.first, group: :company_members, group_args: 4)
+gem 'notifications-rails', github: 'jonhue/notifications-rails'
 ```
 
-**Note:** You are not able to set the `target` attribute when a `group` has been specified.
+## Usage
 
-### Caching
+Details on usage are provided in the [documentation](#philosophy) of the specific modules.
 
-You can cache the amount of unread and read notifications for notification targets by settings the [`cache`](#configuration) configuration option to `true`.
+## Development
 
-Then add the following columns to the database tables of ActiveRecord classes acting as notification targets:
+To start development you first have to fork this repository and locally clone your fork.
 
-```ruby
-add_column :user, :read_notification_count, :integer
-add_column :user, :unread_notification_count, :integer
-```
+Install the projects dependencies by running:
 
----
+    $ bundle install
 
-## Configuration
+### Testing
 
-You can configure NotificationHandler by passing a block to `configure`. This can be done in `config/initializers/notification-handler.rb`:
+Tests are written with RSpec. Integration tests are located in `/spec`, unit tests can be found in `<module>/spec`.
 
-```ruby
-NotificationHandler.configure do |config|
-  config.cache = true
-end
-```
+To run all tests:
 
-**`cache`** Cache amount of unread and read notifications for notification targets. Takes a boolean. Defaults to `false`.
+    $ ./rspec
 
----
+To run RuboCop:
 
-## To Do
+    $ bundle exec rubocop
 
-We use [GitHub projects](https://github.com/jonhue/notifications-rails/projects/2) to coordinate the work on this project.
+You can find all commands run by the CI workflow in `.github/workflows/ci.yml`.
 
-To propose your ideas, initiate the discussion by adding a [new issue](https://github.com/jonhue/notifications-rails/issues/new).
+## Contributing
 
----
+We warmly welcome everyone who is intersted in contributing. Please reference our [contributing guidelines](CONTRIBUTING.md) and our [Code of Conduct](CODE_OF_CONDUCT.md).
 
-## Contributing
+## Releases
 
-We hope that you will consider contributing to NotificationHandler. Please read this short overview for some information about how to get started:
+[Here](https://github.com/jonhue/notifications-rails/releases) you can find details on all past releases. Unreleased breaking changes that are on the current master can be found [here](CHANGELOG.md).
 
-[Learn more about contributing to this repository](https://github.com/jonhue/notifications-rails/blob/master/CONTRIBUTING.md), [Code of Conduct](https://github.com/jonhue/notifications-rails/blob/master/CODE_OF_CONDUCT.md)
+notifications-rails follows Semantic Versioning 2.0 as defined at http://semver.org. Reference our [security policy](SECURITY.md).
 
-### Semantic Versioning
+### Publishing
 
-NotificationHandler follows Semantic Versioning 2.0 as defined at http://semver.org.
+1. Review breaking changes and deprecations in `CHANGELOG.md`.
+1. Change the gem version in `VERSION`.
+1. Reset `CHANGELOG.md`.
+1. Create a pull request to merge the changes into `master`.
+1. After the pull request was merged, create a new release listing the breaking changes and commits on `master` since the last release.
+1. The release workflow will publish the gems to RubyGems.

data/lib/notifications-rails.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'notification-handler'
+require 'notification-renderer'
+require 'notification-pusher'
+require 'notification-settings'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: notification-handler
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Jonas Hübotter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-04 00:00:00.000000000 Z
+date: 2022-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -151,30 +151,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Create and modify your notifications through a simple API.
-email: me@jonhue.me
+email: jonas.huebotter@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- app/models/notification_handler/notification.rb
-- lib/generators/notification_handler/install_generator.rb
-- lib/generators/templates/install/initializer.rb
-- lib/generators/templates/install/notification_model.rb
-- lib/generators/templates/install/notifications_migration.rb.erb
-- lib/notification-handler.rb
-- lib/notification_handler/configuration.rb
-- lib/notification_handler/engine.rb
-- lib/notification_handler/group.rb
-- lib/notification_handler/notification_lib.rb
-- lib/notification_handler/notification_scopes.rb
-- lib/notification_handler/object.rb
-- lib/notification_handler/target.rb
+- lib/notifications-rails.rb
 homepage: https://github.com/jonhue/notifications-rails/tree/master/notification-handler
 licenses:
 - MIT
-metadata: {}
+metadata:
+  github_repo: ssh://github.com/jonhue/notifications-rails
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -183,14 +172,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.2
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Create and modify your notifications through a simple API

data/app/models/notification_handler/notification.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module NotificationHandler
-  class Notification < ApplicationRecord
-    include NotificationHandler::NotificationLib
-    include NotificationHandler::NotificationScopes
-  end
-end

data/lib/generators/notification_handler/install_generator.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/generators'
-require 'rails/generators/migration'
-
-module NotificationHandler
-  class InstallGenerator < Rails::Generators::Base
-    include Rails::Generators::Migration
-
-    source_root(File.join(File.dirname(__FILE__), '../templates/install'))
-    desc 'Install NotificationHandler'
-
-    def self.next_migration_number(dirname)
-      if ActiveRecord::Base.timestamped_migrations
-        Time.now.utc.strftime('%Y%m%d%H%M%S')
-      else
-        format('%.3d', current_migration_number(dirname) + 1)
-      end
-    end
-
-    def create_initializer
-      template 'initializer.rb', 'config/initializers/notification_handler.rb'
-    end
-
-    def create_notifications_migration_file
-      migration_template(
-        'notifications_migration.rb.erb',
-        'db/migrate/notification_handler_migration.rb',
-        migration_version: migration_version
-      )
-    end
-
-    def create_notification_model
-      template 'notification_model.rb', 'app/models/notification.rb'
-    end
-
-    private
-
-    def migration_version
-      return unless Rails.version >= '5.0.0'
-
-      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-NotificationHandler.configure do |config|
-  # Cache amount of unread and read notifications for notification targets.
-  # Learn more: https://github.com/jonhue/notifications-rails/tree/master/notification-handler#caching
-  # config.cache = false
-
-  # Groups are a powerful way to bulk-create notifications for multiple objects
-  # that don't necessarily have a common class.
-  # Learn more: https://github.com/jonhue/notifications-rails/tree/master/notification-handler#groups
-  # config.define_group :subscribers, -> { User.where(subscriber: true) }
-end

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

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-class Notification < NotificationHandler::Notification
-end

data/lib/generators/templates/install/notifications_migration.rb.erb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-class NotificationHandlerMigration < ActiveRecord::Migration<%= migration_version %>
-  def change
-    create_table :notifications do |t|
-      t.references :target, polymorphic: true, index: true
-      t.references :object, polymorphic: true, index: true
-
-      t.boolean :read, default: false, null: false, index: true
-
-      t.text :metadata
-
-      t.timestamps
-    end
-  end
-end

data/lib/notification-handler.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module NotificationHandler
-  require_relative 'notification_handler/configuration'
-
-  require_relative 'notification_handler/engine'
-
-  autoload :Group, 'notification_handler/group'
-
-  autoload :Target, 'notification_handler/target'
-  autoload :Object, 'notification_handler/object'
-  autoload :NotificationLib, 'notification_handler/notification_lib'
-  autoload :NotificationScopes, 'notification_handler/notification_scopes'
-end

data/lib/notification_handler/configuration.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'group'
-
-module NotificationHandler
-  class << self
-    attr_writer :configuration
-
-    def configuration
-      @configuration ||= Configuration.new
-    end
-  end
-
-  def self.configure
-    yield configuration
-  end
-
-  class Configuration
-    attr_accessor :groups
-    attr_accessor :cache
-
-    def initialize
-      @groups = {}
-      @cache = false
-    end
-
-    def define_group(name, target_scope)
-      groups[name.to_sym] = ::NotificationHandler::Group.new(target_scope)
-    end
-  end
-end

data/lib/notification_handler/engine.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails/engine'
-require 'active_record'
-
-module NotificationHandler
-  class Engine < ::Rails::Engine
-    initializer 'notification-handler.active_record' do
-      ActiveSupport.on_load :active_record do
-        include NotificationHandler::Target
-        include NotificationHandler::Object
-      end
-    end
-  end
-end

data/lib/notification_handler/group.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module NotificationHandler
-  class Group
-    attr_reader :target_scope
-
-    def initialize(target_scope)
-      @target_scope = target_scope
-    end
-
-    def self.find_by_name(name)
-      NotificationHandler.configuration.groups[name]
-    end
-
-    def self.find_by_name!(name)
-      find_by_name(name) ||
-        raise(ArgumentError,
-              "Could not find a registered group for #{name}. " \
-              "Make sure you register it with config.define_group :#{name}")
-    end
-  end
-end

data/lib/notification_handler/notification_lib.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support'
-
-module NotificationHandler
-  module NotificationLib
-    extend ActiveSupport::Concern
-
-    included do
-      self.inheritance_column = :_type_disabled
-
-      before_validation :create_for_group
-      after_commit :cache
-
-      serialize :metadata, Hash
-      attr_accessor :group
-      attr_accessor :group_args
-
-      belongs_to :target, polymorphic: true
-      belongs_to :object, polymorphic: true, optional: true
-
-      include NotificationHandler::NotificationLib::InstanceMethods
-
-      if defined?(NotificationRenderer)
-        include NotificationRenderer::NotificationLib
-      end
-      if defined?(NotificationPusher)
-        include NotificationPusher::NotificationLib
-      end
-      if defined?(NotificationSettings)
-        include NotificationSettings::NotificationLib
-      end
-    end
-
-    module InstanceMethods
-      def read?
-        read
-      end
-
-      def unread?
-        !read
-      end
-
-      private
-
-      def create_for_group
-        return if group.nil?
-
-        target_scope = NotificationHandler::Group.find_by_name!(group)
-                                                 .target_scope
-        target_scope.call(*group_args)&.each_with_index do |target, index|
-          notification = index.zero? ? self : dup
-          notification.target = target
-          notification.group = nil
-          notification.save!
-        end
-      end
-
-      def cache
-        return unless read_changed?
-
-        target.read_notification_count = target.notifications.read.count
-        target.unread_notification_count = target.notifications.unread.count
-        target.save!
-      end
-    end
-  end
-end

data/lib/notification_handler/notification_scopes.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support'
-
-module NotificationHandler
-  module NotificationScopes
-    extend ActiveSupport::Concern
-
-    included do
-      scope :read, -> { where(read: true) }
-      scope :unread, -> { where(read: false) }
-
-      if defined?(NotificationRenderer)
-        include NotificationRenderer::NotificationScopes
-      end
-      if defined?(NotificationSettings)
-        include NotificationSettings::NotificationScopes
-      end
-    end
-  end
-end

data/lib/notification_handler/object.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module NotificationHandler
-  module Object
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def notification_object
-        has_many :belonging_notifications,
-                 as: :object, class_name: 'Notification', dependent: :destroy
-        include NotificationHandler::Object::InstanceMethods
-
-        return unless defined?(NotificationSettings)
-
-        include NotificationSettings::Subscribable
-      end
-    end
-
-    module InstanceMethods
-      # ...
-    end
-  end
-end

data/lib/notification_handler/target.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module NotificationHandler
-  module Target
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-      def notification_target
-        has_many :notifications, as: :target, dependent: :destroy
-        include NotificationHandler::Target::InstanceMethods
-
-        include NotificationSettings::Target if defined?(NotificationSettings)
-        return unless defined?(NotificationSettings)
-
-        include NotificationSettings::Subscriber
-      end
-    end
-
-    module InstanceMethods
-      def notify(options = {})
-        notifications.create(options)
-      end
-    end
-  end
-end