mutiny 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 346e69f9b36cf9c2a778b2e62bd51571d171e0f1
-  data.tar.gz: 7b08e6ec512f813849038ef15ef718d0b415bafd
+  metadata.gz: b3b90916fcddcbfd2b6d6b373927154110c8d1a0
+  data.tar.gz: f8d277e9dc277bdde93a449e8a10018be5c96859
 SHA512:
-  metadata.gz: 0cdfbdd49e7349e67cc27fc48a28031a4fe3931952c1bdf13d823a99832b93836f0f59e91aae11d1aa6ffb05cc022d1d7d07d21b377cbf99fc457dbf94aef28e
-  data.tar.gz: 0229bca2450718da9ed3484c5070fd8a6d524cca72392621582c63ef4e59a107b40d93698ec787913a2b4e454621a05e7b48916e356cd20a2e5de0beac5eed05
+  metadata.gz: 74a0c7772807505bc0d79f386fcd958d53ff1466cef6bb6053fe6ba2d978bf07b9fbfe17bb6db1c8243bf30a1750bcc9d8f8273fe902ab5360f62f305d45f7d8
+  data.tar.gz: 3180029d832460442147ff1623b4f535318a1226b1312d41232a736546475fce1f793827a0f16a4ae12e354a7f77d0ad3099f487f0fd21700b048c9a0f60e218

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
-  - 2.2.2
+  - 2.2.3
 addons:
   code_climate:
     repo_token: 0297c93e8cb012ae60aa0760b795608f96c681e1493d98153d5cd7bd97e3b650

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mutiny (0.2.3)
+    mutiny (0.2.4)
       gli (~> 2.13.0)
       metamorpher (~> 0.2.2)
       parser (~> 2.2.2)

data/RELEASES.md

@@ -1,5 +1,9 @@
 # Release History
 
+## v0.2.4 (10 February 2016)
+* Add --cached switch to the score command, which loads mutants from disk rather than generating them anew.
+* Various changes to improve extensibility (i.e., mutant storage, test selection) and capabilities (i.e., mutant location and test hooks).
+
 ## v0.2.3 (26 January 2016)
 * Add mutation name to each mutant written to disk
 * Update to Ruby 2.2.3

data/bin/mutiny

@@ -39,8 +39,11 @@ end
 desc 'Calculates a mutation score for your project'
 long_desc 'Calculates a mutation score for your project and displays a list of surviving mutants'
 command :score do |c|
-  c.action do
-    Mutiny::Mode::Score.new(@configuration).run
+  cached_desc = 'Use the mutants in "./.mutants" rather than generating mutants before scoring'
+  c.switch [:c, :cached], desc: cached_desc, negatable: false
+  c.action do |_, options, _|
+    cached = options.fetch(:cached, false)
+    Mutiny::Mode::Score.new(@configuration, cached: cached).run
   end
 end
 

data/lib/mutiny/analysis/analyser.rb

@@ -11,26 +11,20 @@ module Mutiny
       end
 
       def call
-        analyse_all
-        results
-      end
-
-      private
+        results = Results.new
 
-      def analyse_all
         mutant_set.mutants.each do |mutant|
-          mutant.apply
-          test_run = integration.test(mutant.subject) unless mutant.stillborn?
-          results.add(mutant, test_run)
+          results.add(mutant, analyse(mutant))
         end
-      end
 
-      def results
-        @results ||= Results.new
+        results
       end
 
-      def mutant_set
-        @mutant_set ||= configuration.mutator.mutants_for(environment.subjects)
+      private
+
+      def analyse(mutant)
+        mutant.apply
+        mutant.stillborn? ? nil : integration.test(mutant)
       end
     end
   end

data/lib/mutiny/configuration.rb

@@ -1,11 +1,13 @@
 require_relative 'pattern'
 require_relative 'reporter/stdout'
+require_relative 'tests/selection/default'
 require_relative 'integration/rspec'
 require_relative 'mutants/ruby'
+require_relative 'mutants/storage'
 
 module Mutiny
   class Configuration
-    attr_reader :loads, :requires, :patterns, :reporter, :integration, :mutator
+    attr_reader :loads, :requires, :patterns, :reporter, :mutants, :tests
 
     def initialize(loads: [], requires: [], patterns: [])
       @loads = loads
@@ -14,8 +16,8 @@ module Mutiny
       @patterns.map!(&Pattern.method(:new))
 
       @reporter = Reporter::Stdout.new
-      @integration = Integration::RSpec.new
-      @mutator = Mutants::Ruby.new
+      @mutants = Mutants.new
+      @tests = Tests.new
     end
 
     def load_paths
@@ -25,5 +27,23 @@ module Mutiny
     def can_load?(source_path)
       load_paths.any? { |load_path| source_path.start_with?(load_path) }
     end
+
+    class Mutants
+      attr_reader :mutator, :storage
+
+      def initialize
+        @mutator = Mutiny::Mutants::Ruby.new
+        @storage = Mutiny::Mutants::Storage.new
+      end
+    end
+
+    class Tests
+      attr_reader :selection, :integration
+
+      def initialize
+        @selection = Mutiny::Tests::Selection::Default.new
+        @integration = Mutiny::Integration::RSpec.new(@selection)
+      end
+    end
   end
 end

data/lib/mutiny/integration/hook.rb

@@ -0,0 +1,11 @@
+module Mutiny
+  class Integration
+    class Hook
+      def before(_example)
+      end
+
+      def after(_example)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Mutiny
+  class Integration
+    class RSpec < self
+      class Hook
+        attr_reader :hook
+
+        def initialize(hook)
+          @hook = hook
+        end
+
+        def install(configuration)
+          configuration.reporter.register_listener(self, :example_started)
+          configuration.reporter.register_listener(self, :example_failed)
+          configuration.reporter.register_listener(self, :example_passed)
+        end
+
+        def example_started(notification)
+          example = notification.example
+          hook.before(example) unless example.pending? || example.skipped?
+        end
+
+        def example_failed(notification)
+          hook.after(notification.example)
+        end
+
+        def example_passed(notification)
+          hook.after(notification.example)
+        end
+      end
+    end
+  end
+end

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

@@ -9,9 +9,10 @@ module Mutiny
         extend Forwardable
         def_delegators :@context, :world, :runner, :configuration, :output
 
-        def initialize(test_set, context = Context.new)
+        def initialize(test_set, context = Context.new, hooks = [])
           @test_set = test_set
           @context = context
+          @hooks = hooks
         end
 
         def call
@@ -28,9 +29,9 @@ module Mutiny
         end
 
         def prepare
+          install_hooks
           filter_examples
-          configuration.reporter.register_listener(self, :example_passed)
-          configuration.reporter.register_listener(self, :example_failed)
+          listen_for_example_results
         end
 
         def run
@@ -51,12 +52,8 @@ module Mutiny
           )
         end
 
-        def example_passed(notification)
-          @passed_examples << notification.example
-        end
-
-        def example_failed(notification)
-          @failed_examples << notification.example
+        def install_hooks
+          @hooks.each { |hook| hook.install(configuration) }
         end
 
         def filter_examples
@@ -64,6 +61,19 @@ module Mutiny
             example.keep_if(&@test_set.examples.method(:include?))
           end
         end
+
+        def listen_for_example_results
+          configuration.reporter.register_listener(self, :example_passed)
+          configuration.reporter.register_listener(self, :example_failed)
+        end
+
+        def example_passed(notification)
+          @passed_examples << notification.example
+        end
+
+        def example_failed(notification)
+          @failed_examples << notification.example
+        end
       end
     end
   end

data/lib/mutiny/integration/rspec.rb

@@ -1,6 +1,7 @@
 require_relative "rspec/context"
 require_relative "rspec/parser"
 require_relative "rspec/runner"
+require_relative "rspec/hook"
 
 module Mutiny
   class Integration
@@ -11,8 +12,9 @@ module Mutiny
         Parser.new(context(options)).call
       end
 
-      def run(test_set, options = {})
-        Runner.new(test_set, context(options)).call
+      def run(test_set, hooks: [], **options)
+        rspec_hooks = hooks.map { |hook| RSpec::Hook.new(hook) }
+        Runner.new(test_set, context(options), rspec_hooks).call
       end
 
       private

data/lib/mutiny/integration.rb

@@ -1,11 +1,18 @@
+require_relative "tests/selection/default"
 require_relative "isolation"
 
 module Mutiny
   class Integration
-    def test(subject)
+    attr_reader :test_selection
+
+    def initialize(test_selection = Tests::Selection::Default.new)
+      @test_selection = test_selection
+    end
+
+    def test(mutant)
       Isolation.call do
-        test_set = tests.for(subject) # TODO: is this correctly minimal?
-        run(test_set, fail_fast: true)
+        selected_tests = test_selection.for(mutant, from: tests)
+        run(selected_tests, fail_fast: true)
       end
     end
   end

data/lib/mutiny/mode/check.rb

@@ -51,11 +51,11 @@ module Mutiny
       end
 
       def test_set
-        @test_set ||= configuration.integration.tests.for_all(environment.subjects)
+        @test_set ||= configuration.tests.integration.tests.for_subjects(environment.subjects)
       end
 
       def test_run
-        @test_run ||= configuration.integration.run(test_set)
+        @test_run ||= configuration.tests.integration.run(test_set)
       end
     end
   end

data/lib/mutiny/mode/mutate.rb

@@ -17,12 +17,16 @@ module Mutiny
       end
 
       def store_mutants
-        mutant_set.store
+        mutant_storage.save(mutant_set)
         report "Check the '.mutants' directory to browse the generated mutants."
       end
 
       def mutant_set
-        @mutant_set ||= configuration.mutator.mutants_for(environment.subjects)
+        @mutant_set ||= configuration.mutants.mutator.mutants_for(environment.subjects)
+      end
+
+      def mutant_storage
+        @store ||= configuration.mutants.storage
       end
     end
   end

data/lib/mutiny/mode/score.rb

@@ -58,11 +58,22 @@ module Mutiny
       end
 
       def analyser
-        Analysis::Analyser.new(mutant_set: mutant_set, integration: configuration.integration)
+        Analysis::Analyser.new(
+          mutant_set: mutant_set,
+          integration: configuration.tests.integration
+        )
       end
 
       def mutant_set
-        @mutant_set ||= configuration.mutator.mutants_for(environment.subjects)
+        @mutant_set ||= initialize_mutant_set
+      end
+
+      def initialize_mutant_set
+        if options[:cached]
+          configuration.mutants.storage.load
+        else
+          configuration.mutants.mutator.mutants_for(environment.subjects)
+        end
       end
     end
   end

data/lib/mutiny/mode.rb

@@ -4,11 +4,12 @@ require_relative "mode/score"
 
 module Mutiny
   class Mode
-    attr_reader :configuration, :environment
+    attr_reader :configuration, :environment, :options
 
-    def initialize(configuration)
+    def initialize(configuration, **options)
       @configuration = configuration
       @environment = Subjects::Environment.new(configuration)
+      @options = options
     end
 
     private

data/lib/mutiny/mutants/mutant/location.rb

@@ -0,0 +1,27 @@
+module Mutiny
+  module Mutants
+    class Mutant
+      class Location
+        attr_reader :position, :content
+
+        def initialize(position:, content:)
+          @position = position.freeze
+          @content = content
+        end
+
+        def lines
+          Range.new(
+            line_number_of_offset(position.begin),
+            line_number_of_offset(position.end)
+          )
+        end
+
+        private
+
+        def line_number_of_offset(offset)
+          content[0..offset].lines.size
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/mutant.rb

@@ -1,16 +1,23 @@
-require 'fileutils'
+require_relative "mutant/location"
 
 module Mutiny
   module Mutants
     class Mutant
-      attr_reader :subject, :code, :mutation_name, :stillborn
+      attr_reader :subject, :code, :mutation_name, :stillborn, :location
+      attr_accessor :index
       alias_method :stillborn?, :stillborn
 
-      def initialize(subject: nil, code:, mutation_name: nil)
+      def initialize(subject: nil, code:, mutation_name: nil, index: nil, position: nil)
         @subject = subject
         @code = code
         @mutation_name = mutation_name
+        @index = index
         @stillborn = false
+        @location = Location.new(position: position, content: code)
+      end
+
+      def identifier
+        subject.relative_path.sub(/\.rb$/, ".#{index}.rb")
       end
 
       def apply

data/lib/mutiny/mutants/mutant_set.rb

@@ -20,15 +20,12 @@ module Mutiny
       def ordered
         group_by_subject.flat_map do |_, mutants|
           mutants.map.with_index do |mutant, index|
-            OrderedMutant.new(mutant, index)
+            mutant.index ||= index
+            mutant
           end
         end
       end
 
-      def store(mutant_directory = ".mutants")
-        ordered.each { |m| m.store(mutant_directory) }
-      end
-
       def eql?(other)
         other.mutants == mutants
       end
@@ -38,27 +35,6 @@ module Mutiny
       def hash
         mutants.hash
       end
-
-      class OrderedMutant < SimpleDelegator
-        def initialize(mutant, number)
-          super(mutant)
-          @number = number
-        end
-
-        def identifier
-          subject.relative_path.sub(/\.rb$/, ".#{@number}.rb")
-        end
-
-        def store(directory)
-          path = File.join(directory, identifier)
-          FileUtils.mkdir_p(File.dirname(path))
-          File.open(path, 'w') { |f| f.write(serialised) }
-        end
-
-        def serialised
-          "# " + mutation_name + "\n" + code
-        end
-      end
     end
   end
 end

data/lib/mutiny/mutants/mutation_set.rb

@@ -14,23 +14,37 @@ module Mutiny
       # 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|
-          subjects.product(mutations).each do |subject, mutation|
-            mutants.concat(mutate_one(subject, mutation))
-          end
+        mutants = MutantSet.new
+        subjects.product(mutations).each do |subject, mutation|
+          mutants.concat(mutate_one(subject, mutation))
         end
+        mutants
       end
 
       private
 
       def mutate_one(subject, mutation)
-        safely_mutate_file(subject.path, mutation).map do |code|
-          Mutant.new(subject: subject, code: code, mutation_name: mutation.short_name)
+        safely_mutate_file(subject.path, mutation).map do |code, position|
+          Mutant.new(
+            subject: subject,
+            mutation_name: mutation.short_name,
+            code: code,
+            position: position
+          )
         end
       end
 
       def safely_mutate_file(path, mutation)
-        mutation.mutate_file(path)
+        positions = []
+
+        code = mutation.mutate_file(path) do |change|
+          starting_position = change.original_position.begin
+          ending_position   = change.original_position.begin + change.transformed_code.size - 1
+
+          positions << (starting_position..ending_position)
+        end
+
+        code.zip(positions)
       rescue
         msg = "Error encountered whilst mutating file at '#{path}' with #{mutation.name}"
         raise Mutation::Error, msg

data/lib/mutiny/mutants/storage/file_store.rb

@@ -0,0 +1,27 @@
+require_relative "mutant_file"
+
+module Mutiny
+  module Mutants
+    class Storage
+      class FileStore
+        attr_reader :mutant_directory, :strategy
+
+        def initialize(mutant_directory: ".mutants")
+          @mutant_directory = mutant_directory
+          @strategy = MutantFile.new(mutant_directory)
+        end
+
+        def save_all(mutants)
+          mutants.ordered.each do |mutant|
+            strategy.store(mutant)
+          end
+        end
+
+        def load_all
+          absolute_paths = Dir.glob(File.join(mutant_directory, "**", "*.rb"))
+          absolute_paths.map { |path| strategy.load(path) }
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/storage/mutant_file.rb

@@ -0,0 +1,55 @@
+require "fileutils"
+require_relative "path"
+require_relative "mutant_file_name"
+require_relative "mutant_file_contents"
+
+module Mutiny
+  module Mutants
+    class Storage
+      class MutantFile
+        attr_reader :mutant_directory
+
+        def initialize(mutant_directory)
+          @mutant_directory = mutant_directory
+        end
+
+        def load(absolute_path)
+          path = Path.from_absolute(path: absolute_path, root: mutant_directory)
+          deserialise
+            .merge(deserialised_contents(path)) { |_, left, right| left.merge(right) }
+            .merge(deserialised_filename(path)) { |_, left, right| left.merge(right) }
+        end
+
+        def store(mutant)
+          path = Path.from_relative(root: mutant_directory, path: filename.serialise(mutant))
+          FileUtils.mkdir_p(File.dirname(path.absolute))
+          File.open(path.absolute, 'w') { |f| f.write(contents.serialise(mutant)) }
+        end
+
+        private
+
+        def deserialise
+          {
+            subject: { root: mutant_directory }
+          }
+        end
+
+        def deserialised_filename(path)
+          filename.deserialise(path.relative)
+        end
+
+        def deserialised_contents(path)
+          contents.deserialise(File.read(path.absolute))
+        end
+
+        def filename
+          @filename ||= MutantFileName.new
+        end
+
+        def contents
+          @contents ||= MutantFileContents.new
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/storage/mutant_file_contents.rb

@@ -0,0 +1,33 @@
+module Mutiny
+  module Mutants
+    class Storage
+      class MutantFileContents
+        def serialise(mutant)
+          "# " + mutant.subject.name + "\n" \
+          "# " + mutant.mutation_name + "\n" \
+          "# " + mutant.location.position.to_s + "\n" +
+            mutant.code
+        end
+
+        def deserialise(contents)
+          {
+            subject: { name: extract_contents_of_comment(contents.lines[0]) },
+            mutation_name: extract_contents_of_comment(contents.lines[1]),
+            position: convert_to_range(extract_contents_of_comment(contents.lines[2])),
+            code: contents.lines.drop(3).join
+          }
+        end
+
+        private
+
+        def extract_contents_of_comment(line)
+          line[2..-1].strip
+        end
+
+        def convert_to_range(string)
+          Range.new(*string.split("..").map(&:to_i))
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/storage/mutant_file_name.rb

@@ -0,0 +1,32 @@
+module Mutiny
+  module Mutants
+    class Storage
+      class MutantFileName
+        def serialise(mutant)
+          path_with_index(mutant.subject.relative_path, mutant.index)
+        end
+
+        def deserialise(path)
+          {
+            subject: { path: path_without_index(path) },
+            index: index_of(path)
+          }
+        end
+
+        private
+
+        def path_with_index(path, index)
+          path.sub(/\.rb$/, ".#{index}.rb")
+        end
+
+        def path_without_index(path)
+          path.sub(/\.\d+\.rb$/, ".rb")
+        end
+
+        def index_of(path)
+          path.match(/.*\.(\d+)\.rb/)[1].to_i
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/storage/path.rb

@@ -0,0 +1,31 @@
+require_relative "mutant_file"
+
+module Mutiny
+  module Mutants
+    class Storage
+      class Path
+        def self.from_absolute(path:, root:)
+          relative_path = Pathname.new(path).relative_path_from(Pathname.new(root)).to_s
+          new(relative_path, root)
+        end
+
+        def self.from_relative(path:, root:)
+          new(path, root)
+        end
+
+        attr_reader :relative, :root
+
+        def absolute
+          File.join(root, relative)
+        end
+
+        private
+
+        def initialize(relative, root)
+          @relative = relative
+          @root = root
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/mutants/storage.rb

@@ -0,0 +1,27 @@
+require_relative "storage/file_store"
+
+module Mutiny
+  module Mutants
+    class Storage
+      attr_accessor :store
+
+      def initialize(mutant_directory: ".mutants", store: nil)
+        @store = store || FileStore.new(mutant_directory: mutant_directory)
+      end
+
+      def save(mutants)
+        store.save_all(mutants)
+      end
+
+      def load
+        mutants = store.load_all.map do |mutant_specification|
+          subject = Subjects::Subject.new(**mutant_specification[:subject])
+          mutant_specification[:subject] = subject
+          Mutant.new(**mutant_specification)
+        end
+
+        MutantSet.new(*mutants)
+      end
+    end
+  end
+end

data/lib/mutiny/tests/selection/default.rb

@@ -0,0 +1,11 @@
+module Mutiny
+  module Tests
+    module Selection
+      class Default
+        def for(mutant, from:)
+          from.for_subject(mutant.subject) # TODO: is this correctly minimal?
+        end
+      end
+    end
+  end
+end

data/lib/mutiny/tests/test_set.rb

@@ -18,12 +18,12 @@ module Mutiny
         tests.map(&:location)
       end
 
-      def for_all(subject_set)
-        subset { |test| subject_set.names.include?(test.expression) }
+      def for_subject(subject)
+        subset { |test| subject.name == test.expression }
       end
 
-      def for(subject)
-        subset { |test| subject.name == test.expression }
+      def for_subjects(subjects)
+        subset { |test| subjects.names.include?(test.expression) }
       end
 
       def subset(&block)

data/lib/mutiny/version.rb

@@ -1,3 +1,3 @@
 module Mutiny
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/spec/integration/mutate_spec.rb

@@ -53,4 +53,25 @@ describe "Using Mutiny to generate mutants" do
     check_file_content(".mutants/calculator/max.5.rb", /# RelationalOperatorReplacement/)
     check_file_content(".mutants/calculator/max.6.rb", /# RelationalOperatorReplacement/)
   end
+
+  it "should write position to each mutant" do
+    cd "calculator"
+    run "bundle exec mutiny mutate"
+
+    check_file_content(".mutants/calculator/min.0.rb", /# 93..96/)
+    check_file_content(".mutants/calculator/min.1.rb", /# 93..97/)
+    check_file_content(".mutants/calculator/min.2.rb", /# 93..105/)
+    check_file_content(".mutants/calculator/min.3.rb", /# 93..105/)
+    check_file_content(".mutants/calculator/min.4.rb", /# 93..105/)
+    check_file_content(".mutants/calculator/min.5.rb", /# 93..105/)
+    check_file_content(".mutants/calculator/min.6.rb", /# 93..104/)
+
+    check_file_content(".mutants/calculator/max.0.rb", /# 93..96/)
+    check_file_content(".mutants/calculator/max.1.rb", /# 93..97/)
+    check_file_content(".mutants/calculator/max.2.rb", /# 93..104/)
+    check_file_content(".mutants/calculator/max.3.rb", /# 93..105/)
+    check_file_content(".mutants/calculator/max.4.rb", /# 93..105/)
+    check_file_content(".mutants/calculator/max.5.rb", /# 93..105/)
+    check_file_content(".mutants/calculator/max.6.rb", /# 93..105/)
+  end
 end

data/spec/integration/score_cached_spec.rb

@@ -0,0 +1,34 @@
+describe "Using Mutiny to score existing mutants" do
+  before(:each) do
+    cd "calculator"
+    run "bundle exec mutiny mutate"
+
+    run "rm -rf .mutants/calculator/max.0.rb"
+    run "rm -rf .mutants/calculator/max.1.rb"
+    run "rm -rf .mutants/calculator/max.2.rb"
+    run "rm -rf .mutants/calculator/max.3.rb"
+    run "rm -rf .mutants/calculator/max.4.rb"
+    run "rm -rf .mutants/calculator/max.5.rb"
+    run "rm -rf .mutants/calculator/max.6.rb"
+
+    run "rm -rf .mutants/calculator/min.0.rb"
+    run "rm -rf .mutants/calculator/min.1.rb"
+
+    run "bundle exec mutiny score --cached"
+  end
+
+  it "should report a mutation score" do
+    expected_output = "Scoring...\n" \
+                      "5 mutants, 4 killed\n"
+
+    expect(all_output).to include(expected_output)
+  end
+
+  it "should report status of mutants" do
+    expect(all_output).to include("calculator/min.2.rb | survived")
+    expect(all_output).to include("calculator/min.3.rb | killed")
+    expect(all_output).to include("calculator/min.4.rb | killed")
+    expect(all_output).to include("calculator/min.5.rb | killed")
+    expect(all_output).to include("calculator/min.6.rb | killed")
+  end
+end

data/spec/integration/score_spec.rb

@@ -1,4 +1,4 @@
-describe "Using Mutiny to generate mutants" do
+describe "Using Mutiny to score mutants" do
   before(:each) do
     cd "calculator"
     run "bundle exec mutiny mutate"

data/spec/unit/integration/rspec_spec.rb

@@ -0,0 +1,45 @@
+require "mutiny/integration/hook"
+
+module Mutiny
+  class Integration
+    describe RSpec do
+      let(:test_set) { subject.tests }
+
+      it "should call hooks before each spec" do
+        in_example_project("calculator") do
+          hook = TestHook.new
+          subject.run(test_set, hooks: [hook])
+
+          expect(hook.examples_started.size).to eq(test_set.size)
+        end
+      end
+
+      it "should call hooks after each spec" do
+        in_example_project("calculator") do
+          hook = TestHook.new
+          subject.run(test_set, hooks: [hook])
+
+          expect(hook.examples_finished.size).to eq(test_set.size)
+        end
+      end
+
+      class TestHook < Hook
+        def before(example)
+          examples_started << example
+        end
+
+        def after(example)
+          examples_finished << example
+        end
+
+        def examples_started
+          @examples_started ||= []
+        end
+
+        def examples_finished
+          @examples_finished ||= []
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/mutant/location_spec.rb

@@ -0,0 +1,23 @@
+module Mutiny
+  module Mutants
+    class Mutant
+      describe Location do
+        context "calculates lines" do
+          it "correctly for a multi-line location" do
+            #                                                  0          1         2
+            #                                                  01234567 89012345678901 234
+            location = Location.new(position: 3..21, content: "if BOMB\n raise 'boom'\nend")
+
+            expect(location.lines).to eq(1..2)
+          end
+
+          it "correctly for a single-line location" do
+            location = Location.new(position: 2..4, content: "a <= b\nb <= c")
+
+            expect(location.lines).to eq(1..1)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/storage/mutant_file_contents_spec.rb

@@ -0,0 +1,49 @@
+module Mutiny
+  module Mutants
+    class Storage
+      describe MutantFileContents do
+        it "serialises" do
+          expect(subject.serialise(mutant)).to eq(serialised_mutant)
+        end
+
+        it "deserialises" do
+          expect(subject.deserialise(serialised_mutant)).to eq(deserialised_mutant)
+        end
+
+        def mutant
+          Mutant.new(
+            subject: subject_of_mutation,
+            code: "2 - 2",
+            index: 0,
+            mutation_name: "BAOR",
+            position: 2..3
+          )
+        end
+
+        def subject_of_mutation
+          Subjects::Subject.new(
+            name: "Two",
+            path: "~/Code/sums/two.rb",
+            root: "~/Code/sums"
+          )
+        end
+
+        def serialised_mutant
+          "# Two\n"  \
+          "# BAOR\n" \
+          "# 2..3\n" \
+          "2 - 2"
+        end
+
+        def deserialised_mutant
+          {
+            subject: { name: "Two" },
+            mutation_name: "BAOR",
+            code: "2 - 2",
+            position: 2..3
+          }
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/storage/mutant_file_name_spec.rb

@@ -0,0 +1,34 @@
+module Mutiny
+  module Mutants
+    class Storage
+      describe MutantFileName do
+        it "serialises" do
+          expect(subject.serialise(mutant)).to eq(serialised_mutant)
+        end
+
+        it "deserialises" do
+          expect(subject.deserialise(serialised_mutant)).to eq(deserialised_mutant)
+        end
+
+        def mutant
+          Mutant.new(subject: subject_of_mutation, code: "2 - 2", index: 10, mutation_name: "BAOR")
+        end
+
+        def subject_of_mutation
+          Subjects::Subject.new(name: "Two", path: "~/Code/sums/two.rb", root: "~/Code/sums")
+        end
+
+        def serialised_mutant
+          "two.10.rb"
+        end
+
+        def deserialised_mutant
+          {
+            subject: { path: "two.rb" },
+            index: 10
+          }
+        end
+      end
+    end
+  end
+end

data/spec/unit/mutants/storage_spec.rb

@@ -0,0 +1,46 @@
+module Mutiny
+  module Mutants
+    describe Storage do
+      it "transforms hashes to mutants and subjects" do
+        store = instance_double(Storage::FileStore)
+        allow(store).to receive(:load_all).and_return(loaded_data)
+
+        storage = Storage.new(store: store)
+        expect(storage.load).to eq(expected_mutant_set)
+      end
+
+      # rubocop:disable MethodLength
+      def loaded_data
+        [
+          {
+            subject: { name: "Two", path: "two.rb", root: "~/Code/sums" },
+            code: "2 - 2",
+            index: 0
+          },
+          {
+            subject: { name: "Two", path: "two.rb", root: "~/Code/sums" },
+            code: "2 * 2",
+            index: 1
+          },
+          {
+            subject: { name: "Four", path: "four.rb", root: "~/Code/sums" },
+            code: "4 - 4",
+            index: 0
+          }
+        ]
+      end
+      # rubocop:enable MethodLength
+
+      def expected_mutant_set
+        first_subject  = Subjects::Subject.new(name: "Two", path: "two.rb", root: "~/Code/sums")
+        second_subject = Subjects::Subject.new(name: "Four", path: "four.rb", root: "~/Code/sums")
+
+        MutantSet.new(
+          Mutant.new(subject: first_subject, code: "2 - 2", index: 0),
+          Mutant.new(subject: first_subject, code: "2 * 2", index: 1),
+          Mutant.new(subject: second_subject, code: "4 - 4", index: 2)
+        )
+      end
+    end
+  end
+end

data/spec/unit/{subjects → tests}/test_set_spec.rb

@@ -33,42 +33,84 @@ module Mutiny
         end
       end
 
-      context "for" do
+      context "for all" do
         it "should return only those tests (whose expression) matches a subject" do
           subjects = subject_set_for("Max", "Min")
           test_set = test_set_for("Subtract", "Min", "Add")
+          selected = test_set.for_subjects(subjects)
 
-          expect(test_set.for_all(subjects)).to eq(test_set.subset { |t| t.expression == "Min" })
+          expect(selected).to eq(test_set.subset { |t| t.expression == "Min" })
         end
 
         it "should return multiple tests for a single subject" do
           subjects = subject_set_for("Min")
           test_set = test_set_for("Min", "Max", "Min", "Max", "Min")
+          selected = test_set.for_subjects(subjects)
 
-          expect(test_set.for_all(subjects)).to eq(test_set.subset { |t| t.expression == "Min" })
+          expect(selected).to eq(test_set.subset { |t| t.expression == "Min" })
         end
 
         it "should return no tests when there are no tests" do
           subjects = subject_set_for("Max", "Min")
           test_set = TestSet.empty
+          selected = test_set.for_subjects(subjects)
 
-          expect(test_set.for_all(subjects)).to eq(TestSet.empty)
+          expect(selected).to eq(TestSet.empty)
         end
 
         it "should return no tests when there are no relevant subjects" do
           subjects = subject_set_for("Max", "Min")
           test_set = test_set_for("Subtract", "Add")
+          selected = test_set.for_subjects(subjects)
 
-          expect(test_set.for_all(subjects)).to eq(TestSet.empty)
+          expect(selected).to eq(TestSet.empty)
         end
 
         def subject_set_for(*names)
           Subjects::SubjectSet.new(names.map { |n| Subjects::Subject.new(name: n) })
         end
+      end
+
+      context "for" do
+        it "should return only those tests (whose expression) matches the mutant's subject" do
+          subject = subject_for("Min")
+          test_set = test_set_for("Subtract", "Min", "Add")
+          selected = test_set.for_subject(subject)
+
+          expect(selected).to eq(test_set.subset { |t| t.expression == "Min" })
+        end
+
+        it "should return multiple tests for a single mutant" do
+          subject = subject_for("Min")
+          test_set = test_set_for("Min", "Max", "Min", "Max", "Min")
+          selected = test_set.for_subject(subject)
+
+          expect(selected).to eq(test_set.subset { |t| t.expression == "Min" })
+        end
 
-        def test_set_for(*expressions)
-          TestSet.new(expressions.map { |e| Test.new(expression: e) })
+        it "should return no tests when there are no tests" do
+          subject = subject_for("Min")
+          test_set = TestSet.empty
+          selected = test_set.for_subject(subject)
+
+          expect(selected).to eq(TestSet.empty)
         end
+
+        it "should return no tests when mutant is irrelevant" do
+          subject = subject_for("Min")
+          test_set = test_set_for("Subtract", "Add")
+          selected = test_set.for_subject(subject)
+
+          expect(selected).to eq(TestSet.empty)
+        end
+
+        def subject_for(name)
+          Subjects::Subject.new(name: name)
+        end
+      end
+
+      def test_set_for(*expressions)
+        TestSet.new(expressions.map { |e| Test.new(expression: e) })
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutiny
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Louis Rose
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-26 00:00:00.000000000 Z
+date: 2016-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -194,8 +194,10 @@ files:
 - lib/mutiny/analysis/results.rb
 - lib/mutiny/configuration.rb
 - lib/mutiny/integration.rb
+- lib/mutiny/integration/hook.rb
 - lib/mutiny/integration/rspec.rb
 - lib/mutiny/integration/rspec/context.rb
+- lib/mutiny/integration/rspec/hook.rb
 - lib/mutiny/integration/rspec/parser.rb
 - lib/mutiny/integration/rspec/runner.rb
 - lib/mutiny/integration/rspec/test.rb
@@ -208,6 +210,7 @@ files:
 - lib/mutiny/mode/mutate.rb
 - lib/mutiny/mode/score.rb
 - lib/mutiny/mutants/mutant.rb
+- lib/mutiny/mutants/mutant/location.rb
 - lib/mutiny/mutants/mutant_set.rb
 - lib/mutiny/mutants/mutation.rb
 - lib/mutiny/mutants/mutation/error.rb
@@ -227,6 +230,12 @@ files:
 - lib/mutiny/mutants/mutation/method/unary_arithmetic_operator_insertion.rb
 - lib/mutiny/mutants/mutation_set.rb
 - lib/mutiny/mutants/ruby.rb
+- lib/mutiny/mutants/storage.rb
+- lib/mutiny/mutants/storage/file_store.rb
+- lib/mutiny/mutants/storage/mutant_file.rb
+- lib/mutiny/mutants/storage/mutant_file_contents.rb
+- lib/mutiny/mutants/storage/mutant_file_name.rb
+- lib/mutiny/mutants/storage/path.rb
 - lib/mutiny/output/table.rb
 - lib/mutiny/pattern.rb
 - lib/mutiny/reporter/stdout.rb
@@ -236,6 +245,7 @@ files:
 - lib/mutiny/subjects/subject.rb
 - lib/mutiny/subjects/subject_set.rb
 - lib/mutiny/tests.rb
+- lib/mutiny/tests/selection/default.rb
 - lib/mutiny/tests/test.rb
 - lib/mutiny/tests/test_run.rb
 - lib/mutiny/tests/test_set.rb
@@ -243,6 +253,7 @@ files:
 - mutiny.gemspec
 - spec/integration/check_spec.rb
 - spec/integration/mutate_spec.rb
+- spec/integration/score_cached_spec.rb
 - spec/integration/score_spec.rb
 - spec/spec_helper.rb
 - spec/support/aruba.rb
@@ -250,7 +261,9 @@ files:
 - spec/support/shared_examples/shared_examples_for_an_operator_replacement_mutation.rb
 - spec/unit/integration/rspec/parser_spec.rb
 - spec/unit/integration/rspec/runner_spec.rb
+- spec/unit/integration/rspec_spec.rb
 - spec/unit/isolation_spec.rb
+- spec/unit/mutants/mutant/location_spec.rb
 - spec/unit/mutants/mutant_set_spec.rb
 - spec/unit/mutants/mutant_spec.rb
 - spec/unit/mutants/mutation_set_spec.rb
@@ -266,11 +279,14 @@ files:
 - spec/unit/mutants/mutations/method/shortcut_assignment_operator_replacement_spec.rb
 - spec/unit/mutants/mutations/method/unary_arithmetic_operator_deletion_spec.rb
 - spec/unit/mutants/mutations/method/unary_arithmetic_operator_insertion_spec.rb
+- spec/unit/mutants/storage/mutant_file_contents_spec.rb
+- spec/unit/mutants/storage/mutant_file_name_spec.rb
+- spec/unit/mutants/storage_spec.rb
 - spec/unit/pattern_spec.rb
 - spec/unit/subjects/environment/type_spec.rb
 - spec/unit/subjects/environment_spec.rb
 - spec/unit/subjects/subject_spec.rb
-- spec/unit/subjects/test_set_spec.rb
+- spec/unit/tests/test_set_spec.rb
 homepage: https://github.com/mutiny/mutiny
 licenses:
 - MIT
@@ -298,6 +314,7 @@ summary: A tiny mutation testing framework for Ruby
 test_files:
 - spec/integration/check_spec.rb
 - spec/integration/mutate_spec.rb
+- spec/integration/score_cached_spec.rb
 - spec/integration/score_spec.rb
 - spec/spec_helper.rb
 - spec/support/aruba.rb
@@ -305,7 +322,9 @@ test_files:
 - spec/support/shared_examples/shared_examples_for_an_operator_replacement_mutation.rb
 - spec/unit/integration/rspec/parser_spec.rb
 - spec/unit/integration/rspec/runner_spec.rb
+- spec/unit/integration/rspec_spec.rb
 - spec/unit/isolation_spec.rb
+- spec/unit/mutants/mutant/location_spec.rb
 - spec/unit/mutants/mutant_set_spec.rb
 - spec/unit/mutants/mutant_spec.rb
 - spec/unit/mutants/mutation_set_spec.rb
@@ -321,8 +340,11 @@ test_files:
 - spec/unit/mutants/mutations/method/shortcut_assignment_operator_replacement_spec.rb
 - spec/unit/mutants/mutations/method/unary_arithmetic_operator_deletion_spec.rb
 - spec/unit/mutants/mutations/method/unary_arithmetic_operator_insertion_spec.rb
+- spec/unit/mutants/storage/mutant_file_contents_spec.rb
+- spec/unit/mutants/storage/mutant_file_name_spec.rb
+- spec/unit/mutants/storage_spec.rb
 - spec/unit/pattern_spec.rb
 - spec/unit/subjects/environment/type_spec.rb
 - spec/unit/subjects/environment_spec.rb
 - spec/unit/subjects/subject_spec.rb
-- spec/unit/subjects/test_set_spec.rb
+- spec/unit/tests/test_set_spec.rb