methodist 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ff45a5d0f2788d853ccb9a8b89167e73362f04bdf0a840e3011897031b7003
-  data.tar.gz: 5b36aa6e6969448af121132648ad2204365f98aa465d83e84b65726219a88b43
+  metadata.gz: 1e1231c5c1338d3a4f5c7db47db5ab36cdd4d032f4eb97ad10e50798397e4580
+  data.tar.gz: 9c1afa1729571899206394d775f96ba25366f5c9565b43d55fe80c9c3f7f8edf
 SHA512:
-  metadata.gz: 3685049da7f4de449edcd7f71f9de4b75d56b46b9d39180791b0337f875542a52029f305dd72dabdfb75566cfc703d04ebc98e82e21483c0cd07c1388aee032f
-  data.tar.gz: c0313bc7fcf70e68d49172dc912fd6e57e5bc2fb611e85eb5877d21cc3c35185c263b7c2ada611b4f2aca931a66aec056d43c1dabb518d8fbe79464b12de19d8
+  metadata.gz: 9fcb1943a5af08b284ab7fc16c74d78949a466f2e1a8dca4f910ca8d8c2e883848137e9fbe2d6cf04ee55148b36efced176770f68dc9a0ef120f63b11c95fe26
+  data.tar.gz: 1d09ecd42b89e86c0c7362987ee23809100e9c70e9d83fd7cac1e4bea4963493db50bb50573ab118ae150f843cebe55fd6b3d64eb4a1c73ee0fdd4b6a360d2af

data/lib/methodist/observer.rb

@@ -15,42 +15,44 @@ class Methodist::Observer < Methodist::Pattern
     # * +method_name+ [String/Symbol] - Observation method name
     #
     # ===== Options
-    # * +skip_if+ [Proc] - Skip triggered execution if condition is true
+    # * +skip_if+ [Proc] - Skip triggered execution if condition is true (default nil)
+    # * +instance_method+ [Boolean] - True if observer klass instance method, false if observer klass method (default true)
     #
     # ==== Yield
     # main_block - execution block. If this block was passed,
     # `#execute` block will be ignored
     #
     ##
-    def observe(klass, method_name, skip_if: nil, &main_block)
-      method_name = method_name.to_sym
-      original_method = klass.instance_method(method_name)
-      method_observe = observer_method(method_name)
-      method_dump = method_dump(method_name)
-      me = self
-
-      return false if method_defined?(klass, method_dump)
-
-      klass.send(:alias_method, method_dump, method_name) # dump method
-
-      observer_method_proc = -> (*args, &block) do
-        result = original_method.bind(self).call(*args, &block)
-        unless skip_if.nil?
-          return if skip_if.call(result)
-        end
-        if block_given?
-          main_block.call(klass, method_name)
-        else
-          me.trigger!(klass, method_name)
-        end
-        result # return the result of the original method
+    def observe(klass, method_name, skip_if: nil, instance_method: true, &main_block)
+      method_names = generate_method_names(method_name)
+
+      # Make dump original method.
+      if instance_method
+        alias_instance_method(klass, method_names[:dump], method_names[:name])
+      else
+        alias_class_method(klass, method_names[:dump], method_names[:name])
       end
 
-      klass.send(:define_method, method_observe, observer_method_proc)
+      observe_method!(klass, method_names, skip_if: skip_if, instance_method: instance_method, &main_block)
+    end
 
-      klass.send(:alias_method, method_name, method_observe) # redefine the original method
-      add_observed(klass, method_name)
-      true
+    ##
+    # Subscribe to the class method of the klass to observe
+    #
+    # ==== Parameters
+    # * +klass+ [Class] - The owner of the method for observation
+    # * +method_name+ [String/Symbol] - Observation method name
+    #
+    # ===== Options
+    # * +skip_if+ [Proc] - Skip triggered execution if condition is true
+    #
+    # ==== Yield
+    # main_block - execution block. If this block was passed,
+    # `#execute` block will be ignored
+    #
+    ##
+    def observe_class_method(klass, method_name, skip_if: nil, &main_block)
+      observe(klass, method_name, skip_if: skip_if, instance_method: false, &main_block)
     end
 
     ##
@@ -60,15 +62,28 @@ class Methodist::Observer < Methodist::Pattern
     # * +klass+ [Class] - Klass owner of the observed method
     # * +method_name+ [String/Symbol] - Name of the observed method
     ##
-    def stop_observe(klass, method_name)
-      method_observe = observer_method(method_name)
-      method_dump = method_dump(method_name)
-      return false unless method_defined?(klass, method_observe) && method_defined?(klass, method_dump)
-
-      klass.send(:alias_method, method_name, method_dump) # restore dumped method
-      klass.send(:remove_method, method_observe) # remove observed method
-      klass.send(:remove_method, method_dump) # remove dump method
-      remove_from_observed(klass, method_name)
+    def stop_observe(klass, method_name, instance_method: true)
+      method_names = generate_method_names(method_name)
+
+      if instance_method
+        unless method_defined?(klass, method_names[:observed]) && method_defined?(klass, method_names[:dump])
+          return false
+        end
+
+        klass.send(:alias_method, method_names[:name], method_names[:dump]) # restore dumped instance method
+        klass.send(:remove_method, method_names[:observed]) # remove observed instance method
+        klass.send(:remove_method, method_names[:dump]) # remove dump instance method
+      else
+        unless klass_method_defined?(klass, method_names[:observed]) && klass_method_defined?(klass, method_names[:dump])
+          return false
+        end
+
+        klass.singleton_class.send(:alias_method, method_names[:name], method_names[:dump]) # restore dumped class method
+        klass.singleton_class.send(:remove_method, method_names[:observed]) # remove observed class method
+        klass.singleton_class.send(:remove_method, method_names[:dump]) # remove dump class method
+      end
+
+      remove_from_observed(klass, method_names[:name], instance_method: instance_method)
       true
     end
 
@@ -83,10 +98,10 @@ class Methodist::Observer < Methodist::Pattern
     # ===== Raise
     # +ExecuteBlockWasNotDefined+ - when no block was passed to the execute method in the observer class
     ##
-    def trigger!(klass, method_name)
+    def trigger!(klass, method_name, result, *args)
       block = const_get(CONST_EXECUTION_BLOCK) rescue nil
       raise ExecuteBlockWasNotDefined, "You must define execute block in your #{self.name}" unless block
-      block.call(klass, method_name)
+      block.call(klass, method_name, result, *args)
     end
 
     ##
@@ -102,30 +117,98 @@ class Methodist::Observer < Methodist::Pattern
 
     private
 
-    def observer_method(method)
-      "#{method}_observer"
+    def observe_method!(klass, method_names, skip_if:, instance_method: true, &main_block)
+      observed_method_proc = observer_proc(
+        klass,
+        method_names[:name],
+        skip_if,
+        instance_method: instance_method,
+        &main_block
+      )
+
+      if instance_method
+        define_instance_method(klass, method_names[:observed], observed_method_proc)
+        alias_instance_method(klass, method_names[:name], method_names[:observed]) # redefine the original method
+      else
+        define_class_method(klass, method_names[:observed], observed_method_proc)
+        alias_class_method(klass, method_names[:name], method_names[:observed])
+      end
+      add_observed(klass, method_names[:name], instance_method: instance_method)
+
+      true
     end
 
-    def method_dump(method)
-      "#{method}_dump"
+    def observer_proc(klass, method_name, skip_if, instance_method: true, &main_block)
+      original_method = instance_method ? klass.instance_method(method_name) : klass.method(method_name)
+      me = self
+
+      -> (*args, &block) do
+        result = if instance_method
+          # We must inject context to instance method before call
+          original_method.bind(self).call(*args, &block)
+        else
+          original_method.call(*args, &block)
+        end
+
+        unless skip_if.nil?
+          return if skip_if.call(result)
+        end
+
+        if block_given?
+          main_block.call(klass, method_name, result, *args)
+        else
+          me.trigger!(klass, method_name, result, *args)
+        end
+
+        result # return the result of the original method
+      end
     end
 
-    def klass_with_method(klass, method)
-      "#{klass}##{method}"
+    def klass_with_method(klass, method, instance_method: true)
+      instance_method ? "#{klass}##{method}" : "<ClassMethod:#{klass}##{method}"
     end
 
     def method_defined?(klass, method)
       klass.instance_methods(false).include?(method.to_sym)
     end
 
-    def add_observed(klass, method_name)
-      observed_methods << klass_with_method(klass, method_name)
+    def klass_method_defined?(klass, method)
+      klass.methods(false).include?(method.to_sym)
+    end
+
+    def alias_instance_method(klass, alias_method, original_method)
+      klass.send(:alias_method, alias_method, original_method)
+    end
+
+    def alias_class_method(klass, alias_method, original_method)
+      klass.singleton_class.send(:alias_method, alias_method, original_method)
+    end
+
+    def define_instance_method(klass, method_name, proc)
+      klass.send(:define_method, method_name, proc)
+    end
+
+    def define_class_method(klass, method_name, proc)
+      klass.singleton_class.send(:define_method, method_name, proc)
+    end
+
+    def add_observed(klass, method_name, instance_method: true)
+      observed_methods << klass_with_method(klass, method_name, instance_method: instance_method)
+    end
+
+    def remove_from_observed(klass, method_name, instance_method: true)
+      observed_methods.delete(klass_with_method(klass, method_name, instance_method: instance_method))
     end
 
-    def remove_from_observed(klass, method_name)
-      observed_methods.delete(klass_with_method(klass, method_name))
+    def generate_method_names(method_name)
+      {
+        name: method_name.to_sym,
+        observed: "_methodist_#{method_name}_observer",
+        dump: "_methodist_#{method_name}_dump",
+      }
     end
 
-    class ExecuteBlockWasNotDefined < StandardError; end
+    class ExecuteBlockWasNotDefined < StandardError;
+    end
   end
 end

data/lib/methodist/version.rb

@@ -1,3 +1,3 @@
 module Methodist
-  VERSION = '0.1.2'
+  VERSION = '0.1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: methodist
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Sergey Nesterov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-26 00:00:00.000000000 Z
+date: 2019-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -165,8 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Gem for Ruby on Rails created to stop chaos in your buisness logic.