mutant 0.8.7 → 0.8.8

data/lib/mutant/matcher/method/instance.rb

@@ -3,62 +3,68 @@ module Mutant
     class Method
       # Matcher for instance methods
       class Instance < self
-        SUBJECT_CLASS = Subject::Method::Instance
 
         # Dispatching builder, detects memoizable case
         #
-        # @param [Env::Boostrap] env
         # @param [Class, Module] scope
         # @param [UnboundMethod] method
         #
         # @return [Matcher::Method::Instance]
         #
         # @api private
-        def self.build(env, scope, target_method)
+        def self.new(scope, target_method)
           name = target_method.name
-          if scope.ancestors.include?(::Memoizable) && scope.memoized?(name)
-            return Memoized.new(env, scope, target_method)
-          end
-          super
-        end
-
-        NAME_INDEX = 0
-
-      private
+          evaluator =
+            if scope.include?(Memoizable) && scope.memoized?(name)
+              Evaluator::Memoized
+            else
+              Evaluator
+            end
 
-        # Check if node is matched
-        #
-        # @param [Parser::AST::Node] node
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def match?(node)
-          location   = node.location       || return
-          expression = location.expression || return
-
-          expression.line.equal?(source_line)           &&
-          node.type.equal?(:def)                        &&
-          node.children[NAME_INDEX].equal?(method_name)
+          super(scope, target_method, evaluator)
         end
 
-        # Matcher for memoized instance methods
-        class Memoized < self
-          SUBJECT_CLASS = Subject::Method::Instance::Memoized
+        # Instance method specific evaluator
+        class Evaluator < Evaluator
+          SUBJECT_CLASS = Subject::Method::Instance
+          NAME_INDEX    = 0
 
         private
 
-          # Source location
+          # Check if node is matched
+          #
+          # @param [Parser::AST::Node] node
           #
-          # @return [Array{String,Fixnum}]
+          # @return [Boolean]
           #
           # @api private
-          def source_location
-            scope.unmemoized_instance_method(method_name).source_location
+          def match?(node)
+            n_def?(node)                           &&
+            node.location.line.equal?(source_line) &&
+            node.children.fetch(NAME_INDEX).equal?(method_name)
           end
 
-        end # Memoized
+          # Evaluator specialized for memoized instance mthods
+          class Memoized < self
+            SUBJECT_CLASS = Subject::Method::Instance::Memoized
+
+          private
+
+            # Source location
+            #
+            # @return [Array{String,Fixnum}]
+            #
+            # @api private
+            def source_location
+              scope
+                .unmemoized_instance_method(method_name)
+                .source_location
+            end
+
+          end # Memoized
+        end # Evaluator
 
+        private_constant(*constants(false))
       end # Instance
     end # Method
   end # Matcher

data/lib/mutant/matcher/method/singleton.rb

@@ -3,79 +3,98 @@ module Mutant
     class Method
       # Matcher for singleton methods
       class Singleton < self
-        SUBJECT_CLASS  = Subject::Method::Singleton
-        RECEIVER_INDEX = 0
-        NAME_INDEX     = 1
 
-      private
-
-        # Test for node match
+        # New singleton method matcher
         #
-        # @param [Parser::AST::Node] node
+        # @param [Class, Module] scope
+        # @param [Symbol] method_name
         #
-        # @return [Boolean]
+        # @return [Matcher::Method::Singleton]
         #
         # @api private
-        def match?(node)
-          line?(node) && name?(node) && receiver?(node)
+        def self.new(scope, method_name)
+          super(scope, method_name, Evaluator)
         end
 
-        # Test for line match
-        #
-        # @param [Parser::AST::Node] node
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def line?(node)
-          expression = node.location.expression
-          return false unless expression
-          expression.line.equal?(source_line)
-        end
+        # Singleton method evaluator
+        class Evaluator < Evaluator
+          SUBJECT_CLASS  = Subject::Method::Singleton
+          RECEIVER_INDEX = 0
+          NAME_INDEX     = 1
 
-        # Test for name match
-        #
-        # @param [Parser::AST::Node] node
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def name?(node)
-          node.children[NAME_INDEX].equal?(method_name)
-        end
+        private
 
-        # Test for receiver match
-        #
-        # @param [Parser::AST::Node] node
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def receiver?(node)
-          receiver = node.children[RECEIVER_INDEX]
-          case receiver.type
-          when :self
-            true
-          when :const
-            receiver_name?(receiver)
-          else
-            env.warn(format('Can only match :defs on :self or :const got %s unable to match', receiver.type.inspect))
-            false
+          # Test for node match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def match?(node)
+            n_defs?(node) && line?(node) && name?(node) && receiver?(node)
           end
-        end
 
-        # Test if receiver name matches context
-        #
-        # @param [Parser::AST::Node] node
-        #
-        # @return [Boolean]
-        #
-        # @api private
-        def receiver_name?(node)
-          name = node.children[NAME_INDEX]
-          name.to_s.eql?(context.unqualified_name)
-        end
+          # Test for line match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def line?(node)
+            node
+              .location
+              .line
+              .equal?(source_line)
+          end
+
+          # Test for name match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def name?(node)
+            node.children.fetch(NAME_INDEX).equal?(method_name)
+          end
+
+          # Test for receiver match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def receiver?(node)
+            receiver = node.children.fetch(RECEIVER_INDEX)
+            case receiver.type
+            when :self
+              true
+            when :const
+              receiver_name?(receiver)
+            else
+              env.warn(format('Can only match :defs on :self or :const got %s unable to match', receiver.type.inspect))
+              nil
+            end
+          end
+
+          # Test if receiver name matches context
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          #
+          # @api private
+          def receiver_name?(node)
+            name = node.children.fetch(NAME_INDEX)
+            name.to_s.eql?(context.unqualified_name)
+          end
+
+        end # Evaluator
 
+        private_constant(*constants(false))
       end # Singleton
     end # Method
   end # Matcher

data/lib/mutant/matcher/methods.rb

@@ -2,23 +2,27 @@ module Mutant
   class Matcher
     # Abstract base class for matcher that returns method subjects from scope
     class Methods < self
-      include AbstractType, Concord::Public.new(:env, :scope)
+      include AbstractType, Concord.new(:scope)
+
+      CANDIDATE_NAMES = IceNine.deep_freeze(%i[
+        public_instance_methods
+        private_instance_methods
+        protected_instance_methods
+      ])
+
+      private_constant(*constants(false))
 
       # Enumerate subjects
       #
-      # @return [self]
-      #   if block given
+      # @param [Env] env
       #
-      # @return [Enumerator<Subject>]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each(&block)
-        return to_enum unless block_given?
-
-        subjects.each(&block)
-
-        self
+      def call(env)
+        Chain.new(
+          methods.map { |method| matcher.new(scope, method) }
+        ).call(env)
       end
 
     private
@@ -45,29 +49,16 @@ module Mutant
       end
       memoize :methods
 
-      # Subjects detected on scope
-      #
-      # @return [Array<Subject>]
-      #
-      # @api private
-      def subjects
-        methods.map do |method|
-          matcher.build(env, scope, method)
-        end.flat_map(&:to_a)
-      end
-      memoize :subjects
-
       # Candidate method names on target scope
       #
       # @return [Enumerable<Symbol>]
       #
       # @api private
       def candidate_names
-        (
-          candidate_scope.public_instance_methods(false)   +
-          candidate_scope.private_instance_methods(false)  +
-          candidate_scope.protected_instance_methods(false)
-        ).sort
+        CANDIDATE_NAMES
+          .map(&candidate_scope.method(:public_send))
+          .reduce(:+)
+          .sort
       end
 
       # Candidate scope
@@ -133,7 +124,6 @@ module Mutant
         end
 
       end # Instance
-
     end # Methods
   end # Matcher
 end # Mutant

data/lib/mutant/matcher/namespace.rb

@@ -1,34 +1,40 @@
 module Mutant
   class Matcher
-
     # Matcher for specific namespace
     class Namespace < self
-      include Concord::Public.new(:env, :expression)
+      include Concord::Public.new(:expression)
 
       # Enumerate subjects
       #
-      # @return [self]
-      #   if block given
+      # @param [Env] env
       #
-      # @return [Enumerator<Subject>]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each(&block)
-        return to_enum unless block_given?
-
-        env.matchable_scopes.select do |scope|
-          scope.each(&block) if match?(scope)
-        end
-
-        self
+      def call(env)
+        Chain.new(
+          matched_scopes(env).map { |scope| Scope.new(scope.raw) }
+        ).call(env)
       end
 
     private
 
-      # Test scope if name matches expression
+      # The matched scopes
+      #
+      # @param [Env] env
+      #
+      # @return [Enumerable<Scope>]
+      #
+      # @api private
+      def matched_scopes(env)
+        env
+          .matchable_scopes
+          .select(&method(:match?))
+      end
+
+      # Test scope if matches expression
       #
-      # @param [Module, Class] scope
+      # @param [Scope] scope
       #
       # @return [Boolean]
       #

data/lib/mutant/matcher/null.rb

@@ -6,16 +6,13 @@ module Mutant
 
       # Enumerate subjects
       #
-      # @return [Enumerator<Subject]
-      #   if no block given
+      # @param [Env] env
       #
-      # @return [self]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each
-        return to_enum unless block_given?
-        self
+      def call(_env)
+        EMPTY_ARRAY
       end
 
     end # Null

data/lib/mutant/matcher/scope.rb

@@ -1,31 +1,41 @@
 module Mutant
   class Matcher
-    # Matcher for specific namespace
+    # Matcher expanding Mutant::Scope objects into method matches
+    # at singleton or instance level
+    #
+    # If we *ever* get other subjects than methods, its likely the place
+    # to hook in custom matchers. In that case the scope matchers to expand
+    # should be passed as arguments to the constructor.
     class Scope < self
-      include Concord::Public.new(:env, :scope, :expression)
+      include Concord.new(:scope)
 
       MATCHERS = [
         Matcher::Methods::Singleton,
         Matcher::Methods::Instance
       ].freeze
 
-      # Enumerate subjects
+      private_constant(*constants(false))
+
+      # Matched subjects
       #
-      # @return [self]
-      #   if block given
+      # @param [Env] env
       #
-      # @return [Enumerator<Subject>]
-      #   otherwise
+      # @return [Enumerable<Subject>]
       #
       # @api private
-      def each(&block)
-        return to_enum unless block_given?
+      def call(env)
+        Chain.new(effective_matchers).call(env)
+      end
 
-        MATCHERS.each do |matcher|
-          matcher.new(env, scope).each(&block)
-        end
+    private
 
-        self
+      # Effective matchers
+      #
+      # @return [Enumerable<Matcher>]
+      #
+      # @api private
+      def effective_matchers
+        MATCHERS.map { |matcher| matcher.new(scope) }
       end
 
     end # Scope