mutant 0.5.10 → 0.5.11

data/lib/mutant/warning_filter.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+
+module Mutant
+  # Stream filter for warnings
+  class WarningFilter
+    include Equalizer.new(:target)
+
+    WARNING_PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/
+
+    # Initialize object
+    #
+    # @param [#write] target
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(target)
+      @target   = target
+      @warnings = []
+    end
+
+    # Return filtered warnings
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    #
+    attr_reader :warnings
+
+    # Return target
+    #
+    # @return [#write] target
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    attr_reader :target
+    protected :target
+
+    # Write message to target filtering warnings
+    #
+    # @param [String] message
+    #
+    # @return [self]
+    #
+    def write(message)
+      if WARNING_PATTERN =~ message
+        warnings << message
+      else
+        target.write(message)
+      end
+
+      self
+    end
+
+    # Use warning filter during block execution
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    #
+    def self.use
+      original = $stderr
+      $stderr = filter = new(original)
+      yield
+      filter.warnings
+    ensure
+      $stderr = original
+    end
+
+  end # WarningFilter
+end # Mutant

data/lib/mutant/zombifier/file.rb

@@ -0,0 +1,81 @@
+module Mutant
+  class Zombifier
+    # File containing source beeing zombified
+    class File
+      include NodeHelpers, Adamantium::Flat, Concord::Public.new(:path)
+
+      # Zombify contents of file
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def zombify(namespace)
+        $stderr.puts("Zombifying #{path.to_s}")
+        eval(
+          Unparser.unparse(namespaced_node(namespace)),
+          TOPLEVEL_BINDING,
+          path.to_s
+        )
+        self
+      end
+
+      # Find file by logical path
+      #
+      # @param [String] logical_name
+      #
+      # @return [File]
+      #   if found
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      #
+      def self.find(logical_name)
+        file_name =
+          case ::File.extname(logical_name)
+          when '.so'
+            return
+          when '.rb'
+            logical_name
+          else
+            "#{logical_name}.rb"
+          end
+
+        $LOAD_PATH.each do |path|
+          path = Pathname.new(path).join(file_name)
+          return new(path) if path.file?
+        end
+
+        $stderr.puts "Cannot find file #{file_name} in $LOAD_PATH"
+        nil
+      end
+
+    private
+
+      # Return node
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def node
+        Parser::CurrentRuby.parse(path.read)
+      end
+
+      # Return namespaced root
+      #
+      # @param [Symbol] namespace
+      #
+      # @return [Parser::AST::Node]
+      #
+      # @api private
+      #
+      def namespaced_node(namespace)
+        s(:module, s(:const, nil, namespace), node)
+      end
+
+    end # File
+  end # Zombifier
+end # Mutant

data/lib/mutant/zombifier.rb

@@ -2,264 +2,85 @@
 
 module Mutant
   # Zombifier namespace
-  module Zombifier
+  class Zombifier
+    include Adamantium::Flat, Concord.new(:namespace)
+
+    # Excluded into zombification
+    includes = %w(
+      mutant
+      morpher
+      adamantium
+      equalizer
+      anima
+      concord
+    )
+
+    INCLUDES = %r(\A#{Regexp.union(includes)}(?:/.*)?\z).freeze
+
+    # Initialize object
+    #
+    # @param [Symbol] namespace
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(namespace)
+      @zombified = Set.new
+      @highjack = RequireHighjack.new(Kernel, method(:require))
+      super(namespace)
+    end
 
-    # Excluded from zombification, reasons
+    # Perform zombification of target library
     #
-    # * Relies dynamic require, zombifier does not know how to recurse (racc)
-    # * Unparser bug (optparse)
-    # * Toplevel reference/cbase nodes in code (rspec)
-    # * Creates useless toplevel modules that get vendored under ::Zombie (set)
+    # @param [String] logical_name
+    # @param [Symbol] namespace
     #
-    IGNORE = %w(
-      set
-      rspec
-      diff/lcs
-      diff/lcs/hunk
-      unparser
-      parser
-      parser/all
-      parser/current
-      racc/parser
-      optparse
-    ).to_set
+    # @api private
+    #
+    def self.run(logical_name, namespace)
+      new(namespace).run(logical_name)
+    end
 
-    # Perform self zombification
+    # Run zombifier
     #
-    # @return [self]
+    # @param [String] logical_name
+    #
+    # @return [undefined]
     #
     # @api private
     #
-    def self.zombify
-      run('mutant')
-      self
+    def run(logical_name)
+      @highjack.infect
+      require(logical_name)
     end
 
-    # Zombify gem
+    # Test if logical name is subjected to zombification
+    #
+    # @param [String]
+    #
+    # @api private
     #
-    # @param [String] name
+    def include?(logical_name)
+      !@zombified.include?(logical_name) && INCLUDES =~ logical_name
+    end
+
+    # Require file in zombie namespace
+    #
+    # @param [String] logical_name
     #
     # @return [self]
     #
     # @api private
     #
-    def self.run(name)
-      Gem.new(name).zombify
+    def require(logical_name)
+      @highjack.original.call(logical_name)
+      return unless include?(logical_name)
+      @zombified << logical_name
+      file = File.find(logical_name)
+      file.zombify(namespace) if file
       self
     end
 
-    # Zombifier subject, compatible with mutants loader
-    class Subject < Mutant::Subject
-      include NodeHelpers
-
-      # Return new object
-      #
-      # @param [File]
-      #
-      # @return [Subject]
-      #
-      # @api private
-      #
-      def self.new(file)
-        super(file, file.node)
-      end
-
-      # Perform zombification on subject
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def zombify
-        $stderr.puts("Zombifying #{context.source_path}")
-        Loader::Eval.call(zombified_root, self)
-        self
-      end
-      memoize :zombify
-
-    private
-
-      # Return zombified root
-      #
-      # @return [Parser::AST::Node]
-      #
-      # @api private
-      #
-      def zombified_root
-        s(:module, s(:const, nil, :Zombie), node)
-      end
-
-    end # Subject
-
-    # File containing source beeing zombified
-    class File
-      include Adamantium::Flat, Concord::Public.new(:source_path)
-
-      CACHE = {}
-
-      # Zombify contents of file
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def zombify
-        subject.zombify
-        required_paths.each do |path|
-          file = File.find(path)
-          next unless file
-          file.zombify
-        end
-        self
-      end
-      memoize :zombify
-
-      # Find file
-      #
-      # @param [String] logical_name
-      #
-      # @return [File]
-      #   if found
-      #
-      # @raise [RuntimeError]
-      #   if file cannot be found
-      #
-      # @api private
-      #
-      def self.find(logical_name)
-        return if IGNORE.include?(logical_name)
-        CACHE.fetch(logical_name) do
-          CACHE[logical_name] = find_uncached(logical_name)
-        end
-      end
-
-      # Find file without cache
-      #
-      # @param [String] logical_name
-      #
-      # @return [File]
-      #   if found
-      #
-      # @return [nil]
-      #   otherwise
-      #
-      # @api private
-      #
-      def self.find_uncached(logical_name)
-        file_name =
-          if logical_name.end_with?('.rb')
-            logical_name
-          else
-            "#{logical_name}.rb"
-          end
-
-        $LOAD_PATH.each do |path|
-          path = Pathname.new(path).join(file_name)
-          if path.file?
-            return new(path)
-          end
-        end
-
-        $stderr.puts "Cannot find file #{file_name} in $LOAD_PATH"
-        nil
-      end
-
-      # Return subject
-      #
-      # @return [Subject]
-      #
-      # @api private
-      #
-      def subject
-        Subject.new(self)
-      end
-      memoize :subject
-
-      # Return node
-      #
-      # @return [Parser::AST::Node]
-      #
-      # @api private
-      #
-      def node
-        Parser::CurrentRuby.parse(::File.read(source_path))
-      end
-      memoize :node
-
-      RECEIVER_INDEX = 0
-      SELECTOR_INDEX = 1
-      ARGUMENT_INDEX = 2..-1.freeze
-
-      # Return required paths
-      #
-      # @return [Enumerable<String>]
-      #
-      # @api private
-      #
-      def required_paths
-        require_nodes.map do |node|
-          arguments = node.children[ARGUMENT_INDEX]
-          unless arguments.length == 1
-            raise "Require node with not exactly one argument: #{node}"
-          end
-          argument = arguments.first
-          unless argument.type == :str
-            raise "Require argument is not a literal string: #{argument}"
-          end
-          argument.children.first
-        end
-      end
-      memoize :required_paths
-
-    private
-
-      # Return require nodes
-      #
-      # @return [Enumerable<Parser::AST::Node>]
-      #
-      # @api private
-      #
-      def require_nodes
-        children = node.type == :begin ? node.children : [node]
-        children.select do |node|
-          children = node.children
-          node.type == :send &&
-          children.at(RECEIVER_INDEX).nil? &&
-          children.at(SELECTOR_INDEX) == :require
-        end
-      end
-
-    end # File
-
-    # Gem beeing zombified
-    class Gem
-      include Adamantium::Flat, Concord.new(:name)
-
-      # Return subjects
-      #
-      # @return [Enumerable<Subject>]
-      #
-      # @api private
-      #
-      def zombify
-        root_file.zombify
-      end
-      memoize :zombify
-
-    private
-
-      # Return root souce file
-      #
-      # @return [File]
-      #
-      # @api private
-      #
-      def root_file
-        File.find(name) or raise 'No root file!'
-      end
-      memoize :root_file
-
-    end # Gem
-
   end # Zombifier
 end # Mutant

data/lib/mutant.rb

@@ -11,6 +11,7 @@ require 'digest/sha1'
 require 'inflecto'
 require 'parser'
 require 'parser/current'
+require 'parser_extensions'
 require 'unparser'
 require 'ice_nine'
 require 'diff/lcs'
@@ -25,15 +26,66 @@ module Mutant
   EMPTY_STRING = ''.freeze
   # The frozen empty array used within mutant
   EMPTY_ARRAY = [].freeze
+
+  # Perform self zombification
+  #
+  # @return [self]
+  #
+  # @api private
+  #
+  def self.zombify
+    Zombifier.run('mutant', :Zombie)
+    self
+  end
+
+  # Return a frozen set of symbols from string enumerable
+  #
+  # @param [Enumerable<String>]
+  #
+  # @return [Set<Symbol>]
+  #
+  # @api private
+  #
+  def self.symbolset(strings)
+    strings.map(&:to_sym).to_set.freeze
+  end
+  private_class_method :symbolset
+
+  # Define instance of subclassed superclass as constant
+  #
+  # @param [Class] superclass
+  # @param [Symbol] name
+  #
+  # @return [self]
+  #
+  # @api private
+  #
+  def self.singleton_subclass_instance(name, superclass, &block)
+    klass = Class.new(superclass) do
+      def inspect
+        self.class.name
+      end
+
+      define_singleton_method(:name) do
+        "#{superclass.name}::#{name}".freeze
+      end
+    end
+    klass.class_eval(&block)
+    superclass.const_set(name, klass.new)
+    self
+  end
+
 end # Mutant
 
 require 'mutant/version'
 require 'mutant/cache'
 require 'mutant/node_helpers'
-require 'mutant/singleton_methods'
+require 'mutant/warning_filter'
+require 'mutant/warning_expectation'
 require 'mutant/constants'
 require 'mutant/random'
 require 'mutant/walker'
+require 'mutant/require_highjack'
 require 'mutant/mutator'
 require 'mutant/mutation'
 require 'mutant/mutation/evil'
@@ -77,6 +129,8 @@ require 'mutant/mutator/node/zsuper'
 require 'mutant/mutator/node/restarg'
 require 'mutant/mutator/node/send'
 require 'mutant/mutator/node/send/binary'
+require 'mutant/mutator/node/send/attribute_assignment'
+require 'mutant/mutator/node/send/index'
 require 'mutant/mutator/node/when'
 require 'mutant/mutator/node/define'
 require 'mutant/mutator/node/mlhs'
@@ -89,6 +143,7 @@ require 'mutant/mutator/node/case'
 require 'mutant/mutator/node/splat'
 require 'mutant/mutator/node/resbody'
 require 'mutant/mutator/node/rescue'
+require 'mutant/mutator/node/match_current_line'
 require 'mutant/config'
 require 'mutant/loader'
 require 'mutant/context'
@@ -132,3 +187,4 @@ require 'mutant/reporter/cli/printer/subject'
 require 'mutant/reporter/cli/printer/killer'
 require 'mutant/reporter/cli/printer/mutation'
 require 'mutant/zombifier'
+require 'mutant/zombifier/file'

data/lib/parser_extensions.rb

@@ -0,0 +1,25 @@
+# Monkeypatch to silence warnings in parser
+#
+# Will be removed once https://github.com/whitequark/parser/issues/145 is solved.
+
+# Parser namespace
+module Parser
+  # Monkeypatched lexer
+  class Lexer
+
+    # Return new lexer
+    #
+    # @return [Lexer]
+    #
+    # @api private
+    #
+    def self.new(*arguments)
+      super.tap do |instance|
+        instance.instance_eval do
+          @force_utf32 = false
+        end
+      end
+    end
+
+  end # Lexer
+end # Parser

data/mutant.gemspec

@@ -24,18 +24,19 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 1.9.3'
 
   gem.add_runtime_dependency('parser',        '~> 2.1')
+  gem.add_runtime_dependency('ast',           '~> 2.0')
   gem.add_runtime_dependency('diff-lcs',      '~> 1.2')
-  gem.add_runtime_dependency('morpher',       '~> 0.2.1')
+  gem.add_runtime_dependency('morpher',       '~> 0.2.3')
   gem.add_runtime_dependency('procto',        '~> 0.0.2')
   gem.add_runtime_dependency('abstract_type', '~> 0.0.7')
-  gem.add_runtime_dependency('unparser',      '~> 0.1.10')
+  gem.add_runtime_dependency('unparser',      '~> 0.1.12')
   gem.add_runtime_dependency('ice_nine',      '~> 0.11.0')
   gem.add_runtime_dependency('adamantium',    '~> 0.2.0')
   gem.add_runtime_dependency('memoizable',    '~> 0.4.2')
   gem.add_runtime_dependency('equalizer',     '~> 0.0.9')
   gem.add_runtime_dependency('inflecto',      '~> 0.0.2')
   gem.add_runtime_dependency('anima',         '~> 0.2.0')
-  gem.add_runtime_dependency('concord',       '~> 0.1.4')
+  gem.add_runtime_dependency('concord',       '~> 0.1.5')
 
   gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
 end