reactive_observers 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a474667ccaf5f102c3db4d12ac06f4eccf0e6c46c516736ba5ff6039e4c54d0
-  data.tar.gz: 215c39cb7ecc5396ffda1ea074e826d9a4c9a3367b7bc3a13f9b1337501dc0b8
+  metadata.gz: 9281c4f53d4c4fba288f224c61ca7685a7deb8896b75cbff0198f516606b6171
+  data.tar.gz: 37767ffa7276832fcdf4b0ffb934b00f4d386e3b8d1a6a2974c8f9882c43a34c
 SHA512:
-  metadata.gz: febca242b85002818369bfdfd8ed76a87f74b6799411a48362a7d0ee670b3227dd8f8afed11c187b1a03233eb4c4b40a537125e95f74fc21f988e8a2c483fd4d
-  data.tar.gz: 95014407e067b0a9f2f6fd10d5e64b1df0085465f20f98a2079cb4fe88ceba6e7aaf8ec83ce38e0b047fb81e760eee6c3405340ffa0bda011a09d2147acee0f7
+  metadata.gz: '08dc2fa287cb4ff38cb2ebeeea1ccd84d6b0518a214481fee16163f38232b5631b7edb78538913d4f0c722db65108d7e04d914ce6bf70d96c1aa1b44ac5187d5'
+  data.tar.gz: c302f61b66be4060c2f1258d16f095cfdc46fabf9fbc9497d639e4b6e2095e4319d8073c93baedc3c8fcb8d4383e026e36dec878a1658885ab460549f946d9eb

data/README.md

@@ -4,7 +4,7 @@
 [![Build Status](https://travis-ci.com/martintomas/reactive_observers.svg?branch=master)](https://travis-ci.com/martintomas/reactive_observers)
 [![codecov](https://codecov.io/gh/martintomas/reactive_observers/branch/master/graph/badge.svg)](https://codecov.io/gh/martintomas/reactive_observers)
 
-This gem can make observer from every possible class or object. Observer relation can be defined at Class level and processed dynamically when appropriate record changes. Observable module is using build in Active Record hooks or database triggers which can be turned on for specified tables in multiple App environment.
+This gem can transform every possible class or object to observer. Observer relation can be defined at Class level and processed dynamically when appropriate record changes. Observable module is using build in Active Record hooks or database triggers which can be turned on for specified tables in multiple App environment.
 
 ```ruby
 class Topic < ActiveRecord::Base; end
@@ -40,7 +40,7 @@ Or install it yourself as:
 
 ## Usage
 
-Observing relation can be initialized between object/class pairs. Observer can be any class or object. Observable has to be always Active Record class or object. It is recommended to define class observers as often as possible, because It enables to observe all active records independently and initialize all required data after observer is triggered. 
+Observing relation can be initialized between object/class pairs. Observer can be any class or object. Observable entity has to be always Active Record class or object. It is recommended to define class observers as often as possible, because It enables to observe all active records independently and initialize all required data after observing action is triggered. It is also quite easy to maintain Observer classes when whole logic is encapsulated at one place. 
 
 Every class can be transformed to observer just by including following module:
 
@@ -56,8 +56,8 @@ Observe method accepts several different arguments which are:
     * `fields` - observer is notified only when specified active record attributes are changed, for example: `fields: [:first_name, :last_name]`
     * `only` - accepts Proc and can do additional complex filtering, for example: `only: ->(active_record) { active_record.type == 'ObservableType' }`
 * active options
-    * `trigger` - can be symbol or Proc and defines action which is called on observer, for example: `trigger: :recompute_statistics`. Default value, which can be changed through configuration, is `:changed`. 
-    * `notify` - can be Symbol or Proc and defines action which is used to initialize observes class, for example: `notify: :load_all_dependent_objects`
+    * `trigger` - accepts symbol or Proc and defines action which is called on observer, for example: `trigger: :recompute_statistics`. Default value, which can be changed through configuration, is `:changed`. 
+    * `notify` - accepts be Symbol or Proc and defines action which is used to initialize observer class, for example: `notify: :load_all_dependent_objects`
     * `refine` - accepts Proc and defines operation which is done with active record object before observer is called, for example: `refine: ->(active_record) { active_record.topics }`
 * additional options
     * `context` - observer can be registered with context information which is provided back from observed object when notification happens. Example of such option can be for example: `context: :topic`
@@ -96,7 +96,7 @@ class TopicsStatisticService
 end
 ```
 
-Class observers can become a bit tricky when initialization method is defined inside observer.
+It can be a bit tricky when classes with complex initialization process are transformed to observer - in such case, `notify` parameter is required which specifies how observer class is initialized
 
 ```ruby
 class TopicStatisticService
@@ -113,7 +113,7 @@ class TopicStatisticService
 end
 ```
 
-Initialize method of class can quickly get out of the hand and It can be impossible to initialize it only with observed object information. Fortunately, observing can be defined at object level which doesn't require initialization.
+Initialize method of class can quickly get out of the hand and It can be impossible to initialize it only with observed object data. Fortunately, observing can be defined at object level which doesn't require initialization at all.
 
 ```ruby
 class ComplexStatisticsService
@@ -183,13 +183,17 @@ To enable database observers, following configuration needs to be put into initi
       config.observed_tables = [:topics] # names of tables which should be observed
     end
     
-It is also required to create appropriate database triggers. __TODO:__ prepare jobs that generates appropriate triggers for defined tables.
+It is also required to create database triggers for observed tables which can be done with following command:
+ 
+    rails g reactive_observers:postgresql_listeners topics comments
+ 
+This example will generate migration for PostgreSQL database and add triggers to topics and comments tables.
 
-Gem listens on `TG_TABLE_NAME_notices` which for example means that observer for topic table will listen on `topic_notices`. This default behaviour can be changed at configuration:
+Gem listens on `TG_TABLE_NAME_notices` which for example means that observer for topics table will listen on `topic_notices`. This default behaviour can be changed at configuration:
 
     $ ReactiveObservers.configure { |config| config.listening_job_name = "%{table_name}_notices" }
     
-Data obtained through trigger are forwarded to observers, but can be also used for different purposes (not just observing). It is possible to register any method that can process trigger data at any active record model:
+Data obtained through trigger are forwarded to observers, but can be also used for different purposes (not just observing). It is possible to register any method that can process triggered data for any active record model:
 
 ```ruby
 class Topic < ActiveRecord::Base

data/lib/generators/reactive_observers/USAGE

@@ -0,0 +1,8 @@
+Description:
+    This generator creates migration with listeners for appropriate tables and database type
+
+Example:
+    rails g reactive_observers:postgresql_listeners topics comments
+
+    This will create:
+        db/migrate/#{Time.now.strftime "%Y%m%d%H%M%S"}_create_postgresql_listeners.rb

data/lib/generators/reactive_observers/postgresql_listeners_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "rails/generators/active_record"
+
+module ReactiveObservers
+  class PostgresqlListenersGenerator < Rails::Generators::Base
+    include ActiveRecord::Generators::Migration
+    source_root File.expand_path('templates', __dir__)
+
+    argument :tables, type: :array, default: []
+
+    desc 'This generator creates migration with database listeners for postgresql database'
+
+    def copy_install_file
+      migration_template 'postgresql_listeners_migration.rb', File.join(db_migrate_path, "create_postgresql_listeners.rb")
+    end
+
+    def table_listeners
+      format ReactiveObservers.configuration.listening_job_name, table_name: ''
+    end
+  end
+end

data/lib/generators/reactive_observers/templates/postgresql_listeners_migration.rb.tt

@@ -0,0 +1,62 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    execute <<-SQL
+
+      CREATE OR REPLACE FUNCTION jsonb_diff ( arg1 jsonb, arg2 jsonb ) RETURNS jsonb AS $$
+        SELECT
+          COALESCE(json_object_agg(key, value), '{}')::jsonb
+        FROM
+          jsonb_each(arg1)
+        WHERE
+          (arg1 -> key) <> (arg2 -> key)
+          OR (arg2 -> key) IS NULL
+      $$ LANGUAGE SQL;
+
+      CREATE OR REPLACE FUNCTION notice_insert() RETURNS trigger AS $$
+        DECLARE
+          channel_name varchar DEFAULT (TG_TABLE_NAME || '<%= table_listeners %>');
+        BEGIN
+          PERFORM pg_notify(channel_name, json_build_object('action', TG_OP, 'model', NEW)::text);
+
+          RETURN NEW;
+        END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE OR REPLACE FUNCTION notice_update() RETURNS trigger AS $$
+        DECLARE
+          channel_name varchar DEFAULT (TG_TABLE_NAME || '<%= table_listeners %>');
+          js_new jsonb := row_to_json(NEW)::jsonb;
+          js_old jsonb := row_to_json(OLD)::jsonb;
+        BEGIN
+          PERFORM pg_notify(channel_name, json_build_object('action', TG_OP, 'model', NEW, 'old_model', OLD, 'diff', jsonb_diff(js_new, js_old))::text);
+
+          RETURN NEW;
+        END;
+      $$ LANGUAGE plpgsql;
+
+      CREATE OR REPLACE FUNCTION notice_delete() RETURNS trigger as $$
+        DECLARE
+          channel_name varchar DEFAULT (TG_TABLE_NAME || '<%= table_listeners %>');
+        BEGIN
+          PERFORM pg_notify(channel_name, json_build_object('action', TG_OP, 'model', OLD)::text);
+
+          RETURN OLD;
+        END;
+      $$ LANGUAGE plpgsql;
+
+      <% tables.each do |table_name| %>
+      CREATE TRIGGER notice_on_insert
+        AFTER INSERT ON public.<%= table_name %> FOR EACH ROW
+        EXECUTE PROCEDURE notice_insert();
+
+      CREATE TRIGGER notice_on_update
+        AFTER UPDATE ON public.<%= table_name %> FOR EACH ROW
+        EXECUTE PROCEDURE notice_update();
+
+      CREATE TRIGGER notice_on_delete
+        AFTER DELETE ON public.<%= table_name %> FOR EACH ROW
+        EXECUTE PROCEDURE notice_delete();
+      <% end %>
+    SQL
+  end
+end

data/lib/reactive_observers/observable/notification.rb

@@ -14,9 +14,10 @@ module ReactiveObservers
 
       def perform
         filter_observers.each do |observer|
-          next if observer.only.present? && !observer.only.call(@observed_object)
-
-          trigger_actions_for observer, Array.wrap(refine_observer_records_for(observer))
+          process observer, @observed_object
+          if @action == :update && observer.trigger_with_previous_values
+            process observer, @observed_object.clone.assign_attributes(@options[:diff])
+          end
         end
       end
 
@@ -26,6 +27,12 @@ module ReactiveObservers
         @filtered_observers ||= Filtering.new(@observed_object.id, @observers, @action, @options).perform
       end
 
+      def process(observer, observed_object)
+        return if observer.only.present? && !observer.only.call(observed_object)
+
+        trigger_actions_for observer, Array.wrap(refine_observer_records_for(observer, observed_object))
+      end
+
       def trigger_actions_for(observer, records)
         records.each do |record|
           Array.wrap(observer_objects_for(observer, record)).each do |observer_object|
@@ -42,10 +49,10 @@ module ReactiveObservers
         trigger.call record, observer.to_h
       end
 
-      def refine_observer_records_for(observer)
-        return @observed_object if observer.refine.blank?
+      def refine_observer_records_for(observer, observed_object)
+        return observed_object if observer.refine.blank?
 
-        observer.refine.call @observed_object
+        observer.refine.call observed_object
       end
 
       def observer_objects_for(observer, record)

data/lib/reactive_observers/observer/container.rb

@@ -10,6 +10,7 @@ module ReactiveObservers
       attr_accessor :observer, :observed
       attr_accessor :trigger, :notify, :refine, :context
       attr_accessor :fields, :on, :only, :constrain
+      attr_accessor :trigger_with_previous_values
 
       def initialize(observer, observed, options)
         @observer = observer
@@ -23,6 +24,7 @@ module ReactiveObservers
         @context = options[:context]
         ReactiveObservers::Observer::ContainerValidator.new(self).run_validations!
         @constrain = load_observer_constrains
+        @trigger_with_previous_values = options[:trigger_with_previous_values] || false
       end
 
       def compare

data/lib/reactive_observers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReactiveObservers
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.0.2'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: reactive_observers
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - martintomas
@@ -86,6 +86,9 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- lib/generators/reactive_observers/USAGE
+- lib/generators/reactive_observers/postgresql_listeners_generator.rb
+- lib/generators/reactive_observers/templates/postgresql_listeners_migration.rb.tt
 - lib/reactive_observers.rb
 - lib/reactive_observers/base.rb
 - lib/reactive_observers/configuration.rb