mutant 0.2.20 → 0.3.0.beta2

data/lib/mutant/runner.rb

@@ -1,31 +1,9 @@
 module Mutant
-  # Runner that allows to mutate an entire project
+  # Runner baseclass
   class Runner
-    include Adamantium::Flat
+    include Adamantium::Flat, AbstractType, Equalizer.new(:config)
     extend MethodObject
 
-    # Return killers with errors
-    #
-    # @return [Enumerable<Killer>]
-    #
-    # @api private
-    #
-    attr_reader :errors
-
-    # Test for failure
-    #
-    # @return [true]
-    #   returns true when there are left mutations
-    #
-    # @return [false]
-    #   returns false othewise
-    #
-    # @api private
-    #
-    def fail?
-      !errors.empty?
-    end
-
     # Return config
     #
     # @return [Mutant::Config]
@@ -34,8 +12,6 @@ module Mutant
     #
     attr_reader :config
 
-  private
-
     # Initialize object
     #
     # @param [Config] config
@@ -45,106 +21,80 @@ module Mutant
     # @api private
     #
     def initialize(config)
-      @config, @errors = config, []
-
-      util_reporter = reporter
-      util_reporter.config(config)
+      @config = config
+      @start = Time.now
       run
-      util_reporter.errors(@errors)
-    end
-
-    # Return reporter
-    #
-    # @return [Reporter]
-    #
-    # @api private
-    #
-    def reporter
-      config.reporter
+      @end = Time.now
     end
 
-    # Run mutation killers on subjects
+    # Return runtime
     #
-    # @return [undefined]
+    # @return [Float]
     #
     # @api private
     #
-    def run
-      config.matcher.each do |subject|
-        reporter.subject(subject)
-        run_subject(subject)
-      end
+    def runtime
+      @end - @start
     end
+    memoize :runtime
 
-    # Run mutation killers on subject
+    # Test if runner failed
     #
-    # @param [Subject] subject
+    # @return [true]
+    #   if failed
     #
-    # @return [undefined]
+    # @return [false]
+    #   otherwise
     #
     # @api private
     #
-    def run_subject(subject)
-      return unless noop(subject)
-      subject.each do |mutation|
-        next unless config.filter.match?(mutation)
-        reporter.mutation(mutation)
-        kill(mutation)
-      end
+    def failed?
+      !success?
     end
 
-    # Test for noop mutation
-    #
-    # @param [Subject] subject
+    # Test if runner is successful
     #
     # @return [true]
-    #   if noop mutation is okay
+    #   if successful
     #
     # @return [false]
     #   otherwise
     #
     # @api private
     #
-    def noop(subject)
-      killer = killer(subject.noop)
-      reporter.noop(killer)
-      unless killer.fail?
-        @errors << killer
-        return false
-      end
-
-      true
-    end
+    abstract_method :success?
 
-    # Run killer on mutation
+    # Return reporter
     #
-    # @param [Mutation] mutation
+    # @return [Reporter]
     #
-    # @return [true]
-    #   if killer was unsuccessful
+    # @api private
     #
-    # @return [false]
-    #   otherwise
+    def reporter
+      config.reporter
+    end
+
+  private
+
+    # Perform operation
+    #
+    # @return [undefined]
     #
     # @api private
     #
-    def kill(mutation)
-      killer = killer(mutation)
-      reporter.killer(killer)
+    abstract_method :run
 
-      if killer.fail?
-        @errors << killer
-      end
-    end
-
-    # Return killer for mutation
+    # Return reporter
     #
-    # @return [Killer]
+    # @param [Object] object
+    #
+    # @return [undefined]
     #
     # @api private
     #
-    def killer(mutation)
-      config.strategy.kill(mutation)
+    def report(object)
+      reporter.report(object)
     end
-  end
-end
+
+  end # Runner
+end # Mutant

data/lib/mutant/singleton_methods.rb

@@ -10,7 +10,7 @@ module Mutant
   #
   # @api private
   #
-  def self.define_singleton_subclass(name, superclass, &block)
+  def self.singleton_subclass_instance(name, superclass, &block)
     klass = Class.new(superclass) do
 
       def inspect; self.class.name; end
@@ -25,4 +25,4 @@ module Mutant
     self
   end
 
-end
+end # Mutant

data/lib/mutant/strategy/method_expansion.rb

@@ -0,0 +1,51 @@
+module Mutant
+  class Strategy
+    module MethodExpansion
+
+      # Run method name expansion
+      #
+      # @param [Symbol] name
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def self.run(name)
+        name = map(name) || expand(name)
+      end
+
+      # Return mapped name
+      #
+      # @param [Symbol] name
+      #
+      # @return [Symbol]
+      #   if name was mapped
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      #
+      def self.map(name)
+        OPERATOR_EXPANSIONS[name]
+      end
+      private_class_method :map
+
+      REGEXP = /#{Regexp.union(*METHOD_POSTFIX_EXPANSIONS.keys)}\z/.freeze
+
+      # Return expanded name
+      #
+      # @param [Symbol] name
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def self.expand(name)
+        name.to_s.gsub(REGEXP, METHOD_POSTFIX_EXPANSIONS).to_sym
+      end
+      private_class_method :expand
+
+    end # MethodExpansion
+  end # Strategy
+end # Mutant

data/lib/mutant/strategy/rspec/dm2/lookup/method.rb

@@ -0,0 +1,142 @@
+module Mutant
+  class Strategy
+    class Rspec
+      class DM2
+        class Lookup
+
+          # Base class for dm2 style method lookup
+          class Method < self
+
+            # Return spec files
+            #
+            # @return [Enumerable<String>]
+            #
+            # @api private
+            #
+            def spec_files
+              Dir.glob(glob_expression)
+            end
+            memoize :spec_files
+
+          private
+
+            # Return base path
+            #
+            # @return [String]
+            #
+            # @api private
+            #
+            def base_path
+              "spec/unit/#{Inflecto.underscore(subject.context.name)}"
+            end
+
+            # Return method name
+            #
+            # @return [Symbol]
+            #
+            # @api private
+            #
+            def method_name
+              subject.name
+            end
+
+            # Test if method is public
+            #
+            # @return [true]
+            #   if method is public
+            #
+            # @return [false]
+            #
+            # @api private
+            #
+            def public?
+              subject.public?
+            end
+
+            # Return expanded name
+            #
+            # @return [String]
+            #
+            # @api private
+            #
+            def expanded_name
+              MethodExpansion.run(method_name)
+            end
+
+            # Return glob expression
+            #
+            # @return [String]
+            #
+            # @api private
+            #
+            def glob_expression
+              public? ? public_glob_expression : private_glob_expression
+            end
+
+            # Return public glob expression
+            #
+            # @return [String]
+            #
+            # @api private
+            #
+            def public_glob_expression
+              "#{base_path}/#{expanded_name}_spec.rb"
+            end
+
+            # Return private glob expression
+            #
+            # @return [String]
+            #
+            # @api private
+            #
+            def private_glob_expression
+              "#{base_path}/*_spec.rb"
+            end
+
+            # Instance method dm2 style method lookup
+            class Instance < self
+              handle(Subject::Method::Instance)
+
+            private
+
+              # Return glob expression
+              #
+              # @return [String]
+              #
+              # @api private
+              #
+              def glob_expression
+                glob_expression = super
+                if method_name == :initialize and !public?
+                  "{#{glob_expression},#{base_path}/class_methods/new_spec.rb}"
+                else
+                  glob_expression
+                end
+              end
+
+            end # Instance
+
+            # Singleton method dm2 style method lookup
+            class Singleton < self
+              handle(Subject::Method::Singleton)
+
+            private
+
+              # Return base path
+              #
+              # @return [String]
+              #
+              # @api private
+              #
+              def base_path
+                "#{super}/class_methods"
+              end
+
+            end # Singleton
+
+          end # Method
+        end # Lookup
+      end # DM2
+    end # Rspec
+  end # Strategy
+end # Mutant

data/lib/mutant/strategy/rspec/dm2/lookup.rb

@@ -0,0 +1,61 @@
+module Mutant
+  class Strategy
+    class Rspec
+      class DM2
+
+        # Example lookup for the rspec dm2
+        class Lookup
+          include AbstractType, Adamantium::Flat, Concord::Public.new(:subject)
+
+          # Return glob expression
+          #
+          # @return [String]
+          #
+          # @api private
+          #
+          abstract_method :spec_files
+
+          # Perform example lookup
+          #
+          # @param [Subject] subject
+          #
+          # @return [Enumerable<String>]
+          #
+          # @api private
+          #
+          def self.run(subject)
+            build(subject).spec_files
+          end
+
+          REGISTRY = {}
+
+          # Register subject hander
+          #
+          # @param [Class:Subject]
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def self.handle(subject_class)
+            REGISTRY[subject_class]=self
+          end
+          private_class_method :handle
+
+          # Build lookup object
+          #
+          # @param [Subjecŧ] subject
+          #
+          # @return [Lookup]
+          #
+          # @api private
+          #
+          def self.build(subject)
+            REGISTRY.fetch(subject.class).new(subject)
+          end
+
+        end # Lookup
+      end # DM2
+    end # Rspec
+  end # Strategy
+end # Mutant

data/lib/mutant/strategy/rspec/dm2.rb

@@ -0,0 +1,22 @@
+module Mutant
+  class Strategy
+    class Rspec
+      # DM2-style strategy
+      class DM2 < self
+
+        # Return filename pattern
+        #
+        # @param [Subject] subject
+        #
+        # @return [Enumerable<String>]
+        #
+        # @api private
+        #
+        def self.spec_files(subject)
+          Lookup.run(subject)
+        end
+
+      end # DM2
+    end # Rspec
+  end # Strategy
+end # Mutant

data/lib/mutant/strategy/rspec.rb

@@ -6,18 +6,15 @@ module Mutant
 
       KILLER = Killer::Forking.new(Killer::Rspec)
 
-      # DM2-style strategy
-      class DM2 < self
-
-        # Return filename pattern
-        #
-        # @return [Enumerable<String>]
-        #
-        # @api private
-        #
-        def spec_files(mutation)
-          ExampleLookup.run(mutation)
-        end
+      # Setup rspec strategy
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def self.setup
+        require('./spec/spec_helper.rb')
+        self
       end
 
       # Run all unit specs per mutation
@@ -29,10 +26,10 @@ module Mutant
         #
         # @api private
         #
-        def spec_files(mutation)
-          ['spec/unit']
+        def self.spec_files(_mutation)
+          Dir['spec/unit/**/*_spec.rb']
         end
-      end
+      end # Unit
 
       # Run all integration specs per mutation
       class Integration < self
@@ -43,10 +40,10 @@ module Mutant
         #
         # @api private
         #
-        def spec_files(mutation)
+        def self.spec_files(_mutation)
           Dir['spec/integration/**/*_spec.rb']
         end
-      end
+      end # Integration
 
       # Run all specs per mutation
       class Full < self
@@ -57,10 +54,11 @@ module Mutant
         #
         # @api private
         #
-        def spec_files(mutation)
+        def self.spec_files(_mutation)
           Dir['spec/**/*_spec.rb']
         end
-      end
-    end
-  end
-end
+      end # Full
+
+    end # Rspec
+  end # Strategy
+end # Mutant

data/lib/mutant/strategy/static.rb

@@ -0,0 +1,18 @@
+module Mutant
+  class Strategy
+    # Static strategies
+    class Static < self
+
+      # Always fail to kill strategy
+      class Fail < self
+        KILLER = Killer::Static::Fail
+      end # Fail
+
+      # Always succeed to kill strategy
+      class Success < self
+        KILLER = Killer::Static::Success
+      end # Success
+
+    end # Static
+  end # Strategy
+end # Mutant

data/lib/mutant/strategy.rb

@@ -1,47 +1,27 @@
 module Mutant
 
   # Abstract base class for killing strategies
-  class Strategy 
-    include AbstractType, Adamantium::Flat, Equalizer.new
+  class Strategy
+    include AbstractType, Adamantium::Flat
 
-    # Return config
+    # Perform setup
     #
-    # @return [Config]
+    # @return [self]
     #
     # @api private
     #
-    attr_reader :config
-
-    # Initialize object
-    #
-    # @param [Config] config
-    #
-    # @return [undefined
-    #
-    # @api private
-    #
-    def initialize(config)
-      @config = config
-    end
-
-    # Return output stream
-    #
-    # @return [IO]
-    #
-    # @api private
-    #
-    def output_stream
-      config.reporter.output_stream
+    def self.setup
+      self
     end
 
-    # Return error stream
+    # Perform teardown
     #
-    # @return [IO]
+    # @return [self]
     #
     # @api private
     #
-    def error_stream
-      config.reporter.error_stream
+    def self.teardown
+      self
     end
 
     # Kill mutation
@@ -52,7 +32,7 @@ module Mutant
     #
     # @api private
     #
-    def kill(mutation)
+    def self.kill(mutation)
       killer.new(self, mutation)
     end
 
@@ -62,24 +42,9 @@ module Mutant
     #
     # @api private
     #
-    def killer
-      self.class::KILLER
+    def self.killer
+      self::KILLER
     end
 
-    # Static strategies
-    class Static < self
-      include Equalizer.new
-
-      # Always fail to kill strategy
-      class Fail < self
-        KILLER = Killer::Static::Fail
-      end
-
-      # Always succeed to kill strategy
-      class Success < self
-        KILLER = Killer::Static::Success
-      end
-
-    end
-  end
-end
+  end # Strategy
+end # Mutant