mutant 0.5.17 → 0.5.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ed19319f31c14a3b2677f67cda130f8ae053af1
-  data.tar.gz: 6cb628e6e446ed9d1f0c14ad88cfd254d49ee216
+  metadata.gz: e86610168e1a64b920f694f5854137186fb808e0
+  data.tar.gz: e33eeafaebdb1a32042f56e03ed0794e25056f16
 SHA512:
-  metadata.gz: 482eeee0d39d0e9b869b6a0625d71bf7b08bbdf8acff2fc9f29b44a9b74472cd038e166f053e17323dd41d46295f802245db69d7bb6dc7085336243bc448351b
-  data.tar.gz: f332afc9b4404fbcb8ee20e5e74fe6789df531c856d1fc4562d5cb92dee1d771d900405ba044f5360bad39f6400002786584da7f0f4c6efce0be2c5bd4ba5f64
+  metadata.gz: 6237bcc40f7b53097546148fe68488f7b8af9e7c5e9b348cc3fa2811a3fb860f9b92b551ad3daf7aed87158061cc0ade88e894154352f54c6b50a2b0effee5d9
+  data.tar.gz: 42a09a5d0011978606d9ee12fae5bc1b9d4f2919a11aa783dcdc088f22127edd99fbb66a42c1ef7ab2c04efbc842b15c2e8f13af0ffa33ae3c481059ef4495b6

data/Changelog.md

@@ -1,3 +1,9 @@
+# v0.5.18 2014-06-04
+
+Changes:
+
+* Do not rename lhs of or assigns when lhs is a ivasgn. Closes #150
+
 # v0.5.17 2014-05-27
 
 Changes:

data/Rakefile

@@ -15,3 +15,16 @@ if ENV['TRAVIS']
     end
   end
 end
+
+desc 'Generate mutation operator listing'
+task :list do
+  require 'mutant'
+  # TODO: Add a nice public interface
+  registry = Mutant::Mutator::Registry.send(:registry)
+  registry.keys.select do |key|
+    key.is_a?(Symbol)
+  end.sort.each do |type|
+    mutator = registry.fetch(type)
+    puts '%-18s: %s' % [type, mutator.name.sub(/\AMutant::Mutator::Node::/, '')]
+  end
+end

data/config/flay.yml

@@ -1,3 +1,3 @@
 ---
 threshold: 18
-total_score: 801
+total_score: 849

data/config/reek.yml

@@ -10,7 +10,8 @@ ClassVariable:
   exclude: []
 ControlParameter:
   enabled: true
-  exclude: []
+  exclude:
+  - Mutant::Expression#match_length
 DataClump:
   enabled: true
   exclude: []
@@ -33,6 +34,8 @@ FeatureEnvy:
   # Nature of OptionParser :(
   - Mutant::CLI#add_environmental_options
   - Mutant::CLI#parse
+  # False positive, its a utility
+  - Mutant::Meta::Example::Verification#format_mutation
 IrresponsibleModule:
   enabled: true
   exclude: []
@@ -69,6 +72,7 @@ RepeatedConditional:
   - Mutant::Mutator
   - Mutant::Rspec::Strategy
   - Mutant::Reporter::CLI
+  - Mutant::Meta::Example::DSL
   max_ifs: 1
 TooManyInstanceVariables:
   enabled: true
@@ -94,6 +98,8 @@ TooManyStatements:
   - Mutant::Reporter::CLI#colorized_diff
   - Mutant::Reporter::CLI::Report::Config#run
   - Mutant::Runner#visit_collection
+  - Mutant::Runner#initialize
+  - Mutant::Runner::Mutation#run
   - Mutant::Zombifier::File#self.find
   - Mutant::RequireHighjack#infect
   - Mutant::Reporter::CLI::Registry#included
@@ -152,4 +158,5 @@ UtilityFunction:
   - Mutant::Rspec::Strategy#options
   - Mutant::Rspec::Strategy#world
   - Mutant::Rspec::Strategy#rspec2
+  - Mutant::Meta::Example::Verification#format_mutation
   max_helper_calls: 0

data/lib/mutant.rb

@@ -26,6 +26,20 @@ module Mutant
   # The frozen empty array used within mutant
   EMPTY_ARRAY = [].freeze
 
+  # Lookup constant for location
+  #
+  # @param [String] location
+  #
+  # @return [Object]
+  #
+  # @api private
+  #
+  def self.constant_lookup(location)
+    location.sub(CBASE_PATTERN, EMPTY_STRING).split(SCOPE_OPERATOR).reduce(Object) do |parent, name|
+      parent.const_get(name, nil)
+    end
+  end
+
   # Perform self zombification
   #
   # @return [self]
@@ -144,6 +158,7 @@ require 'mutant/mutator/node/named_value/constant_assignment'
 require 'mutant/mutator/node/named_value/variable_assignment'
 require 'mutant/mutator/node/loop_control'
 require 'mutant/mutator/node/noop'
+require 'mutant/mutator/node/or_asgn'
 require 'mutant/mutator/node/op_asgn'
 require 'mutant/mutator/node/conditional_loop'
 require 'mutant/mutator/node/yield'
@@ -186,6 +201,9 @@ require 'mutant/matcher/namespace'
 require 'mutant/matcher/scope'
 require 'mutant/matcher/filter'
 require 'mutant/matcher/null'
+require 'mutant/expression'
+require 'mutant/expression/method'
+require 'mutant/expression/namespace'
 require 'mutant/killer'
 require 'mutant/test'
 require 'mutant/strategy'
@@ -195,9 +213,6 @@ require 'mutant/runner/subject'
 require 'mutant/runner/mutation'
 require 'mutant/runner/killer'
 require 'mutant/cli'
-require 'mutant/cli/classifier'
-require 'mutant/cli/classifier/namespace'
-require 'mutant/cli/classifier/method'
 require 'mutant/color'
 require 'mutant/diff'
 require 'mutant/reporter'

data/lib/mutant/cli.rb

@@ -249,8 +249,11 @@ module Mutant
     #
     def parse_matchers(patterns)
       patterns.each do |pattern|
-        matcher = Classifier.run(@cache, pattern)
-        @builder.add_matcher(matcher)
+        expression = Expression.parse(pattern)
+        unless expression
+          raise Error, "Invalid mutant expression: #{pattern.inspect}"
+        end
+        @builder.add_matcher(expression.matcher(@cache))
       end
     end
 
@@ -321,7 +324,7 @@ module Mutant
     #
     def add_filter_options(opts)
       opts.on('--ignore-subject PATTERN', 'Ignore subjects that match PATTERN') do |pattern|
-        @builder.add_subject_ignore(Classifier.run(@cache, pattern))
+        @builder.add_subject_ignore(Expression.parse(pattern).matcher(@cache))
       end
       opts.on('--code CODE', 'Scope execution to subjects with CODE') do |code|
         @builder.add_subject_selector(Morpher.compile(s(:eql, s(:attribute, :code), s(:static, code))))

data/lib/mutant/constants.rb

@@ -4,6 +4,9 @@ module Mutant
 
   symbolset = ->(strings) { strings.map(&:to_sym).to_set.freeze }
 
+  SCOPE_OPERATOR     = '::'.freeze
+  CBASE_PATTERN      = /\A#{SCOPE_OPERATOR}/.freeze
+
   # Set of nodes that cannot be on the LHS of an assignment
   NOT_ASSIGNABLE = symbolset.(%w[int float str dstr class module self])
 

data/lib/mutant/expression.rb

@@ -0,0 +1,110 @@
+module Mutant
+
+  # Abstract base class for match expression
+  class Expression
+    include AbstractType, Adamantium, Concord::Public.new(:match)
+
+    include Equalizer.new(:syntax)
+
+    SCOPE_NAME_PATTERN = /[A-Za-z][A-Za-z\d_]*/.freeze
+
+    METHOD_NAME_PATTERN = Regexp.union(
+      /[A-Za-z_][A-Za-z\d_]*[!?=]?/,
+      *OPERATOR_METHODS.map(&:to_s)
+    ).freeze
+
+    SCOPE_PATTERN = /
+      (?:#{SCOPE_OPERATOR})?#{SCOPE_NAME_PATTERN}
+      (?:#{SCOPE_OPERATOR}#{SCOPE_NAME_PATTERN})*
+    /x.freeze
+
+    REGISTRY = {}
+
+    # Initialize expression
+    #
+    # @param [MatchData] match
+    def initialize(*)
+      super
+      @syntax = match.to_s
+    end
+
+    # Return syntax
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    attr_reader :syntax
+
+    # Return match length for expression
+    #
+    # @param [Expression] neddle
+    #
+    # @return [Fixnum]
+    #
+    def match_length(neddle)
+      if eql?(neddle)
+        syntax.length
+      else
+        0
+      end
+    end
+
+    # Register expression
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.register(regexp)
+      REGISTRY[regexp] = self
+    end
+    private_class_method :register
+
+    # Parse input into expression
+    #
+    # @param [String] pattern
+    #
+    # @return [Expression]
+    #   if expression is valid
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def self.parse(pattern)
+      expressions = expressions(pattern)
+      case expressions.length
+      when 0
+      when 1
+        expressions.first
+      else
+        fail "Ambigous expression: #{pattern.inspect}"
+      end
+    end
+
+    # Return expressions for input
+    #
+    # @param [String] input
+    #
+    # @return [Classifier]
+    #   if classifier can be found
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def self.expressions(input)
+      REGISTRY.each_with_object([]) do |(regexp, klass), expressions|
+        match = regexp.match(input)
+        if match
+          expressions << klass.new(match)
+        end
+      end
+    end
+    private_class_method :expressions
+
+  end # Expression
+end # Mutant

data/lib/mutant/expression/method.rb

@@ -0,0 +1,92 @@
+module Mutant
+  class Expression
+
+    # Explicit method expression
+    class Method < self
+
+      MATCHERS = {
+        '.' => Matcher::Methods::Singleton,
+        '#' => Matcher::Methods::Instance
+      }.freeze
+
+      regexp = /
+        \A
+          (?<scope_name>#{SCOPE_PATTERN})
+          (?<scope_symbol>[.#])
+          (?<method_name>#{METHOD_NAME_PATTERN})
+        \z
+      /x.freeze
+
+      register(regexp)
+
+      # Return method matcher
+      #
+      # @param [Cache] cache
+      #
+      # @return [Matcher::Method]
+      #
+      # @api private
+      #
+      def matcher(cache)
+        methods_matcher = MATCHERS.fetch(scope_symbol).new(cache, scope)
+        method = methods_matcher.methods.detect do |meth|
+          meth.name == method_name
+        end or raise NameError, "Cannot find method #{identifier}"
+        methods_matcher.matcher.build(cache, scope, method)
+      end
+
+    private
+
+      # Return scope name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def scope_name
+        match[__method__]
+      end
+
+      # Return scope
+      #
+      # @return [Class, Method]
+      #
+      # @api private
+      #
+      def scope
+        Mutant.constant_lookup(scope_name)
+      end
+
+      # Return method name
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def method_name
+        match[__method__].to_sym
+      end
+
+      # Return scope symbol
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def scope_symbol
+        match[__method__]
+      end
+
+      # Return matcher class
+      #
+      # @return [Class:Mutant::Matcher]
+      #
+      # @api private
+      #
+      def methods_matcher(cache)
+        MATCHERS.fetch(scope_symbol).new(cache, scope)
+      end
+
+    end # Method
+  end # Expression
+end # Mutant

data/lib/mutant/expression/namespace.rb

@@ -0,0 +1,90 @@
+module Mutant
+  class Expression
+    # Abstract base class for expressions matching namespaces
+    class Namespace < self
+      include AbstractType
+
+      # Return matcher
+      #
+      # @param [Cache] cache
+      #
+      # @return [Matcher]
+      #
+      # @api private
+      #
+      def matcher(cache)
+        self.class::MATCHER.new(cache, namespace)
+      end
+
+    private
+
+      # Return namespace
+      #
+      # @return [Class, Module]
+      #
+      # @api private
+      #
+      def namespace
+        Mutant.constant_lookup(match[__method__].to_s)
+      end
+
+      # Recursive namespace expression
+      class Recursive < self
+
+        register(/\A(?<namespace>#{SCOPE_PATTERN})?\*\z/)
+
+        MATCHER = Matcher::Namespace
+
+        # Initialize object
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(*)
+          super
+          namespace_src = Regexp.escape(namespace)
+          @recursion_pattern = Regexp.union(/\A#{namespace_src}\z/, /\A#{namespace_src}::/)
+        end
+
+        # Return length of match
+        #
+        # @param [Expression] expression
+        #
+        # @return [Fixnum]
+        #
+        # @api private
+        #
+        def match_length(expression)
+          if @recursion_pattern =~ expression.syntax
+            namespace.length
+          else
+            0
+          end
+        end
+
+      private
+
+        # Return matched namespace
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def namespace
+          match[__method__] || ''
+        end
+
+      end # Recursive
+
+      # Exact namespace expression
+      class Exact < self
+
+        register(/\A(?<namespace>#{SCOPE_PATTERN})\z/)
+
+        MATCHER = Matcher::Scope
+
+      end # Exact
+
+    end # Namespace
+  end # Namespace
+end # Mutant