siftery-wisper 2.0.1

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require 'coveralls/rake/task'
+
+RSpec::Core::RakeTask.new
+Coveralls::RakeTask.new
+
+task :test_with_coveralls => [:spec, 'coveralls:push']
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wisper"
+
+require "pry"
+Pry.start
+

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/gem-public_cert.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDeDCCAmCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBBMRMwEQYDVQQDDAprcmlz
+LmxlZWNoMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZFgNj
+b20wHhcNMTQxMTA1MTEwMzQ4WhcNMTUxMTA1MTEwMzQ4WjBBMRMwEQYDVQQDDApr
+cmlzLmxlZWNoMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
+FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtW0/UtrFK/tSm
+uq5HnCUkZAQjnSaZ/h1Tby9s30CDJjDUdizPRdLQCplLDAMHFsAfTyD0Mc+Ez8o9
+CdTh8EZ4TSf+nokL+SUprpdR6qm6OWU03Ntd+bDCP0+rdqCX82g3N3mnvjR9aD3a
++hd9Fhp0WuEyqTNjQ7IlopeUPDW7eYfSwI4bjfRHxsDR1GuZ3j0npxCAgAIN41WH
+MSTTZhdo0vKEiKZEtMMnT6w6fG/c3XIhVVPGnqy5+IZqBL0SYC+WJL3vC6yUBgqB
+nrpA/q+b3M69W+q+TkGv0qOnrxln0O7J2pykjoGIxUhhRkiGEldEhy9dxQWubffr
+hVJ4F0wLAgMBAAGjezB5MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+BBSzq+x8mwj0ldvNkvjOl44OJG354jAfBgNVHREEGDAWgRRrcmlzLmxlZWNoQGdt
+YWlsLmNvbTAfBgNVHRIEGDAWgRRrcmlzLmxlZWNoQGdtYWlsLmNvbTANBgkqhkiG
+9w0BAQUFAAOCAQEAF5M2Md3DcNCrQrDRDLaIzHaMM+RTgfbpgmZ6tU0iEowES18g
+QWQgrAbFuvQRPETJ2gbL5AC35fEqN80nU+3GhgW/bDYhII5D3PGLMorxhFw1JYLI
+0Fd7MCE0sImc2rPybYUdpZ6TxvqgPKp+8CzM8vBUrdYd+dSHXit1piViWBcZcJb+
+EL5Ze4IodjkCPAeHvu2MQieieViLyfB4eG1syvfkxvAXCjFHeQoIFP16vVtcljdF
+k5cHH/4SGeMuGrSLRsqVvltxVV3AbQAfH8WUos2brjYHsoH5tVPrJ7UcFhzP95oU
+pEfFMW42smiNTOXpzG6JoIpA11szEHFT5ZS+UQ==
+-----END CERTIFICATE-----

data/lib/wisper.rb

@@ -0,0 +1,65 @@
+require 'set'
+require 'wisper/version'
+require 'wisper/configuration'
+require 'wisper/publisher'
+require 'wisper/value_objects/prefix'
+require 'wisper/value_objects/events'
+require 'wisper/registration/registration'
+require 'wisper/registration/object'
+require 'wisper/registration/block'
+require 'wisper/global_listeners'
+require 'wisper/temporary_listeners'
+require 'wisper/broadcasters/send_broadcaster'
+require 'wisper/broadcasters/logger_broadcaster'
+
+module Wisper
+  # Examples:
+  #
+  #   Wisper.subscribe(AuditRecorder.new)
+  #
+  #   Wisper.subscribe(AuditRecorder.new, StatsRecorder.new)
+  #
+  #   Wisper.subscribe(AuditRecorder.new, on: 'order_created')
+  #
+  #   Wisper.subscribe(AuditRecorder.new, scope: 'MyPublisher')
+  #
+  #   Wisper.subscribe(AuditRecorder.new, StatsRecorder.new) do
+  #     # ..
+  #   end
+  #
+  def self.subscribe(*args, &block)
+    if block_given?
+      TemporaryListeners.subscribe(*args, &block)
+    else
+      GlobalListeners.subscribe(*args)
+    end
+  end
+
+  def self.unsubscribe(*listeners)
+    GlobalListeners.unsubscribe(*listeners)
+  end
+
+  def self.publisher
+    Publisher
+  end
+
+  def self.clear
+    GlobalListeners.clear
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.setup
+    configure do |config|
+      config.broadcaster(:default, Broadcasters::SendBroadcaster.new)
+    end
+  end
+end
+
+Wisper.setup

data/lib/wisper/broadcasters/logger_broadcaster.rb

@@ -0,0 +1,37 @@
+# Provides a way of wrapping another broadcaster with logging
+
+module Wisper
+  module Broadcasters
+    class LoggerBroadcaster
+      def initialize(logger, broadcaster)
+        @logger      = logger
+        @broadcaster = broadcaster
+      end
+
+      def broadcast(listener, publisher, event, args)
+        @logger.info("[WISPER] #{name(publisher)} published #{event} to #{name(listener)} with #{args_info(args)}")
+        @broadcaster.broadcast(listener, publisher, event, args)
+      end
+
+      private
+
+      def name(object)
+        id_method  = %w(id uuid key object_id).find do |method_name|
+          object.respond_to?(method_name) && object.method(method_name).arity <= 0
+        end
+        id         = object.send(id_method)
+        class_name = object.class == Class ? object.name : object.class.name
+        "#{class_name}##{id}"
+      end
+
+      def args_info(args)
+        return 'no arguments' if args.empty?
+        args.map do |arg|
+          arg_string = name(arg)
+          arg_string += ": #{arg.inspect}" if [Numeric, Array, Hash, String].any? {|klass| arg.is_a?(klass) }
+          arg_string
+        end.join(', ')
+      end
+    end
+  end
+end

data/lib/wisper/broadcasters/send_broadcaster.rb

@@ -0,0 +1,9 @@
+module Wisper
+  module Broadcasters
+    class SendBroadcaster
+      def broadcast(listener, publisher, event, args)
+        listener.public_send(event, *args)
+      end
+    end
+  end
+end

data/lib/wisper/configuration.rb

@@ -0,0 +1,44 @@
+require 'forwardable'
+
+module Wisper
+  class Configuration
+    attr_reader :broadcasters
+
+    def initialize
+      @broadcasters = Broadcasters.new
+    end
+
+    # registers a broadcaster, referenced by key
+    #
+    # @param key [String, #to_s] an arbitrary key
+    # @param broadcaster [#broadcast] a broadcaster
+    def broadcaster(key, broadcaster)
+      @broadcasters[key] = broadcaster
+      self
+    end
+
+    # sets the default value for prefixes
+    #
+    # @param [#to_s] value
+    #
+    # @return [String]
+    def default_prefix=(value)
+      ValueObjects::Prefix.default = value
+    end
+
+    class Broadcasters
+      extend Forwardable
+
+      def_delegators :@data, :[], :[]=, :empty?, :include?, :clear, :keys, :to_h
+
+      def initialize
+        @data = {}
+      end
+
+      def fetch(key)
+        raise KeyError, "broadcaster not found for #{key}" unless include?(key)
+        @data[key]
+      end
+    end
+  end
+end

data/lib/wisper/global_listeners.rb

@@ -0,0 +1,74 @@
+# Handles global subscriptions
+
+# @api private
+
+require 'singleton'
+
+module Wisper
+  class GlobalListeners
+    include Singleton
+
+    def initialize
+      @registrations = Set.new
+      @mutex         = Mutex.new
+    end
+
+    def subscribe(*listeners)
+      options = listeners.last.is_a?(Hash) ? listeners.pop : {}
+
+      with_mutex do
+        listeners.each do |listener|
+          @registrations << ObjectRegistration.new(listener, options)
+        end
+      end
+      self
+    end
+
+    def unsubscribe(*listeners)
+      with_mutex do
+        @registrations.delete_if do |registration|
+          listeners.include?(registration.listener)
+        end
+      end
+      self
+    end
+
+    def registrations
+      with_mutex { @registrations }
+    end
+
+    def listeners
+      registrations.map(&:listener).freeze
+    end
+
+    def clear
+      with_mutex { @registrations.clear }
+    end
+
+    def self.subscribe(*listeners)
+      instance.subscribe(*listeners)
+    end
+
+    def self.unsubscribe(*listeners)
+      instance.unsubscribe(*listeners)
+    end
+
+    def self.registrations
+      instance.registrations
+    end
+
+    def self.listeners
+      instance.listeners
+    end
+
+    def self.clear
+      instance.clear
+    end
+
+    private
+
+    def with_mutex
+      @mutex.synchronize { yield }
+    end
+  end
+end

data/lib/wisper/publisher.rb

@@ -0,0 +1,89 @@
+module Wisper
+  module Publisher
+    def listeners
+      registrations.map(&:listener).freeze
+    end
+
+    # subscribe a listener
+    #
+    # @example
+    #   my_publisher.subscribe(MyListener.new)
+    #
+    # @return [self]
+    def subscribe(listener, options = {})
+      raise ArgumentError, "#{__method__} does not take a block, did you mean to call #on instead?" if block_given?
+      local_registrations << ObjectRegistration.new(listener, options)
+      self
+    end
+
+    # subscribe a block
+    #
+    # @example
+    #   my_publisher.on(:order_created) { |args| ... }
+    #
+    # @return [self]
+    def on(*events, &block)
+      raise ArgumentError, 'must give at least one event' if events.empty?
+      raise ArgumentError, 'must pass a block' if !block
+      local_registrations << BlockRegistration.new(block, on: events)
+      self
+    end
+
+    # broadcasts an event
+    #
+    # @example
+    #   def call
+    #     # ...
+    #     broadcast(:finished, self)
+    #   end
+    #
+    # @return [self]
+    def broadcast(event, *args)
+      registrations.each do | registration |
+        registration.broadcast(clean_event(event), self, *args)
+      end
+      self
+    end
+
+    alias :publish :broadcast
+
+    private :broadcast, :publish
+
+    module ClassMethods
+      # subscribe a listener
+      #
+      # @example
+      #   MyPublisher.subscribe(MyListener.new)
+      #
+      def subscribe(listener, options = {})
+        GlobalListeners.subscribe(listener, options.merge(:scope => self))
+      end
+    end
+
+    private
+
+    def local_registrations
+      @local_registrations ||= Set.new
+    end
+
+    def global_registrations
+      GlobalListeners.registrations
+    end
+
+    def temporary_registrations
+      TemporaryListeners.registrations
+    end
+
+    def registrations
+      local_registrations + global_registrations + temporary_registrations
+    end
+
+    def clean_event(event)
+      event.to_s.gsub('-', '_')
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/wisper/registration/block.rb

@@ -0,0 +1,11 @@
+# @api private
+
+module Wisper
+  class BlockRegistration < Registration
+    def broadcast(event, publisher, *args)
+      if should_broadcast?(event)
+        listener.call(*args)
+      end
+    end
+  end
+end

data/lib/wisper/registration/object.rb

@@ -0,0 +1,77 @@
+# @api private
+
+module Wisper
+  class ObjectRegistration < Registration
+    attr_reader :with, :prefix, :allowed_classes, :broadcaster
+
+    def initialize(listener, options)
+      super(listener, options)
+      @with   = options[:with]
+      @prefix = ValueObjects::Prefix.new options[:prefix]
+      @allowed_classes = Array(options[:scope]).map(&:to_s).to_set
+      @broadcaster = map_broadcaster
+    end
+
+    def broadcast(event, publisher, *args)
+      method_to_call = map_event_to_method(event)
+      if should_broadcast?(event) && listener.respond_to?(method_to_call) && publisher_in_scope?(publisher)
+        broadcaster.broadcast(listener, publisher, method_to_call, args)
+      end
+    end
+
+    private
+
+    def publisher_in_scope?(publisher)
+      allowed_classes.empty? || publisher.class.ancestors.any? { |ancestor| allowed_classes.include?(ancestor.to_s) }
+    end
+
+    def map_event_to_method(event)
+      prefix + (with || event).to_s
+    end
+
+    # @return [Object] broadcaster instance
+    def map_broadcaster
+      key = broadcaster_key
+      value = options[key]
+      return value if value.respond_to?(:broadcast)
+
+      broadcaster_with_options(key, value)
+    end
+
+    # @return [Symbol] key to fetch broadcaster by
+    #
+    # @example (setup => key)
+    #   publisher.subscribe(Subscriber, async: Wisper::SidekiqBroadcaster.new)       # => :async
+    #   publisher.subscribe(Subscriber, async: true)                                 # => :async
+    #   publisher.subscribe(Subscriber, sidekiq: { queue: 'custom' })                # => :sidekiq
+    #   publisher.subscribe(Subscriber)                                              # => :default
+    #   publisher.subscribe(Subscriber, broadcaster: Wisper::SidekiqBroadcaster.new) # => :broadcaster
+    #   publisher.subscribe(Subscriber, broadcaster: :custom)                        # => :custom
+    #
+    def broadcaster_key
+      return :async if options.has_key?(:async) && options[:async]
+      return :default unless options.has_key?(:broadcaster)
+      options[:broadcaster].is_a?(Symbol) ? options[:broadcaster] : :broadcaster
+    end
+
+    # @param [Symbol] key - param to fetch broadcaster by
+    # @param [Boolean, Nil, Hash, Object] value - broadcaster value. Allowed values are the following:
+    #   nil                 # => default broadcaster
+    #   false               # => default broadcaster
+    #   true                # => async broadcaster
+    #   Broadcaster.new     # => returns the provided broadcaster instance
+    #   { queue: 'custom' } # => is used when broadcaster is configured as a callable object. In this case
+    #                       #    the given options are passed to broadcaster initializer
+    #
+    # @return [Object] broadcaster instance for the given key / value pair
+    #
+    def broadcaster_with_options(key, value)
+      result = configuration.broadcasters.fetch(key)
+      result.respond_to?(:call) ? result.call(value) : result
+    end
+
+    def configuration
+      Wisper.configuration
+    end
+  end
+end