symbiont-ruby 0.2.0 → 0.7.0

data/Rakefile

@@ -2,8 +2,21 @@
 
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
+require 'rubocop'
+require 'rubocop/rake_task'
+require 'rubocop-performance'
+require 'rubocop-rspec'
+require 'rubocop-rake'
 require 'yard'
 
+RuboCop::RakeTask.new(:rubocop) do |t|
+  config_path = File.expand_path(File.join('.rubocop.yml'), __dir__)
+  t.options = ['--config', config_path]
+  t.requires << 'rubocop-rspec'
+  t.requires << 'rubocop-performance'
+  t.requires << 'rubocop-rake'
+end
+
 RSpec::Core::RakeTask.new(:rspec)
 
 YARD::Rake::YardocTask.new(:doc) do |t|
@@ -13,6 +26,7 @@ end
 
 task default: :rspec
 
+desc 'Code documentation coverage check'
 task yardoc: :doc do
   undocumented_code_objects = YARD::Registry.tap(&:load).select do |code_object|
     code_object.docstring.empty?
@@ -22,7 +36,7 @@ task yardoc: :doc do
     puts 'YARD COVERAGE [SUCCESS] => 100% documentation coverage!'
   else
     failing_code_objects = undocumented_code_objects.map do |code_object|
-      "- #{code_object.class} => #{code_object.to_s}"
+      "- #{code_object.class} => #{code_object}"
     end.join("\n")
 
     abort("YARD COVERAGE [FAILURE] => No documentation found for: \n #{failing_code_objects}")

data/Steepfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+target :lib do
+  signature 'sig'
+  check 'lib'
+end

data/bin/console

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
-require 'symbiont/ruby'
+require 'symbiont'
 
 require 'pry'
 Pry.start

data/lib/symbiont.rb

@@ -9,6 +9,7 @@ module Symbiont
   require_relative 'symbiont/trigger'
   require_relative 'symbiont/public_trigger'
   require_relative 'symbiont/private_trigger'
+  require_relative 'symbiont/isolator'
   require_relative 'symbiont/executor'
   require_relative 'symbiont/context'
 

data/lib/symbiont/executor.rb

@@ -32,7 +32,8 @@ module Symbiont
       # @api public
       # @since 0.1.0
       def evaluate(*required_contexts, context_direction: Trigger::IOK, &closure)
-        public_trigger(*required_contexts, context_direction: context_direction, &closure).__evaluate__
+        Isolator.new(default_direction: context_direction, &closure)
+                .evaluate(*required_contexts)
       end
 
       # Starts execution of a proc object in the context of the passed object with the selected
@@ -59,63 +60,8 @@ module Symbiont
       # @api public
       # @since 0.1.0
       def evaluate_private(*required_contexts, context_direction: Trigger::IOK, &closure)
-        private_trigger(*required_contexts, context_direction: context_direction, &closure).__evaluate__
-      end
-
-      # Factory method that instantiates a public trigger with the desired execution context,
-      # the direction of method dispatching and the closure that needs to be performed.
-      #
-      # @param required_contexts [Array<Object>]
-      #   A set of objects that should be used as the main context series for method resolving
-      #   algorithm.
-      # @param context_direction [Array<Symbol>]
-      #   An array of symbols that represents the direction of contexts. Possible values:
-      #
-      #     - Symbiont::IOK
-      #     - Symbiont::OIK
-      #     - Symbiont::OKI
-      #     - Symbiont::IKO
-      #     - Symbiont::KOI
-      #     - Symbiont::KIO
-      # @param closure [Proc]
-      #   Proc object that will be evaluated in many contexts: initial, outer and kernel.
-      # @return [Symbiont::PublicTrigger]
-      #
-      # @see Symbiont::PublicTrigger
-      # @see Symbiont::Trigger
-      #
-      # @api public
-      # @since 0.1.0
-      def public_trigger(*required_contexts, context_direction: Trigger::IOK, &closure)
-        PublicTrigger.new(*required_contexts, context_direction: context_direction, &closure)
-      end
-
-      # Factory method that instantiates a private trigger with the desired execution context,
-      # the direction of method dispatching and the closure that needs to be performed.
-      #
-      # @param required_contexts [Array<Object>]
-      #   A set of objects that should be used as the main context series for method resolving
-      #   algorithm.
-      # @param context_direction [Array<Symbol>]
-      #   An array of symbols that represents the direction of contexts. Possible values:
-      #
-      #     - Symbiont::IOK
-      #     - Symbiont::OIK
-      #     - Symbiont::OKI
-      #     - Symbiont::IKO
-      #     - Symbiont::KOI
-      #     - Symbiont::KIO
-      # @param closure [Proc]
-      #   Proc object that will be evaluated in many contexts: initial, outer and kernel.
-      # @return [Symbiont::PrivateTrigger]
-      #
-      # @see Symbiont::PrivateTrigger
-      # @see Symbiont::Trigger
-      #
-      # @api public
-      # @since 0.1.0
-      def private_trigger(*required_contexts, context_direction: Trigger::IOK, &closure)
-        PrivateTrigger.new(*required_contexts, context_direction: context_direction, &closure)
+        Isolator.new(default_direction: context_direction, &closure)
+                .evaluate_private(*required_contexts)
       end
 
       # Gets the method object taken from the context that can respond to it.
@@ -142,7 +88,8 @@ module Symbiont
       # @api public
       # @since 0.1.0
       def public_method(method_name, *required_contexts, context_direction: Trigger::IOK, &closure)
-        public_trigger(*required_contexts, context_direction: context_direction, &closure).method(method_name)
+        Isolator.new(default_direction: context_direction, &closure)
+                .public_method(method_name, *required_contexts)
       end
 
       # Gets the method object taken from the context that can respond to it.
@@ -169,7 +116,8 @@ module Symbiont
       # @api public
       # @since 0.1.0
       def private_method(method_name, *required_contexts, context_direction: Trigger::IOK, &closure)
-        private_trigger(*required_contexts, context_direction: context_direction, &closure).method(method_name)
+        Isolator.new(default_direction: context_direction, &closure)
+                .private_method(method_name, *required_contexts)
       end
     end
   end

data/lib/symbiont/isolator.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Symbiont
+  # Special object that wraps your proc object from any place and provides
+  # an ability to invoke this proc object lazily inside an any series of contexts.
+  #
+  # @api public
+  # @since 0.3.0
+  class Isolator
+    # Is raised when closure is not provided.
+    #
+    # @see #initialize
+    #
+    # @api public
+    # @since 0.3.0
+    UnprovidedClosureAttributeError = Class.new(ArgumentError)
+
+    # Proc object that will be evaluated in many contexts: initial, outer and kernel.
+    # Will be used as an outer-context for the method resolution.
+    #
+    # @return [Proc]
+    #
+    # @api public
+    # @since 0.3.0
+    attr_reader :closure
+
+    # An array of symbols that represents the direction of contexts. Used by default.
+    #
+    # @return [Array<Symbol>]
+    #
+    # @api public
+    # @since 0.3.0
+    attr_reader :default_direction
+
+    # Instantiates isolator object with corresponding default direction and closure.
+    #
+    # @option default_direction [Array<Symbol>]
+    #   An array of symbols that represents the direction of contexts which is used as default
+    #   context direction. Symbiont::Trigger::IOK is chosen by default.
+    # @param closure [Proc]
+    #   Proc object that will be evaluated in many contexts: initial, outer and kernel.
+    #   Will be used as an outer-context for the method resolution.
+    #
+    # @api public
+    # @since 0.3.0
+    def initialize(default_direction: Trigger::IOK, &closure)
+      raise UnprovidedClosureAttributeError, 'You should provide a closure' unless block_given?
+
+      @default_direction = default_direction
+      @closure = closure
+    end
+
+    # Starts execution of a proc object in the context of the passed object with the selected
+    # direction of method dispatching. Delegates execution to a public trigger.
+    #
+    # @param required_contexts [Array<Object>]
+    #   A set of objects that should be used as the main context series for method resolving
+    #   algorithm.
+    # @param direction [Array<Symbol>]
+    #   An array of symbols that represents the direction of contexts.
+    # @return [void]
+    #
+    # @see Symbiont::Trigger#__evaluate__
+    # @see Symbiont::PublicTrigger
+    #
+    # @api public
+    # @since 0.3.0
+    def evaluate(*required_contexts, direction: default_direction)
+      public_trigger(*required_contexts, direction: direction).__evaluate__
+    end
+
+    # Starts execution of a proc object in the context of the passed object with the selected
+    # direction of method dispatching. Delegates execution to a private trigger.
+    #
+    # @param required_contexts [Array<Object>]
+    #   A set of objects that should be used as the main context series for method resolving
+    #   algorithm.
+    # @param direction [Array<Symbol>]
+    #   An array of symbols that represents the direction of contexts.
+    # @return [void]
+    #
+    # @see Symbiont::Trigger#__evaluate__
+    # @see Symbiont::PrivateTrigger
+    #
+    # @api public
+    # @since 0.3.0
+    def evaluate_private(*required_contexts, direction: default_direction)
+      private_trigger(*required_contexts, direction: direction).__evaluate__
+    end
+
+    # Gets the method object taken from the context that can respond to it.
+    # Considers only public methods.
+    #
+    # @param method_name [Symbol,String] A name of required method.
+    # @param required_contexts [Array<Object>]
+    #   A set of objects that should be used as the main context series for method resolving
+    #   algorithm.
+    # @param direction [Array<Symbol>]
+    #   An array of symbols that represents the direction of contexts.
+    # @return [Method]
+    #
+    # @see Symbiont::PublicTrigger
+    # @see Symbiont::Trigger#method
+    #
+    # @api public
+    # @since 0.3.0
+    def public_method(method_name, *required_contexts, direction: default_direction)
+      public_trigger(*required_contexts, direction: direction).method(method_name)
+    end
+
+    # Gets the method object taken from the context that can respond to it.
+    # Considers private methods and public methods.
+    #
+    # @param method_name [Symbol,String] A name of required method.
+    # @param required_contexts [Array<Object>]
+    #   A set of objects that should be used as the main context series for method resolving
+    #   algorithm.
+    # @param direction [Array<Symbol>]
+    #   An array of symbols that represents the direction of contexts.
+    # @return [Method]
+    #
+    # @see Symbiont::PrivateTrigger
+    # @see Symbiont::Trigger#method
+    #
+    # @api public
+    # @since 0.3.0
+    def private_method(method_name, *required_contexts, direction: default_direction)
+      private_trigger(*required_contexts, direction: direction).method(method_name)
+    end
+
+    private
+
+    # Factory method that instantiates a public trigger with the desired execution context,
+    # the direction of method dispatching and the closure that needs to be performed.
+    #
+    # @param required_contexts [Array<Object>]
+    #   A set of objects that should be used as the main context series for method resolving
+    #   algorithm.
+    # @param direction [Array<Symbol>]
+    #   An array of symbols that represents the direction of contexts. Possible values:
+    #
+    #     - Symbiont::IOK
+    #     - Symbiont::OIK
+    #     - Symbiont::OKI
+    #     - Symbiont::IKO
+    #     - Symbiont::KOI
+    #     - Symbiont::KIO
+    # @return [Symbiont::PublicTrigger]
+    #
+    # @see Symbiont::PublicTrigger
+    # @see Symbiont::Trigger
+    #
+    # @api private
+    # @since 0.3.0
+    def public_trigger(*required_contexts, direction: default_direction)
+      PublicTrigger.new(*required_contexts, context_direction: direction, &closure)
+    end
+
+    # Factory method that instantiates a private trigger with the desired execution context,
+    # the direction of method dispatching and the closure that needs to be performed.
+    #
+    # @param required_contexts [Array<Object>]
+    #   A set of objects that should be used as the main context series for method resolving
+    #   algorithm.
+    # @param direction [Array<Symbol>]
+    #   An array of symbols that represents the direction of contexts. Possible values:
+    #
+    #     - Symbiont::IOK
+    #     - Symbiont::OIK
+    #     - Symbiont::OKI
+    #     - Symbiont::IKO
+    #     - Symbiont::KOI
+    #     - Symbiont::KIO
+    # @return [Symbiont::PrivateTrigger]
+    #
+    # @see Symbiont::PrivateTrigger
+    # @see Symbiont::Trigger
+    #
+    # @api private
+    # @since 0.3.0
+    def private_trigger(*required_contexts, direction: default_direction)
+      PrivateTrigger.new(*required_contexts, context_direction: direction, &closure)
+    end
+  end
+end

data/lib/symbiont/private_trigger.rb

@@ -17,7 +17,7 @@ module Symbiont
     #
     # @param method_name [String,Symbol] Method that a context should respond to.
     # @raise NoMethodError
-    #  Is raised when no one of the contexts are able to respond to the required method.
+    #   Is raised when no one of the contexts are able to respond to the required method.
     # @return [Objcet]
     #
     # @see Symbiont::Trigger#__actual_context__
@@ -26,8 +26,47 @@ module Symbiont
     # @since 0.1.0
     def __actual_context__(method_name)
       __directed_contexts__.find do |context|
-        context.respond_to?(method_name, true)
+        begin
+          context.respond_to?(method_name, true)
+        rescue ::NoMethodError
+          # NOTE:
+          #   this situation is caused when the context object does not respodond to
+          #   #resond_to? method (BasicObject instances for example)
+
+          context_singleton = __extract_singleton_class__(context)
+
+          context_singleton.private_instance_methods(true).include?(method_name) ||
+            context_singleton.instance_methods(true).include?(method_name)
+        end
       end || super
     end
+
+    # Returns a corresponding public/private method object of the actual context.
+    #
+    # @param method_name [String,Symbol] Method name
+    # @return [Method]
+    #
+    # @see [Symbiont::Trigger#method]
+    #
+    # @api private
+    # @since 0.5.0
+    def method(method_name)
+      __context__ = __actual_context__(method_name)
+
+      # NOTE:
+      #   block is used cuz #__actual_context__can raise
+      #   ::NoMethodError (ContextNoMethodError) too (and we should raise it).
+      begin
+        __context__.method(method_name)
+      rescue ::NoMethodError
+        # NOTE:
+        #   this situation is caused when the context object does not respond
+        #   to #method method (BasicObject instances for example). We can extract
+        #   method objects via it's singleton class.
+
+        __context_singleton__ = __extract_singleton_class__(__context__)
+        __context_singleton__.instance_method(method_name).bind(__context__)
+      end
+    end
   end
 end

data/lib/symbiont/public_trigger.rb

@@ -26,8 +26,47 @@ module Symbiont
     # @since 0.1.0
     def __actual_context__(method_name)
       __directed_contexts__.find do |context|
-        context.respond_to?(method_name, false)
+        begin
+          context.respond_to?(method_name, false)
+        rescue ::NoMethodError
+          # NOTE:
+          #   this situation is caused when the context object does not respodond to
+          #   #resond_to? method (BasicObject instances for example)
+
+          context_singleton = __extract_singleton_class__(context)
+          context_singleton.public_instance_methods(true).include?(method_name)
+        end
       end || super
     end
+
+    # Returns a corresponding public method object of the actual context.
+    #
+    # @param method_name [String,Symbol] Method name
+    # @raise [::NameError]
+    # @raise [Symbiont::Trigger::ContextNoMethodError, ::NoMethodError]
+    # @return [Method]
+    #
+    # @see [Symbiont::Trigger#method]
+    #
+    # @api private
+    # @since 0.5.0
+    def method(method_name)
+      __context__ = __actual_context__(method_name)
+
+      # NOTE:
+      #   block is used cuz #__actual_context__can raise
+      #   ::NoMethodError (ContextNoMethodError) too (and we should raise it)
+      begin
+        __context__.method(method_name)
+      rescue ::NoMethodError
+        # NOTE:
+        #   this situation is caused when the context object does not respond
+        #   to #method method (BasicObject instances for example). We can extract
+        #   method objects via it's singleton class.
+
+        __context_singleton__ = __extract_singleton_class__(__context__)
+        __context_singleton__.public_instance_method(method_name).bind(__context__)
+      end
+    end
   end
 end