mutant 0.2.20 → 0.3.0.beta2

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

@@ -3,6 +3,7 @@ module Mutant
     class Method
       # Matcher for singleton methods
       class Singleton < self
+        SUBJECT_CLASS = Subject::Method::Singleton
 
         # Return identification
         #
@@ -15,117 +16,105 @@ module Mutant
         end
         memoize :identification
 
-        # Test if method is public
-        #
-        # @return [true]
-        #   if method is public
-        #
-        # @return [false]
-        #   otherwise
-        #
-        # @api private
-        #
-        def public?
-          scope.singleton_class.public_method_defined?(method_name)
-        end
-        memoize :public?
-
+        RECEIVER_INDEX = 0
+        NAME_INDEX     = 1
+        CONST_NAME_INDEX = 1
 
       private
 
         # Test for node match
         #
-        # @param [Rubinius::AST::Node] node
+        # @param [Parser::AST::Node] node
         #
         # @return [true]
-        #   returns true if node matches method
+        #   if node matches method
         #
         # @return [false]
-        #   returns false if node NOT matches method
+        #   otherwise
         #
         # @api private
         #
         def match?(node)
-          node.class == Rubinius::AST::DefineSingleton  &&
-          line?(node)                                   && 
-          name?(node)                                   && 
-          receiver?(node)
+          line?(node) && name?(node) && receiver?(node)
         end
 
         # Test for line match
         #
-        # @param [Rubinius::AST::Node] node
+        # @param [Parser::AST::Node] node
         #
         # @return [true]
-        #   returns true if node matches source line
+        #   if node matches source line
         #
         # @return [false]
-        #   returns false otherwise
+        #   otherwise
         #
         # @api private
         #
         def line?(node)
-          node.line  == source_line
+          expression = node.location.expression
+          return false unless expression
+          expression.line == source_line
         end
 
         # Test for name match
         #
-        # @param [Rubinius::AST::DefineSingleton] node
+        # @param [Parser::AST::Node] node
         #
         # @return [true]
-        #   returns true if node name matches
+        #   if node name matches
         #
         # @return [false]
-        #   returns false otherwise
+        #   otherwise
         #
         # @api private
         #
         def name?(node)
-          node.body.name == method_name 
+          node.children[NAME_INDEX] == method_name
         end
 
         # Test for receiver match
         #
-        # @param [Rubinius::AST::DefineSingleton] node
+        # @param [Parser::AST::Node] node
         #
         # @return [true]
-        #   returns true when receiver is self or scope from pattern
+        #   when receiver matches
         #
         # @return [false]
-        #   returns false otherwise
+        #   otherwise
         #
         # @api private
         #
         def receiver?(node)
-          receiver = node.receiver
-          case receiver
-          when Rubinius::AST::Self
+          receiver = node.children[RECEIVER_INDEX]
+          case receiver.type
+          when :self
             true
-          when Rubinius::AST::ConstantAccess
+          when :const
             receiver_name?(receiver)
           else
-            $stderr.puts "Unable to find singleton method definition only match receiver on Rubinius::AST::Self or Rubinius::AST::ConstantAccess, got #{receiver.class}"
+            $stderr.puts "Can only match self or const, got #{receiver.type}, unable to match receiver of defs node"
             false
           end
         end
 
         # Test if reciver name matches context
         #
-        # @param [Rubinius::AST::Node] node
+        # @param [Parser::AST::Node] node
         #
         # @return [true]
-        #   returns true when node name matches unqualified scope name
+        #   if node name matches unqualified scope name
         #
         # @return [false]
-        #   returns false otherwise
+        #   otherwise
         #
         # @api private
         #
         def receiver_name?(node)
-          node.name.to_s == context.unqualified_name
+          name = node.children[CONST_NAME_INDEX]
+          name.to_s == context.unqualified_name
         end
 
-      end
-    end
-  end
-end
+      end # Singleton
+    end # Method
+  end # Matcher
+end # Mutant

data/lib/mutant/matcher/method.rb

@@ -2,21 +2,9 @@ module Mutant
   class Matcher
     # Matcher for subjects that are a specific method
     class Method < self
-      include Adamantium::Flat, Equalizer.new(:identification)
+      include Adamantium::Flat, Concord::Public.new(:scope, :method)
 
-      # Parse a method string into filter
-      #
-      # @param [String] input
-      #
-      # @return [Matcher::Method]
-      #
-      # @api private
-      #
-      def self.parse(input)
-        Classifier.run(input)
-      end
-
-      # Methods within rbx kernel directory are precompiled and their source 
+      # Methods within rbx kernel directory are precompiled and their source
       # cannot be accessed via reading source location
       BLACKLIST = /\Akernel\//.freeze
 
@@ -29,74 +17,20 @@ module Mutant
       #   returns self when block given
       #
       # @api private
-      # 
+      #
       def each(&block)
         return to_enum unless block_given?
 
         return self if skip?
 
-        subject.tap do |subject|
-          yield subject if subject
-        end
+        util = subject
+        yield util if util
 
         self
       end
 
-      # Return method
-      #
-      # @return [UnboundMethod, Method]
-      #
-      # @api private
-      #
-      attr_reader :method
-
-      # Return scope
-      #
-      # @return [Class|Module]
-      #
-      # @api private
-      #
-      attr_reader :scope
-
-      # Return method name
-      #
-      # @return [String]
-      #
-      # @api private
-      #
-      def method_name
-        method.name
-      end
-
-      # Test if method is public
-      #
-      # @return [true]
-      #   if method is public
-      #
-      # @return [false]
-      #   otherwise
-      #
-      # @api private
-      #
-      abstract_method :public?
-
     private
 
-      # Initialize method filter
-      #
-      # @param [Class|Module] scope
-      # @param [Method, UnboundMethod] method
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def initialize(scope, method)
-        @scope, @method = scope, method
-        # FIXME: cache public private should not be needed, loader should not override visibility! (But does currently) :(
-        public?
-      end
-
       # Test if method is skipped
       #
       # @return [true]
@@ -117,6 +51,16 @@ module Mutant
         false
       end
 
+      # Return method name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def method_name
+        method.name
+      end
+
       # Return context
       #
       # @return [Context::Scope]
@@ -129,12 +73,12 @@ module Mutant
 
       # Return full ast
       #
-      # @return [Rubinius::AST::Node]
+      # @return [Parser::AST::Node]
       #
       # @api private
       #
       def ast
-        File.read(source_path).to_ast
+        Parser::CurrentRuby.parse(File.read(source_path))
       end
 
       # Return path to source
@@ -180,24 +124,92 @@ module Mutant
       def subject
         node = matched_node
         return unless node
-        Subject.new(self, context, node)
+        self.class::SUBJECT_CLASS.new(context, node)
       end
       memoize :subject
 
+      # Visitor to find last match inside AST
+      class Finder
+
+        # Run finder
+        #
+        # @param [Parser::AST::Node]
+        #
+        # @return [Parser::AST::Node]
+        #   if found
+        #
+        # @return [nil]
+        #   otherwise
+        #
+        # @api private
+        #
+        #
+        def self.run(root, &predicate)
+          new(root, predicate).match
+        end
+
+        private_class_method :new
+
+        # Return match
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @api private
+        #
+        attr_reader :match
+
+      private
+
+        # Initialize object
+        #
+        # @param [Parer::AST::Node]
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        #
+        def initialize(root, predicate)
+          @root, @predicate = root, predicate
+          visit(root)
+        end
+
+        # Visit node
+        #
+        # @param [Parser::AST::Node] node
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def visit(node)
+          if @predicate.call(node)
+            @match = node
+          end
+
+          node.children.each do |child|
+            visit(child) if child.kind_of?(Parser::AST::Node)
+          end
+        end
+
+      end # Finder
+
       # Return matched node
       #
-      # @return [Rubinus::AST::Node]
+      # @return [Parser::AST::Node]
+      #   if node could be found
+      #
+      # @return [nil]
+      #   otherwise
       #
       # @api private
       #
       def matched_node
-        last_match = nil
-        ast.walk do |predicate, node|
-          last_match = node if match?(node)
-          predicate
+        Finder.run(ast) do |node|
+          match?(node)
         end
-        last_match
       end
-    end
-  end
-end
+
+    end # Method
+  end # Matcher
+end # Mutant

data/lib/mutant/matcher/{scope_methods.rb → methods.rb}

@@ -1,23 +1,15 @@
 module Mutant
   class Matcher
-    # Abstract base class for matcher that returns subjects extracted from scope methods
-    class ScopeMethods < self
-      include AbstractType
-
-      # Return scope
-      #
-      # @return [Class,Model]
-      #
-      # @api private
-      #
-      attr_reader :scope
+    # Abstract base class for matcher that returns method subjects extracted from scope
+    class Methods < self
+      include AbstractType, Concord::Public.new(:scope)
 
       # Enumerate subjects
       #
       # @return [self]
       #   if block given
       #
-      # @return [Enumerator<Subject>] 
+      # @return [Enumerator<Subject>]
       #   otherwise
       #
       # @api private
@@ -32,19 +24,6 @@ module Mutant
         self
       end
 
-      # Return methods
-      #
-      # @return [Enumerable<Method, UnboundMethod>]
-      #
-      # @api private
-      #
-      def methods
-        method_names.map do |name|
-          access(name)
-        end
-      end
-      memoize :methods
-
       # Return method matcher class
       #
       # @return [Class:Matcher::Method]
@@ -55,59 +34,66 @@ module Mutant
         self.class::MATCHER
       end
 
-      # Return method names
-      #
-      # @param [Object] object
+      # Return methods
       #
-      # @return [Enumerable<Symbol>]
+      # @return [Enumerable<Method, UnboundMethod>]
       #
       # @api private
       #
-      def self.method_names(object)
-        object.public_instance_methods(false)   +
-        object.private_instance_methods(false)  +
-        object.protected_instance_methods(false)
+      def methods
+        candidate_names.each_with_object([]) do |name, methods|
+          method = access(name)
+          methods << method if method.owner == candidate_scope
+        end
       end
+      memoize :methods
 
     private
 
-      # Initialize object
+      # Emit matches for method
       #
-      # @param [Class,Module] scope
+      # @param [UnboundMethod, Method] method
       #
       # @return [undefined]
       #
       # @api private
       #
-      def initialize(scope)
-        @scope = scope
+      def emit_matches(method)
+        matcher.new(scope, method).each do |subject|
+          yield subject
+        end
       end
 
-      # Emit matches for method
+      # Return candidate names
       #
-      # @param [UnboundMethod, Method] method
+      # @param [Object] object
       #
-      # @return [undefined]
+      # @return [Enumerable<Symbol>]
       #
       # @api private
       #
-      def emit_matches(method)
-        matcher.new(scope, method).each do |subject|
-          yield subject
-        end
+      def candidate_names
+        names =
+          candidate_scope.public_instance_methods(false)   +
+          candidate_scope.private_instance_methods(false)  +
+          candidate_scope.protected_instance_methods(false)
+        names.sort
       end
 
-      # Return method names
+      # Return candidate scope
       #
-      # @return [Enumerable<Symbol>] 
+      # @return [Class, Module]
       #
       # @api private
       #
-      abstract_method :method_names
+      abstract_method :candidate_scope
 
+      # Matcher for singleton methods
       class Singleton < self
         MATCHER = Matcher::Method::Singleton
 
+      private
+
         # Return method for name
         #
         # @param [Symbol] method_name
@@ -120,29 +106,25 @@ module Mutant
           scope.method(method_name)
         end
 
-      private
-
-        # Return singleton methods defined on scope
-        #
-        # @param [Class|Module] scope
+        # Return candidate scope
         #
-        # @return [Enumerable<Symbol>]
+        # @return [Class]
         #
         # @api private
         #
-        def method_names
-          singleton_class = scope.singleton_class
-          names = self.class.method_names(singleton_class)
-
-          names.sort.reject do |name|
-            name.to_sym == :__class_init__
-          end
+        def candidate_scope
+          scope.singleton_class
         end
-      end
+        memoize :candidate_scope, :freezer => :noop
 
+      end # Singleton
+
+      # Matcher for instance methods
       class Instance < self
         MATCHER = Matcher::Method::Instance
 
+      private
+
         # Return method for name
         #
         # @param [Symbol] method_name
@@ -155,23 +137,18 @@ module Mutant
           scope.instance_method(method_name)
         end
 
-      private
-
-        # Return instance methods names of scope
-        #
-        # @param [Class|Module] scope
+        # Return candidate scope
         #
-        # @return [Enumerable<Symbol>]
+        # @return [Class, Module]
         #
         # @api private
         #
-        def method_names
-          scope = self.scope
-          return [] unless scope.kind_of?(Module)
-          names = self.class.method_names(scope)
-          names.uniq.sort
+        def candidate_scope
+          scope
         end
-      end
-    end
-  end
-end
+
+      end # Instance
+
+    end # Methods
+  end # Matcher
+end # Mutant

data/lib/mutant/matcher/namespace.rb

@@ -0,0 +1,71 @@
+module Mutant
+  class Matcher
+
+    # Matcher for specific namespace
+    class Namespace < self
+      include Concord::Public.new(:namespace)
+
+      # Enumerate subjects
+      #
+      # @return [self]
+      #   if block given
+      #
+      # @return [Enumerator<Subject>]
+      #   otherwise
+      #
+      # @api private
+      #
+      def each(&block)
+        return to_enum unless block_given?
+
+        scopes.each do |scope|
+          Scope.each(scope, &block)
+        end
+
+        self
+      end
+
+    private
+
+      # Return pattern
+      #
+      # @return [Regexp]
+      #
+      # @api private
+      #
+      def pattern
+        %r(\A#{Regexp.escape(namespace.name)}(?:::)?)
+      end
+      memoize :pattern
+
+      # Return scope enumerator
+      #
+      # @return [Enumerable<Object>]
+      #
+      # @api private
+      #
+      def scopes(&block)
+        return to_enum(__method__) unless block_given?
+
+        ::ObjectSpace.each_object(Module).each do |scope|
+          emit_scope(scope, &block)
+        end
+      end
+
+      # Yield scope if name matches pattern
+      #
+      # @param [Module,Class] scope
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_scope(scope)
+        if pattern =~ scope.name
+          yield scope
+        end
+      end
+
+    end # Namespace
+  end # Matcher
+end # Mutant

data/lib/mutant/matcher/scope.rb

@@ -0,0 +1,34 @@
+module Mutant
+  class Matcher
+    # Matcher for specific namespace
+    class Scope < self
+      include Concord::Public.new(:scope)
+
+      MATCHERS = [
+        Matcher::Methods::Singleton,
+        Matcher::Methods::Instance
+      ].freeze
+
+      # Enumerate subjects
+      #
+      # @return [self]
+      #   if block given
+      #
+      # @return [Enumerator<Subject>]
+      #   otherwise
+      #
+      # @api private
+      #
+      def each(&block)
+        return to_enum unless block_given?
+
+        MATCHERS.each do |matcher|
+          matcher.each(scope, &block)
+        end
+
+        self
+      end
+
+    end # Scope
+  end # Matcher
+end # Mutant