active_spy 1.4.4 → 2.0.0.pre1

data/lib/active_spy/rails/listener.rb

@@ -1,117 +0,0 @@
-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)
-        ActiveSpy::Rails::HookList << child
-      end
-
-      # Set the external class of the model that we are listening to.
-      #
-      def self.external_class(klass)
-        @external_classes = [klass]
-      end
-
-      # Set the external classes which we are listening to.
-      #
-      def self.external_classes(*classes)
-        @external_classes = classes
-      end
-
-      # Convert the listener class into one or more hook hashes
-      #
-      def self.to_hook
-        hooks = []
-        hook_classes.each do |hook_class|
-          hooks << { 'class' => hook_class, 'post_class' => name.split('Listener')[0] }
-        end
-        hooks
-      end
-
-      # Get the classes that we are listegnig to.
-      #
-      def self.hook_classes
-        return @external_classes if defined? @external_classes
-        [name.split('Listener')[0]]
-      end
-
-      # Handle a request with +params+ and sync the database according to
-      # them.
-      #
-      def handle(params)
-        object_type = params.delete('type')
-        callback = params.delete('action')
-        payload_content = params.delete('payload')[object_type.downcase]
-        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)
-        object = klass.new
-        object.update_attributes(payload)
-        object
-      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['guid']
-        object = klass.find_by(guid: guid)
-        object.update_attributes(payload)
-        object
-      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')
-        object = klass.find_by(guid: guid)
-        object.destroy!
-        object
-      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

@@ -1,13 +0,0 @@
-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
-end

data/lib/active_spy/rails/spy.rb

@@ -1,70 +0,0 @@
-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)
-          dynamically_define_method_or_call_block(:realm, realm_name)
-        end
-
-        # Class method to define the actor of the model.
-        #
-        def model_actor(actor_name = nil)
-          dynamically_define_method_or_call_block(:actor, actor_name)
-        end
-
-        # Defines a method called +method_name+ that will call a method called
-        # +method_value+ if a symbol is provided. If a block is provided
-        # instead, it will be returned.
-        #
-        def dynamically_define_method_or_call_block(abstract_name, method_name)
-          return unless method_name
-          if abstract_name == method_name
-            attr_accessor method_name
-          else
-            define_method method_name do
-              send(:instance_variable_get, "@#{abstract_name}")
-            end
-            define_method "#{method_name}=" do |new_value|
-              send(:instance_variable_set, "@#{abstract_name}", new_value)
-            end
-          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/rails/validation.rb

@@ -1,87 +0,0 @@
-require 'json'
-
-module ActiveSpy
-  module Rails
-    # Module to hold classes that are intended to validate something.
-    #
-    module Validation
-      # Class responsible to validate event that are send to event-runner
-      # instances.
-      #
-      class Event
-
-        def initialize(event_json)
-          @event = JSON.load(event_json)
-        end
-
-        # Validates the +event_json+ provided in the initializer
-        #
-        # (see #initialize)
-        def validate!
-          check_actor_key(@event['event']['actor'])
-          check_realm_key(@event['event']['realm'])
-        end
-
-        private
-
-        # Check if actor is valid.
-        #
-        def check_actor_key(actor)
-          fail ActorNotPresent if actor.nil?
-          errors = get_errors_from_hash(actor, :actor)
-          fail InvalidActor, errors unless errors.empty?
-        end
-
-        # Check if realm is valid.
-        #
-        def check_realm_key(realm)
-          fail RealmNotPresent if realm.nil?
-          errors = get_errors_from_hash(realm, :realm)
-          fail InvalidRealm, errors unless errors.empty?
-        end
-
-        # Get the error from +data+ regarding +hash_type+ checking if the
-        # required keys are being provided.
-        #
-        def get_errors_from_hash(data, hash_type)
-          keys = hash_type == :actor ? required_actor_keys : required_realm_keys
-          keys.map do |key|
-            "#{key} should not be empty." if data[key].nil?
-          end.compact.join(' ')
-        end
-
-        # Required keys for an actor to be valid.
-        #
-        def required_actor_keys
-          %w[id class login url avatar_url]
-        end
-
-        # Required keys for realm to be valid.
-        #
-        def required_realm_keys
-          %w[id class name url]
-        end
-      end
-
-      # Error when actor is not present.
-      #
-      class ActorNotPresent < RuntimeError
-      end
-
-      # Error when the actor is invalid.
-      #
-      class InvalidActor < RuntimeError
-      end
-
-      # Error when realm is not present.
-      #
-      class RealmNotPresent < RuntimeError
-      end
-
-      # Error when the realm is invalid.
-      #
-      class InvalidRealm < RuntimeError
-      end
-    end
-  end
-end

data/lib/active_spy/spy/spy.rb

@@ -1,42 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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} class to a
-    # {ActiveSpy::SpyList} instance. Just a syntax sugar.
-    #
-    def self.method_missing(method, *args, &block)
-      instance.send(method, *args, &block)
-    end
-
-    # Activate 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']
-
-        spy['old_method'] = patch(spied_class, spied_method) unless spy['active']
-        spy['active'] = true
-      end
-    end
-
-    # Deactivate all the spies defined in the spy list by unpatching the methods
-    # in their classes.
-    #
-    def deactivate
-      @spies.each do |spy|
-        unpatch(spy['class'], spy['method'], spy['old_method'])
-        spy['active'] = nil
-      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)
-      old_method = nil
-      ActiveSupport::Inflector.constantize(klass).class_eval do
-        old_method = instance_method(method)
-        define_method method do |*args, &block|
-          send(:invoke_callback, method, :before)
-          result = old_method.bind(self).call(*args, &block)
-          if defined?(Rails)
-            send(:invoke_callback, method, :after) if result
-          else
-            send(:invoke_callback, method, :after)
-          end
-          result
-        end
-      end
-      old_method
-    end
-
-    # Properyly unpatch the +method+ in class +klass+ and put back +old_method+
-    # in its place.
-    #
-    def unpatch(klass, method, old_method)
-      ActiveSupport::Inflector.constantize(klass).class_eval do
-        define_method method do |*args, &block|
-          old_method.bind(self).call(*args, &block)
-        end
-      end
-    end
-  end
-end