reactive_observers 0.0.1.pre

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6be66bbad98da7ba75c596f536c7d20eb8abf6b376c3d53db9a2c8e2fe925128
+  data.tar.gz: 13a0090307196c9295bee4640fd57a938276063c5c4c7a508f3d7dee46694400
+SHA512:
+  metadata.gz: 46689eaebf879db1bb5c256405383f13bc406295abce70932d1b1328914fe6c8b09907dc08b7ae57f6e70dd7990035b4b2dab3d6754b62eac8e3c3d035b071a3
+  data.tar.gz: 11bb559400d8313adf10754cc409e2c9453612e4b11c469e52c0af7f865c551aa948b1953b8f661c095332158a1c18a5f7d8e5625c6da4d6107416f0b20c89dc

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+/reactive_observers-*.*.*.gem
+/Gemfile.lock

data/.ruby-gemset

@@ -0,0 +1 @@
+reactive_observers

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.6.3

data/.travis.yml

@@ -0,0 +1,16 @@
+---
+language: ruby
+cache: bundler
+sudo: required
+rvm:
+  - 2.6.3
+services:
+  - postgresql
+addons:
+  postgresql: 9.6
+before_script:
+  - sudo apt-get -qq update
+  - sudo apt-get install -y postgresql-9.6-postgis-2.4
+  - psql -U postgres -c 'create database test'
+  - psql -U postgres -d test -c 'create extension postgis'
+before_install: gem install bundler -v 2.1.0.pre.3

data/Gemfile

@@ -0,0 +1,18 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in reactive_observers.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+
+group :test do
+  gem "minitest", "~> 5.0"
+  gem 'minitest-reporters'
+  gem 'minitest-stub_any_instance'
+  gem 'simplecov'
+  gem 'codecov'
+
+  gem 'pg'
+  gem 'activerecord-postgis-adapter'
+  gem 'sqlite3'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 martintomas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,208 @@
+# ReactiveObservers
+
+[![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.
+
+```ruby
+class Topic < ActiveRecord::Base; end
+class CustomObserver
+  include ReactiveObservers::Base
+  
+  def changed(topic, **observer); end
+end
+
+# possible usage of observer
+# when observer is defined at class level, observer object is initialized when observed record changes
+CustomObserver.observe(:topics) # observer klass is observing Topic (Active Record klass)
+CustomObserver.observe(Topic.first) # observer is observing specific topic
+CustomObserver.new.observe(:topics) # specific observer is observing Topic
+CustomObserver.new.observe(Topic.first) # specific observer is observing specific topic
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'reactive_observers'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install reactive_observers
+
+## 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. 
+
+Every class can be transformed to observer just by including following module:
+
+    $ include ReactiveObservers::Base
+
+Class has access to `observe` method now and can observe any active record object or class. Registering of observer can be done for example by:
+
+    $ YourClass.observe(ActiveRecord::Base)
+    
+Observe method accepts several different arguments which are:
+* filtering options
+    * `on` - observer is notified only when specific types of action happens, for example: `on: [:create, :update]`
+    * `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`
+    * `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`
+
+### Active Record as Observer
+
+Every Active Record class can be transformed to observer - It can observe and be observed at same time. Let's have following example:
+
+```ruby
+class Comment < ActiveRecord::Base; end
+class Topic < ActiveRecord::Base
+  include ReactiveObservers::Base
+
+  # register observer for comments
+  # when Comment is created, call update_topic_dashboard of Topic
+  # notify param tells observed objects which topic should be called
+  observe :comments, on: :create, trigger: :update_topic_dashboard, notify: ->(comment) { comment.topic }
+  
+  def update_topic_dashboard(**observer); end
+end
+```
+
+### Observer as part of any class
+
+Every possible class can be transformed to observer. Let's define simple class as our first example:
+
+```ruby
+class TopicsStatisticService
+  include ReactiveObservers::Base
+
+  observe :topics, fields: :active_users, trigger: :recompute_statistics
+  observe :comments, on: :create, trigger: :recompute_statistics, refine: ->(comment) { comment.topic }
+
+  # you can recompute statistics for topic which has changed
+  def recompute_statistics(topic, **observer); end
+end
+```
+
+Class observers can become a bit tricky when initialization method is defined inside observer.
+
+```ruby
+class TopicStatisticService
+  include ReactiveObservers::Base
+
+  observe :topics, fields: :active_users, trigger: :recompute_statistics, only: -> (topic) { topic.active? },
+          notify: ->(topic) { TopicStatisticService.new(topic, topic.active_comments) }
+
+  # observed object will use notify param to instanciate TopicStatisticService object
+  # this param is required because initialize requires additional arguments 
+  def initialize(topic, active_comments); end
+
+  def recompute_statistics(topic, **observer); end
+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.
+
+```ruby
+class ComplexStatisticsService
+  include ReactiveObservers::Base
+ 
+  # both params are unknown and It is impossible to initialize ComplexStatisticsService with observed data
+  def initialize(unknown_param1, unknown_param2); end
+
+  def changed(record, **observer); end
+end
+
+# Class.observe pattern cannot be used in this case, because observed record cannot probably instantiate this service.
+# You can register specific service as observer
+ComplexStatisticsService.new(param1, param2).observe(:topics) # all topics will be observed
+ComplexStatisticsService.new(param1, param2).observe(Topic.first) # only first topic will be observed
+```
+
+### Observer Class
+
+Implementation of specific observers can be encapsulated into one class which makes future maintenance quite simple - in reality, this is preferred way how to define observers. Quite dummy example of such observer class can be:
+
+```ruby
+# Example of Activity Observer
+# observe appropriate record and recompute topic activity when data changes 
+class ActivityObserver
+  include ReactiveObservers::Base
+
+  observe :topics, fields: :last_activity
+  observe :comments, refine: ->(comment) { comment.topic }
+  observe :users, fields: :open_topic, refine: ->(user) { user.open_topic }
+  observe :images, on: :create, trigger: :image_uploaded
+
+  # activity data at topic changed, recompute it
+  def changed(topic, **observer); end
+
+  # image upload requires specifies approach, use special trigger for it
+  def image_uploaded(image, **observer); end
+end
+```
+
+### Remove Observer
+
+It is possible to remove observers from observed class or object at any time.
+
+```ruby
+Topic.remove_observer(ActivityObserver) # remove activity observer from Topic class
+Topic.first.remove_observer(ActivityObserver) # remove observer from first topic
+Topic.remove_observer(observing_service) # observer can be also object and this observer can be removed same way as class observer
+
+# remove_observer method accepts additional arguments that specifies which observers should be removed
+Topic.remove_observer(ActivityObserver, trigger: :image_uploaded) # only observer with appropriate trigger will be removed
+Topic.remove_observer(ActivityObserver, trigger: :image_uploaded, on: [:create, :update])
+Topic.remove_observer(ActivityObserver, fields: [:first_name, :last_name])
+Topic.remove_observer(ActivityObserver, notify: :prepare_observer)
+Topic.remove_observer(ActivityObserver, context: :topic) # only observer with appropriate context will be removed
+```
+
+### Database Triggers (Advanced)
+
+Observed data can be sometimes manipulated by several different sources - for example different apps can update it. Unfortunately, active record hooks in our Rails App cannot catch such change - which can cause that observers are not notified. For this purpose, this gem supports observers which use database triggers.
+
+Only __PostgreSQL database__ is supported now but You are welcomed to add other database adapters!
+
+To enable database observers, following configuration needs to be put into initializers:
+
+    ReactiveObservers.configure do |config| 
+      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.
+
+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:
+
+    $ 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:
+
+```ruby
+class Topic < ActiveRecord::Base
+  register_observer_listener :process_trigger
+  
+  def self.process_trigger(data); end
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/martintomas/reactive_observers. This project is intended to be a safe and welcoming space for collaboration.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "reactive_observers"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/reactive_observers/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'reactive_observers/observer/container'
+
+module ReactiveObservers
+  # add observe methods to appropriate class
+  #
+  # class CustomObserver
+  #   include ReactiveObservers::Base
+  #
+  #   def changed(topic, **observer); end
+  # end
+  #
+  module Base
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # create class observer for provided active record object or class
+      #
+      # CustomObserver.observe(:topics) # observer is observing Topic klass
+      # CustomObserver.observe(Topic.first) # observer is observing specific topic
+      #
+      # @param observed [Symbol, Object] observed object or symbol defining specific ActiveRecord class
+      # @param refine [Proc] lambda or Proc function defining observed object pre-process before It is sent to observer
+      # @param trigger [Proc, Symbol] function that is triggered inside observer during notification
+      # @param notify [Proc, Symbol] function that is used to initialize appropriate observer objects
+      # @param options [Hash] additional arguments such as: on, only, fields or context
+      # @return [ReactiveObservers::Observer::Container] observer
+      def observe(observed, refine: nil, trigger: ReactiveObservers.configuration.default_trigger, notify: nil, **options)
+        add_observer_to_observable self, observed, options.merge(refine: refine, trigger: trigger, notify: notify)
+      end
+
+      # register observer at observed entity
+      # @param observer [Class, Object]
+      # @param observed [Symbol, Object]
+      # @param options [Hash]
+      # @return [ReactiveObservers::Observer::Container] observer
+      def add_observer_to_observable(observer, observed, options)
+        ReactiveObservers::Observer::Container.new(observer, observed, options).tap do |observer_container|
+          observer_container.observed_klass.register_observer observer_container
+        end
+      end
+    end
+
+    # create object observer for provided active record object or class
+    #
+    # CustomObserver.new.observe(:topics) # observer is observing Topic klass
+    # CustomObserver.new.observe(Topic.first) # observer is observing specific topic
+    #
+    # @param observed [Symbol, Object] observed object or symbol defining specific ActiveRecord class
+    # @param refine [Proc] lambda or Proc function defining observed object pre-process before It is sent to observer
+    # @param trigger [Proc, Symbol] function that is triggered inside observer during notification
+    # @param notify [Proc, Symbol] function that is used to initialize appropriate observer objects
+    # @param options [Hash] additional arguments such as: on, only, fields or context
+    # @return [ReactiveObservers::Observer::Container] observer
+    def observe(observed, refine: nil, trigger: ReactiveObservers.configuration.default_trigger, notify: nil, **options)
+      self.class.add_observer_to_observable self, observed, options.merge(refine: refine, trigger: trigger, notify: notify)
+    end
+  end
+end

data/lib/reactive_observers/configuration.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ReactiveObservers
+  class Configuration
+
+    attr_accessor :listening_job_name, :observed_tables, :default_trigger
+
+    def initialize
+      reset!
+    end
+
+    def reset!
+      @listening_job_name = "%{table_name}_notices" # trigger listens for these type of notices
+      @observed_tables = [] # these tables are observed at database level
+      @default_trigger = :changed # default name of method that is called inside observer during notification
+    end
+  end
+end

data/lib/reactive_observers/database_adapters/abstract_adapter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ReactiveObservers
+  module DatabaseAdapters
+    class AbstractAdapter
+      def initialize(configuration, klasses)
+        @configuration = configuration
+        @klasses = klasses
+      end
+
+      def start_listening
+        @klasses.each { |klass| create_listening_job_for klass }
+      end
+
+      def stop_listening
+        @klasses.each { |klass| stop_listening_job_for klass }
+      end
+
+      private
+
+      def create_listening_job_for(klass)
+        raise NotImplementedError
+      end
+
+      def stop_listening_job_for(klass)
+        raise NotImplementedError
+      end
+
+      def process_notification_for(data, klass)
+        klass.observer_listener_services.each { |service| klass.method(service).call data }
+      end
+    end
+  end
+end

data/lib/reactive_observers/database_adapters/factory.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'reactive_observers/database_adapters/postgresql_adapter'
+
+module ReactiveObservers
+  module DatabaseAdapters
+    class Factory
+      def initialize(configuration)
+        @configuration = configuration
+      end
+
+      def initialize_observer_listeners
+        collect_database_adapters.each do |database_adapter, klasses|
+          case database_adapter
+          when 'PostgreSQL'
+            PostgreSQLAdapter.new(@configuration, klasses).start_listening
+          when 'PostGIS'
+            PostgreSQLAdapter.new(@configuration, klasses).start_listening
+          else
+            raise StandardError, "Reactive observers cannot be run with this database adapter: #{database_adapter}!"
+          end
+        end
+      end
+
+      private
+
+      def collect_database_adapters
+        {}.tap do |result|
+          @configuration.observed_tables.map do |observed_table|
+            klass = observed_table.to_s.classify.constantize
+            adapter = klass.connection.adapter_name
+            result[adapter] = (result[adapter] || []) << klass
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reactive_observers/database_adapters/postgresql_adapter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'reactive_observers/database_adapters/abstract_adapter'
+
+module ReactiveObservers
+  module DatabaseAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+
+      private
+
+      def create_listening_job_for(klass)
+        Thread.new do
+          klass.connection.execute "LISTEN #{ @configuration.listening_job_name % { table_name: klass.table_name }}"
+          loop do
+            klass.connection.raw_connection.wait_for_notify do |event, pid, payload|
+              data = JSON.parse payload, symbolize_names: true
+              process_notification_for data, klass
+            end
+          end
+        end.abort_on_exception = true
+      end
+
+      def stop_listening_job_for(klass)
+        klass.connection.execute "UNLISTEN #{ @configuration.listening_job_name % { table_name: klass.table_name }}"
+      end
+    end
+  end
+end

data/lib/reactive_observers/observable/base.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'reactive_observers/observable/db_listener'
+require 'reactive_observers/observable/notification'
+require 'reactive_observers/observable/removing'
+
+require 'active_support/concern'
+
+module ReactiveObservers
+  module Observable
+    # enables class to be observable
+    # automatically included to ActiveRecord::Base
+    module Base
+      extend ActiveSupport::Concern
+      include Observable::DbListener
+
+      included do
+        class_attribute :active_observers
+        self.active_observers = []
+        register_observer_listener :process_observer_notification
+
+        after_create do
+          process_observer_hook_notification :create
+        end
+
+        after_update do
+          process_observer_hook_notification :update, diff: previous_changes.each_with_object({}) { |(k, v), r| r[k] = v.first }
+        end
+
+        after_destroy do
+          process_observer_hook_notification :destroy
+        end
+      end
+
+      class_methods do
+        # register observer to this class
+        # @param observer [ReactiveObservers::Observer::Container]
+        # @return [Array] active observers
+        def register_observer(observer)
+          return if active_observers.any? { |active_observer| active_observer.compare.full? observer }
+
+          active_observers << observer
+        end
+
+        # remove observer for specific object
+        #
+        # Topic.remove_observer(ActivityObserver) # remove observer from Topic
+        # Topic.remove_observer(observing_service) # removed observer can be also object
+        #
+        # @param observer [Class, Object] observer that should be removed
+        # @param options [Hash] additional options that specifies which observers should be removed
+        # @return [Array] still active observers
+        def remove_observer(observer, **options)
+          Observable::Removing.new(active_observers, observer, options).perform
+        end
+
+        # process notification from db trigger
+        # @param data [Hash] data obtain from db trigger
+        def process_observer_notification(data)
+          return if active_observers.blank?
+
+          if data[:action] == 'INSERT'
+            find(data[:id]).process_observer_notifications :create
+          elsif data[:action] == 'UPDATE'
+            find(data[:id]).process_observer_notifications :update, diff: data[:diff]
+          elsif data[:action] == 'DELETE'
+            new(data[:diff]).process_observer_notifications :destroy
+          else
+            raise StandardError, "Notification from db returned unknown action: #{data[:action]}"
+          end
+        end
+      end
+
+      # remove observer for specific object
+      #
+      # Topic.first.remove_observer(ActivityObserver) # remove observer from first topic
+      #
+      # @param observer [Class, Object] observer that should be removed
+      # @param options [Hash] additional options that specifies which observers should be removed
+      # @return [Array] still active observers
+      def remove_observer(observer, **options)
+        self.class.remove_observer observer, options.merge(constrain: [id])
+      end
+
+      # process notification from ActiveRecord hooks
+      # @param action [Symbol]
+      # @param options [Hash]
+      def process_observer_hook_notification(action, **options)
+        return if ReactiveObservers.configuration.observed_tables.include?(self.class.table_name.to_sym) || self.class.active_observers.blank?
+
+        process_observer_notifications action, **options
+      end
+
+      # process observer notification
+      # @param action [Symbol]
+      # @param options [Hash]
+      def process_observer_notifications(action, **options)
+        Observable::Notification.new(self, self.class.active_observers, action, options).perform
+      end
+    end
+  end
+end

data/lib/reactive_observers/observable/db_listener.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module ReactiveObservers
+  module Observable
+    module DbListener
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :observer_listener_services
+        self.observer_listener_services = []
+      end
+
+      class_methods do
+        def register_observer_listener(method_name)
+          observer_listener_services << method_name
+        end
+      end
+    end
+  end
+end

data/lib/reactive_observers/observable/filtering.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ReactiveObservers
+  module Observable
+    class Filtering
+      def initialize(observed_object_id, observers, action, options)
+        @observed_object_id = observed_object_id
+        @observers = observers
+        @action = action
+        @options = options
+      end
+
+      def perform
+        @observers.select do |observer|
+          filter_action(observer) && filter_record_constrains(observer) && filter_fields(observer)
+        end
+      end
+
+      private
+
+      def filter_action(observer)
+        observer.on.blank? || observer.on.include?(@action)
+      end
+
+      def filter_record_constrains(observer)
+        observer.constrain.blank? || observer.constrain.include?(@observed_object_id)
+      end
+
+      def filter_fields(observer)
+        return true unless @action == :update && @options[:diff].present?
+
+        observer.fields.blank? || (observer.fields & changed_fields).length.positive?
+      end
+
+      def changed_fields
+        @changed_fields ||= @options[:diff].keys.map &:to_sym
+      end
+    end
+  end
+end

data/lib/reactive_observers/observable/notification.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'reactive_observers/observable/filtering'
+
+module ReactiveObservers
+  module Observable
+    class Notification
+      def initialize(observed_object, observers, action, options)
+        @observed_object = observed_object
+        @observers = observers
+        @action = action
+        @options = options
+      end
+
+      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))
+        end
+      end
+
+      private
+
+      def filter_observers
+        @filtered_observers ||= Filtering.new(@observed_object.id, @observers, @action, @options).perform
+      end
+
+      def trigger_actions_for(observer, records)
+        records.each do |record|
+          Array.wrap(observer_objects_for(observer, record)).each do |observer_object|
+            observer_object = observer_simplification?(observer, observer_object, record) ? record : observer_object
+            trigger_observer_action_for observer, observer_object, record
+          end
+        end
+      end
+
+      def trigger_observer_action_for(observer, observer_object, record)
+        trigger = build_proc_for observer.trigger, observer_object
+        return trigger.call observer.to_h if observer_object == record
+
+        trigger.call record, observer.to_h
+      end
+
+      def refine_observer_records_for(observer)
+        return @observed_object if observer.refine.blank?
+
+        observer.refine.call @observed_object
+      end
+
+      def observer_objects_for(observer, record)
+        return observer_objects_from_klass observer, record if observer.klass_observer?
+        return build_proc_for(observer.notify, observer.observer).call(observer.observer, record) if observer.notify.present?
+
+        observer.observer
+      end
+
+      def observer_objects_from_klass(observer, record)
+        return build_proc_for(observer.notify, observer.observer).call(record) if observer.notify.present?
+
+        observer.observer.new
+      end
+
+      def build_proc_for(variable, object)
+        return variable unless variable.is_a? Symbol
+
+        object.method variable
+      end
+
+      def observer_simplification?(observer, record, observer_object)
+        (observer_object == record) || (observer.klass_observer? && observer_object.is_a?(record.class))
+      end
+    end
+  end
+end

data/lib/reactive_observers/observable/removing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ReactiveObservers
+  module Observable
+    class Removing
+      REQUIRED_FIELDS = %i[klass object].freeze
+
+      def initialize(active_observers, observer, removing_options)
+        @active_observers = active_observers
+        @observer = observer
+        @removing_options = removing_options
+      end
+
+      def perform
+        @active_observers.delete_if do |active_observer|
+          active_observer.compare.partial? @observer, @removing_options
+        end
+      end
+    end
+  end
+end

data/lib/reactive_observers/observer/container.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'reactive_observers/observer/container_validator'
+require 'reactive_observers/observer/container_comparator'
+
+module ReactiveObservers
+  module Observer
+    class Container
+
+      attr_accessor :observer, :observed
+      attr_accessor :trigger, :notify, :refine, :context
+      attr_accessor :fields, :on, :only, :constrain
+
+      def initialize(observer, observed, options)
+        @observer = observer
+        @observed = observed.is_a?(Symbol) ? observed.to_s.classify.constantize : observed
+        @on = Array.wrap options[:on]
+        @fields = Array.wrap options[:fields]
+        @only = options[:only]
+        @trigger = options[:trigger] || ReactiveObservers.configuration.default_trigger
+        @notify = options[:notify]
+        @refine = options[:refine]
+        @context = options[:context]
+        ReactiveObservers::Observer::ContainerValidator.new(self).run_validations!
+        @constrain = load_observer_constrains
+      end
+
+      def compare
+        ReactiveObservers::Observer::ContainerComparator.new(self)
+      end
+
+      def klass_observer?
+        @observer.is_a? Class
+      end
+
+      def klass_observed?
+        @observed.is_a? Class
+      end
+
+      def observer_klass
+        return @observer if klass_observer?
+
+        @observer.class
+      end
+
+      def observed_klass
+        return @observed if klass_observed?
+
+        @observed.class
+      end
+
+      def to_h
+        { observer: @observer, observed: @observed, fields: @fields, on: @on, only: @only, constrain: @constrain,
+          trigger: @trigger, refine: @refine, notify: @notify, context: @context}
+      end
+
+      private
+
+      def load_observer_constrains
+        return [] if @observed.is_a?(Class)
+
+        [@observed.id]
+      end
+    end
+  end
+end

data/lib/reactive_observers/observer/container_comparator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ReactiveObservers
+  module Observer
+    class ContainerComparator
+      def initialize(observer)
+        @observer = observer
+      end
+
+      def partial?(observer, options)
+        @observer.observer == observer &&
+          array_compare_of(@observer.fields, options[:fields]) &&
+          array_compare_of(@observer.on, options[:on]) &&
+          context_compare_with(options[:context]) &&
+          constrain_compare_with(options[:constrain])
+      end
+
+      def full?(observer)
+        partial?(observer.observer, fields: observer.fields, on: observer.on, constrain: observer.constrain) &&
+          @observer.observed == observer.observed &&
+          @observer.trigger == observer.trigger &&
+          @observer.notify == observer.notify &&
+          @observer.refine == observer.refine &&
+          @observer.only == observer.only
+      end
+
+      private
+
+      def array_compare_of(argument, option_value)
+        argument.blank? || option_value.blank? || (argument & Array.wrap(option_value)).length.positive?
+      end
+
+      def constrain_compare_with(value)
+        value = Array.wrap value
+        value.blank? || @observer.constrain == value || (@observer.constrain & value).length.positive?
+      end
+
+      def context_compare_with(value)
+        value.blank? || @observer.context == value
+      end
+    end
+  end
+end

data/lib/reactive_observers/observer/container_validator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ReactiveObservers
+  module Observer
+    class ContainerValidator
+      def initialize(observer)
+        @observer = observer
+      end
+
+      def run_validations!
+        validate_observe_trigger!
+        validate_observe_notification!
+        validate_observe_active_record!
+        true
+      end
+
+      private
+
+      def validate_observe_trigger!
+        return unless @observer.trigger.is_a?(Symbol) && !@observer.observer_klass.method_defined?(@observer.trigger)
+
+        raise ArgumentError, "Class #{@observer.observer_klass.name} is missing required observed method #{@observer.trigger}"
+      end
+
+      def validate_observe_notification!
+        return if @observer.notify.present? || !@observer.klass_observer?
+
+        @observer.observer.new
+      rescue ArgumentError
+        raise ArgumentError, "Notify parameter is required for observer class #{@observer.observer_klass.name} which has complex initialization"
+      end
+
+      def validate_observe_active_record!
+        return if (!@observer.klass_observed? && @observer.observed.is_a?(ActiveRecord::Base)) ||
+          (@observer.klass_observed? && @observer.observed <= ActiveRecord::Base)
+
+        raise ArgumentError, "Class #{@observer.observed_klass.name} is not Active Record class"
+      end
+    end
+  end
+end

data/lib/reactive_observers/version.rb

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

data/lib/reactive_observers.rb

@@ -0,0 +1,23 @@
+require 'reactive_observers/version'
+require 'reactive_observers/configuration'
+require 'reactive_observers/base'
+require 'reactive_observers/observable/base'
+require 'reactive_observers/database_adapters/factory'
+
+require 'active_record'
+
+module ReactiveObservers
+  class Error < StandardError; end
+
+  mattr_accessor :configuration, default: Configuration.new
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+    DatabaseAdapters::Factory.new(configuration).initialize_observer_listeners
+  end
+end
+
+class ActiveRecord::Base
+  include ReactiveObservers::Observable::Base
+end

data/reactive_observers.gemspec

@@ -0,0 +1,35 @@
+require_relative 'lib/reactive_observers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "reactive_observers"
+  spec.version       = ReactiveObservers::VERSION
+  spec.authors       = ["martintomas"]
+  spec.email         = ["tomas@jchsoft.cz"]
+
+  spec.summary       = %q{Observe Active Record classes and records reactive way!}
+  spec.description   = %q{Every class or object can be transformed to observer and dynamically react to data changes across several models. Observable module is using build in Active Record hooks or database triggers which can be turned on in multiple App environment. }
+  spec.homepage      = "https://github.com/martintomas/reactive_observers.git"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/martintomas/reactive_observers.git"
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 5.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: reactive_observers
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+platform: ruby
+authors:
+- martintomas
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-11-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 'Every class or object can be transformed to observer and dynamically
+  react to data changes across several models. Observable module is using build in
+  Active Record hooks or database triggers which can be turned on in multiple App
+  environment. '
+email:
+- tomas@jchsoft.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/reactive_observers.rb
+- lib/reactive_observers/base.rb
+- lib/reactive_observers/configuration.rb
+- lib/reactive_observers/database_adapters/abstract_adapter.rb
+- lib/reactive_observers/database_adapters/factory.rb
+- lib/reactive_observers/database_adapters/postgresql_adapter.rb
+- lib/reactive_observers/observable/base.rb
+- lib/reactive_observers/observable/db_listener.rb
+- lib/reactive_observers/observable/filtering.rb
+- lib/reactive_observers/observable/notification.rb
+- lib/reactive_observers/observable/removing.rb
+- lib/reactive_observers/observer/container.rb
+- lib/reactive_observers/observer/container_comparator.rb
+- lib/reactive_observers/observer/container_validator.rb
+- lib/reactive_observers/version.rb
+- reactive_observers.gemspec
+homepage: https://github.com/martintomas/reactive_observers.git
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/martintomas/reactive_observers.git
+  source_code_uri: https://github.com/martintomas/reactive_observers.git
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Observe Active Record classes and records reactive way!
+test_files: []