mutant 0.0.1 → 0.1.0

data/.gitignore

@@ -1,6 +1,11 @@
+.DS_Store
 *.gem
 .bundle
 Gemfile.lock
 pkg/*
 tmp
+*.rbx
+*.rbc
+bin
 .rbx
+test_spec.rb

data/.rvmrc

@@ -1 +1 @@
-rvm use rbx@mutant --create
+rvm use rbx-head@mutant --create

data/.travis.yml

@@ -0,0 +1,6 @@
+rvm:
+  - rbx-18mode
+  - rbx-19mode
+
+bundler_args: "--binstubs"
+script: "bin/rspec spec"

data/Readme.md

@@ -0,0 +1,13 @@
+# mutant [![Build Status](https://secure.travis-ci.org/txus/mutant.png)](http://travis-ci.org/txus/mutant) [![Dependency Status](https://gemnasium.com/txus/mutant.png)](https://gemnasium.com/txus/mutant)
+
+Mutant is a mutation tester. It modifies your code and runs your tests to make sure they fail. The idea is that if code can be changed and your tests don't notice, either that code isn't being covered or it doesn't do anything.
+
+Largely based on [heckle](https://github.com/seattlerb/heckle), this is a rewrite on top of [Rubinius](http://rubini.us).
+
+## Development roadmap
+
+As an experiment, I've set up a [public Trello board](https://trello.com/board/mutant/4f452510101d860b203b542d) with the development roadmap up to the 1.0 release. You can vote and comment cards to give constructive feedback to the project. Just have a look and leave a comment! :)
+
+## Who's this
+
+This project was originally created by [@justinko](http://twitter.com/justinko) and is released under the MIT license. I am pleased to be the current maintainer :) I'm [@txustice](http://twitter.com/txustice) on twitter (where you should probably follow me!).

data/exe/mutate

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'mutant'
+
+Mutant.run(ARGV)

data/lib/mutant.rb

@@ -1,7 +1,28 @@
+require 'mutant/extensions'
+require 'mutant/formatter'
+require 'mutant/implementation'
+require 'mutant/literal'
+require 'mutant/method'
+require 'mutant/mutatee'
+require 'mutant/mutation'
+require 'mutant/mutator'
+require 'mutant/node'
+require 'mutant/random'
+require 'mutant/reporter'
 require 'mutant/version'
 
 module Mutant
   module Runners
     autoload :RSpec, 'mutant/runners/rspec'
   end
+
+  def self.run(args)
+    Runners::RSpec.run(args)
+  end
+
+  def self.mutate(implementation)
+    implementation.mutatees.each do |mutatee|
+      Mutator.new(mutatee).mutate
+    end
+  end
 end

data/lib/mutant/extensions.rb

@@ -0,0 +1,8 @@
+module ClassExtensions
+  def basename
+    name.split('::').last
+  end
+end
+
+Class.send :include, ClassExtensions
+Rubinius::AST::Node.send :include, ClassExtensions

data/lib/mutant/formatter.rb

@@ -0,0 +1,19 @@
+require 'to_source'
+
+module Mutant
+  class Formatter
+    attr_reader :item
+
+    def initialize(item)
+      @item = item
+    end
+
+    def nested?
+      false
+    end
+
+    def to_s
+      item.to_source
+    end
+  end
+end

data/lib/mutant/implementation.rb

@@ -0,0 +1,70 @@
+module Mutant
+  class Implementation
+    SINGLETON_SCOPE = '.'
+    INSTANCE_SCOPE = '#'
+    SCOPE_REGEXP = Regexp.union(SINGLETON_SCOPE, INSTANCE_SCOPE)
+
+    def initialize(str)
+      @str = str
+    end
+
+    def scope_type
+      { SINGLETON_SCOPE => :singleton, INSTANCE_SCOPE => :instance
+      }[method_scope]
+    end
+
+    def class_name
+      @str.split(SCOPE_REGEXP)[0]
+    end
+
+    def method_scope
+      @str[SCOPE_REGEXP]
+    end
+
+    def method_name
+      @str.split(SCOPE_REGEXP)[1] if method_scope
+    end
+
+    def constant
+      class_name.split(/::/).inject(Object) do |context, name|
+        context.const_get name
+      end
+    end
+
+    def all_implementations
+      all_methods.map {|formatted_method| self.class.new(formatted_method)}
+    end
+
+    def all_methods
+      all_singleton_methods + all_instance_methods
+    end
+
+    def all_singleton_methods
+      constant.singleton_methods(false).delete_if {|meth_name|
+        meth_name.to_s == '__class_init__' }.map {|meth_name|
+          format_method(meth_name, SINGLETON_SCOPE)}
+    end
+
+    def all_instance_methods
+      constant.instance_methods(false).map do |meth_name|
+        format_method(meth_name, INSTANCE_SCOPE)
+      end
+    end
+
+    def mutatees
+      Array(method_scope ? self : all_implementations).map do |impl|
+        Mutatee.new(impl)
+      end
+    end
+
+    def to_s
+      @str
+    end
+
+    private
+
+    def format_method(meth_name, method_scope_type)
+      class_name + method_scope_type + meth_name.to_s
+    end
+  end
+end

data/lib/mutant/literal.rb

@@ -0,0 +1,134 @@
+module Mutant
+  class Literal
+    def self.literal_class(node)
+      const_get(node.class.basename)
+    end
+
+    def initialize(node)
+      @node = node
+      @class = self.class.literal_class(node)
+    end
+
+    def swap
+      @class.new(@node).swap
+    end
+
+    class BaseLiteral
+      def initialize(node)
+        @node = node
+      end
+    end
+
+    class FalseLiteral < BaseLiteral
+      def swap
+        Rubinius::AST::TrueLiteral.new(@node.line)
+      end
+    end
+
+    class TrueLiteral < BaseLiteral
+      def swap
+        Rubinius::AST::FalseLiteral.new(@node.line)
+      end
+    end
+
+    class SymbolLiteral < BaseLiteral
+      def swap
+        @node.value = Random.symbol
+        @node
+      end
+    end
+
+    class StringLiteral < BaseLiteral
+      def swap
+        @node.string = Random.string
+        @node
+      end
+    end
+
+    class FixnumLiteral < BaseLiteral
+      def swap
+        @node.value = Random.fixnum
+        @node
+      end
+    end
+
+    class FloatLiteral < BaseLiteral
+      def swap
+        @node.value = Random.float
+        @node
+      end
+    end
+
+    class Range < BaseLiteral
+      def swap
+        range = Random.range
+        @node.start = Rubinius::AST::FixnumLiteral.new(@node.line, range.min)
+        @node.finish = Rubinius::AST::FixnumLiteral.new(@node.line, range.max)
+        @node
+      end
+    end
+
+    class RegexLiteral < BaseLiteral
+      def swap
+        @node.source = Regexp.escape(Random.string)
+        @node
+      end
+    end
+
+    class ArrayLiteral < BaseLiteral
+      def swap
+        @node.body = @node.body.reverse[1..-1]
+        @node
+      end
+    end
+
+    class HashLiteral < BaseLiteral
+      def swap
+        new_body = @node.array.each_slice(2).inject([]) do |body, (key, value)|
+          new_value = literal_class(value).new(value.clone).swap
+
+          body << key << new_value
+        end
+
+        @node.array = new_body
+        @node
+      end
+
+      private
+
+      def literal_class(value)
+        Module.nesting[1].literal_class(value)
+      end
+    end
+
+    class LocalVariableAssignment < BaseLiteral
+      def swap
+        @node.value = literal_class.new(@node.value.clone).swap
+        @node
+      end
+
+      private
+
+      def literal_class
+        Module.nesting[1].literal_class(@node.value)
+      end
+    end
+
+    class If < BaseLiteral
+      def swap
+        @node.body, @node.else = @node.else, @node.body
+        @node
+      end
+    end
+
+    class Send < BaseLiteral
+      def swap
+        line  = @node.line
+        @node = Rubinius::AST::NilLiteral.new(line)
+        @node
+      end
+    end
+
+    SendWithArguments = Send
+  end
+end

data/lib/mutant/method.rb

@@ -0,0 +1,31 @@
+module Mutant
+  class Method < Rubinius::Melbourne
+    attr_reader :ast, :source_name, :source_file, :source_line
+
+    DEFAULT_LINE = 1
+
+    def initialize(method)
+      @ast         = nil
+      @source_name = method.name.to_sym
+      @source_file, @source_line = method.source_location
+      super(source_file, DEFAULT_LINE)
+    end
+
+    # TODO: Check for edge cases where just the line won't work.
+    def match?(ast)
+      source_line == ast.line
+    end
+  end
+
+  class InstanceMethod < Method
+    def process_defn(*)
+      super.tap { |ast| @ast = ast if match?(ast) }
+    end
+  end
+
+  class SingletonMethod < Method
+    def process_defs(*)
+      super.tap { |ast| @ast = ast if match?(ast.body) }
+    end
+  end
+end

data/lib/mutant/mutatee.rb

@@ -0,0 +1,61 @@
+require 'forwardable'
+
+module Mutant
+  class Mutatee
+    extend Forwardable
+
+    attr_reader :implementation, :mutations
+
+    def initialize(implementation)
+      @implementation = implementation
+      @mutations = []
+    end
+
+    def_delegators :@implementation, :class_name, :method_name, :to_s
+
+    def clean
+      body.array.delete_if do |literal|
+        not Mutant::Literal.constants.map(&:to_sym).include?(literal.class.basename.to_sym)
+      end
+    end
+
+    def set_mutations
+      nodes.each do |node|
+        @mutations << Mutation.new(node, body.array)
+      end
+    end
+
+    def nodes
+      body.array.map {|item| Node.new(item) }
+    end
+
+    def mutations_remaining
+      @mutations.reject(&:mutated?)
+    end
+
+    def ast
+      @ast ||= rbx_method.parse_file && rbx_method.ast
+    end
+
+    def body
+      @body ||= rbx_method.is_a?(SingletonMethod) ? ast.body.body : ast.body
+
+    end
+
+    def rbx_method
+      @rbx_method ||=
+        case implementation.scope_type
+        when :singleton then SingletonMethod.new \
+          implementation.constant.method(method_name)
+        when :instance then InstanceMethod.new \
+          implementation.constant.instance_method(method_name)
+        end
+    end
+
+    private
+
+    def marshal(data)
+      Marshal.load(Marshal.dump(data))
+    end
+  end
+end

data/lib/mutant/mutation.rb

@@ -0,0 +1,24 @@
+module Mutant
+  class Mutation
+    extend Forwardable
+
+    attr_reader :array
+
+    def initialize(node, array)
+      @node = node
+      @array = array
+      @mutated = false
+    end
+
+    def_delegators :@node, :line, :from, :to
+
+    def mutated?
+      @mutated
+    end
+
+    def mutate
+      @array[@array.index(@node.item)] = @node.swap
+      @mutated = true
+    end
+  end
+end

data/lib/mutant/mutator.rb

@@ -0,0 +1,49 @@
+module Mutant
+  class Mutator
+    COMPILER = Rubinius::Compiler.new(:bytecode, :compiled_method)
+
+    def initialize(mutatee)
+      @mutatee = mutatee
+    end
+
+    def mutate
+      @mutatee.clean
+      @mutatee.set_mutations
+
+      if @mutatee.mutations.size.zero?
+        Reporter.no_mutations(@mutatee)
+        return
+      else
+        Reporter.method_loaded(@mutatee)
+      end
+
+      @mutatee.mutations.each do |mutation|
+        @mutatee.body.array = mutation.mutate && mutation.array
+        Reporter.mutating(mutation)
+        # setup the compiler
+        COMPILER.generator.input(root)
+        # compile the script and replace the original method
+        # with the mutated method
+        Rubinius.run_script(compiled_method)
+      end
+    end
+
+    def block
+      Rubinius::AST::Block.new(1, [ @mutatee.ast ])
+    end
+
+    def class_ast
+      Rubinius::AST::Class.new(1, @mutatee.class_name.to_sym, nil, block)
+    end
+
+    def root
+      Rubinius::AST::Script.new(class_ast).tap do |script|
+        script.file = @mutatee.rbx_method.source_file
+      end
+    end
+
+    def compiled_method
+      COMPILER.run.create_script.compiled_method
+    end
+  end
+end