pub_sub_model_sync 0.2.4 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7655730b3b89716b76be52db708b7c93ec64176cc158fc84323d4e811f6dcdf1
-  data.tar.gz: 874aa3f5c5c679fd3e7ec02550426f0824481194ebd99b1a0494180df3a22cc6
+  metadata.gz: c0bd383488f8214ca409871adf231319b905f41833b8a9db9c2bc58a9d5a2691
+  data.tar.gz: c05ca888a6c085280407f9a1e26fe7552efa1c33f6be7735129ff2f8addd77fc
 SHA512:
-  metadata.gz: 9e8406293a7528fa5d697c2a6a30b4cb00cee900b349ef834fad5fd7771ce864a8338ac95bc1bcbe41568d9efa1737111720607cb0f002e684ab532e835ec651
-  data.tar.gz: 0f995774ddf1b916db02fed9051c26b106e549261877c72a718e9e23c45544dff6c9757231e094201c9d466b2c4922d8e6364f8167697820db5833d78ee85c85
+  metadata.gz: f8769aee9d08936fd9fd4707e1dd5664c30ccbb6b2b59e386182ac4a0c173b46813df9ca5ccc3a3e3139af4297c160ca5ddb05a555d8f2c1fbb719e7a54384f4
+  data.tar.gz: bc25309e3894fd5905d0e3fdc180d93a98cfced77ff006f24d0044f1db717f5b0fa475722126901ec18381d3e4890a2a0ff00f7ecb234405cdad4a1e7049a5fb

data/.github/workflows/ruby.yml

@@ -6,28 +6,45 @@ on:
       - master
   pull_request:
 
-
 jobs:
   build:
     name: Tests and Code Style
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [2.4, 2.5, 2.6]
+        rails: [4, 5, 6]
+        include:
+          - ruby: 2.7
+            rails: 6
+        exclude: # rails 6 requires ruby >= 2.5
+          - ruby: 2.4
+            rails: 6
 
     steps:
       - uses: actions/checkout@v2
-      - name: Set up Ruby 2.6
+      - name: Set up Ruby
         uses: actions/setup-ruby@v1
         with:
-          ruby-version: 2.6.x
-
+          ruby-version: ${{ matrix.ruby }}
       - name: Install sqlite3
         run: sudo apt-get install libsqlite3-dev
 
-      - name: Bundle install
+      - name: Install bundler
+        env:
+          GEMFILE_PATH: gemfiles/Gemfile_${{ matrix.rails }}
+          RAILS_V: ${{ matrix.rails }}
         run: |
-          gem install bundler
-          bundle install --jobs 4 --retry 3
+          rm -f Gemfile.lock && rm -f Gemfile
+          cp $GEMFILE_PATH ./Gemfile
+          bundler_v='2.1.4'
+          if [ $RAILS_V = "4" ]; then bundler_v="1.16.6"; fi
+          gem install bundler -v "~> $bundler_v"
+          bundle _${bundler_v}_ install --jobs 4 --retry 3
+
       - name: Tests (rspec)
         run: |
           bundle exec rspec
+
       - name: Code style (Rubocop)
         run: bundle exec rubocop

data/.rubocop.yml

@@ -6,13 +6,11 @@ AllCops:
     - 'Gemfile'
     - 'Rakefile'
     - 'bin/*'
-  TargetRubyVersion: 2.3
 
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*.rb'
 
-
 Style/SymbolArray:
   Exclude:
     - 'Gemfile'

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Change Log
 
+# 0.4.1 (May 12, 2020)
+- chore: improve log messages
+- feat: do not update model if no changes
+- feat: skip publisher after updating if no changes
+
+
+# 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
+
+# 0.3.0 (April 29, 2020)
+- Support for multiple identifiers when syncing
+- Add klass.ps_find_model method for a custom model finder
+
 # 0.2.4 (April 28, 2020)
 - Delegate .publish to the .publisher for better understanding
 

data/Gemfile

@@ -5,5 +5,9 @@ gem 'bunny' # rabbit-mq
 gem 'google-cloud-pubsub' # google pub/sub
 gem 'ruby-kafka' # kafka pub/sub
 
+group :test do
+  gem 'database_cleaner-active_record'
+end
+
 # Specify your gem's dependencies in pub_sub_model_sync.gemspec
 gemspec

data/Gemfile.lock

@@ -1,8 +1,7 @@
 PATH
   remote: .
   specs:
-    pub_sub_model_sync (0.2.4)
-      activesupport
+    pub_sub_model_sync (0.4.2)
       rails
 
 GEM
@@ -72,6 +71,10 @@ GEM
       amq-protocol (~> 2.3, >= 2.3.0)
     concurrent-ruby (1.1.6)
     crass (1.0.6)
+    database_cleaner (1.8.4)
+    database_cleaner-active_record (1.8.0)
+      activerecord
+      database_cleaner (~> 1.8.0)
     diff-lcs (1.3)
     digest-crc (0.5.1)
     erubi (1.9.0)
@@ -119,7 +122,7 @@ GEM
       concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.4)
     jwt (2.2.1)
-    loofah (2.5.0)
+    loofah (2.6.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     mail (2.7.1)
@@ -128,21 +131,21 @@ GEM
       mimemagic (~> 0.3.2)
     memoist (0.16.2)
     method_source (1.0.0)
-    mimemagic (0.3.4)
+    mimemagic (0.3.5)
     mini_mime (1.0.2)
     mini_portile2 (2.4.0)
     minitest (5.14.0)
     multi_json (1.14.1)
     multipart-post (2.1.1)
     nio4r (2.5.2)
-    nokogiri (1.10.9)
+    nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
     os (1.0.1)
     parallel (1.19.1)
     parser (2.7.0.4)
       ast (~> 2.4.0)
     public_suffix (4.0.3)
-    rack (2.2.2)
+    rack (2.2.3)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rails (6.0.2.2)
@@ -204,7 +207,7 @@ GEM
       faraday (~> 0.9)
       jwt (>= 1.5, < 3.0)
       multi_json (~> 1.10)
-    sprockets (4.0.0)
+    sprockets (4.0.2)
       concurrent-ruby (~> 1.0)
       rack (> 1, < 3)
     sprockets-rails (3.2.1)
@@ -217,9 +220,9 @@ GEM
     tzinfo (1.2.7)
       thread_safe (~> 0.1)
     unicode-display_width (1.6.1)
-    websocket-driver (0.7.1)
+    websocket-driver (0.7.3)
       websocket-extensions (>= 0.1.0)
-    websocket-extensions (0.1.4)
+    websocket-extensions (0.1.5)
     zeitwerk (2.3.0)
 
 PLATFORMS
@@ -228,6 +231,7 @@ PLATFORMS
 DEPENDENCIES
   bundler
   bunny
+  database_cleaner-active_record
   google-cloud-pubsub
   pub_sub_model_sync!
   rake

data/README.md

@@ -61,13 +61,16 @@ And then execute: $ bundle install
     ```
     Note: Publishers do not need todo this
 
+- Check the service status with:    
+  ```PubSubModelSync::MessagePublisher.publish_data('Test message', {sample_value: 10}, :create)```
+
 ## Examples
 ```ruby
 # App 1 (Publisher)
 # attributes: name email age 
 class User < ActiveRecord::Base
   include PubSubModelSync::PublisherConcern
-  ps_publish(%i[name email])
+  ps_publish(%i[id name email])
 end
 
 # App 2 (Subscriber)
@@ -86,7 +89,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
@@ -95,7 +98,7 @@ PubSubModelSync::Publisher.new.publish_data(User, { msg: 'Hello' }, :greeting) #
 class User < ActiveRecord::Base
   self.table_name = 'publisher_users'
   include PubSubModelSync::PublisherConcern
-  ps_publish(%i[name:full_name email], actions: %i[update], as_klass: 'Client', id: :client_id)
+  ps_publish(%i[id:client_id name:full_name email], actions: %i[update], as_klass: 'Client')
   
   def ps_skip_callback?(_action)
     false # here logic with action to skip push message
@@ -110,30 +113,66 @@ end
 class User < ActiveRecord::Base
   self.table_name = 'subscriber_users'
   include PubSubModelSync::SubscriberConcern
-  ps_subscribe(%i[name], actions: %i[update], as_klass: 'Client', id: :custom_id)
-  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)
     puts 'Class message called through custom_greeting'
   end
+  
+  # def self.ps_find_model(data)
+  #   where(email: data[:email], ...).first_or_initialize 
+  # end
 end
 ```
 
 Note: Be careful with collision of names
 ```
-class User
-    # ps_publish %i[name_data:name name:key] # key will be replaced with name_data 
-    ps_publish %i[name_data:name key_data:key] # use alias to avoid collision
-    
-    def key_data
-      name
-    end
-end
+  # ps_publish %i[name_data:name name:key] # key will be replaced with name_data 
+  ps_publish %i[name_data:name key_data:key] # use alias to avoid collision
 ``` 
 
 ## API
+### Subscribers
+- Permit to configure class level subscriptions
+  ```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 subscriptions (CRUD)
+  ```ps_subscribe(attrs, from_klass: nil, actions: nil, id: nil)```
+  * attrs: (Array/Required) Array of all attributes to be synced
+  * 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
+
+- Permit to configure a custom model finder
+  ```ps_find_model(data)```
+  * data: (Hash) Data received from sync
+  Must return an existent or a new model object
+
+- Get crud subscription configured for the class   
+  ```User.ps_subscriber(action_name)```  
+  * action_name (default :create, :sym): can be :create, :update, :destroy
+
+- Inspect all configured subscribers   
+  ```PubSubModelSync::Config.subscribers```    
+
+- Permit to customize the way to detect if the subscribed model was changed (Only for update action).   
+  ```.ps_subscriber_changed?(data)```    
+  By default: ```model.changed?```
+
+### Publishers
+- Permit to configure crud publishers
+  ```ps_publish(attrs, actions: nil, as_klass: nil)```
+  * attrs: (Array/Required) Array of attributes to be published
+  * actions: (Array/Optional, default: create/update/destroy) permit to customize action names
+  * as_klass: (String/Optional) Output class name (Instead of the model class name, will use this value)
+
 - Permit to cancel sync called after create/update/destroy (Before initializing sync service)
   ```model.ps_skip_callback?(action)```    
+  Default: False  
   Note: Return true to cancel sync
   
 - Callback called before preparing data for sync (Permit to stop sync)
@@ -150,29 +189,24 @@ end
 - Perform sync on demand (:create, :update, :destroy):   
   The target model will receive a notification to perform the indicated action  
   ```my_model.ps_perform_sync(action_name, custom_settings = {})```  
-  * custom_settings: override default settings defined for action_name ({ attrs: [], as_klass: nil, id: nil })
+  * custom_settings: override default settings defined for action_name ({ attrs: [], as_klass: nil })
     
-- Class level notification:     
+- Publish a class level notification:     
   ```User.ps_class_publish(data, action: action_name, as_klass: custom_klass_name)```
   Target class ```User.action_name``` will be called when message is received    
   * data: (required, :hash) message value to deliver    
-  * action_name: (required, :sim) same action name as defined in ps_class_subscribe(...)    
-  * as_klass: (optional, :string) same class name as defined in ps_class_subscribe(...)
+  * action_name: (required, :sim) Action name    
+  * as_klass: (optional, :string) Custom class name (Default current model name)
       
-- Class level notification (Same as above: on demand call)    
-  ```PubSubModelSync::Publisher.new.publish_data(Klass_name, data, action_name)```  
+- Publish a class level notification (Same as above: on demand call)    
+  ```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(...)
   
-- Get crud subscription configured for the class   
-  ```User.ps_subscriber(action_name)```  
-  * action_name (default :create, :sym): can be :create, :update, :destroy
 - Get crud publisher configured for the class   
   ```User.ps_publisher(action_name)```  
   * action_name (default :create, :sym): can be :create, :update, :destroy
-- Inspect all configured listeners
-  ```PubSubModelSync::Config.listeners```
   
 ## Testing with RSpec
 - Config: (spec/rails_helper.rb)
@@ -205,12 +239,10 @@ end
     # Subscriber
     it 'receive model message' do
       action = :create
-      data = { name: 'name' }
-      user_id = 999
-      attrs = PubSubModelSync::Publisher.build_attrs('User', action, user_id)
-      publisher = PubSubModelSync::MessageProcessor.new(data, 'User', action, id: user_id)
+      data = { name: 'name', id: 999 }
+      publisher = PubSubModelSync::MessageProcessor.new(data, 'User', action)
       publisher.process
-      expect(User.where(id: user_id).any?).to be_truth
+      expect(User.where(id: data[:id]).any?).to be_truth
     end
       
     it 'receive class message' do
@@ -223,20 +255,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/gemfiles/Gemfile_4

@@ -0,0 +1,16 @@
+source "https://rubygems.org"
+
+gem 'rubocop'
+gem 'bunny' # rabbit-mq
+gem 'google-cloud-pubsub' # google pub/sub
+gem 'ruby-kafka' # kafka pub/sub
+gem 'rails', '~> 4'
+gem 'bundler'
+gem 'sqlite3', '1.3.13'
+
+group :test do
+  gem 'database_cleaner-active_record'
+end
+
+# Specify your gem's dependencies in pub_sub_model_sync.gemspec
+gemspec

data/gemfiles/Gemfile_5

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem 'rubocop'
+gem 'bunny' # rabbit-mq
+gem 'google-cloud-pubsub' # google pub/sub
+gem 'ruby-kafka' # kafka pub/sub
+gem 'rails', '~> 5'
+
+group :test do
+  gem 'database_cleaner-active_record'
+end
+
+# Specify your gem's dependencies in pub_sub_model_sync.gemspec
+gemspec

data/gemfiles/Gemfile_6

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+gem 'rubocop'
+gem 'bunny' # rabbit-mq
+gem 'google-cloud-pubsub' # google pub/sub
+gem 'ruby-kafka' # kafka pub/sub
+gem 'rails', '~> 6'
+
+group :test do
+  gem 'database_cleaner-active_record'
+end
+
+# Specify your gem's dependencies in pub_sub_model_sync.gemspec
+gemspec

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/connector.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'google/cloud/pubsub'
 module PubSubModelSync
   class Connector
     attr_accessor :service

data/lib/pub_sub_model_sync/message_processor.rb

@@ -2,83 +2,39 @@
 
 module PubSubModelSync
   class MessageProcessor
-    attr_accessor :data, :attrs, :settings
+    attr_accessor :data, :klass, :action
 
     # @param data (Hash): any hash value to deliver
-    # @param settings (optional): { id: id_val }
-    def initialize(data, klass, action, settings = {})
+    def initialize(data, klass, action)
       @data = data
-      @settings = settings
-      @attrs = settings.merge(klass: klass, action: action)
+      @klass = klass
+      @action = action
     end
 
     def process
-      @failed = false
-      log 'processing message'
-      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 attrs[: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
-      identifier = listener[:settings][:id] || :id
-      model_class.where(identifier => attrs[:id]).first_or_initialize
-    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 == attrs[:klass].to_s &&
-          listener[:as_action].to_s == attrs[: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 "#{message} ==> #{[data, attrs]}", 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,47 +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 settings (Hash): { attrs: [], as_klass: nil, id: nil }
-    def publish_model(model, action, settings = nil)
-      return if model.ps_skip_sync?(action)
-
-      settings ||= model.class.ps_publisher_info(action)
-      attributes = build_model_attrs(model, action, settings)
-      data = {}
-      data = build_model_data(model, settings[:attrs]) if action != :destroy
-      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, id = nil)
-      {
-        klass: klass.to_s,
-        action: action.to_sym,
-        id: id
-      }
+    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)
@@ -50,14 +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
-      id_val = model.send(settings[:id] || :id)
-      self.class.build_attrs(as_klass, action, id_val)
-    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

@@ -11,6 +11,7 @@ module PubSubModelSync
       false
     end
 
+    # TODO: make it using respond_to?(:ps_skip_sync?)
     # before preparing data to sync
     def ps_skip_sync?(_action)
       false
@@ -23,49 +24,49 @@ module PubSubModelSync
     def ps_after_sync(_action, _data); end
 
     # To perform sync on demand
-    # @param custom_settings (Hash): { attrs: [], as_klass: nil, id: nil }
-    def ps_perform_sync(action = :create, custom_settings = {})
-      service = self.class.ps_publisher_service
-      model_settings = self.class.ps_publisher_info(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)
-      # @param settings (Hash): { actions: nil, as_klass: nil, id: nil }
-      def ps_publish(attrs, settings = {})
-        actions = settings.delete(:actions) || %i[create update destroy]
+      def ps_publish(attrs, actions: %i[create update destroy], as_klass: nil)
+        klass = PubSubModelSync::Publisher
+        publisher = klass.new(attrs, name, actions, as_klass)
+        PubSubModelSync::Config.publishers << publisher
         actions.each do |action|
-          info = settings.merge(klass: name, action: action, attrs: attrs)
-          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_info(action = :create)
-        PubSubModelSync::Config.publishers.select do |listener|
-          listener[:klass] == name && listener[:action] == action
-        end.last
-      end
-
-      def ps_publisher_service
-        PubSubModelSync::Publisher.new
+      def ps_publisher(action = :create)
+        PubSubModelSync::Config.publishers.find do |publisher|
+          publisher.klass == name && publisher.actions.include?(action)
+        end
       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

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

data/lib/pub_sub_model_sync/service_google.rb

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

data/lib/pub_sub_model_sync/service_kafka.rb

@@ -29,12 +29,12 @@ module PubSubModelSync
     end
 
     def publish(data, attributes)
-      log("Publishing: #{[data, attributes]}")
+      log("Publishing: #{[attributes, data]}")
       payload = { data: data, attributes: attributes }
       producer.produce(payload.to_json, message_settings)
       producer.deliver_messages
     rescue => e
-      info = [data, attributes, e.message, e.backtrace]
+      info = [attributes, data, e.message, e.backtrace]
       log("Error publishing: #{info}", :error)
     end
 

data/lib/pub_sub_model_sync/service_rabbit.rb

@@ -19,7 +19,8 @@ module PubSubModelSync
       log('Listener starting...')
       subscribe_to_queue
       log('Listener started')
-      queue.subscribe(block: true, manual_ack: false, &method(:process_message))
+      queue.subscribe(subscribe_settings, &method(:process_message))
+      loop { sleep 5 }
     rescue PubSubModelSync::Runner::ShutDown
       raise
     rescue => e
@@ -27,7 +28,7 @@ module PubSubModelSync
     end
 
     def publish(data, attributes)
-      log("Publishing: #{[data, attributes]}")
+      log("Publishing: #{[attributes, data]}")
       deliver_data(data, attributes)
     # TODO: max retry
     rescue Timeout::Error => e
@@ -35,7 +36,7 @@ module PubSubModelSync
       initialize
       retry
     rescue => e
-      info = [data, attributes, e.message, e.backtrace]
+      info = [attributes, data, e.message, e.backtrace]
       log("Error publishing: #{info}", :error)
     end
 
@@ -50,6 +51,10 @@ module PubSubModelSync
       { routing_key: queue.name, type: SERVICE_KEY }
     end
 
+    def subscribe_settings
+      { manual_ack: false }
+    end
+
     def process_message(_delivery_info, meta_info, payload)
       return unless meta_info[:type] == SERVICE_KEY
 

data/lib/pub_sub_model_sync/subscriber.rb

@@ -0,0 +1,67 @@
+# 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)
+        return if action == :update && !model.ps_subscriber_changed?(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

@@ -6,39 +6,40 @@ module PubSubModelSync
       base.extend(ClassMethods)
     end
 
+    # check if model was changed to .save!
+    def ps_subscriber_changed?(_data)
+      changed?
+    end
+
     module ClassMethods
-      # @param settings (Hash): { as_klass: nil, actions: nil, id: nil }
-      def ps_subscribe(attrs, settings = {})
-        as_klass = (settings[:as_klass] || name).to_s
-        actions = settings.delete(:actions) || %i[create update destroy]
-        settings = settings.merge(attrs: attrs)
+      def ps_subscribe(attrs, actions: nil, from_klass: name, id: :id)
+        settings = { id: id, from_klass: from_klass }
+        actions ||= %i[create update destroy]
         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.select do |listener|
-          listener[:klass] == name && listener[:action] == action
-        end.last
+        PubSubModelSync::Config.subscribers.find do |subscriber|
+          subscriber.klass == name && subscriber.action == action
+        end
       end
 
       private
 
-      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 << 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.2.4'
+  VERSION = '0.4.2'
 end

data/pub_sub_model_sync.gemspec

@@ -32,7 +32,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'activesupport'
   spec.add_dependency 'rails'
 
   spec.add_development_dependency 'bundler'

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: pub_sub_model_sync
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.4.2
 platform: ruby
 authors:
 - Owen
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-04-28 00:00:00.000000000 Z
+date: 2020-08-15 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -114,10 +100,14 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- gemfiles/Gemfile_4
+- gemfiles/Gemfile_5
+- gemfiles/Gemfile_6
 - lib/pub_sub_model_sync.rb
 - 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
@@ -129,6 +119,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
@@ -140,7 +131,7 @@ metadata:
   homepage_uri: https://github.com/owen2345/pub_sub_model_sync
   source_code_uri: https://github.com/owen2345/pub_sub_model_sync
   changelog_uri: https://github.com/owen2345/pub_sub_model_sync/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -156,7 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.8
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Permit to sync models between apps through pub/sub
 test_files: []