noticed 1.6.3 → 2.0.1

data/lib/noticed/delivery_methods/twilio.rb

@@ -1,51 +0,0 @@
-module Noticed
-  module DeliveryMethods
-    class Twilio < Base
-      def deliver
-        post(url, basic_auth: {user: account_sid, pass: auth_token}, form: format)
-      end
-
-      private
-
-      def format
-        if (method = options[:format])
-          notification.send(method)
-        else
-          {
-            From: phone_number,
-            To: recipient.phone_number,
-            Body: notification.params[:message]
-          }
-        end
-      end
-
-      def url
-        if (method = options[:url])
-          notification.send(method)
-        else
-          "https://api.twilio.com/2010-04-01/Accounts/#{account_sid}/Messages.json"
-        end
-      end
-
-      def account_sid
-        credentials.fetch(:account_sid)
-      end
-
-      def auth_token
-        credentials.fetch(:auth_token)
-      end
-
-      def phone_number
-        credentials.fetch(:phone_number)
-      end
-
-      def credentials
-        if (method = options[:credentials])
-          notification.send(method)
-        else
-          Rails.application.credentials.twilio
-        end
-      end
-    end
-  end
-end

data/lib/noticed/delivery_methods/vonage.rb

@@ -1,40 +0,0 @@
-module Noticed
-  module DeliveryMethods
-    class Vonage < Base
-      def deliver
-        response = post("https://rest.nexmo.com/sms/json", json: format)
-        status = response.parse.dig("messages", 0, "status")
-        if !options[:ignore_failure] && status != "0"
-          raise ResponseUnsuccessful.new(response)
-        end
-
-        response
-      end
-
-      private
-
-      def format
-        if (method = options[:format])
-          notification.send(method)
-        else
-          {
-            api_key: credentials[:api_key],
-            api_secret: credentials[:api_secret],
-            from: notification.params[:from],
-            text: notification.params[:body],
-            to: notification.params[:to],
-            type: "unicode"
-          }
-        end
-      end
-
-      def credentials
-        if (method = options[:credentials])
-          notification.send(method)
-        else
-          Rails.application.credentials.vonage
-        end
-      end
-    end
-  end
-end

data/lib/noticed/has_notifications.rb

@@ -1,49 +0,0 @@
-module Noticed
-  module HasNotifications
-    # Defines a method for the association and a before_destroy callback to remove notifications
-    # where this record is a param
-    #
-    #    class User < ApplicationRecord
-    #      has_noticed_notifications
-    #      has_noticed_notifications param_name: :owner, destroy: false, model: "Notification"
-    #    end
-    #
-    #    @user.notifications_as_user
-    #    @user.notifications_as_owner
-
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def has_noticed_notifications(param_name: model_name.singular, **options)
-        define_method "notifications_as_#{param_name}" do
-          model = options.fetch(:model_name, "Notification").constantize
-          case current_adapter
-          when "postgresql", "postgis"
-            model.where("params @> ?", Noticed::Coder.dump(param_name.to_sym => self).to_json)
-          when "mysql2"
-            model.where("JSON_CONTAINS(params, ?)", Noticed::Coder.dump(param_name.to_sym => self).to_json)
-          when "sqlite3"
-            model.where("json_extract(params, ?) = ?", "$.#{param_name}", Noticed::Coder.dump(self).to_json)
-          else
-            # This will perform an exact match which isn't ideal
-            model.where(params: {param_name.to_sym => self})
-          end
-        end
-
-        if options.fetch(:destroy, true)
-          before_destroy do
-            send("notifications_as_#{param_name}").destroy_all
-          end
-        end
-      end
-    end
-
-    def current_adapter
-      if ActiveRecord::Base.respond_to?(:connection_db_config)
-        ActiveRecord::Base.connection_db_config.adapter
-      else
-        ActiveRecord::Base.connection_config[:adapter]
-      end
-    end
-  end
-end

data/lib/noticed/model.rb

@@ -1,85 +0,0 @@
-module Noticed
-  module Model
-    DATABASE_ERROR_CLASS_NAMES = lambda {
-      classes = [ActiveRecord::NoDatabaseError]
-      classes << ActiveRecord::ConnectionNotEstablished
-      classes << Mysql2::Error if defined?(::Mysql2)
-      classes << PG::ConnectionBad if defined?(::PG)
-      classes
-    }.call.freeze
-
-    extend ActiveSupport::Concern
-
-    included do
-      self.inheritance_column = nil
-
-      if Rails.gem_version >= Gem::Version.new("7.1.0.alpha")
-        serialize :params, coder: noticed_coder
-      else
-        serialize :params, noticed_coder
-      end
-
-      belongs_to :recipient, polymorphic: true
-
-      scope :newest_first, -> { order(created_at: :desc) }
-      scope :unread, -> { where(read_at: nil) }
-      scope :read, -> { where.not(read_at: nil) }
-    end
-
-    class_methods do
-      def mark_as_read!
-        update_all(read_at: Time.current, updated_at: Time.current)
-      end
-
-      def mark_as_unread!
-        update_all(read_at: nil, updated_at: Time.current)
-      end
-
-      def noticed_coder
-        return Noticed::TextCoder unless table_exists?
-
-        case attribute_types["params"].type
-        when :json, :jsonb
-          Noticed::Coder
-        else
-          Noticed::TextCoder
-        end
-      rescue *DATABASE_ERROR_CLASS_NAMES => _error
-        warn("Noticed was unable to bootstrap correctly as the database is unavailable.")
-
-        Noticed::TextCoder
-      end
-    end
-
-    # Rehydrate the database notification into the Notification object for rendering
-    def to_notification
-      @_notification ||= begin
-        instance = type.constantize.with(params)
-        instance.record = self
-        instance.recipient = recipient
-        instance
-      end
-    end
-
-    def mark_as_read!
-      update(read_at: Time.current)
-    end
-
-    def mark_as_unread!
-      update(read_at: nil)
-    end
-
-    def unread?
-      !read?
-    end
-
-    def read?
-      read_at?
-    end
-
-    # If a GlobalID record in params is no longer found, the params will default with a noticed_error key
-    def deserialize_error?
-      !!params[:noticed_error]
-    end
-  end
-end

data/lib/noticed/notification_channel.rb

@@ -1,15 +0,0 @@
-module Noticed
-  class NotificationChannel < ApplicationCable::Channel
-    def subscribed
-      stream_for current_user
-    end
-
-    def unsubscribed
-      stop_all_streams
-    end
-
-    def mark_as_read(data)
-      current_user.notifications.where(id: data["ids"]).mark_as_read!
-    end
-  end
-end

data/lib/noticed/text_coder.rb

@@ -1,16 +0,0 @@
-module Noticed
-  class TextCoder
-    def self.load(data)
-      return if data.nil?
-
-      # Text columns need JSON parsing
-      data = JSON.parse(data)
-      ActiveJob::Arguments.send(:deserialize_argument, data)
-    end
-
-    def self.dump(data)
-      return if data.nil?
-      ActiveJob::Arguments.send(:serialize_argument, data).to_json
-    end
-  end
-end

data/lib/rails_6_polyfills/actioncable/test_adapter.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require "action_cable/subscription_adapter/base"
-require "action_cable/subscription_adapter/subscriber_map"
-require "action_cable/subscription_adapter/async"
-
-module ActionCable
-  module SubscriptionAdapter
-    # == Test adapter for Action Cable
-    #
-    # The test adapter should be used only in testing. Along with
-    # <tt>ActionCable::TestHelper</tt> it makes a great tool to test your Rails application.
-    #
-    # To use the test adapter set +adapter+ value to +test+ in your +config/cable.yml+ file.
-    #
-    # NOTE: Test adapter extends the <tt>ActionCable::SubscriptionsAdapter::Async</tt> adapter,
-    # so it could be used in system tests too.
-    class Test < Async
-      def broadcast(channel, payload)
-        broadcasts(channel) << payload
-        super
-      end
-
-      def broadcasts(channel)
-        channels_data[channel] ||= []
-      end
-
-      def clear_messages(channel)
-        channels_data[channel] = []
-      end
-
-      def clear
-        @channels_data = nil
-      end
-
-      private
-
-      def channels_data
-        @channels_data ||= {}
-      end
-    end
-  end
-
-  # Update how broadcast_for determines the channel name so it's consistent with the Rails 6 way
-  module Channel
-    module Broadcasting
-      delegate :broadcast_to, to: :class
-      module ClassMethods
-        def broadcast_to(model, message)
-          ActionCable.server.broadcast(broadcasting_for(model), message)
-        end
-
-        def broadcasting_for(model)
-          serialize_broadcasting([channel_name, model])
-        end
-
-        def serialize_broadcasting(object) # :nodoc:
-          case # standard:disable Style/EmptyCaseCondition
-          when object.is_a?(Array)
-            object.map { |m| serialize_broadcasting(m) }.join(":")
-          when object.respond_to?(:to_gid_param)
-            object.to_gid_param
-          else
-            object.to_param
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rails_6_polyfills/actioncable/test_helper.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-module ActionCable
-  # Have ActionCable pick its Test SubscriptionAdapter when it's called for in cable.yml
-  module Server
-    class Configuration
-      def pubsub_adapter
-        (cable["adapter"] == "test") ? ActionCable::SubscriptionAdapter::Test : super
-      end
-    end
-  end
-
-  # Provides helper methods for testing Action Cable broadcasting
-  module TestHelper
-    def before_setup # :nodoc:
-      server = ActionCable.server
-      test_adapter = ActionCable::SubscriptionAdapter::Test.new(server)
-
-      @old_pubsub_adapter = server.pubsub
-
-      server.instance_variable_set(:@pubsub, test_adapter)
-      super
-    end
-
-    def after_teardown # :nodoc:
-      super
-      ActionCable.server.instance_variable_set(:@pubsub, @old_pubsub_adapter)
-    end
-
-    # Asserts that the number of broadcasted messages to the stream matches the given number.
-    #
-    #   def test_broadcasts
-    #     assert_broadcasts 'messages', 0
-    #     ActionCable.server.broadcast 'messages', { text: 'hello' }
-    #     assert_broadcasts 'messages', 1
-    #     ActionCable.server.broadcast 'messages', { text: 'world' }
-    #     assert_broadcasts 'messages', 2
-    #   end
-    #
-    # If a block is passed, that block should cause the specified number of
-    # messages to be broadcasted.
-    #
-    #   def test_broadcasts_again
-    #     assert_broadcasts('messages', 1) do
-    #       ActionCable.server.broadcast 'messages', { text: 'hello' }
-    #     end
-    #
-    #     assert_broadcasts('messages', 2) do
-    #       ActionCable.server.broadcast 'messages', { text: 'hi' }
-    #       ActionCable.server.broadcast 'messages', { text: 'how are you?' }
-    #     end
-    #   end
-    #
-    def assert_broadcasts(stream, number)
-      if block_given?
-        original_count = broadcasts_size(stream)
-        yield
-        new_count = broadcasts_size(stream)
-        actual_count = new_count - original_count
-      else
-        actual_count = broadcasts_size(stream)
-      end
-
-      assert_equal number, actual_count, "#{number} broadcasts to #{stream} expected, but #{actual_count} were sent"
-    end
-
-    # Asserts that no messages have been sent to the stream.
-    #
-    #   def test_no_broadcasts
-    #     assert_no_broadcasts 'messages'
-    #     ActionCable.server.broadcast 'messages', { text: 'hi' }
-    #     assert_broadcasts 'messages', 1
-    #   end
-    #
-    # If a block is passed, that block should not cause any message to be sent.
-    #
-    #   def test_broadcasts_again
-    #     assert_no_broadcasts 'messages' do
-    #       # No job messages should be sent from this block
-    #     end
-    #   end
-    #
-    # Note: This assertion is simply a shortcut for:
-    #
-    #   assert_broadcasts 'messages', 0, &block
-    #
-    def assert_no_broadcasts(stream, &block)
-      assert_broadcasts stream, 0, &block
-    end
-
-    # Asserts that the specified message has been sent to the stream.
-    #
-    #   def test_assert_transmitted_message
-    #     ActionCable.server.broadcast 'messages', text: 'hello'
-    #     assert_broadcast_on('messages', text: 'hello')
-    #   end
-    #
-    # If a block is passed, that block should cause a message with the specified data to be sent.
-    #
-    #   def test_assert_broadcast_on_again
-    #     assert_broadcast_on('messages', text: 'hello') do
-    #       ActionCable.server.broadcast 'messages', text: 'hello'
-    #     end
-    #   end
-    #
-    def assert_broadcast_on(stream, data)
-      # Encode to JSON and back–we want to use this value to compare
-      # with decoded JSON.
-      # Comparing JSON strings doesn't work due to the order of the keys.
-      serialized_msg =
-        ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data))
-
-      new_messages = broadcasts(stream)
-      if block_given?
-        old_messages = new_messages
-        clear_messages(stream)
-
-        yield
-        new_messages = broadcasts(stream)
-        clear_messages(stream)
-
-        # Restore all sent messages
-        (old_messages + new_messages).each { |m| pubsub_adapter.broadcast(stream, m) }
-      end
-
-      message = new_messages.find { |msg| ActiveSupport::JSON.decode(msg) == serialized_msg }
-
-      assert message, "No messages sent with #{data} to #{stream}"
-    end
-
-    def pubsub_adapter # :nodoc:
-      ActionCable.server.pubsub
-    end
-
-    delegate :broadcasts, :clear_messages, to: :pubsub_adapter
-
-    private
-
-    def broadcasts_size(channel)
-      broadcasts(channel).size
-    end
-  end
-end