pub_sub_model_sync 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ebe8b2dd34e248070f411cac0cd10fd690df7a46592f4a9827b8d185d0dbd29b
-  data.tar.gz: 2361233134bb4ffa7974fa72e14063d075134e64baeb3cca586b8704922c5242
+  metadata.gz: 733ca5e3413a098031be8a2ca5d0c3df9bf972ed8cdbf8954a1968c517ac81f4
+  data.tar.gz: a4c419efb5446e8a8632942936589b1b0a4bad2ab913a9ddd34cffb2bfdf8f2a
 SHA512:
-  metadata.gz: 5e5e022e72481ce79f69ff111562fc4fb338ab0a9caca18620825dbfabb5fd5a0467bd54c3f9e6d72b5e5bb94fcc13aaf92fb504c44d78e4929d3cd6b5b4fae8
-  data.tar.gz: 3c6a9a4f04333a34944deef057b4c6a76f9a049c8e131740604647fe7be4fcf7123e2d996c80421e12c716c62e3792ef3405e4d2fbe8e3c4d0674169a3f71c35
+  metadata.gz: 3054010e2bad46d8d2377a01757b0f52abc31f27832ddc150b12f3fb5d05f50a9aa87aa1bcafff7237918ecdc3d4cc637033dec76d32d7991d69c36d5e949ea8
+  data.tar.gz: 734be5a88e56fa6f508f1c37acdada68cf3b53db5b2d5b3d612616c27a63f4d46c305d0d2148d656c970d0a6cc9e25ec6840ead4c4a74b1c4f39b777a791e2cc

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+# 0.4.0 (May 06, 2020)
+- rename as_klass to from_klass and as_action to from_action for subscribers
+- refactor subscribers to be independent
+- refactor message_publisher to use publisher
+- rename publisher into message_publisher
+- reformat publisher to reuse connector
+
 # 0.3.1 (May 05, 2020)
 - improve rabbit service to use sleep instead of block ("Block is not recommended for production")
 - improve message ID

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pub_sub_model_sync (0.3.1)
+    pub_sub_model_sync (0.4.0)
       activesupport
       rails
 

data/README.md

@@ -86,7 +86,7 @@ User.create(name: 'test user', email: 'sample@gmail.com') # Review your App 2 to
 User.new(name: 'test user').ps_perform_sync(:create) # similar to above to perform sync on demand
 
 User.ps_class_publish({ msg: 'Hello' }, action: :greeting) # User.greeting method (Class method) will be called in App2
-PubSubModelSync::Publisher.new.publish_data(User, { msg: 'Hello' }, :greeting) # similar to above when not included publisher concern
+PubSubModelSync::MessagePublisher.publish_data(User, { msg: 'Hello' }, :greeting) # similar to above when not included publisher concern
 ```
 
 ## Advanced Example
@@ -110,8 +110,8 @@ end
 class User < ActiveRecord::Base
   self.table_name = 'subscriber_users'
   include PubSubModelSync::SubscriberConcern
-  ps_subscribe(%i[name], actions: %i[update], as_klass: 'Client', id: %i[client_id email])
-  ps_class_subscribe(:greeting, as_action: :custom_greeting, as_klass: 'CustomUser')
+  ps_subscribe(%i[name], actions: %i[update], from_klass: 'Client', id: %i[client_id email])
+  ps_class_subscribe(:greeting, from_action: :custom_greeting, from_klass: 'CustomUser')
   alias_attribute :full_name, :name
   
   def self.greeting(data)
@@ -139,14 +139,14 @@ end
 ## API
 ### Subscribers
 - Permit to configure class level listeners
-  ```ps_class_subscribe(action_name, as_action: nil, as_klass: nil)```
-  * as_action: (Optional) Source method name
-  * as_klass: (Optional) Source class name
+  ```ps_class_subscribe(action_name, from_action: nil, from_klass: nil)```
+  * from_action: (Optional) Source method name
+  * from_klass: (Optional) Source class name
   
 - Permit to configure instance level listeners (CRUD)
-  ```ps_subscribe(attrs, as_klass: nil, actions: nil, id: nil)```
+  ```ps_subscribe(attrs, from_klass: nil, actions: nil, id: nil)```
   * attrs: (Array/Required) Array of all attributes to be synced
-  * as_klass: (String/Optional) Source class name (Instead of the model class name, will use this value) 
+  * from_klass: (String/Optional) Source class name (Instead of the model class name, will use this value) 
   * actions: (Array/Optional, default: create/update/destroy) permit to customize action names
   * id: (Sym|Array/Optional, default: id) Attr identifier(s) to find the corresponding model
 
@@ -198,7 +198,7 @@ end
   * as_klass: (optional, :string) Custom class name (Default current model name)
       
 - Publish a class level notification (Same as above: on demand call)    
-  ```PubSubModelSync::Publisher.new.publish_data(Klass_name, data, action_name)```  
+  ```PubSubModelSync::MessagePublisher.publish_data(Klass_name, data, action_name)```  
   * klass_name: (required, Class) same class name as defined in ps_class_subscribe(...)
   * data: (required, :hash) message value to deliver    
   * action_name: (required, :sim) same action name as defined in ps_class_subscribe(...)
@@ -254,20 +254,20 @@ end
   
     # Publisher
     it 'publish model action' do
-      publisher = PubSubModelSync::Publisher  
+      publisher = PubSubModelSync::MessagePublisher  
       data = { name: 'hello'}
       action = :create
       User.ps_class_publish(data, action: action)
       user = User.create(name: 'name', email: 'email')
-      expect_any_instance_of(publisher).to receive(:publish_model).with(user, :create, anything)
+      expect(publisher).to receive(:publish_model).with(user, :create, anything)
     end
        
     it 'publish class message' do
-      publisher = PubSubModelSync::Publisher  
+      publisher = PubSubModelSync::MessagePublisher  
       data = {msg: 'hello'}
       action = :greeting
       User.ps_class_publish(data, action: action)
-      expect_any_instance_of(publisher).to receive(:publish_data).with('User', data, action)
+      expect(publisher).to receive(:publish_data).with('User', data, action)
     end
     ```
 

data/lib/pub_sub_model_sync.rb

@@ -6,12 +6,15 @@ require 'active_support'
 require 'pub_sub_model_sync/railtie'
 require 'pub_sub_model_sync/config'
 require 'pub_sub_model_sync/subscriber_concern'
-require 'pub_sub_model_sync/publisher'
+require 'pub_sub_model_sync/message_publisher'
 require 'pub_sub_model_sync/publisher_concern'
 require 'pub_sub_model_sync/runner'
 require 'pub_sub_model_sync/connector'
 require 'pub_sub_model_sync/message_processor'
 
+require 'pub_sub_model_sync/publisher'
+require 'pub_sub_model_sync/subscriber'
+
 require 'pub_sub_model_sync/service_base'
 require 'pub_sub_model_sync/service_google'
 require 'pub_sub_model_sync/service_rabbit'

data/lib/pub_sub_model_sync/config.rb

@@ -2,7 +2,7 @@
 
 module PubSubModelSync
   class Config
-    cattr_accessor(:listeners) { [] }
+    cattr_accessor(:subscribers) { [] }
     cattr_accessor(:publishers) { [] }
     cattr_accessor(:service_name) { :google }
     cattr_accessor :logger

data/lib/pub_sub_model_sync/message_processor.rb

@@ -2,91 +2,39 @@
 
 module PubSubModelSync
   class MessageProcessor
-    attr_accessor :data, :settings, :message_id
+    attr_accessor :data, :klass, :action
 
     # @param data (Hash): any hash value to deliver
     def initialize(data, klass, action)
       @data = data
-      @settings = { klass: klass, action: action }
-      @message_id = [klass, action, Time.now.hash].join('-')
+      @klass = klass
+      @action = action
     end
 
     def process
-      @failed = false
-      log "processing message: #{[data, settings]}"
-      listeners = filter_listeners
-      return log 'Skipped: No listeners' unless listeners.any?
-
-      eval_message(listeners)
-      log 'processed message' unless @failed
+      subscribers = filter_subscribers
+      subscribers.each { |subscriber| run_subscriber(subscriber) }
     end
 
     private
 
-    def eval_message(listeners)
-      listeners.each do |listener|
-        if listener[:direct_mode]
-          call_class_listener(listener)
-        else
-          call_listener(listener)
-        end
-      end
-    end
-
-    def call_class_listener(listener)
-      model_class = listener[:klass].constantize
-      model_class.send(listener[:action], data)
+    def run_subscriber(subscriber)
+      subscriber.eval_message(data)
+      log "processed message with: #{[klass, action, data]}"
     rescue => e
-      log("Error listener (#{listener}): #{e.message}", :error)
-      @failed = true
-    end
-
-    # support for: create, update, destroy
-    def call_listener(listener)
-      model = find_model(listener)
-      if settings[:action].to_sym == :destroy
-        model.destroy!
-      else
-        populate_model(model, listener)
-        model.save!
-      end
-    rescue => e
-      log("Error listener (#{listener}): #{e.message}", :error)
-      @failed = true
-    end
-
-    def find_model(listener)
-      model_class = listener[:klass].constantize
-      if model_class.respond_to?(:ps_find_model)
-        return model_class.ps_find_model(data, settings)
-      end
-
-      model_class.where(model_identifiers(listener)).first_or_initialize
-    end
-
-    def model_identifiers(listener)
-      identifiers = listener[:settings][:id]
-      identifiers = [identifiers] unless identifiers.is_a?(Array)
-      identifiers.map { |key| [key, data[key.to_sym]] }.to_h
-    end
-
-    def populate_model(model, listener)
-      values = data.slice(*listener[:settings][:attrs])
-      values.each do |attr, value|
-        model.send("#{attr}=", value)
-      end
+      info = [klass, action, data, e.message, e.backtrace]
+      log("error processing message: #{info}", :error)
     end
 
-    def filter_listeners
-      listeners = PubSubModelSync::Config.listeners
-      listeners.select do |listener|
-        listener[:as_klass].to_s == settings[:klass].to_s &&
-          listener[:as_action].to_s == settings[:action].to_s
+    def filter_subscribers
+      PubSubModelSync::Config.subscribers.select do |subscriber|
+        subscriber.settings[:from_klass].to_s == klass.to_s &&
+          subscriber.settings[:from_action].to_s == action.to_s
       end
     end
 
     def log(message, kind = :info)
-      PubSubModelSync::Config.log "(ID: #{message_id}) #{message}", kind
+      PubSubModelSync::Config.log message, kind
     end
   end
 end

data/lib/pub_sub_model_sync/message_publisher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class MessagePublisher
+    class << self
+      delegate :publish, to: :connector
+
+      def connector
+        @connector ||= PubSubModelSync::Connector.new
+      end
+
+      def publish_data(klass, data, action)
+        attrs = { klass: klass.to_s, action: action.to_sym }
+        publish(data, attrs)
+      end
+
+      # @param model: ActiveRecord model
+      # @param action: (Sym) Action name
+      # @param publisher: (Publisher, optional) Publisher to be used
+      def publish_model(model, action, publisher = nil)
+        return if model.ps_skip_sync?(action)
+
+        publisher ||= model.class.ps_publisher(action)
+        payload = publisher.payload(model, action)
+        res_before = model.ps_before_sync(action, payload[:data])
+        return if res_before == :cancel
+
+        publish(payload[:data], payload[:attrs])
+        model.ps_after_sync(action, payload[:data])
+      end
+    end
+  end
+end

data/lib/pub_sub_model_sync/publisher.rb

@@ -2,42 +2,24 @@
 
 module PubSubModelSync
   class Publisher
-    attr_accessor :connector
-    delegate :publish, to: :connector
-
-    def initialize
-      @connector = PubSubModelSync::Connector.new
-    end
-
-    def publish_data(klass, data, action)
-      attributes = self.class.build_attrs(klass, action)
-      publish(data, attributes)
+    attr_accessor :attrs, :actions, :klass, :as_klass
+    def initialize(attrs, klass, actions = nil, as_klass = nil)
+      @attrs = attrs
+      @klass = klass
+      @actions = actions || %i[create update destroy]
+      @as_klass = as_klass || klass
     end
 
-    # @param custom_settings (Hash): { attrs: [], as_klass: nil }
-    def publish_model(model, action, custom_settings = {})
-      return if model.ps_skip_sync?(action)
-
-      settings = model.class.ps_publisher(action).merge(custom_settings)
-      attributes = build_model_attrs(model, action, settings)
-      data = build_model_data(model, settings[:attrs])
-      res_before = model.ps_before_sync(action, data)
-      return if res_before == :cancel
-
-      publish(data.symbolize_keys, attributes)
-      model.ps_after_sync(action, data)
-    end
-
-    def self.build_attrs(klass, action)
-      { klass: klass.to_s, action: action.to_sym }
+    def payload(model, action)
+      { data: payload_data(model), attrs: payload_attrs(model, action) }
     end
 
     private
 
-    def build_model_data(model, model_props)
-      source_props = model_props.map { |prop| prop.to_s.split(':').first }
+    def payload_data(model)
+      source_props = @attrs.map { |prop| prop.to_s.split(':').first }
       data = model.as_json(only: source_props, methods: source_props)
-      aliased_props = model_props.select { |prop| prop.to_s.include?(':') }
+      aliased_props = @attrs.select { |prop| prop.to_s.include?(':') }
       aliased_props.each do |prop|
         source, target = prop.to_s.split(':')
         data[target] = data.delete(source)
@@ -45,13 +27,8 @@ module PubSubModelSync
       data.symbolize_keys
     end
 
-    def build_model_attrs(model, action, settings)
-      as_klass = (settings[:as_klass] || model.class.name).to_s
-      self.class.build_attrs(as_klass, action)
-    end
-
-    def log(msg)
-      PubSubModelSync::Config.log(msg)
+    def payload_attrs(model, action)
+      { klass: (as_klass || model.class.name).to_s, action: action.to_sym }
     end
   end
 end

data/lib/pub_sub_model_sync/publisher_concern.rb

@@ -23,49 +23,49 @@ module PubSubModelSync
     def ps_after_sync(_action, _data); end
 
     # To perform sync on demand
-    # @param custom_settings (Hash): { attrs: [], as_klass: nil }
-    def ps_perform_sync(action = :create, custom_settings = {})
-      service = self.class.ps_publisher_service
-      model_settings = self.class.ps_publisher(action) || {}
-      service.publish_model(self, action, model_settings.merge(custom_settings))
+    # @param attrs (Array, optional): custom attrs to be used
+    # @param as_klass (Array, optional): custom klass name to be used
+    # @param publisher (Publisher, optional): custom publisher object
+    def ps_perform_sync(action = :create, attrs: nil, as_klass: nil,
+                        publisher: nil)
+      publisher ||= self.class.ps_publisher(action).dup
+      publisher.attrs = attrs if attrs
+      publisher.as_klass = as_klass if as_klass
+      PubSubModelSync::MessagePublisher.publish_model(self, action, publisher)
     end
 
     module ClassMethods
       # Permit to configure to publish crud actions (:create, :update, :destroy)
       def ps_publish(attrs, actions: %i[create update destroy], as_klass: nil)
-        as_klass ||= name
+        klass = PubSubModelSync::Publisher
+        publisher = klass.new(attrs, name, actions, as_klass)
+        PubSubModelSync::Config.publishers << publisher
         actions.each do |action|
-          info = { klass: name, action: action, attrs: attrs,
-                   as_klass: as_klass }
-          PubSubModelSync::Config.publishers << info
-          ps_register_callback(action.to_sym, info)
+          ps_register_callback(action.to_sym, publisher)
         end
       end
 
       # On demand class level publisher
       def ps_class_publish(data, action:, as_klass: nil)
         as_klass = (as_klass || name).to_s
-        ps_publisher_service.publish_data(as_klass, data, action.to_sym)
+        klass = PubSubModelSync::MessagePublisher
+        klass.publish_data(as_klass, data, action.to_sym)
       end
 
       # Publisher info for specific action
       def ps_publisher(action = :create)
-        PubSubModelSync::Config.publishers.find do |listener|
-          listener[:klass] == name && listener[:action] == action
+        PubSubModelSync::Config.publishers.find do |publisher|
+          publisher.klass == name && publisher.actions.include?(action)
         end
       end
 
-      def ps_publisher_service
-        PubSubModelSync::Publisher.new
-      end
-
       private
 
-      def ps_register_callback(action, info)
+      def ps_register_callback(action, publisher)
         after_commit(on: action) do |model|
           unless model.ps_skip_callback?(action)
-            service = model.class.ps_publisher_service
-            service.publish_model(model, action.to_sym, info)
+            klass = PubSubModelSync::MessagePublisher
+            klass.publish_model(model, action.to_sym, publisher)
           end
         end
       end

data/lib/pub_sub_model_sync/service_base.rb

@@ -19,7 +19,7 @@ module PubSubModelSync
     private
 
     # @param payload (String JSON): '{"data":{}, "attributes":{..}}'
-    #   refer: PubSubModelSync::Publisher (.publish_model | .publish_data)
+    #   refer: PubSubModelSync::MessagePublisher(.publish_model | .publish_data)
     def perform_message(payload)
       data, attrs = parse_message_payload(payload)
       args = [data, attrs[:klass], attrs[:action]]

data/lib/pub_sub_model_sync/service_google.rb

@@ -30,9 +30,11 @@ module PubSubModelSync
 
     def publish(data, attributes)
       log("Publishing message: #{[data, attributes]}")
-
       payload = { data: data, attributes: attributes }.to_json
       topic.publish(payload, { SERVICE_KEY => true })
+    rescue => e
+      info = [data, attributes, e.message, e.backtrace]
+      log("Error publishing: #{info}", :error)
     end
 
     def stop

data/lib/pub_sub_model_sync/subscriber.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class Subscriber
+    attr_accessor :klass, :action, :attrs, :settings
+
+    # @param settings: (Hash) { id: :id, direct_mode: false,
+    #                           from_klass: klass, from_action: action }
+    def initialize(klass, action, attrs: nil, settings: {})
+      def_settings = { id: :id, direct_mode: false,
+                       from_klass: klass, from_action: action }
+      @klass = klass
+      @action = action
+      @attrs = attrs
+      @settings = def_settings.merge(settings)
+    end
+
+    def eval_message(message)
+      if settings[:direct_mode]
+        run_class_message(message)
+      else
+        run_model_message(message)
+      end
+    end
+
+    private
+
+    def run_class_message(message)
+      model_class = klass.constantize
+      model_class.send(action, message)
+    end
+
+    # support for: create, update, destroy
+    def run_model_message(message)
+      model = find_model(message)
+      if action == :destroy
+        model.destroy!
+      else
+        populate_model(model, message)
+        model.save!
+      end
+    end
+
+    def find_model(message)
+      model_class = klass.constantize
+      if model_class.respond_to?(:ps_find_model)
+        return model_class.ps_find_model(message)
+      end
+
+      model_class.where(model_identifiers(message)).first_or_initialize
+    end
+
+    def model_identifiers(message)
+      identifiers = Array(settings[:id])
+      identifiers.map { |key| [key, message[key.to_sym]] }.to_h
+    end
+
+    def populate_model(model, message)
+      values = message.slice(*attrs)
+      values.each do |attr, value|
+        model.send("#{attr}=", value)
+      end
+    end
+  end
+end

data/lib/pub_sub_model_sync/subscriber_concern.rb

@@ -7,37 +7,34 @@ module PubSubModelSync
     end
 
     module ClassMethods
-      def ps_subscribe(attrs, as_klass: nil, actions: nil, id: :id)
+      def ps_subscribe(attrs, actions: nil, from_klass: name, id: :id)
+        settings = { id: id, from_klass: from_klass }
         actions ||= %i[create update destroy]
-        settings = { attrs: attrs, id: id }
         actions.each do |action|
-          add_ps_subscriber(as_klass, action, action, false, settings)
+          add_ps_subscriber(action, attrs, settings)
         end
       end
 
-      def ps_class_subscribe(action, as_action: nil, as_klass: nil)
-        add_ps_subscriber(as_klass, action, as_action, true, {})
+      def ps_class_subscribe(action, from_action: nil, from_klass: nil)
+        settings = { direct_mode: true }
+        settings[:from_action] = from_action if from_action
+        settings[:from_klass] = from_klass if from_klass
+        add_ps_subscriber(action, nil, settings)
       end
 
       def ps_subscriber(action = :create)
-        PubSubModelSync::Config.listeners.find do |listener|
-          listener[:klass] == name && listener[:action] == action
+        PubSubModelSync::Config.subscribers.find do |subscriber|
+          subscriber.klass == name && subscriber.action == action
         end
       end
 
       private
 
-      # @param settings (Hash): { id:, attrs: }
-      def add_ps_subscriber(as_klass, action, as_action, direct_mode, settings)
-        listener = {
-          klass: name,
-          as_klass: (as_klass || name).to_s,
-          action: action.to_sym,
-          as_action: (as_action || action).to_sym,
-          direct_mode: direct_mode,
-          settings: settings
-        }
-        PubSubModelSync::Config.listeners.push(listener) && listener
+      # @param settings (Hash): refer to PubSubModelSync::Subscriber.settings
+      def add_ps_subscriber(action, attrs, settings = {})
+        klass = PubSubModelSync::Subscriber
+        subscriber = klass.new(name, action, attrs: attrs, settings: settings)
+        PubSubModelSync::Config.subscribers.push(subscriber) && subscriber
       end
     end
   end

data/lib/pub_sub_model_sync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PubSubModelSync
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pub_sub_model_sync
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Owen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-05 00:00:00.000000000 Z
+date: 2020-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -127,6 +127,7 @@ files:
 - lib/pub_sub_model_sync/config.rb
 - lib/pub_sub_model_sync/connector.rb
 - lib/pub_sub_model_sync/message_processor.rb
+- lib/pub_sub_model_sync/message_publisher.rb
 - lib/pub_sub_model_sync/mock_google_service.rb
 - lib/pub_sub_model_sync/mock_kafka_service.rb
 - lib/pub_sub_model_sync/mock_rabbit_service.rb
@@ -138,6 +139,7 @@ files:
 - lib/pub_sub_model_sync/service_google.rb
 - lib/pub_sub_model_sync/service_kafka.rb
 - lib/pub_sub_model_sync/service_rabbit.rb
+- lib/pub_sub_model_sync/subscriber.rb
 - lib/pub_sub_model_sync/subscriber_concern.rb
 - lib/pub_sub_model_sync/tasks/worker.rake
 - lib/pub_sub_model_sync/version.rb