mutant 0.1.1 → 0.2.0

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

@@ -0,0 +1,141 @@
+module Mutant
+  class Matcher
+    class Method
+      # Matcher for singleton methods
+      class Singleton < self
+
+        # Return identification
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def identification
+          "#{scope.name}.#{method_name}"
+        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?
+
+
+      private
+
+        # Return method instance
+        #
+        # @return [UnboundMethod]
+        #
+        # @api private
+        #
+        def method
+          scope.method(method_name)
+        end
+        memoize :method, :freezer => :noop
+
+        # Test for node match
+        #
+        # @param [Rubinius::AST::Node] node
+        #
+        # @return [true]
+        #   returns true if node matches method
+        #
+        # @return [false]
+        #   returns false if node NOT matches method
+        #
+        # @api private
+        #
+        def match?(node)
+          node.class == Rubinius::AST::DefineSingleton  &&
+          line?(node)                                   && 
+          name?(node)                                   && 
+          receiver?(node)
+        end
+
+        # Test for line match
+        #
+        # @param [Rubinius::AST::Node] node
+        #
+        # @return [true]
+        #   returns true if node matches source line
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def line?(node)
+          node.line  == source_line
+        end
+
+        # Test for name match
+        #
+        # @param [Rubinius::AST::DefineSingleton] node
+        #
+        # @return [true]
+        #   returns true if node name matches
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def name?(node)
+          node.body.name == method_name 
+        end
+
+        # Test for receiver match
+        #
+        # @param [Rubinius::AST::DefineSingleton] node
+        #
+        # @return [true]
+        #   returns true when receiver is self or scope from pattern
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def receiver?(node)
+          receiver = node.receiver
+          case receiver
+          when Rubinius::AST::Self
+            true
+          when Rubinius::AST::ConstantAccess
+            receiver_name?(receiver)
+          else
+            raise 'Can only match receiver on Rubinius::AST::Self or Rubinius::AST::ConstantAccess'
+          end
+        end
+
+        # Test if reciver name matches context
+        #
+        # @param [Rubinius::AST::Node] node
+        #
+        # @return [true]
+        #   returns true when node name matches unqualified scope name
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def receiver_name?(node)
+          node.name.to_s == context.unqualified_name
+        end
+
+      end
+    end
+  end
+end

data/lib/mutant/matcher/object_space.rb

@@ -0,0 +1,114 @@
+module Mutant
+  class Matcher
+    # Matcher against object space
+    class ObjectSpace < self
+      include Equalizer.new(:scope_name_pattern)
+
+      PATTERN = %r(\A::(.+)\z)
+
+      # Parse matcher
+      #
+      # @param [String] input
+      #
+      # @return [Matcher::ObjectSpace]
+      #   returns object space matcher if successful
+      #
+      # @return [nil]
+      #   returns nil otherwise
+      #
+      # @api private
+      #
+      def self.parse(input)
+        match = PATTERN.match(input)
+        return unless match
+
+        new(%r(\A#{Regexp.escape(match[1])}(\z|::)))
+      end
+
+      # Enumerate subjects
+      #
+      # @return [Enumerator<Subject>]
+      #   returns subject enumerator when no block given
+      #
+      # @return [self]
+      #   returns self otherwise
+      #
+      # @api private
+      #
+      def each(&block)
+        return to_enum unless block_given?
+
+        scopes.each do |scope|
+          emit_scope_matches(scope, &block)
+        end
+
+        self
+      end
+
+      # Return scope name pattern
+      #
+      # @return [Regexp]
+      #
+      # @api private
+      #
+      def scope_name_pattern; @scope_name_pattern; end
+
+    private
+
+      # Initialize object space matcher 
+      #
+      # @param [Regexp] scope_name_pattern
+      # @param [Enumerable<#each(scope)>] matchers
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(scope_name_pattern, matchers = [Matcher::ScopeMethods::Singleton, Matcher::ScopeMethods::Instance])
+        @scope_name_pattern, @matchers = scope_name_pattern, @matchers = matchers #[Method::Singleton, Method::Instance]
+      end
+
+      # Yield matchers for scope
+      #
+      # @param [::Class,::Module] scope
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_scope_matches(scope, &block)
+        @matchers.each do |matcher|
+          matcher.new(scope).each(&block)
+        end
+      end
+
+      # Return scope enumerator
+      #
+      # @return [Enumerable<Object>]
+      #
+      # @api private
+      #
+      def scopes(&block)
+        return to_enum(__method__) unless block_given?
+
+        ::ObjectSpace.each_object(Module) do |scope|
+          emit_scope(scope, &block)
+        end
+      end
+
+      # Yield scope if name matches pattern
+      #
+      # @param [::Module,::Class]
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_scope(scope)
+        if [::Module, ::Class].include?(scope.class) and @scope_name_pattern =~ scope.name 
+          yield scope 
+        end
+      end
+    end
+  end
+end

data/lib/mutant/matcher/scope_methods.rb

@@ -0,0 +1,127 @@
+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
+
+      # Enumerate subjects
+      #
+      # @return [self]
+      #   if block given
+      #
+      # @return [Enumerator<Subject>] 
+      #   otherwise
+      #
+      # @api private
+      #
+      def each(&block)
+        return to_enum unless block_given?
+        methods.each do |method|
+          emit_matches(method, &block)
+        end
+
+        self
+      end
+
+    private
+
+      # Initialize object
+      #
+      # @param [Class,Module] scope
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(scope)
+        @scope = scope
+      end
+
+      # Emit matches for method
+      #
+      # @param [UnboundMethod] method
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_matches(method)
+        matcher.new(scope, method).each do |subject|
+          yield subject
+        end
+      end
+
+
+      abstract_method :methods
+
+      # Return method matcher class
+      #
+      # @return [Class:Matcher::Method]
+      #
+      # @api private
+      #
+      def matcher
+        self.class::MATCHER
+      end
+
+      class Singleton < self
+        MATCHER = Mutant::Matcher::Method::Singleton
+
+      private
+
+        # Return singleton methods defined on scope
+        #
+        # @param [Class|Module] scope
+        #
+        # @return [Enumerable<Symbol>]
+        #
+        # @api private
+        #
+        def methods
+          singleton_class = scope.singleton_class
+
+          names = 
+            singleton_class.public_instance_methods(false)   +
+            singleton_class.private_instance_methods(false)  +
+            singleton_class.protected_instance_methods(false)
+
+          names.map(&:to_sym).sort.reject do |name|
+            name.to_sym == :__class_init__
+          end
+        end
+      end
+
+      class Instance < self
+        MATCHER = Mutant::Matcher::Method::Instance
+
+      private
+
+        # Return instance methods names of scope
+        #
+        # @param [Class|Module] scope
+        #
+        # @return [Enumerable<Symbol>]
+        #
+        def methods
+          scope = self.scope
+          return [] unless scope.kind_of?(Module)
+
+          names = 
+            scope.public_instance_methods(false)  +
+            scope.private_instance_methods(false) + 
+            scope.protected_instance_methods(false)
+
+          names.uniq.map(&:to_sym).sort
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutation.rb

@@ -1,24 +1,113 @@
 module Mutant
+  # Represent a mutated node with its subject
   class Mutation
-    extend Forwardable
+    include Adamantium::Flat, Equalizer.new(:sha1)
 
-    attr_reader :array
+    # Return mutation subject
+    #
+    # @return [Subject]
+    #
+    # @api private
+    #
+    attr_reader :subject
 
-    def initialize(node, array)
-      @node = node
-      @array = array
-      @mutated = false
+    # Return mutated node
+    #
+    # @return [Rubinius::AST::Node]
+    #
+    # @api private
+    #
+    attr_reader :node
+
+    # Return mutated root node
+    #
+    # @return [Rubinius::AST::Node]
+    #
+    # @api private
+    #
+    def root
+      subject.root(node)
+    end
+    memoize :root
+
+    # Insert mutated node
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def insert
+      Loader::Eval.run(root)
+      self
     end
 
-    def_delegators :@node, :line, :from, :to
+    # Return identification
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def identification
+      "#{subject.identification}:#{code}"
+    end
+    memoize :identification
+
+    # Return mutation code
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def code
+      sha1[0..4]
+    end
+    memoize :code
 
-    def mutated?
-      @mutated
+    # Return sha1 sum of source and subject identification
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def sha1
+      Digest::SHA1.hexdigest(subject.identification + source)
     end
+    memoize :sha1
+
+    # Return source
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def source
+      ToSource.to_source(node)
+    end
+    memoize :source
+
+    # Return original source
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def original_source
+      subject.source
+    end
+
+  private
 
-    def mutate
-      @array[@array.index(@node.item)] = @node.swap
-      @mutated = true
+    # Initialize mutation object
+    #
+    # @param [Subject] subject
+    # @param [Rubinius::Node::AST] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(subject, node)
+      @subject, @node = subject, node
     end
   end
 end