mutant 0.3.1 → 0.3.2

data/lib/mutant/mutator/node/connective/binary.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-module Mutant
-  class Mutator
-    class Node
-      module Connective
-
-        # Mutation emitter to handle binary connectives
-        class Binary < Node
-
-          INVERSE = {
-            and: :or,
-            or:  :and
-          }.freeze
-
-          handle(*INVERSE.keys)
-
-          children :left, :right
-
-        private
-
-          # Emit mutations
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def dispatch
-            emit_nil
-            emit(left)
-            emit(right)
-            mutate_operator
-            mutate_operands
-          end
-
-          # Emit operator mutations
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def mutate_operator
-            emit(s(INVERSE.fetch(node.type), left, right))
-          end
-
-          # Emit condition mutations
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def mutate_operands
-            emit(s(node.type, n_not(left), right))
-            emit(n_not(node))
-          end
-
-        end # Binary
-      end # Connective
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/support/method_object.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-module Mutant
-  # A mixing to create method object semantics
-  module MethodObject
-
-    # Hook called when descendant is extended
-    #
-    # @param [Module|Class] descendant
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def self.extended(descendant)
-      descendant.class_eval do
-        private_class_method :new
-      end
-    end
-
-    # Run the method object
-    #
-    # Not aliased to prevent problems from inheritance
-    #
-    # @return [Objecct]
-    #
-    # @api private
-    #
-    def run(*args)
-      new(*args)
-    end
-
-  end # MethodObject
-end # Mutant

data/spec/unit/mutant/class_methods/singleton_subclass_instance_spec.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant, '.singleton_subclass_instance' do
-  let(:object) { described_class }
-
-  subject { object.singleton_subclass_instance(name, superclass, &block) }
-
-  before do
-    subject
-  end
-
-  let(:name)       { 'Test'                }
-  let(:block)      { proc { def foo; end } }
-  let(:superclass) { Class.new             }
-
-  let(:generated) { superclass.const_get(:Test) }
-
-  it_should_behave_like 'a command method'
-
-  it 'sets expected name' do
-    name = generated.class.name
-    name.should eql("::#{self.name}")
-    name.should be_frozen
-  end
-
-  it 'stores instance of subclass' do
-    generated.should be_kind_of(superclass)
-  end
-
-  it 'evaluates the context of proc inside subclass' do
-    generated.should respond_to(:foo)
-  end
-
-  it 'generates nice #inspect' do
-    inspect = generated.inspect
-    inspect.should eql("::#{self.name}")
-    inspect.should be_frozen
-  end
-end

data/spec/unit/mutant/differ/class_methods/build_spec.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Differ, '.build' do
-  let(:object) { described_class }
-
-  subject { object.build(old_string, new_string) }
-
-  let(:old_string) { "foo\nbar" }
-  let(:new_string) { "bar\nbaz" }
-
-  it { should eql(Mutant::Differ.new(%w(foo bar), %w(bar baz))) }
-end

data/spec/unit/mutant/differ/class_methods/colorize_line_spec.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Differ, '.colorize_line' do
-  let(:object) { described_class }
-
-  subject { object.colorize_line(line) }
-
-  context 'line beginning with "+"' do
-    let(:line) { '+line' }
-
-    it { should eql(Mutant::Color::GREEN.format(line)) }
-  end
-
-  context 'line beginning with "-"' do
-    let(:line) { '-line' }
-
-    it { should eql(Mutant::Color::RED.format(line)) }
-  end
-
-  context 'line beginning in other char' do
-    let(:line) { ' line' }
-
-    it { should eql(line) }
-  end
-end

data/spec/unit/mutant/matcher/chain/each_spec.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Matcher::Chain, '#each' do
-  subject { object.each { |entry| yields << entry } }
-
-  let(:object) { described_class.new(matchers) }
-
-  let(:matchers) { [matcher_a, matcher_b] }
-
-  let(:matcher_a) { double('Matcher A') }
-  let(:matcher_b) { double('Matcher B') }
-
-  let(:subject_a) { double('Subject A') }
-  let(:subject_b) { double('Subject B') }
-
-  before do
-    matcher_a.stub(:each).and_yield(subject_a).and_return(matcher_a)
-    matcher_b.stub(:each).and_yield(subject_b).and_return(matcher_b)
-  end
-
-  # it_should_behave_like 'an #each method'
-  context 'with no block' do
-    subject { object.each }
-
-    it { should be_instance_of(to_enum.class) }
-
-    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
-      pending 'FIX RBX rspec? BUG HERE'
-    else
-      it 'yields the expected values' do
-        subject.to_a.should eql(object.to_a)
-      end
-    end
-  end
-
-  let(:yields) { [] }
-
-  it 'should yield subjects' do
-    expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
-  end
-end

data/spec/unit/mutant/matcher/chain/matchers_spec.rb

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Matcher::Chain, '#matchers' do
-  subject { object.matchers }
-
-  let(:object)   { described_class.new(matchers) }
-  let(:matchers) { double('Matchers')            }
-
-  it { should be(matchers) }
-
-  it_should_behave_like 'an idempotent method'
-end

data/spec/unit/mutant/matcher/each_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-# This spec is only present to ensure 100% test coverage.
-# The code should not be triggered on runtime.
-
-describe Mutant::Matcher, '#each' do
-  subject { object.send(:each) }
-
-  let(:object) { described_class.allocate }
-
-  it 'should raise error' do
-    expect do
-      subject
-    end.to raise_error(
-      NotImplementedError,
-      'Mutant::Matcher#each is not implemented'
-    )
-  end
-end

data/spec/unit/mutant/matcher/method/instance/class_methods/build_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Matcher::Method::Instance, '.build' do
-  let(:object) { described_class }
-
-  subject { object.build(cache, scope, method) }
-
-  let(:cache) { double }
-
-  let(:scope) do
-    Class.new do
-      include Adamantium
-
-      def foo
-      end
-      memoize :foo
-
-      def bar
-      end
-    end
-  end
-
-  let(:method) do
-    scope.instance_method(method_name)
-  end
-
-  context 'with adamantium infected scope' do
-    context 'with unmemoized method' do
-      let(:method_name) { :bar }
-
-      it { should eql(described_class.new(cache, scope, method)) }
-    end
-
-    context 'with memoized method' do
-      let(:method_name) { :foo }
-
-      it { should eql(described_class::Memoized.new(cache, scope, method)) }
-    end
-  end
-end

data/spec/unit/mutant/matcher/method/instance/each_spec.rb

@@ -1,114 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Matcher::Method::Instance, '#each' do
-  subject { object.each { |subject| yields << subject } }
-
-  let(:cache)        { Fixtures::AST_CACHE                       }
-  let(:object)       { described_class.new(cache, scope, method) }
-  let(:method)       { scope.instance_method(method_name)        }
-  let(:yields)       { []                                        }
-  let(:namespace)    { self.class                                }
-  let(:scope)        { self.class::Foo                           }
-  let(:type)         { :def                                      }
-  let(:method_name)  { :bar                                      }
-  let(:method_arity) { 0                                         }
-
-  def name
-    node.children[0]
-  end
-
-  def arguments
-    node.children[1]
-  end
-
-  context 'when method is defined once' do
-    let(:base) { __LINE__ }
-    class self::Foo
-      def bar; end
-    end
-
-    let(:method_line) { 2 }
-
-    it_should_behave_like 'a method matcher'
-  end
-
-  context 'when method is defined multiple times' do
-    context 'on differend lines' do
-      let(:base) { __LINE__ }
-      class self::Foo
-        def bar
-        end
-
-        def bar(arg)
-        end
-      end
-
-      let(:method_line)  { 5 }
-      let(:method_arity) { 1 }
-
-      it_should_behave_like 'a method matcher'
-    end
-
-    context 'on the same line' do
-      let(:base) { __LINE__ }
-      class self::Foo
-        def bar; end; def bar(arg); end
-      end
-
-      let(:method_line)  { 2 }
-      let(:method_arity) { 1 }
-
-      it_should_behave_like 'a method matcher'
-    end
-
-    context 'on the same line with differend scope' do
-      let(:base) { __LINE__ }
-      class self::Foo
-        def self.bar; end; def bar(arg); end
-      end
-
-      let(:method_line)  { 2 }
-      let(:method_arity) { 1 }
-
-      it_should_behave_like 'a method matcher'
-    end
-
-    context 'when nested' do
-      let(:pattern) { 'Foo::Bar#baz' }
-
-      context 'in class' do
-        let(:base) { __LINE__ }
-        class self::Foo
-          class Bar
-            def baz
-            end
-          end
-        end
-
-        let(:method_line) { 3                    }
-        let(:method_name) { :baz                 }
-        let(:scope)       { self.class::Foo::Bar }
-
-        it_should_behave_like 'a method matcher'
-      end
-
-      context 'in module' do
-        let(:base) { __LINE__ }
-        module self::Foo
-          class Bar
-            def baz
-            end
-          end
-        end
-
-        let(:method_line) { 3                    }
-        let(:method_name) { :baz                 }
-        let(:scope)       { self.class::Foo::Bar }
-
-        it_should_behave_like 'a method matcher'
-      end
-    end
-  end
-end

data/spec/unit/mutant/mutator/each_spec.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-# This file is the sandbox for new mutations.
-# Once finished mutation test will be moved to class specfic
-# file.
-
-require 'spec_helper'
-
-describe Mutant::Mutator, '.each' do
-
-  pending 'interpolated string literal (DynamicString)' do
-    let(:source) { '"foo#{1}bar"' }
-
-    let(:random_string) { 'this-is-random' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-    end
-
-    before do
-      Mutant::Random.stub(hex_string: random_string)
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end