mutest 0.0.1 → 0.0.2

data/lib/mutest/test.rb

@@ -0,0 +1,14 @@
+module Mutest
+  # Abstract base class for test that might kill a mutation
+  class Test
+    include Adamantium::Flat, Anima.new(
+      :expression,
+      :id
+    )
+
+    # Identification string
+    #
+    # @return [String]
+    alias_method :identification, :id
+  end # Test
+end # Mutest

data/lib/mutest/util.rb

@@ -0,0 +1,18 @@
+module Mutest
+  # Utility methods
+  module Util
+    # Error raised by `Util.one` if size is less than zero or greater than one
+    SizeError = Class.new(IndexError)
+
+    # Return only element in array if it contains exactly one member
+    #
+    # @param array [Array]
+    #
+    # @return [Object] first entry
+    def self.one(array)
+      return array.first if array.one?
+
+      fail SizeError, "expected size to be exactly 1 but size was #{array.size}"
+    end
+  end # Util
+end # Mutest

data/lib/mutest/version.rb

@@ -0,0 +1,4 @@
+module Mutest
+  # Current mutest version
+  VERSION = '0.0.2'.freeze
+end # Mutest

data/lib/mutest/warning_filter.rb

@@ -0,0 +1,58 @@
+module Mutest
+  # Stream filter for warnings
+  class WarningFilter
+    include Equalizer.new(:target)
+
+    WARNING_PATTERN = /\A(?:.+):(?:\d+): warning: (?:.+)\n\z/
+
+    # Initialize object
+    #
+    # @param [#write] target
+    #
+    # @return [undefined]
+    def initialize(target)
+      @target   = target
+      @warnings = []
+    end
+
+    # Warnings captured by filter
+    #
+    # @return [Array<String>]
+    attr_reader :warnings
+
+    # Target stream to capture warnings on
+    #
+    # @return [#write] target
+    #
+    # @return [undefined]
+    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>]
+    def self.use
+      original = $stderr
+      $stderr = filter = new(original)
+      yield
+      filter.warnings
+    ensure
+      $stderr = original
+    end
+  end # WarningFilter
+end # Mutest

data/lib/mutest/zombifier.rb

@@ -0,0 +1,119 @@
+module Mutest
+  # Zombifier namespace
+  class Zombifier
+    include Anima.new(
+      :includes,
+      :load_path,
+      :kernel,
+      :namespace,
+      :pathname,
+      :require_highjack,
+      :root_require
+    )
+
+    private(*anima.attribute_names)
+
+    include AST::Sexp
+
+    LoadError = Class.new(::LoadError)
+
+    # Initialize object
+    #
+    # @param [Symbol] namespace
+    #
+    # @return [undefined]
+    def initialize(*)
+      super
+      @includes = %r{\A#{Regexp.union(includes)}(?:/.*)?\z}
+      @zombified = Set.new
+    end
+
+    # Call zombifier
+    #
+    # @return [self]
+    def self.call(*args)
+      new(*args).__send__(:call)
+      self
+    end
+
+    private
+
+    # Original require method
+    #
+    # @return [Method]
+    attr_reader :original
+
+    # Run zombifier
+    #
+    # @return [undefined]
+    def call
+      @original = require_highjack.call(method(:require))
+      require(root_require)
+    end
+
+    # Test if logical name is subjected to zombification
+    #
+    # @param [String]
+    def include?(logical_name)
+      !@zombified.include?(logical_name) && includes =~ logical_name
+    end
+
+    # Require file in zombie namespace
+    #
+    # @param [#to_s] logical_name
+    #
+    # @return [Bool]
+    #   true if successful and false if feature already loaded
+    def require(logical_name)
+      logical_name = logical_name.to_s
+      loaded = original.call(logical_name)
+      return loaded unless include?(logical_name)
+      @zombified << logical_name
+      zombify(find(logical_name))
+      true
+    end
+
+    # Find file by logical path
+    #
+    # @param [String] logical_name
+    #
+    # @return [File]
+    #
+    # @raise [LoadError]
+    #   otherwise
+    def find(logical_name)
+      file_name = "#{logical_name}.rb"
+
+      load_path.each do |path|
+        path = pathname.new(path).join(file_name)
+        return path if path.file?
+      end
+
+      fail LoadError, "Cannot find file #{file_name.inspect} in load path"
+    end
+
+    # Zombify contents of file
+    #
+    # Probably the 2nd valid use of eval ever. (First one is inserting mutests!).
+    #
+    # @param [Pathname] source_path
+    #
+    # @return [undefined]
+    def zombify(source_path)
+      kernel.eval(
+        Unparser.unparse(namespaced_node(source_path)),
+        TOPLEVEL_BINDING,
+        source_path.to_s
+      )
+    end
+
+    # Namespaced root node
+    #
+    # @param [Pathname] source_path
+    #
+    # @return [Parser::AST::Node]
+    def namespaced_node(source_path)
+      s(:module, s(:const, nil, namespace), ::Parser::CurrentRuby.parse(source_path.read))
+    end
+  end # Zombifier
+end # Mutest

data/meta/and.rb

@@ -0,0 +1,13 @@
+Mutest::Meta::Example.add :and do
+  source 'true and false'
+
+  singleton_mutations
+  mutation 'true'
+  mutation 'false'
+  mutation 'true or false'
+  mutation 'true and nil'
+  mutation 'nil and false'
+  mutation 'false and false'
+  mutation 'true and true'
+  mutation '!true and false'
+end

data/meta/and_asgn.rb

@@ -0,0 +1,12 @@
+Mutest::Meta::Example.add :and_asgn do
+  source 'a &&= 1'
+
+  singleton_mutations
+
+  mutation 'a__mutest__ &&= 1'
+  mutation 'a &&= nil'
+  mutation 'a &&= 0'
+  mutation 'a &&= -1'
+  mutation 'a &&= 2'
+  mutation 'a &&= self'
+end

data/meta/array.rb

@@ -0,0 +1,28 @@
+Mutest::Meta::Example.add :array do
+  source '[true]'
+
+  singleton_mutations
+  mutation 'true'
+  mutation '[false]'
+  mutation '[nil]'
+  mutation '[]'
+end
+
+Mutest::Meta::Example.add :array do
+  source '[true, false]'
+
+  singleton_mutations
+
+  # Mutation of each element in array
+  mutation '[nil, false]'
+  mutation '[false, false]'
+  mutation '[true, nil]'
+  mutation '[true, true]'
+
+  # Remove each element of array once
+  mutation '[true]'
+  mutation '[false]'
+
+  # Empty array
+  mutation '[]'
+end

data/meta/begin.rb

@@ -0,0 +1,19 @@
+Mutest::Meta::Example.add :begin do
+  source 'true; false'
+  # Mutation of each statement in block
+  mutation 'true; true'
+  mutation 'false; false'
+  mutation 'nil; false'
+  mutation 'true; nil'
+
+  # Delete each statement
+  mutation 'true'
+  mutation 'false'
+end
+
+Mutest::Meta::Example.add :begin do
+  source s(:begin, s(:true))
+  # Mutation of each statement in block
+  mutation s(:begin, s(:nil))
+  mutation s(:begin, s(:false))
+end

data/meta/block.rb

@@ -0,0 +1,104 @@
+Mutest::Meta::Example.add :block do
+  source 'foo { a; b }'
+
+  singleton_mutations
+  mutation 'foo { a }'
+  mutation 'foo { b }'
+  mutation 'foo {}'
+  mutation 'foo { raise }'
+  mutation 'foo { a; nil }'
+  mutation 'foo { a; self }'
+  mutation 'foo { nil; b }'
+  mutation 'foo { self; b }'
+  mutation 'foo'
+  mutation 'a; b'
+end
+
+Mutest::Meta::Example.add :block do
+  source 'foo { |a, b| }'
+
+  singleton_mutations
+  mutation 'foo'
+  mutation 'foo { |a, **b| }'
+  mutation 'foo { |a, b| raise }'
+  mutation 'foo { |a, _b| }'
+  mutation 'foo { |_a, b| }'
+  mutation 'foo { |a| }'
+  mutation 'foo { |b| }'
+  mutation 'foo { || }'
+end
+
+Mutest::Meta::Example.add :block do
+  source 'foo { |(a, b), c| }'
+
+  singleton_mutations
+  mutation 'foo { || }'
+  mutation 'foo { |(a, b), **c| }'
+  mutation 'foo { |a, b, c| }'
+  mutation 'foo { |(a, b), c| raise }'
+  mutation 'foo { |(a), c| }'
+  mutation 'foo { |(b), c| }'
+  mutation 'foo { |(a, b)| }'
+  mutation 'foo { |c| }'
+  mutation 'foo { |(_a, b), c| }'
+  mutation 'foo { |(a, _b), c| }'
+  mutation 'foo { |(a, b), _c| }'
+  mutation 'foo'
+end
+
+Mutest::Meta::Example.add :block do
+  source 'foo(a, b) {}'
+
+  singleton_mutations
+  mutation 'foo(a, nil) {}'
+  mutation 'foo(nil, b) {}'
+  mutation 'foo(self, b) {}'
+  mutation 'foo(a, self) {}'
+  mutation 'foo(a, b)'
+  mutation 'foo(a, b) { raise }'
+  mutation 'foo(a) {}'
+  mutation 'foo(b) {}'
+  mutation 'foo {}'
+end
+
+Mutest::Meta::Example.add :block do
+  source 'foo { |(a)| }'
+
+  singleton_mutations
+  mutation 'foo { || }'
+  mutation 'foo { |a| }'
+  mutation 'foo { |(a)| raise }'
+  mutation 'foo { |(_a)| }'
+  mutation 'foo'
+end
+
+Mutest::Meta::Example.add :block do
+  source 'foo { bar(nil) }'
+
+  singleton_mutations
+  mutation 'foo'
+  mutation 'foo { bar }'
+  mutation 'foo { nil }'
+  mutation 'foo {}'
+  mutation 'foo { self }'
+  mutation 'foo { raise }'
+  mutation 'foo.bar(nil)'
+  mutation 'bar(nil)'
+end
+
+Mutest::Meta::Example.add :block do
+  source 'foo { self << true }'
+
+  singleton_mutations
+  mutation 'foo { self << false }'
+  mutation 'foo { self << nil }'
+  mutation 'foo { nil << true }'
+  mutation 'foo { nil }'
+  mutation 'foo { self }'
+  mutation 'foo { true }'
+  mutation 'self << true'
+  mutation 'foo << true'
+  mutation 'foo { raise }'
+  mutation 'foo { }'
+  mutation 'foo'
+end

data/meta/block_pass.rb

@@ -0,0 +1,6 @@
+Mutest::Meta::Example.add :block_pass do
+  source 'foo(&bar)'
+
+  singleton_mutations
+  mutation 'foo'
+end

data/meta/blockarg.rb

@@ -0,0 +1,8 @@
+Mutest::Meta::Example.add :blockarg do
+  source 'foo { |&bar| }'
+
+  singleton_mutations
+  mutation 'foo { |&bar| raise }'
+  mutation 'foo {}'
+  mutation 'foo'
+end

data/meta/break.rb

@@ -0,0 +1,8 @@
+Mutest::Meta::Example.add :break do
+  source 'break true'
+
+  singleton_mutations
+  mutation 'break false'
+  mutation 'break nil'
+  mutation 'break'
+end

data/meta/case.rb

@@ -0,0 +1,221 @@
+Mutest::Meta::Example.add :case do
+  source <<-RUBY
+    case
+    when true
+    else
+    end
+  RUBY
+
+  singleton_mutations
+
+  mutation <<-RUBY
+    case
+    when true
+      raise
+    else
+    end
+  RUBY
+  mutation <<-RUBY
+    case
+    when false
+    else
+    end
+  RUBY
+  mutation <<-RUBY
+    case
+    when nil
+    else
+    end
+  RUBY
+end
+
+# rubocop:disable Metrics/BlockLength
+Mutest::Meta::Example.add :case do
+  source <<-RUBY
+    case condition
+    when A
+    when B, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  singleton_mutations
+
+  mutation <<-RUBY
+    case nil
+    when A
+    when B, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case self
+    when A
+    when B, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+      raise
+    when B, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when nil
+    when B, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when self
+    when B, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when B, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B, C
+      nil
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B, C
+      self
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when nil, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when self, C
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B, nil
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B, self
+      C
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    else
+      D
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B, C
+      C
+    else
+      nil
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B, C
+      C
+    else
+      self
+    end
+  RUBY
+
+  mutation <<-RUBY
+    case condition
+    when A
+    when B, C
+      C
+    end
+  RUBY
+end