notification-handler 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dc02802065493c5e297334667b3331b8b0c8757e80989b052d6426b154d450b
-  data.tar.gz: 4c3f0782b4a05e9df8960cfcfcd18cbb27bc14d25855fa0f63ce0b973324b55b
+  metadata.gz: 44da09c04b6282f1d6eba56e5a195858d5646964e5e7f6e1ee47eda4252d7df2
+  data.tar.gz: acbc2f716492d9450c40d294c91b3a6145e9520bc4a3c942211d9e3f7df668b4
 SHA512:
-  metadata.gz: 9a49f5df7d39be5495797718c4909b35c831bcd59dfcde06b14ad7b63a8866d4d9e666cb9de868b30fc18008db0fc9090f8a36bcce98e8fe339625c7b4775ccd
-  data.tar.gz: fc6f3e388e7cb39e44fcda525b4b6adde35dd7d1adb05733010d4aa1a7c8d4006efbcd04f23f0b15ae24d2257aa05b12bf7ea1891d9d513c7e54f4aa2c86cb5d
+  metadata.gz: 41d91481c7d251290aa7c3a12cec7cfa778f74aeb579a3ea7224a3e3947c9736aa0fe8d339d3ec5af16492391c41828d50384b37ab976eff004d842ffe78e5ea
+  data.tar.gz: f658cb7133391ac215459a7831b50a6280a4d4aa2e9c2f3d8541725749154197663eec3d83050b27f80a3805fc7bd7c3a8cbcefeed33ce3fee8ba680ece76f3e

data/README.md

@@ -1,226 +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)
+notifications-rails is the most powerful notification library for Rails. It offers not only simple APIs to create and render notifications but also supports user-integration and cross-platform delivery of notifications.
 
-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?"
-}
-```
+**[notification-settings](notification-settings):** Integrates with your authentication solution to craft a personalized user notification platform.
 
-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
+You may just use the components you actually need, or instead use this gem to bundle everything for a complete notification solution.
 
-# Return all unread notifications
-Notification.unread
-
-# Number of unread notifications
-Notification.unread.size
-```
-
-### `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:
-
-```ruby
-class Recipe < ApplicationRecord
-  notification_object
-end
-```
-
-Now associated notifications are easy to access:
-
-```ruby
-notifications = Recipe.first.belonging_notifications
-```
-
-### Groups
-
-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
-notifications = Notification.for_group(:subscribers, attrs: { object: Recipe.first })
-notifications = Notification.for_group(:company_members, args: [4], attrs: { object: Recipe.first })
+gem 'notifications-rails', github: 'jonhue/notifications-rails'
 ```
 
-`Notification.for_group` returns an array of `Notification` objects.
+## Usage
 
-**Note:** You are not able to set the `target` attribute when a `group` has been specified.
+Details on usage are provided in the [documentation](#philosophy) of the specific modules.
 
-### Caching
+## Development
 
-You can cache the amount of unread and read notifications for notification targets by settings the [`cache`](#configuration) configuration option to `true`.
+To start development you first have to fork this repository and locally clone your fork.
 
-Then add the following columns to the database tables of ActiveRecord classes acting as notification targets:
+Install the projects dependencies by running:
 
-```ruby
-add_column :user, :read_notification_count, :integer
-add_column :user, :unread_notification_count, :integer
-```
+    $ bundle install
 
----
+### Testing
 
-## Configuration
+Tests are written with RSpec. Integration tests are located in `/spec`, unit tests can be found in `<module>/spec`.
 
-You can configure NotificationHandler by passing a block to `configure`. This can be done in `config/initializers/notification-handler.rb`:
+To run all tests:
 
-```ruby
-NotificationHandler.configure do |config|
-  config.cache = true
-end
-```
-
-**`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: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - Jonas Hübotter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-10 00:00:00.000000000 Z
+date: 2020-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -151,26 +151,14 @@ 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
@@ -191,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 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,46 +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('%<migration_number>.3d',
-               migration_number: 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,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support'
-
-module NotificationHandler
-  module NotificationLib
-    extend ActiveSupport::Concern
-
-    included do
-      self.inheritance_column = :_type_disabled
-
-      after_commit :cache
-
-      serialize :metadata, Hash
-
-      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 ClassMethods
-      def for_group(group, args: [], attrs: {})
-        return if group.nil?
-
-        target_scope = NotificationHandler::Group.find_by_name!(group)
-                                                 .target_scope
-        target_scope.call(*args)&.map do |target|
-          Notification.create(attrs.merge(target: target))
-        end
-      end
-    end
-
-    module InstanceMethods
-      def read?
-        read
-      end
-
-      def unread?
-        !read
-      end
-
-      private
-
-      def cache
-        return unless read_changed?
-
-        target.read_notification_count = target.notifications.read.size
-        target.unread_notification_count = target.notifications.unread.size
-        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,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support'
-
-module NotificationHandler
-  module Object
-    extend ActiveSupport::Concern
-
-    included do
-      def self.notification_object
-        has_many :belonging_notifications,
-                 as: :object, class_name: 'Notification', dependent: :destroy
-
-        # rubocop:disable Style/GuardClause
-        if defined?(NotificationSettings)
-          include NotificationSettings::Subscribable
-        end
-        # rubocop:enable Style/GuardClause
-      end
-    end
-  end
-end

data/lib/notification_handler/target.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support'
-
-module NotificationHandler
-  module Target
-    extend ActiveSupport::Concern
-
-    included do
-      def self.notification_target
-        has_many :notifications, as: :target, dependent: :destroy
-        include NotificationHandler::Target::InstanceMethods
-
-        include NotificationSettings::Target if defined?(NotificationSettings)
-        # rubocop:disable Style/GuardClause
-        if defined?(NotificationSettings)
-          include NotificationSettings::Subscriber
-        end
-        # rubocop:enable Style/GuardClause
-      end
-    end
-
-    module InstanceMethods
-      def notify(options = {})
-        notifications.create(options)
-      end
-    end
-  end
-end