active_spy 1.0.0.rc

data/lib/active_spy/rails/base.rb

@@ -0,0 +1,90 @@
+require 'rest-client'
+require 'singleton'
+
+module ActiveSpy
+  # Module to hold Rails specific classes and helpers.
+  #
+  module Rails
+    # Default template for callbacks handlers.
+    #
+    class Base
+      def initialize(object)
+        @object = object
+      end
+
+      # Overriding to avoid sending the object to server 2 times (in both
+      # before and after callabcks).
+      #
+      def respond_to?(method)
+        method.include?('after_') || method == 'before_save'
+      end
+
+      # Set a flag in the object to tell us wether it's a new record or not.
+      #
+      def before_save
+        inject_is_new_method(@object)
+        @object.is_new = true if @object.new_record?
+      end
+
+      # Inject an attribute in the +object+, called +is_new?+ and a setter
+      # for it.
+      #
+      def inject_is_new_method(object)
+        object.instance_eval do
+          def is_new=(value)
+            @is_new = value
+          end
+
+          def is_new?
+            @is_new
+          end
+        end
+      end
+
+      # Overriding to always send the object to the server, even though the
+      # after callback is not explicitly defined.
+      #
+      def method_missing(method, *_args, &_block)
+        host = ActiveSpy::Configuration.event_host
+        port = ActiveSpy::Configuration.event_port
+
+        RestClient.post "#{host}:#{port}/",
+          event: get_request_params(method)
+        remove_is_new_method(@object)
+      end
+
+      # Get the event request params for a given +method+.
+      #
+      def get_request_params(method)
+        real_method = method.to_s.split('_').last
+        action = get_action(real_method)
+        {
+          type:     @object.class.name,
+          actor:    @object.actor,
+          realm:    @object.realm,
+          payload:  @object.payload_for(action),
+          action:   action
+        }
+      end
+
+      # Remove a previously added +is_new+ attribute from a given object.
+      #
+      def remove_is_new_method(object)
+        object.instance_eval do
+          undef :is_new=
+          undef :is_new?
+        end
+      end
+
+      # Returns the correct action for the method called in the model.
+      #
+      def get_action(real_method)
+        if real_method == 'save'
+          return 'create' if @object.is_new?
+          return 'update'
+        end
+        'destroy'
+      end
+    end
+  end
+end

data/lib/active_spy/rails/engine.rb

@@ -0,0 +1,7 @@
+module ActiveSpy
+  # Class responsible for the controller and routes integration with Rails
+  #
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveSpy
+  end
+end

data/lib/active_spy/rails/hook_list.rb

@@ -0,0 +1,114 @@
+module ActiveSpy
+  module Rails
+    # Class used to hold all the events hook's paths and later sync
+    # them with an event runner instance.
+    #
+    class HookList
+      include Singleton
+
+      # Initialize an empty hook list
+      #
+      def initialize
+        host = ActiveSpy::Configuration.event_host
+        port = ActiveSpy::Configuration.event_port
+        name = ActiveSpy::Configuration.name.downcase.gsub(' ', '-').strip
+        @base_service_url = "#{host}:#{port}/services/#{name}"
+        @hooks = []
+      end
+
+      # Proxy all methods called in the {ActiveSpy::Hook} to
+      # {ActiveSpy::Hook} instance. Just a syntax sugar.
+      #
+      def self.method_missing(method, *args, &block)
+        instance.send(method, *args, &block)
+      end
+
+      # Clear the hook list.
+      #
+      def clear
+        @hooks = []
+      end
+
+      # forward {<<} method to the hook list.
+      #
+      def <<(other)
+        @hooks << other
+      end
+
+      # Register in event runner all the hooks defined in the list. If some of
+      # them already exists, they will be excluded and readded.
+      #
+      def register
+        old_hooks = get_old_hooks
+        hooks_to_delete = get_hooks_to_delete(old_hooks)
+        hooks_to_add = get_hooks_to_add(old_hooks)
+        delete_hooks(hooks_to_delete) if hooks_to_delete.any?
+        add_hooks(hooks_to_add) unless hooks_to_add.empty?
+      end
+
+      # Get the old hooks list for this service from the event-runner
+      #
+      def get_old_hooks
+
+        JSON.load(RestClient.get(@base_service_url))['hooks']
+      end
+
+      # Select from old hooks those that should be deleted from event runner.
+      #
+      def get_hooks_to_delete(old_hooks)
+        hooks_to_delete = []
+        old_hooks.each do |old_hook|
+          found = false
+          @hooks.each do |hook|
+            if hook['class'] == old_hook['class'] && old_hook['active']
+              found = true
+              break
+            end
+          end
+          next if found
+          hooks_to_delete << old_hook
+        end
+        hooks_to_delete
+      end
+
+      # Select from the hooks defined in the app those that should be created
+      # in the event runner.
+      #
+      def get_hooks_to_add(old_hooks)
+        hooks_to_add = []
+        @hooks.each do |hook|
+          found = false
+          old_hooks.each do |old_hook|
+            if hook['class'] == old_hook['class'] && old_hook['active']
+              found = true
+              break
+            end
+          end
+          next if found
+          hooks_to_add << hook
+        end
+        hooks_to_add
+      end
+
+      # Properly delete the +hooks_to_delete+ in the event runner.
+      #
+      def delete_hooks(hooks_to_delete)
+        hooks_to_delete.each do |hook|
+          RestClient.delete "#{@base_service_url}/hooks/#{hook['id']}"
+        end
+      end
+
+      # # Properly creates the +hooks_to_add+ in the event runner..
+      #
+      def add_hooks(hooks_to_add)
+        hooks_to_add.each do |hook|
+          RestClient.post "#{@base_service_url}/hooks", {
+            'class'=> hook['class'],
+            'postPath' => ActiveSpy::Engine.routes.url_helpers.notifications_path(hook['class'].downcase),
+            'active' => true
+          }
+        end
+      end
+    end
+  end
+end

data/lib/active_spy/rails/listener.rb

@@ -0,0 +1,87 @@
+require 'rest-client'
+require 'json'
+
+module ActiveSpy
+  module Rails
+    # Base class used to process the events received.
+    #
+    class Listener
+      include ActiveSupport::Inflector
+
+
+      # Constant to hold the model translations. The key is the incoming
+      # +ref_type+ and the value is the matching model class.
+      #
+      MODEL_HANDLER = {}
+
+      # Store the event handler hook in the {ActiveSpy::Rails::HookList} for
+      # later registration of them within the event runner.
+      #
+      def self.inherited(child)
+        if child.name.include? 'Listener'
+          ActiveSpy::Rails::HookList << {
+            'class' => child.name.split('Listener')[0]
+          }
+        end
+      end
+
+      # Handle a request with +params+ and sync the database according to
+      # them.
+      #
+      def handle(params)
+        object_type = params.delete(:type)
+        callback = params[:payload].delete(:action)
+        payload_content = params.delete(:payload)[object_type.downcase.to_sym]
+        actor = params.delete(:actor)
+        realm = params.delete(:realm)
+
+        sync_database(callback, object_type, payload_content, actor, realm)
+      end
+
+      # Calls the proper method to sync the database. It will manipulate
+      # objects of the class +object_type+, with the attributes sent in the
+      # +payload+, triggered by the callback +callback+.
+      #
+      def sync_database(callback, object_type, payload, actor, realm)
+        send(callback, object_type, payload, actor, realm)
+      end
+
+      # Logic to handle object's creation. You can override this, as you wish,
+      # to suit your own needs
+      #
+      def create(object_type, payload, _actor, _realm)
+        klass = get_object_class(object_type)
+        klass.new.update_attributes(payload)
+      end
+
+      # Logic to handle object's update. You can override this, as you wish,
+      # to suit your own needs
+      #
+      def update(object_type, payload, _actor, _realm)
+        klass = get_object_class(object_type)
+        guid = payload.delete(:guid)
+        klass.find_by(guid: guid).update_attributes(payload)
+      end
+
+      # Destroy a record from our database. You can override this, as you wish,
+      # to suit your own needs
+      #
+      def destroy(klass, payload, _actor, _realm)
+        klass = get_object_class(klass)
+        guid = payload.delete(:guid)
+        klass.find_by(guid: guid).destroy!
+      end
+
+      # Gets the object class. First, it'll look the {MODEL_HANDLER} hash and
+      # see if there is any translation for a given +object_type+. If it does
+      # not have a translation, this method will try to +constantize+ the
+      # +object_type+.
+      #
+      def get_object_class(object_type)
+        translated_object_type = MODEL_HANDLER[object_type]
+        return constantize(translated_object_type) if translated_object_type
+        constantize(object_type)
+      end
+    end
+  end
+end

data/lib/active_spy/rails/railtie.rb

@@ -0,0 +1,17 @@
+require 'rails'
+
+# Railtie class to automatically include {ActiveSpy::Spy} in all
+# +ActiveRecord::Base+
+#
+class Railtie < Rails::Railtie
+  initializer 'active_spy.spies' do
+    ActiveSupport.on_load(:active_record) do
+      include ActiveSpy::Spy
+      include ActiveSpy::Rails::Spy
+    end
+  end
+
+  config.after_initialize do
+    Rails.application.eager_load!
+  end
+end

data/lib/active_spy/rails/spy.rb

@@ -0,0 +1,60 @@
+require 'active_support'
+
+module ActiveSpy
+  # Module used to hold Rails specific logic.
+  #
+  module Rails
+    # Module that defines methods used to spy on some class methods.
+    #
+    module Spy
+      # Default snippet to extends the class with
+      # {ActiveSpy::Spy::ClassMethods} when {ActiveSpy::Spy} is included in
+      # it.
+      #
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      # Class methods to be defined in classes that includes {ActiveSpy::Spy}
+      #
+      module ClassMethods
+        # Class method to define the realm of the model.
+        #
+        def model_realm(realm_name = nil, &block)
+          realm = -> { send(realm_name) } if realm_name
+          realm = block if block_given?
+          define_method :realm do
+            realm.call
+          end
+        end
+
+        # Class method to define the actor of the model.
+        #
+        def model_actor(actor_name = nil, &block)
+          actor = -> { send(actor_name) } if actor_name
+          actor = block if block_given?
+          define_method :actor do
+            actor.call
+          end
+        end
+
+        # Helper to use on Rails app and watch for model creation, update and
+        # destruction.
+        #
+        def watch_model_changes
+          watch_method :save, :destroy
+          inject_payload_for_method
+        end
+
+        # Helper to inject the method +payload_for(method)+ in the model
+        # with the default behavior: all attributes are sent in all
+        # actions.
+        #
+        def inject_payload_for_method
+          define_method :payload_for do |_method|
+            { self.class.name.downcase.to_sym => attributes }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_spy/spy/spy.rb

@@ -0,0 +1,42 @@
+require 'active_support'
+
+module ActiveSpy
+  # Module that defines methods used to spy on some class methods
+  #
+  module Spy
+    # Default snippet to extends the class with {ActiveSpy::Spy::ClassMethods}
+    # when {ActiveSpy::Spy} is included in it.
+    #
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # Invokes the callback method on the invoker class. The +callback_type+
+    # param tells wether it will be called +:after+ or +before+.
+    #
+    def invoke_callback(method, callback_type)
+      callback_invoker = callback_invoker_class.new(self)
+      callback = "#{callback_type}_#{method}"
+      return unless callback_invoker.respond_to?(callback)
+      callback_invoker.send(callback)
+    end
+
+    # Gets the invoker class based on the class' name
+    #
+    def callback_invoker_class
+      ActiveSupport::Inflector.constantize "#{self.class.name}Events"
+    end
+
+    # Class methods to be defined in classes that includes {ActiveSpy::Spy}
+    #
+    module ClassMethods
+      # Set watchers for the +method+
+      #
+      def watch_method(*methods)
+        methods.each do |method|
+          ActiveSpy::SpyList << { 'class' => name, 'method' => method }
+        end
+      end
+    end
+  end
+end

data/lib/active_spy/spy/spy_list.rb

@@ -0,0 +1,64 @@
+require 'active_support'
+require 'singleton'
+
+module ActiveSpy
+  # Singleton used to hold the spies and lazely active these spies by patching
+  # the methods in the specified classes.
+  #
+  class SpyList
+    include Singleton
+
+    # Just to initiliaze the spy list.
+    #
+    def initialize
+      @spies = []
+    end
+
+    attr_reader :spies
+
+    # Proxy all methods called in the {ActiveSpy::SpyList} to
+    # {ActiveSpy::SpyList} instance. Just a syntax sugar.
+    #
+    def self.method_missing(method, *args, &block)
+      instance.send(method, *args, &block)
+    end
+
+    # Active all the spies defined in the spy list by patching the methods
+    # in their classes.
+    #
+    def activate
+      @spies.each do |spy|
+        spied_class = spy['class']
+        spied_method = spy['method']
+
+        patch(spied_class, spied_method)
+      end
+    end
+
+    # forward {<<} method to the spy list.
+    #
+    def <<(other)
+      @spies << other
+    end
+
+    private
+
+    # This method patches the +method+ in the class +klass+ to invoke the
+    # callbacks defined in the respective class, that should be named using
+    # appending 'Events' to the class' name, and inherites from
+    # {ActiveSpy::Base}.
+    #
+    def patch(klass, method)
+      ActiveSupport::Inflector.constantize(klass).class_eval do
+
+        old_method = instance_method(method)
+        define_method method do
+          send(:invoke_callback, method, :before)
+          result = old_method.bind(self).call
+          send(:invoke_callback, method, :after)
+          result
+        end
+      end
+    end
+  end
+end

data/lib/active_spy.rb

@@ -0,0 +1,48 @@
+require 'active_spy/configuration'
+require 'active_spy/base'
+require 'active_spy/spy/spy'
+require 'active_spy/spy/spy_list'
+require 'active_spy/rails/base' if defined?(Rails)
+require 'active_spy/rails/spy' if defined?(Rails)
+require 'active_spy/rails/railtie' if defined?(Rails)
+require 'active_spy/rails/engine' if defined?(Rails)
+require 'active_spy/rails/engine' if defined?(Rails)
+require 'active_spy/rails/hook_list' if defined?(Rails)
+require 'active_spy/rails/listener'
+
+# Base module for the gem
+#
+module ActiveSpy
+  if defined?(Rails)
+    # @!method self.configure
+    # Class method to set the service's name, host and port.
+    #
+    def self.configure
+      Configuration.instance_eval do
+        yield(self)
+      end
+    end
+
+    # @!method self.register_service
+    # Class method to register the service in an event-runner instance.
+    #
+    def self.register_service
+      host = ActiveSpy::Configuration.event_host
+      port = ActiveSpy::Configuration.event_port
+      @@base_url = "#{host}:#{port}/services"
+
+      return if self.service_registered?
+      RestClient.post @@base_url, service: ActiveSpy::Configuration.settings
+    end
+
+    # @!method self.service_registered?
+    # Check if the service was already registetered in the configured event
+    # runner instance.
+    #
+    def self.service_registered?
+      name = ActiveSpy::Configuration.name
+      r = RestClient.get "#{@@base_url}/#{name.downcase.gsub(' ', '-').strip}"
+      r.code == 200
+    end
+  end
+end

data/lib/rails/generators/active_event/install/install_generator.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module ActiveSpy
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      desc 'Creates an active_spy gem configuration file at config/active_spy.yml, and an initializer at config/initializers/active_spy.rb'
+
+      def self.source_root
+        @_active_spy_source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def create_config_file
+        template 'active_spy.yml', File.join('config', 'active_spy.yml')
+      end
+
+      def create_initializer_file
+        template 'initializer.rb', File.join('config', 'initializers', 'active_spy.rb')
+      end
+    end
+  end
+end

data/lib/rails/generators/active_event/install/templates/active_event.yml

@@ -0,0 +1,20 @@
+test:
+    name: dummy
+    host: http://dummy.com
+    port: 80
+    event_host: http://event-runner.com
+    event_port: 443
+
+development:
+    name: dummy
+    host: http://dummy.com
+    port: 80
+    event_host: http://event-runner.com
+    event_port: 443
+
+production:
+    name: dummy
+    host: http://dummy.com
+    port: 80
+    event_host: http://event-runner.com
+    event_port: 443

data/lib/rails/generators/active_event/install/templates/initializer.rb

@@ -0,0 +1,7 @@
+ActiveSpy::SpyList.activate
+
+if Rails.env.production?
+  ActiveSpy.register_service
+  ActiveSpy::Rails::HookList.register
+end
+