mutiny 0.1.0

data/examples/untested_calculator/spec/spec_helper.rb

@@ -0,0 +1,89 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # These two settings work together to allow you to limit a spec run
+  #   # to individual examples or groups you care about by tagging them with
+  #   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  #   # get run.
+  #   config.filter_run :focus
+  #   config.run_all_when_everything_filtered = true
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  #   if config.files_to_run.one?
+  #     # Use the documentation formatter for detailed output,
+  #     # unless a formatter has already been configured
+  #     # (e.g. via a command-line flag).
+  #     config.default_formatter = 'doc'
+  #   end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # 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
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+end

data/lib/mutiny/configuration.rb

@@ -0,0 +1,25 @@
+require_relative 'pattern'
+require_relative 'reporter/stdout'
+require_relative 'integration/rspec'
+require_relative 'mutants/ruby'
+
+module Mutiny
+  class Configuration
+    attr_reader :loads, :requires, :patterns, :reporter, :integration, :mutator
+
+    def initialize(loads: [], requires: [], patterns: [])
+      @loads = loads
+      @requires = requires
+      @patterns = patterns
+      @patterns.map!(&Pattern.method(:new))
+
+      @reporter = Reporter::Stdout.new
+      @integration = Integration::RSpec.new
+      @mutator = Mutants::Ruby.new
+    end
+
+    def load_paths
+      loads.map(&File.method(:expand_path))
+    end
+  end
+end

data/lib/mutiny/integration/rspec/context.rb

@@ -0,0 +1,26 @@
+require "rspec/core"
+require "stringio"
+
+module Mutiny
+  class Integration
+    class RSpec
+      # This code originally based on Markus Schirp's implementation of Mutant::Integration::Rspec
+      #  https://github.com/mbj/mutant/blob/master/lib/mutant/integration/rspec.rb
+      class Context
+        # NB: the --fail-fast option can be used in order to find only the first failing test
+        # CLI_OPTIONS = %w(spec --fail-fast)
+        CLI_OPTIONS = %w(spec)
+
+        attr_reader :runner, :world, :configuration, :output
+
+        def initialize
+          @output = StringIO.new
+          @world  = ::RSpec.world
+          @configuration = ::RSpec.configuration
+          @runner = ::RSpec::Core::Runner.new(::RSpec::Core::ConfigurationOptions.new(CLI_OPTIONS))
+          @runner.setup($stderr, @output)
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/integration/rspec/parser.rb

@@ -0,0 +1,36 @@
+require_relative "test"
+require_relative "test_set"
+
+module Mutiny
+  class Integration
+    class RSpec
+      # This code originally based on Markus Schirp's implementation of Mutant::Integration::Rspec
+      #  https://github.com/mbj/mutant/blob/master/lib/mutant/integration/rspec.rb
+      class Parser
+        EXPRESSION_DELIMITER = " "
+
+        def initialize(context = Context.new)
+          @world = context.world
+        end
+
+        def call
+          TestSet.new(all_examples.map(&method(:parse_example)))
+        end
+
+        private
+
+        def all_examples
+          @world.example_groups.flat_map(&:descendants).flat_map(&:examples)
+        end
+
+        def parse_example(example)
+          metadata = example.metadata
+          location = metadata.fetch(:location)
+          expression = metadata.fetch(:full_description).split(EXPRESSION_DELIMITER, 2).first
+
+          Test.new(location: location, expression: expression, example: example)
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/integration/rspec/runner.rb

@@ -0,0 +1,58 @@
+require "forwardable"
+
+module Mutiny
+  class Integration
+    class RSpec
+      # This code originally based on Markus Schirp's implementation of Mutant::Integration::Rspec
+      #  https://github.com/mbj/mutant/blob/master/lib/mutant/integration/rspec.rb
+      class Runner
+        extend Forwardable
+        def_delegators :@context, :world, :runner, :configuration, :output
+
+        def initialize(test_set, context = Context.new)
+          @test_set = test_set
+          @context = context
+        end
+
+        def call
+          reset
+          prepare
+          run
+        end
+
+        private
+
+        def reset
+          @failed_examples = []
+        end
+
+        def prepare
+          filter_examples
+          configuration.reporter.register_listener(self, :example_failed)
+        end
+
+        def run
+          start = Time.now
+          runner.run_specs(world.ordered_example_groups)
+          output.rewind
+          Tests::TestRun.new(
+            tests: @test_set,
+            failed_tests: @test_set.subset_for_examples(@failed_examples),
+            output: output.read,
+            runtime: Time.now - start
+          )
+        end
+
+        def example_failed(notification)
+          @failed_examples << notification.example
+        end
+
+        def filter_examples
+          world.filtered_examples.each_value do |example|
+            example.keep_if(&@test_set.examples.method(:include?))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/integration/rspec/test.rb

@@ -0,0 +1,16 @@
+require_relative "../../tests"
+
+module Mutiny
+  class Integration
+    class RSpec
+      class Test < Tests::Test
+        attr_reader :example
+
+        def initialize(example:, **rest)
+          super(rest)
+          @example = example
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/integration/rspec/test_set.rb

@@ -0,0 +1,17 @@
+require_relative "../../tests"
+
+module Mutiny
+  class Integration
+    class RSpec
+      class TestSet < Tests::TestSet
+        def examples
+          @tests.map(&:example)
+        end
+
+        def subset_for_examples(examples)
+          subset { |test| examples.include?(test.example) }
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/integration/rspec.rb

@@ -0,0 +1,25 @@
+require_relative "rspec/context"
+require_relative "rspec/parser"
+require_relative "rspec/runner"
+
+module Mutiny
+  class Integration
+    # This code originally based on Markus Schirp's implementation of Mutant::Integration::Rspec
+    #  https://github.com/mbj/mutant/blob/master/lib/mutant/integration/rspec.rb
+    class RSpec
+      def tests
+        Parser.new(context).call
+      end
+
+      def run(test_set)
+        Runner.new(test_set, context).call
+      end
+
+      private
+
+      def context
+        @context ||= Context.new
+      end
+    end
+  end
+end

data/lib/mutiny/mode/check.rb

@@ -0,0 +1,62 @@
+require_relative "../integration/rspec"
+
+module Mutiny
+  class Mode
+    class Check < self
+      def run
+        report "Checking..."
+
+        if test_set.empty?
+          report_invalid
+
+        elsif test_run.passed?
+          report_valid
+
+        else
+          report_warning
+        end
+      end
+
+      private
+
+      def report_invalid
+        report "  No relevant tests found (for modules matching '#{pattern_string}')"
+        report "Either your mutiny configuration is wrong, or you're missing some tests!"
+      end
+
+      def report_warning
+        report "  At least one relevant test found (#{test_set.size} in total)"
+        report "  Not all relevant tests passed. The failing tests are:\n"
+
+        failed_test_locations.each do |location|
+          report "    #{location}"
+        end
+
+        report ""
+        report "Looks ok, but note that mutiny is most effective when all tests pass."
+      end
+
+      def report_valid
+        report "  At least one relevant test found (#{test_set.size} in total)"
+        report "  All relevant tests passed"
+        report "Looks good!"
+      end
+
+      def pattern_string
+        configuration.patterns.join(',')
+      end
+
+      def failed_test_locations
+        test_run.failed_tests.locations
+      end
+
+      def test_set
+        @test_set ||= configuration.integration.tests.for(environment.subjects)
+      end
+
+      def test_run
+        @test_run ||= configuration.integration.run(test_set)
+      end
+    end
+  end
+end

data/lib/mutiny/mode/mutate.rb

@@ -0,0 +1,29 @@
+module Mutiny
+  class Mode
+    class Mutate < self
+      def run
+        report "Mutating..."
+        report_mutant_summary
+        store_mutants
+      end
+
+      private
+
+      def report_mutant_summary
+        report "Generated #{mutant_set.size} mutants:"
+        mutant_set.group_by_subject.sort_by { |s, _| s.relative_path }.each do |subject, mutants|
+          report "  * #{subject.relative_path} - #{mutants.size} mutants"
+        end
+      end
+
+      def store_mutants
+        mutant_set.store
+        report "Check the '.mutants' directory to browse the generated mutants."
+      end
+
+      def mutant_set
+        @mutant_set ||= configuration.mutator.mutants_for(environment.subjects)
+      end
+    end
+  end
+end

data/lib/mutiny/mode.rb

@@ -0,0 +1,19 @@
+require_relative "mode/check"
+require_relative "mode/mutate"
+
+module Mutiny
+  class Mode
+    attr_reader :configuration, :environment
+
+    def initialize(configuration)
+      @configuration = configuration
+      @environment = Subjects::Environment.new(configuration)
+    end
+
+    private
+
+    def report(message)
+      configuration.reporter.report(message)
+    end
+  end
+end

data/lib/mutiny/mutants/mutant.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+module Mutiny
+  module Mutants
+    class Mutant
+      attr_reader :subject, :code
+
+      def initialize(subject:, code:)
+        @subject = subject
+        @code = code
+      end
+
+      def store(directory, index)
+        filename = subject.relative_path.sub(/\.rb$/, ".#{index}.rb")
+        path = File.join(directory, filename)
+
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'w') { |f| f.write(code) }
+      end
+
+      def eql?(other)
+        is_a?(other.class) && other.subject == subject && other.code == code
+      end
+
+      alias_method "==", "eql?"
+
+      def hash
+        [subject, code].hash
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutant_set.rb

@@ -0,0 +1,42 @@
+require_relative "mutant"
+
+module Mutiny
+  module Mutants
+    class MutantSet
+      def initialize
+        @mutants_by_subject = Hash.new([])
+      end
+
+      def add(subject, mutated_code)
+        mutants = mutated_code.map { |code| create_mutant(subject, code) }
+        @mutants_by_subject[subject] = @mutants_by_subject[subject] + mutants
+      end
+
+      def size
+        mutants.size
+      end
+
+      def group_by_subject
+        @mutants_by_subject.dup
+      end
+
+      def store(mutant_directory = ".mutants")
+        group_by_subject.each do |_, mutants|
+          mutants.each_with_index { |mutant, index| mutant.store(mutant_directory, index) }
+        end
+      end
+
+      protected
+
+      def create_mutant(subject, code)
+        Mutant.new(subject: subject, code: code)
+      end
+
+      private
+
+      def mutants
+        @mutants_by_subject.values.flatten
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+require "mutiny/mutants/mutation"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class ConditionalOperatorDeletion < Mutation
+          def pattern
+            builder.literal!(:send, builder.VAL, :!)
+          end
+
+          def replacement
+            builder.derivation!(:val)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "mutiny/mutants/mutation"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class ConditionalOperatorInsertion < Mutation
+          def pattern
+            builder.either!(
+              builder.true,
+              builder.false,
+              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/conditional_operator_replacement.rb

@@ -0,0 +1,19 @@
+require_relative "helpers/operator_replacement"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class ConditionalOperatorReplacement < Helpers::OperatorReplacement
+          def infix_operator_names
+            %i(^)
+          end
+
+          def prefix_operator_names
+            %i(and or)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/helpers/infix_operator_replacement.rb

@@ -0,0 +1,17 @@
+require_relative "operator_replacement"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        module Helpers
+          class InfixOperatorReplacement < OperatorReplacement
+            def operators
+              operator_names.map { |name| InfixOperator.new(name) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutation/method/helpers/operator_replacement.rb

@@ -0,0 +1,81 @@
+require "mutiny/mutants/mutation"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        module Helpers
+          class OperatorReplacement < Mutation
+            def pattern
+              builder.either!(
+                *operators.map { |ot| ot.build_pattern(builder) }
+              )
+            end
+
+            def replacement
+              builder.derivation! :left, :right, :& do |left, right, root|
+                builder.either!(*mutations_for(left, operator_name_from(root), right))
+              end
+            end
+
+            private
+
+            def operator_name_from(root)
+              # the operator is the root element when prefix (2 children)
+              # and is the middle child when infix (3 children)
+              root.children.size == 2 ? root : root.children[1]
+            end
+
+            def mutations_for(left, original_operator, right)
+              operators
+                .reject { |o| o.name == original_operator.name }
+                .map { |o| o.build_literal(builder, left, right) }
+            end
+
+            def operators
+              infix_operator_names.map { |op| InfixOperator.new(op, infix_operator_root) } +
+                prefix_operator_names.map { |op| PrefixOperator.new(op) }
+            end
+
+            def infix_operator_root
+              :send
+            end
+
+            class PrefixOperator
+              attr_reader :name
+
+              def initialize(name)
+                @name = name
+              end
+
+              def build_pattern(builder)
+                builder.literal!(name, builder.LEFT, builder.RIGHT)
+              end
+
+              def build_literal(builder, left, right)
+                builder.literal!(name, left, right)
+              end
+            end
+
+            class InfixOperator
+              attr_reader :name, :root
+
+              def initialize(name, root = :send)
+                @name = name
+                @root = root
+              end
+
+              def build_pattern(builder)
+                builder.literal!(root, builder.LEFT, name, builder.RIGHT)
+              end
+
+              def build_literal(builder, left, right)
+                builder.literal!(root, left, builder.literal!(name), right)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "mutiny/mutants/mutation"
+
+module Mutiny
+  module Mutants
+    class Mutation
+      module Method
+        class LogicalOperatorDeletion < Mutation
+          def pattern
+            builder.literal!(:send, builder.VAL, :~)
+          end
+
+          def replacement
+            builder.derivation!(:val)
+          end
+        end
+      end
+    end
+  end
+end