wazowski 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b3b3ba72596ae107acd23c4e967a7f67227a86bb4f12484bdd516427915a3445
+  data.tar.gz: ad1645836bb7b460f82569bc2c69de577b8af4a24f40f3063ccd0ef8920e2e9e
+SHA512:
+  metadata.gz: 88b7a93e0ecab89bdedd9f352f56a392ef0a47828ba4c1c0abaa2707ae2ee218a5b4466004a6b29204d0764c46df4bf2c843462723addf135e74d8832f81799b
+  data.tar.gz: 8996a9448947f9b02f416bfbf731766a27b10074e8ca6851796ea62050cc0759826b75d94abf2bea55aa6214f629e3f78ab69988ca882c53540667bc935d40aa

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.env

data/.travis.yml

@@ -0,0 +1,13 @@
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.4
+  - 2.4.0
+services:
+  - postgresql
+before_install: gem install bundler -v 1.16.0
+env:
+  - WAZOWSKI_PG_DATABASE=travis_ci_test WAZOWSKI_PG_USERNAME=postgres
+before_script:
+  - psql -c 'create database travis_ci_test;' -U postgres

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in wazowski.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    wazowski (0.1.0)
+      activerecord (>= 4.2)
+      activesupport (>= 4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.1.4)
+      activesupport (= 5.1.4)
+    activerecord (5.1.4)
+      activemodel (= 5.1.4)
+      activesupport (= 5.1.4)
+      arel (~> 8.0)
+    activesupport (5.1.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (8.0.0)
+    concurrent-ruby (1.0.5)
+    dotenv (2.2.1)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.1)
+    pg (0.21.0)
+    rake (10.5.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  dotenv
+  minitest (~> 5.0)
+  pg
+  rake (~> 10.0)
+  wazowski!
+
+BUNDLED WITH
+   1.16.0

data/README.md

@@ -0,0 +1,291 @@
+[![Build Status](https://travis-ci.org/rogercampos/wazowski.svg?branch=master)](https://travis-ci.org/rogercampos/wazowski)
+
+
+# Wazowski
+
+You can use this library to observe changes on data and execute your code when those changes occur.
+
+Example:
+
+```ruby
+class Something < Wazowski::Observer
+  observable(:observable_name) do
+    depends_on Order, :user_id, :state
+    
+    handler(Order) do |order, event, changes|
+      # This block will be called every time an Order is created, destroyed or updated on user_id or state
+      # 'event' will be either insert, delete or update
+      # changes will be a hash of changes occurred on the order instance, in the case of an update, ex:
+      #   `{user_id: [1, 2], state: ["pending", "sent"]}` (pairs of old_value, new_value)    
+    end
+  end
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wazowski'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wazowski
+
+
+
+## Why this?
+
+- Allows you to put your code in the scope it belongs, not necessarily in the model. Ex: If you're syncing a model
+with third party service, you could setup the observer inside the namespace of this third party (ej `Salesforce`)
+instead of using AR hooks directly in the observed model. It makes it easy to remove the integration with that
+service in the future, it helps you decouple things.
+
+- Provides an unified point of control from where to manage data observations and derived logic. Ex: If you want
+to sync data to a third party service, having that source data in 3 different models that should be combined and
+pushed. If all those 3 models change during a transaction, you'll be executing the
+sync 3 times, when you could just do it once. This kind of control is difficult when using AR hooks directly in
+models, but it can be implemented easily with Wazowski (see example use cases at the end). 
+
+- Abstracts away the particularities about how the data is observed. You write in a declarative way what do you
+want to happen (ej: run this if that changes) instead of directly using AR hooks. Helps in maintaining changes in
+AR itself, or if you want to change your data management strategy (change AR for something else). 
+
+- Because it's declarative, allows you to work transparently with different data sources (different databases, 
+different ORM's, etc) while maintaining a unique view about how to declare data observations.
+
+
+## Detailed usage and public API
+
+You must start by creating a class inheriting from `Wazowski::Observer`. Then, you can declare observers with the
+`observable` method and syntax described below. The organization of the observers is up to you, you can declare 
+many `observable's` in the same class or create multiple different classes, depending on your code organization needs.
+
+For every `observable` you must indicate which models and attributes of those models you want to observe. For any
+observed model, then you must provide a handler. This handler will be invoked when a change on that model occurs.
+
+You can observe changes on a model in different ways. The first one is manually specifying a list of attributes
+to observe:
+
+```ruby
+observable(:name) do
+  depends_on User, :name, :email
+  
+  handler(User) do |obj, event, changes|
+    # changes will include the old a new values of name and email on update
+    # on creation and deletion, changes will be an empty hash 
+  end
+end
+```
+
+But you can also choose to observe on any attribute:
+
+```ruby
+observable(:name) do
+  depends_on User, :any
+  
+  handler(User) do |obj, event, changes|
+    # Since you're observing User on any attribute, changes will be always empty
+  end
+end
+```
+
+In this case the handler callback will receive no information about changes, even in update.
+
+You can also observe a model's "presence". Your code will be executed only on create and deletion of the dependant
+model, but not on updates:
+
+```ruby
+observable(:name) do
+  depends_on User, :none
+  
+  handler(User) do |obj, event, changes|
+    # This block will not run on update of users.
+  end
+end
+```
+
+
+You can also observe more than one model in one observable, in this case you must provide a handler for each model:
+
+```ruby
+observable(:user_sync_to_salesforce) do
+  depends_on User, :all
+  depends_on Order, :none
+  depends_on BillingInfo, :all
+  
+  foo = proc do |obj, event, changes|
+    # reused handler
+  end
+  
+  handler(User, &foo)
+  handler(Order, &foo)
+  handler(BillingInfo, &foo)
+  # ...
+end
+```
+
+When defining handlers, you can also specify handlers to run only on certain events. You can choose between `:insert`,
+`:update` and `:delete`. 
+
+```ruby
+observable(:user_sync_to_salesforce) do
+  depends_on User, :none
+  
+  handler(User, only: :insert) do |obj, event|
+    # Will run only on create 
+  end
+end
+```
+ 
+Your blocks will be executed always on `after_commit`. They will not run if the transaction is rolled back. 
+Before triggering your code, the changes that happened inside the transaction will be accumulated 
+(ej: insert+delete = noop, insert + update = insert, etc.).
+
+Note that if you update attributes on a model inside a handler, this can result in an infinite loop if the attributes
+you're changing are also observed by the same handler. You can, however, "chain" multiple observers (i.e., one
+handler can trigger an update for an attribute observed in a second handler, etc.) as long as this graph 
+does not contain cycles. 
+
+ 
+### Context of execution for handlers
+
+The context in which your handlers will be executed is an instance of the class in which the `observable` 
+is defined. This gives you flexibility for reusing common code across your handlers by including your own modules, ex:
+
+```ruby
+class ObserversForSomething < Wazowski::Observer
+  include MyCommonObserverLogic
+  
+  observable(:name) do
+    # ...
+    handler(Model) do |_|
+      # use_common_logic_here from MyCommonObserverLogic
+      # 'self' == ObserversForSomething.new
+    end
+  end
+end
+```
+
+The instance used as context will be newly created for every committed transaction occurred. 
+
+If you're observing multiple models inside an observable, and all those models experience changes inside a transaction 
+(say, i.e. 4 models), all your 4 handlers will be executed. Since all those changes occurred in a single transaction, 
+the context instance will be the same for the 4 handler executions, so you can use state to implement features.
+
+On the other hand, if those 4 models experience changes in 4 isolated transactions, your 4 handlers will be executed
+every time with a newly created context instance.
+
+Your observer classes can implement an initialization method, but it must have no arguments in order for Wazowski
+to be able to instantiate them.
+
+
+## Usage examples
+
+### Execute a handler only once per transaction
+
+If you're implementing a synchronization of data with a third party service, it's a common practice to develop
+an Etl on your side, which reads information on your database and creates a new representation of that data (possibly
+with manipulation logics, like re-formatting of currencies, countries, etc.) that is then pushed to the service.
+
+The source data is scattered across multiple models, so you need to watch for all those points to re-sync when
+they change. But since the Etl has only one entry point, in the case all those models are updated inside the same 
+transaction you want the Etl to run only once.
+
+To accomplish this, you can use some state inside your observer class to run the handler only on the first time:
+
+```ruby
+class MyObserver < Wazowski::Observer
+  def initialize
+    @counter = 0 
+  end
+  
+  def run_only_once
+    return unless @counter == 0
+    yield
+    @counter += 1
+  end
+ 
+  observable(:user_sync_to_salesforce) do
+    depends_on User, :all
+    depends_on Order, :none
+    depends_on BillingInfo, :all
+  
+    handler(User) { |user| 
+      run_only_once { Etl.run(user) } 
+    }
+    handler(Order) { |order| 
+      run_only_once { Etl.run(order.user) }
+    }
+    handler(BillingInfo) { |billing_info| 
+      run_only_once { Etl.run(billing_info.user) }
+    }
+  end
+end
+```
+
+
+## Internal details
+
+This tool currently works only with ActiveRecord, but it's design accepts multiple adapters if you ever want
+to write a new one. 
+
+The public API currently supports only relational info, but it could be expanded in the future to support 
+other types of data (graph, key/value, etc.) maintaining backwards compatibility.
+
+Even tough the current public API works by specifying directly models (ej: `User`) this class is never used
+internally and is only forwarded to the adapter. To use this library with a repository pattern, the same API
+could be used but instead of providing AR Classes your could provide Repository classes. However, this is only
+an idea, no attempt to use this with a repository pattern has been tried. 
+
+
+### Adapter's API
+
+- An adapter is the responsible to actually observe the data. It will receive the information provided by the
+user about what data has to be observed (models, attributes) and it will be responsible of calling Wazowski's hooks
+whenever a database commit happens.
+
+- An adapter is a module or class.
+
+- An adapter must implement a `register_node` class method. This method receives 1) a node_id (string) and 
+2) a hash of Class => list_of_attributes (as symbols) as defined in the public DSL. The adapter must use this information to
+prepare its setup. It must keep the `node_id` string to reuse it. An attribute can also be `:none` or `:any`. 
+For `:none`, the observer indicates it only wants to receive creation and deletion callbacks. For `:any`, the observer
+indicates it wants to receive all callbacks, including updates on any attribute, but no need to pass specific 
+dirty info. 
+
+- The adapter must call the `Wazowski.run_handlers(changes_per_node)` every time a transaction is committed, 
+once and only once per transaction even if multiple models have changed inside the transaction. It must provide as
+an argument the accumulated information of changes occurred per node inside the transaction. This data structure
+is a hash where each key is a node_id (as provided in the `register_node` call) and each value is an array of
+changes occurred on that node. A change is defined as an array of 3 elements: the change type, the class and the 
+object. Example:
+
+```ruby
+{
+  "TestObserver/valid_comments_count"=>[[:insert, Post, #<Post id: 1, ...>]],
+  "TestObserver/only_on_insert"=>[[:insert, Post, #<Post id: 1, ...>]]}
+}
+```
+ 
+- The adapter must behave in a transactional way, i.e., if a record is created and deleted inside a transaction, no
+callback should be called whatsoever. 
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rogercampos/wazowski.
+
+

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 "wazowski"
+
+# 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/wazowski.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'active_support/core_ext/module'
+require 'active_record'
+
+require "wazowski/version"
+require 'wazowski/active_record_adapter'
+
+module Wazowski
+  NoSuchNode = Class.new(StandardError)
+  ConfigurationError = Class.new(StandardError)
+
+  module Observable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def observable(name, &block)
+        id = "#{self.name || object_id}/#{name}"
+
+        node = Node.new(id, self, block)
+        Config.derivations[id] = node
+
+        ActiveRecordAdapter.register_node(id, node.dependants)
+      end
+    end
+  end
+
+  class Observer
+    include Observable
+  end
+
+  module Config
+    mattr_accessor :derivations
+    self.derivations = {}
+  end
+
+  class Node
+    attr_reader :name
+
+    def initialize(name, klass, block)
+      @name = name
+      @observer_klass = klass
+      instance_eval(&block)
+    end
+
+    def depends_on(klass, *attrs)
+      if attrs.empty?
+        raise ConfigurationError, 'Must depend on some attributes. You can also use `:none` and `:any`'
+      end
+
+      @depends_on ||= {}
+      @depends_on[klass] ||= []
+      @depends_on[klass] += attrs
+    end
+
+    def handler(klass, opts = {}, &block)
+      @handlers ||= {}
+      raise ConfigurationError, "Already defined handler for #{klass}" if @handlers[klass]
+
+      @handlers[klass] = { block: block, opts: opts }
+    end
+
+    def dependants
+      @depends_on
+    end
+
+    def inspect
+      "<Wazowski::Node #{@name}>"
+    end
+
+    def lookup_handler(klass)
+      handler = if @handlers[klass]
+                  @handlers[klass]
+                else
+                  lookup_handler(klass.superclass) unless klass.superclass == Object
+                end
+
+      if handler.nil?
+        raise(ConfigurationError, "Cannot run handler for klass #{klass}, it has been never "\
+                                  'registered! Check your definitions.')
+      end
+
+      handler
+    end
+
+    def wrapping
+      @context = @observer_klass.new
+
+      yield
+    end
+
+    def after_commit_on_update(klass, object, dirty_changes)
+      raise ConfigurationError, "Needs to be called within a #wrapping call!" if @context.nil?
+      handler = lookup_handler(klass)
+
+      return unless handler[:opts][:only].nil? || [handler[:opts][:only]].flatten.include?(:update)
+      @context.instance_exec(object, :update, dirty_changes, &handler[:block])
+    end
+
+    def after_commit_on_delete(klass, object)
+      raise ConfigurationError, "Needs to be called within a #wrapping call!" if @context.nil?
+      handler = lookup_handler(klass)
+
+      return unless handler[:opts][:only].nil? || [handler[:opts][:only]].flatten.include?(:delete)
+      @context.instance_exec(object, :delete, {}, &handler[:block])
+    end
+
+    def after_commit_on_create(klass, object)
+      raise ConfigurationError, "Needs to be called within a #wrapping call!" if @context.nil?
+      handler = lookup_handler(klass)
+
+      return unless handler[:opts][:only].nil? || [handler[:opts][:only]].flatten.include?(:insert)
+      @context.instance_exec(object, :insert, {}, &handler[:block])
+    end
+  end
+
+  class << self
+    def find_node(node_id)
+      Config.derivations[node_id] || raise(NoSuchNode, "Node not found! #{node_id}")
+    end
+
+    def run_handlers(changes_per_node)
+      changes_per_node.each do |node_id, changes|
+        node = find_node(node_id)
+
+        node.wrapping do
+          changes.each do |change_type, klass, object, changeset|
+            case change_type
+              when :insert
+                node.after_commit_on_create(klass, object)
+              when :delete
+                node.after_commit_on_delete(klass, object)
+              when :update
+                node.after_commit_on_update(klass, object, changeset)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/wazowski/active_record_adapter.rb

@@ -0,0 +1,204 @@
+module Wazowski
+  module ActiveRecordAdapter
+    module TransactionState
+      class StateData
+        def initialize
+          @changed_models = Set.new
+        end
+
+        def run_after_commit_only_once!
+          return if @changed_models.empty?
+
+          info = {}
+
+          # even @changed_models being a Set, it's possible that the "same" model
+          # have been included in the set before and after persistence (so they're different,
+          # we have both in the set) and by the time this code runs, the non persisted model
+          # becomes persisted and now they're identical, but still in the set.
+          # So we may have duplicates. `.to_a.uniq` to remove them.
+          @changed_models.to_a.uniq.each do |model|
+            info.merge!(model.__wazowski_changes_per_node) do |_, old_val, new_val|
+              old_val + new_val
+            end
+          end
+
+          clear_after_commit_performed!
+
+          Wazowski.run_handlers(info)
+        end
+
+        def clear_after_commit_performed!
+          @changed_models.clear
+        end
+
+        def register_model_changed(model)
+          @changed_models << model
+        end
+      end
+
+      mattr_accessor :states
+      self.states = {}
+
+      def self.current_state
+        states[ActiveRecord::Base.connection.hash] ||= StateData.new
+      end
+    end
+
+    module WatchDog
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_accessor :__wazowski_tracked_attrs, :__wazowski_tracked_base, :__wazowski_tracked_any
+        self.__wazowski_tracked_attrs = {}
+        self.__wazowski_tracked_base = Set.new
+        self.__wazowski_tracked_any = Set.new
+
+        before_update(append: true) do
+          self.class.__wazowski_tracked_any.each do |node_id|
+            __wazowski_presence_state.push([:update, node_id])
+            TransactionState.current_state.register_model_changed(self)
+          end
+
+          self.class.__wazowski_tracked_attrs.each do |attr, node_ids|
+            if send("#{attr}_changed?")
+              node_ids.each { |node_id| __wazowski_store_dirty!(attr, node_id, :update, send("#{attr}_was")) }
+            end
+          end
+        end
+
+        before_destroy do
+          self.class.__wazowski_all_nodes.each do |node_id|
+            __wazowski_presence_state.push([:delete, node_id])
+            TransactionState.current_state.register_model_changed(self)
+          end
+        end
+
+        before_create do
+          self.class.__wazowski_all_nodes.each do |node_id|
+            __wazowski_presence_state.push([:insert, node_id])
+            TransactionState.current_state.register_model_changed(self)
+          end
+        end
+
+        after_commit do
+          TransactionState.current_state.run_after_commit_only_once!
+
+          __wazowski_clean_dirty!
+          __wazowski_presence_state.clear
+        end
+
+        after_rollback do
+          __wazowski_clean_dirty!
+          __wazowski_presence_state.clear
+
+          TransactionState.current_state.clear_after_commit_performed!
+        end
+
+        def __wazowski_store_dirty!(attr, node_id, change_type, attr_was = nil)
+          __wazowski_dirty_state[attr] ||= {}
+          __wazowski_dirty_state[attr][:change_type] = change_type
+          __wazowski_dirty_state[attr][:dirty] = attr_was if __wazowski_dirty_state[attr][:dirty].nil?
+          __wazowski_dirty_state[attr][:node_ids] ||= Set.new
+          __wazowski_dirty_state[attr][:node_ids] << node_id
+
+          TransactionState.current_state.register_model_changed(self)
+        end
+
+        def __wazowski_changes_per_node
+          info = {}
+
+          states = __wazowski_presence_state.map(&:first)
+
+          unless states.include?(:insert) || states.include?(:delete)
+            changes_by_node = {}
+
+            __wazowski_dirty_state.each do |attr, data|
+              node_ids = data[:node_ids]
+              new_data = data.except(:node_ids).merge(attr: attr)
+
+              node_ids.each do |node_id|
+                changes_by_node[node_id] ||= []
+                changes_by_node[node_id] << new_data
+              end
+            end
+
+            changes_by_node.each do |node_id, datas|
+              list_of_changes = datas.map { |x| [x[:attr], [x[:dirty], send(x[:attr])]] }.to_h
+
+              info[node_id] ||= []
+              info[node_id] << [:update, self.class, self, list_of_changes]
+            end
+          end
+
+          unless states.include?(:insert) && states.include?(:delete)
+            __wazowski_presence_state.each do |type, node_id|
+              info[node_id] ||= []
+
+              case type
+                when :insert
+                  info[node_id] << [:insert, self.class, self]
+                when :delete
+                  info[node_id] << [:delete, self.class, self]
+                when :update
+                  info[node_id] << [:update, self.class, self, {}]
+              end
+            end
+          end
+
+          info
+        end
+
+        def __wazowski_clean_dirty!
+          @__wazowski_dirty_state = {}
+        end
+
+        def __wazowski_dirty_state
+          @__wazowski_dirty_state ||= {}
+        end
+
+        def __wazowski_presence_state
+          @__wazowski_presence_state ||= []
+        end
+      end
+
+      class_methods do
+        def __wazowski_track_on!(attr, node_id)
+          __wazowski_tracked_attrs[attr] ||= Set.new
+          __wazowski_tracked_attrs[attr] << node_id
+        end
+
+        def __wazowski_track_base!(node_id)
+          __wazowski_tracked_base << node_id
+        end
+
+        def __wazowski_track_any!(node_id)
+          __wazowski_tracked_any << node_id
+        end
+
+        def __wazowski_all_nodes
+          nodes_by_attribute = __wazowski_tracked_attrs.values
+
+          (nodes_by_attribute.any? ? nodes_by_attribute.sum : Set.new) +
+            __wazowski_tracked_base +
+            __wazowski_tracked_any
+        end
+      end
+    end
+
+    def self.register_node(node_id, observed_hierarchy)
+      observed_hierarchy.each do |klass, attrs|
+        klass.send(:include, WatchDog) unless klass.included_modules.include?(WatchDog)
+
+        if attrs.size == 1 && attrs[0] == :none
+          klass.__wazowski_track_base!(node_id)
+        elsif attrs.size == 1 && attrs[0] == :any
+          klass.__wazowski_track_any!(node_id)
+        else
+          attrs.each do |attr|
+            klass.__wazowski_track_on!(attr, node_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wazowski/version.rb

@@ -0,0 +1,3 @@
+module Wazowski
+  VERSION = "0.1.1"
+end

data/wazowski.gemspec

@@ -0,0 +1,39 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "wazowski/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "wazowski"
+  spec.version       = Wazowski::VERSION
+  spec.authors       = ["Roger Campos"]
+  spec.email         = ["roger@rogercampos.com"]
+
+  spec.summary       = %q{declarative active record data observers}
+  spec.description   = %q{declarative active record data observers}
+  spec.homepage      = "https://github.com/rogercampos/wazowski"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |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", ">= 4.2"
+  spec.add_dependency "activesupport", ">= 4.2"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pg"
+  spec.add_development_dependency "dotenv"
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: wazowski
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Roger Campos
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: declarative active record data observers
+email:
+- roger@rogercampos.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/wazowski.rb
+- lib/wazowski/active_record_adapter.rb
+- lib/wazowski/version.rb
+- wazowski.gemspec
+homepage: https://github.com/rogercampos/wazowski
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: declarative active record data observers
+test_files: []