mutant 0.1.1 → 0.2.0

data/.rvmrc

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

data/Readme.md

@@ -1,13 +0,0 @@
-# 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

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

data/lib/mutant/extensions.rb

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

data/lib/mutant/formatter.rb

@@ -1,19 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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 InstanceVariableAssignment < 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

@@ -1,31 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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/node.rb

@@ -1,26 +0,0 @@
-module Mutant
-  class Node
-    attr_reader :item, :copy
-
-    def initialize(item)
-      @item = item
-      @copy = item.clone
-    end
-
-    def line
-      item.line
-    end
-
-    def from
-      @from ||= Formatter.new(item)
-    end
-
-    def to
-      @to ||= Formatter.new(copy)
-    end
-
-    def swap
-      @copy = Literal.new(copy).swap
-    end
-  end
-end

data/lib/mutant/runners/rspec.rb

@@ -1,34 +0,0 @@
-require 'rspec/core'
-
-module Mutant
-  module Runners
-    class RSpec
-      ABORT_MESSAGE = 'Initial run of specs failed... fix and run mutant again'
-
-      def self.run(args)
-        runner = new(args)
-        runner.initial_run
-        runner.mutate
-        puts runner.run.zero? ? 'failed' : 'passed'
-      end
-
-      def initialize(args)
-        @implementation = Implementation.new(args.shift)
-        @args = args
-      end
-
-      def initial_run
-        abort ABORT_MESSAGE unless run.zero?
-      end
-
-      def run
-        ::RSpec::Core::Runner.run(@args)
-      end
-
-      def mutate
-        Mutant.mutate(@implementation)
-      end
-    end
-  end
-end
-

data/lib/mutant/version.rb

@@ -1,3 +0,0 @@
-module Mutant
-  VERSION = "0.1.1"
-end

data/spec/functional/class_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe 'Mutating a class' do
-  before do
-    write_file 'thing.rb', """
-      class Thing
-        def alive?; true end
-        def dead?; false end
-        def mood; :happy end
-        def gender; 'male' end
-        def alphabet_range; 'a'..'k' end
-      end
-    """
-    write_file 'spec/thing_spec.rb', """
-      $: << '.'
-      require 'thing'
-
-      describe Thing do
-        describe '#alive?' do
-          specify { Thing.new.should be_alive }
-        end
-
-        describe '#dead?' do
-          specify { Thing.new.should_not be_dead }
-        end
-
-        describe '#mood' do
-          specify { Thing.new.mood.should eq(:happy) }
-        end
-
-        describe '#gender' do
-          specify { Thing.new.gender.should eq('male') }
-        end
-
-        describe '#alphabet_range' do
-          specify { Thing.new.alphabet_range.should eq('a'..'k') }
-        end
-      end
-    """
-    mutate 'Thing spec/thing_spec.rb'
-  end
-
-  it 'runs all possible mutations' do
-    all_output.should include('passed')
-  end
-end