mutiny 0.1.0

data/lib/mutiny/mutants/mutation/method/logical_operator_insertion.rb

@@ -0,0 +1,24 @@
+require "mutiny/mutants/mutation"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class LogicalOperatorInsertion < Mutation
+          def pattern
+            builder.either!(
+              builder.literal!(:int, builder.VAL),
+              builder.literal!(:send, nil, builder.VAL)
+            )
+          end
+
+          def replacement
+            builder.derivation! :& do |root|
+              builder.literal!(:send, root, :~)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/logical_operator_replacement.rb

@@ -0,0 +1,15 @@
+require_relative "helpers/infix_operator_replacement"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class LogicalOperatorReplacement < Helpers::InfixOperatorReplacement
+          def operator_names
+            %i(& | ^)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/relational_expression_replacement.rb

@@ -0,0 +1,19 @@
+require_relative "helpers/infix_operator_replacement"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class RelationalExpressionReplacement < Helpers::InfixOperatorReplacement
+          def operator_names
+            %i(< <= == != >= >)
+          end
+
+          def replacement
+            builder.either!(builder.true, builder.false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/relational_operator_replacement.rb

@@ -0,0 +1,15 @@
+require_relative "helpers/infix_operator_replacement"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class RelationalOperatorReplacement < Helpers::InfixOperatorReplacement
+          def operator_names
+            %i(< <= == != >= >)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/shortcut_assignment_operator_replacement.rb

@@ -0,0 +1,23 @@
+require_relative "helpers/operator_replacement"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class ShortcutAssignmentOperatorReplacement < Helpers::OperatorReplacement
+          def infix_operator_root
+            :op_asgn
+          end
+
+          def infix_operator_names
+            %i(+ - * / % ** & | ^ << >>)
+          end
+
+          def prefix_operator_names
+            %i(and_asgn or_asgn)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/unary_arithmetic_operator_deletion.rb

@@ -0,0 +1,29 @@
+require "mutiny/mutants/mutation"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class UnaryArithmeticOperatorDeletion < Mutation
+          def pattern # rubocop:disable Metrics/AbcSize
+            builder.either!(
+              builder.literal!(:int, builder.VAL { |val| val.name < 0 }),
+              builder.literal!(:float, builder.VAL { |val| val.name < 0 }),
+              builder.literal!(:send, builder.VAL, :-@)
+            )
+          end
+
+          def replacement
+            builder.derivation! :val, :& do |val, root|
+              if val.name.is_a?(Numeric)
+                builder.literal!(root.name, -val.name)
+              else
+                val
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/unary_arithmetic_operator_insertion.rb

@@ -0,0 +1,29 @@
+require "mutiny/mutants/mutation"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class UnaryArithmeticOperatorInsertion < Mutation
+          def pattern # rubocop:disable Metrics/AbcSize
+            builder.either!(
+              builder.literal!(:int, builder.VAL { |val| val.name > 0 }),
+              builder.literal!(:float, builder.VAL { |val| val.name > 0 }),
+              builder.literal!(:send, nil, builder.VAL)
+            )
+          end
+
+          def replacement
+            builder.derivation! :val, :& do |val, root|
+              if val.name.is_a?(Numeric)
+                builder.literal!(root.name, -val.name)
+              else
+                builder.literal!(:send, root, :-@)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation.rb

@@ -0,0 +1,10 @@
+require "metamorpher"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      include Metamorpher::Mutator
+      include Metamorpher::Builders::AST
+    end
+  end
+end

data/lib/mutiny/mutants/mutation_set.rb

@@ -0,0 +1,24 @@
+require_relative "mutant_set"
+
+module Mutiny
+  module Mutants
+    class MutationSet
+      def initialize(*mutations)
+        @mutations = mutations
+      end
+
+      # TODO : would performance improve by iterating over subjects than over operators?
+      # Probably could improve (more) if metamorpher also supported composite transformers so that
+      # several mutation operators could be matched simulatenously during a single AST traversal
+      def mutate(subjects)
+        MutantSet.new.tap do |mutants|
+          @mutations.each do |mutation|
+            subjects.each do |subject|
+              mutants.add(subject, mutation.mutate_file(subject.path))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/ruby.rb

@@ -0,0 +1,42 @@
+require_relative "mutation_set"
+require_relative "mutation/method/binary_arithmetic_operator_replacement"
+require_relative "mutation/method/conditional_operator_deletion"
+require_relative "mutation/method/conditional_operator_insertion"
+require_relative "mutation/method/conditional_operator_replacement"
+require_relative "mutation/method/relational_expression_replacement"
+require_relative "mutation/method/relational_operator_replacement"
+require_relative "mutation/method/logical_operator_deletion"
+require_relative "mutation/method/logical_operator_insertion"
+require_relative "mutation/method/logical_operator_replacement"
+require_relative "mutation/method/shortcut_assignment_operator_replacement"
+require_relative "mutation/method/unary_arithmetic_operator_deletion"
+require_relative "mutation/method/unary_arithmetic_operator_insertion"
+
+module Mutiny
+  module Mutants
+    class Ruby
+      def mutants_for(subjects)
+        mutations.mutate(subjects)
+      end
+
+      private
+
+      def mutations # rubocop:disable Metrics/MethodLength
+        @operators ||= MutationSet.new(
+          Mutation::Method::BinaryArithmeticOperatorReplacement.new,
+          Mutation::Method::ConditionalOperatorDeletion.new,
+          Mutation::Method::ConditionalOperatorInsertion.new,
+          Mutation::Method::ConditionalOperatorReplacement.new,
+          Mutation::Method::RelationalExpressionReplacement.new,
+          Mutation::Method::RelationalOperatorReplacement.new,
+          Mutation::Method::LogicalOperatorDeletion.new,
+          Mutation::Method::LogicalOperatorInsertion.new,
+          Mutation::Method::LogicalOperatorReplacement.new,
+          Mutation::Method::ShortcutAssignmentOperatorReplacement.new,
+          Mutation::Method::UnaryArithmeticOperatorDeletion.new,
+          Mutation::Method::UnaryArithmeticOperatorInsertion.new
+        )
+      end
+    end
+  end
+end

data/lib/mutiny/pattern.rb

@@ -0,0 +1,17 @@
+module Mutiny
+  class Pattern
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def match?(identifier)
+      raw == "*" || identifier.start_with?(raw)
+    end
+
+    def to_s
+      raw
+    end
+  end
+end

data/lib/mutiny/reporter/stdout.rb

@@ -0,0 +1,9 @@
+module Mutiny
+  module Reporter
+    class Stdout
+      def report(message)
+        puts message
+      end
+    end
+  end
+end

data/lib/mutiny/subjects/environment/type.rb

@@ -0,0 +1,54 @@
+module Mutiny
+  module Subjects
+    class Environment
+      class Type
+        attr_reader :mod, :configuration
+
+        def initialize(mod, configuration)
+          @mod = mod
+          @configuration = configuration
+        end
+
+        def relevant?
+          !name.nil? && in_scope? && loadable?
+        end
+
+        def to_subject
+          Subject.new(name: name, path: absolute_path, root: load_path)
+        end
+
+        private
+
+        def name
+          mod.name
+        end
+
+        def in_scope?
+          configuration.patterns.any? { |pattern| pattern.match?(name) }
+        end
+
+        def loadable?
+          !load_path.nil?
+        end
+
+        def load_path
+          configuration.load_paths.detect do |load_path|
+            source_locations.any? { |locs| locs.start_with?(load_path) }
+          end
+        end
+
+        def source_locations
+          mod.instance_methods(false)
+            .map { |method_name| mod.instance_method(method_name).source_location }
+            .reject(&:nil?)
+            .map(&:first)
+            .uniq
+        end
+
+        def absolute_path
+          source_locations.first
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/subjects/environment.rb

@@ -0,0 +1,25 @@
+require_relative "environment/type"
+
+module Mutiny
+  module Subjects
+    class Environment
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        configuration.loads.each { |l| $LOAD_PATH << l }
+        configuration.requires.each { |r| require r }
+      end
+
+      def subjects
+        SubjectSet.new(modules.select(&:relevant?).map(&:to_subject))
+      end
+
+      private
+
+      def modules
+        ObjectSpace.each_object(Module).map { |mod| Type.new(mod, configuration) }
+      end
+    end
+  end
+end

data/lib/mutiny/subjects/subject.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+
+module Mutiny
+  module Subjects
+    class Subject
+      attr_reader :name, :path, :root
+
+      def initialize(name:, path: nil, root: nil)
+        @name = name
+        @path = path
+        @root = root
+      end
+
+      def relative_path
+        absolute_path = Pathname.new(path)
+        root_path = Pathname.new(root)
+
+        absolute_path.relative_path_from(root_path).to_s
+      end
+
+      def eql?(other)
+        is_a?(other.class) && other.name == name && other.path == path && other.root == root
+      end
+
+      alias_method "==", "eql?"
+
+      def hash
+        [name, path, root].hash
+      end
+    end
+  end
+end

data/lib/mutiny/subjects/subject_set.rb

@@ -0,0 +1,17 @@
+module Mutiny
+  module Subjects
+    class SubjectSet
+      def initialize(subjects)
+        @subjects = subjects
+      end
+
+      def names
+        @names ||= @subjects.map(&:name).sort
+      end
+
+      def each(&block)
+        @subjects.each(&block)
+      end
+    end
+  end
+end

data/lib/mutiny/subjects.rb

@@ -0,0 +1,3 @@
+require_relative "subjects/subject"
+require_relative "subjects/subject_set"
+require_relative "subjects/environment"

data/lib/mutiny/tests/test.rb

@@ -0,0 +1,12 @@
+module Mutiny
+  module Tests
+    class Test
+      attr_reader :location, :expression
+
+      def initialize(location: nil, expression:)
+        @location = location
+        @expression = expression
+      end
+    end
+  end
+end

data/lib/mutiny/tests/test_run.rb

@@ -0,0 +1,18 @@
+module Mutiny
+  module Tests
+    class TestRun
+      attr_reader :tests, :failed_tests, :output, :runtime
+
+      def initialize(tests:, failed_tests:, output:, runtime:)
+        @tests = tests
+        @failed_tests = failed_tests
+        @output = output
+        @runtime = runtime
+      end
+
+      def passed?
+        failed_tests.empty?
+      end
+    end
+  end
+end

data/lib/mutiny/tests/test_set.rb

@@ -0,0 +1,44 @@
+require "forwardable"
+
+module Mutiny
+  module Tests
+    class TestSet
+      extend Forwardable
+      def_delegators :tests, :size, :empty?, :hash
+
+      def self.empty
+        new([])
+      end
+
+      def initialize(tests)
+        @tests = tests
+      end
+
+      def locations
+        tests.map(&:location)
+      end
+
+      def for(subject_set)
+        subset { |test| subject_set.names.include?(test.expression) }
+      end
+
+      def subset(&block)
+        self.class.new(tests.select(&block))
+      end
+
+      def take(n)
+        self.class.new(tests.take(n))
+      end
+
+      def eql?(other)
+        is_a?(other.class) && other.tests == tests
+      end
+
+      alias_method "==", "eql?"
+
+      protected
+
+      attr_reader :tests
+    end
+  end
+end

data/lib/mutiny/tests.rb

@@ -0,0 +1,3 @@
+require_relative "tests/test"
+require_relative "tests/test_set"
+require_relative "tests/test_run"

data/lib/mutiny/version.rb

@@ -0,0 +1,3 @@
+module Mutiny
+  VERSION = "0.1.0"
+end

data/lib/mutiny.rb

@@ -0,0 +1,4 @@
+require_relative "mutiny/configuration"
+require_relative "mutiny/subjects"
+require_relative "mutiny/tests"
+require_relative "mutiny/mode"

data/mutiny.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mutiny/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mutiny"
+  spec.version       = Mutiny::VERSION
+  spec.authors       = ["Louis Rose"]
+  spec.email         = ["louis.rose@york.ac.uk"]
+  spec.description   = %q{A tiny and experimental mutation testing framework for exploring research ideas.}
+  spec.summary       = %q{A tiny mutation testing framework for Ruby}
+  spec.homepage      = "https://github.com/mutiny/mutiny"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "parser", "~> 2.2.2"
+  spec.add_runtime_dependency "unparser", "~> 0.2.4"
+  spec.add_runtime_dependency "gli", "~> 2.13.0"
+  spec.add_runtime_dependency "metamorpher", "~> 0.2.2"
+
+  spec.add_development_dependency "bundler", "~> 1.10.2"
+  spec.add_development_dependency "rake", "~> 10.4.2"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+  spec.add_development_dependency "aruba", "~> 0.6.0"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4.6"
+  spec.add_development_dependency "rubocop", "~> 0.31.0"
+end

data/spec/integration/check_spec.rb

@@ -0,0 +1,39 @@
+describe "Using Mutiny to check whether mutation testing can be carried out" do
+  it "should report success for a valid setup" do
+    cd "calculator"
+    run "bundle exec mutiny check"
+
+    expected_output = "Checking...\n" \
+                      "  At least one relevant test found (6 in total)\n" \
+                      "  All relevant tests passed\n" \
+                      "Looks good!\n"
+
+    expect(all_output).to eq(expected_output)
+  end
+
+  it "should report failure when there are no relevant tests" do
+    cd "untested_calculator"
+    run "bundle exec mutiny -r calculator check"
+
+    expected_output = "Checking...\n" \
+                      "  No relevant tests found (for modules matching '*')\n" \
+                      "Either your mutiny configuration is wrong, or you're missing some tests!\n"
+
+    expect(all_output).to eq(expected_output)
+  end
+
+  it "should report warning when there are failing tests" do
+    cd "buggy_calculator"
+    run "bundle exec mutiny -r calculator check"
+
+    expected_output = "Checking...\n" \
+                      "  At least one relevant test found (3 in total)\n" \
+                      "  Not all relevant tests passed. The failing tests are:\n" \
+                      "    ./spec/calculator/max_spec.rb:9\n" \
+                      "    ./spec/calculator/max_spec.rb:13\n" \
+                      "\n" \
+                      "Looks ok, but note that mutiny is most effective when all tests pass.\n"
+
+    expect(all_output).to eq(expected_output)
+  end
+end

data/spec/integration/mutate_spec.rb

@@ -0,0 +1,35 @@
+describe "Using Mutiny to generate mutants" do
+  it "should report statistics of generated mutants" do
+    cd "calculator"
+    run "bundle exec mutiny mutate"
+
+    expected_output = "Mutating...\n" \
+                      "Generated 14 mutants:\n" \
+                      "  * calculator/max.rb - 7 mutants\n" \
+                      "  * calculator/min.rb - 7 mutants\n" \
+                      "Check the '.mutants' directory to browse the generated mutants.\n"
+
+    expect(all_output).to eq(expected_output)
+  end
+
+  it "should write mutants to the .mutants directory" do
+    cd "calculator"
+    run "bundle exec mutiny mutate"
+
+    check_file_content(".mutants/calculator/min.0.rb", /if true/)
+    check_file_content(".mutants/calculator/min.1.rb", /if false/)
+    check_file_content(".mutants/calculator/min.2.rb", /if right <= left/)
+    check_file_content(".mutants/calculator/min.3.rb", /if right == left/)
+    check_file_content(".mutants/calculator/min.4.rb", /if right != left/)
+    check_file_content(".mutants/calculator/min.5.rb", /if right >= left/)
+    check_file_content(".mutants/calculator/min.6.rb", /if right > left/)
+
+    check_file_content(".mutants/calculator/max.0.rb", /if true/)
+    check_file_content(".mutants/calculator/max.1.rb", /if false/)
+    check_file_content(".mutants/calculator/max.2.rb", /if right < left/)
+    check_file_content(".mutants/calculator/max.3.rb", /if right <= left/)
+    check_file_content(".mutants/calculator/max.4.rb", /if right == left/)
+    check_file_content(".mutants/calculator/max.5.rb", /if right != left/)
+    check_file_content(".mutants/calculator/max.6.rb", /if right >= left/)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+require 'rspec/core/sandbox'
+require 'rspec/support/spec/stderr_splitter'
+require 'rspec/support/spec/in_sub_process'
+
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+Dir["./spec/support/**/*.rb"].each { |f| require f }
+
+require "mutiny"
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  # Isolate mutiny-under-test from its own test suite
+  config.around(:example) do |example|
+    RSpec::Core::Sandbox.sandboxed do
+      example.run
+    end
+  end
+
+  # Make in_sub_process method available for any tests that need
+  # to pollute the Ruby environment (e.g., change the ObjectSpace)
+  config.include RSpec::Support::InSubProcess
+end

data/spec/support/aruba.rb

@@ -0,0 +1,12 @@
+require 'aruba/api'
+require 'aruba/reporting'
+
+RSpec.configure do |config|
+  config.include Aruba::Api
+
+  config.before(:each) do
+    @dirs = [File.join(Dir.pwd, "examples")]
+    restore_env
+    set_env "GLI_DEBUG", "true"
+  end
+end