mutant 0.2.20 → 0.3.0.beta2

data/config/{site.reek → reek.yml}

@@ -1,104 +1,128 @@
 ---
-UncommunicativeParameterName:
-  accept: []
+Attribute:
+  enabled: false
   exclude: []
+BooleanParameter:
   enabled: true
-  reject:
-  - !ruby/regexp /^.$/
-  - !ruby/regexp /[0-9]$/
-  - !ruby/regexp /[A-Z]/
-LargeClass:
-  max_methods: 10
-  exclude: 
-  - "Mutant::Reporter::CLI" # 16 methods TODO Reduce!
-  - "Mutant::Reporter::Stats" # 6 ivars TODO Reduce!
-  - "Mutant::CLI" # 19 methods and 7 ivars, TODO Reduce!
-  enabled: true
-  max_instance_variables: 3
-UncommunicativeMethodName:
-  accept: 
-  - sha1
   exclude: []
+ClassVariable:
   enabled: true
-  reject:
-  - !ruby/regexp /^[a-z]$/
-  - !ruby/regexp /[0-9]$/
-  - !ruby/regexp /[A-Z]/
-LongParameterList:
-  max_params: 2
-  exclude: 
-  - "Mutant::Mutator::Node#new_send_with_arguments" # 3 params
-  - "Mutant::Context::Constant#initialize" # 3 params
-  - "Mutant::Subject#initialize" # 3 params
-  enabled: true
-  overrides: {}
-FeatureEnvy:
   exclude: []
+ControlParameter:
   enabled: true
-ClassVariable:
   exclude: []
+DataClump:
   enabled: true
-BooleanParameter:
   exclude: []
+  max_copies: 2
+  min_clump_size: 2
+DuplicateMethodCall:
+  enabled: false
+  exclude: []
+  max_calls: 1
+  allow_calls: []
+FeatureEnvy:
   enabled: true
+  exclude:
+  - Mutant::Matcher::Method::Singleton#receiver?
+  - Mutant::Matcher::Method::Instance#match?
+  - Mutant::CLI#parse
+  - Mutant::Mutation::Evil#success?
+  - Mutant::Mutation::Neutral#success?
+  - Mutant::Reporter::CLI#subject_results
 IrresponsibleModule:
+  enabled: true
   exclude: []
+LongParameterList:
   enabled: true
-UncommunicativeModuleName:
-  accept: 
-  - Mutant::Mutator::Node::Iter19
-  - Mutant::Strategy::Rspec::DM2
   exclude: []
+  max_params: 2
+LongYieldList:
   enabled: true
-  reject:
-  - !ruby/regexp /^.$/
-  - !ruby/regexp /[0-9]$/
+  exclude: []
+  max_params: 2
 NestedIterators:
-  ignore_iterators: []
-  exclude: 
-  - Mutant#self.define_singleton_subclass
-  - Mutant::Mutator::Util::Array::Element#dispatch
-  - Mutant::Mutator::Node::ReceiverCase#emit_when_branch_mutation
   enabled: true
+  exclude:
+  - Mutant#self.singleton_subclass_instance
+  - Mutant::Mutator::Util::Array::Element#dispatch
+  - Mutant::CLI#parse
   max_allowed_nesting: 1
-LongMethod:
-  max_statements: 6
-  exclude: []
+  ignore_iterators: []
+NilCheck:
   enabled: true
-Duplication:
-  allow_calls: []
-  exclude: 
-  - Mutant::Mutator::Node::Literal::Hash#emit_element_presence
+  exclude:
+  - Mutant::Matcher::Method#skip?
+RepeatedConditional:
   enabled: true
-  max_calls: 1
-UtilityFunction:
-  max_helper_calls: 0
-  exclude: []
+  exclude:
+  - Mutant::Mutator
+  - Mutant::Reporter::CLI
+  - Mutant::Mutator::Node::Send
+  - Mutant::Mutator::Node::If
+  max_ifs: 1
+TooManyInstanceVariables:
   enabled: true
-Attribute:
-  exclude: []
-  enabled: false
-UncommunicativeVariableName:
+  exclude:
+  - Mutant::CLI     # 4 vars
+  - Mutant::Killer  # 4 vars
+  max_instance_variables: 3
+TooManyMethods:
+  enabled: true
+  exclude:
+  - Mutant::CLI
+  - Mutant::Reporter::CLI
+  max_methods: 10
+TooManyStatements:
+  enabled: true
+  exclude:
+  - Mutant::CLI#parse
+  - Mutant::Reporter::CLI#colorized_diff
+  - Mutant::Reporter::CLI::Printer::Config::Runner#run
+  - Mutant#self.singleton_subclass_instance
+  max_statements: 6
+UncommunicativeMethodName:
+  enabled: true
+  exclude:
+  - Mutant::Mutation#sha1
+  - Mutant::NodeHelpers#s
+  reject:
+  - !ruby/regexp /^[a-z]$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
   accept: []
-  exclude: []
+UncommunicativeModuleName:
   enabled: true
+  exclude:
+  - Mutant::Strategy::Rspec::DM2
   reject:
   - !ruby/regexp /^.$/
   - !ruby/regexp /[0-9]$/
-  - !ruby/regexp /[A-Z]/
-SimulatedPolymorphism:
-  exclude: []
+  accept: []
+UncommunicativeParameterName:
   enabled: true
-  max_ifs: 1
-DataClump:
   exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UncommunicativeVariableName:
   enabled: true
-  max_copies: 2
-  min_clump_size: 2
-ControlCouple:
   exclude: []
+  reject:
+  - !ruby/regexp /^.$/
+  - !ruby/regexp /[0-9]$/
+  - !ruby/regexp /[A-Z]/
+  accept: []
+UnusedParameters:
   enabled: true
-LongYieldList:
-  max_params: 1
   exclude: []
+UtilityFunction:
   enabled: true
+  exclude:
+  - Mutant::NodeHelpers#s
+  - Mutant::CLI#reporter
+  - Mutant::Mutation::Evil#success?
+  - Mutant::Mutation::Neutral#success?
+  max_helper_calls: 0

data/lib/mutant/cli/classifier/method.rb

@@ -0,0 +1,100 @@
+module Mutant
+  class CLI
+    class Classifier
+      # Explicit method classifier
+      class Method < self
+        register
+
+        TABLE = {
+          '.' => Matcher::Methods::Singleton,
+          '#' => Matcher::Methods::Instance
+        }.freeze
+
+        REGEXP = %r(\A(#{SCOPE_PATTERN})([.#])(#{METHOD_NAME_PATTERN}\z)).freeze
+
+        # Positions of captured regexp groups
+        SCOPE_NAME_POSITION   = 1
+        SCOPE_SYMBOL_POSITION = 2
+        METHOD_NAME_POSITION  = 3
+
+        # Return method matcher
+        #
+        # @return [Matcher::Method]
+        #
+        # @api private
+        #
+        def matcher
+          methods_matcher.matcher.new(scope, method)
+        end
+        memoize :matcher
+
+      private
+
+        # Return method
+        #
+        # @return [Method, UnboundMethod]
+        #
+        # @api private
+        #
+        def method
+          methods_matcher.methods.detect do |method|
+            method.name == method_name
+          end or raise("Cannot find method #{identification}")
+        end
+        memoize :method, :freezer => :noop
+
+        # Return scope name
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def scope_name
+          match[SCOPE_NAME_POSITION]
+        end
+
+        # Return scope
+        #
+        # @return [Class, Method]
+        #
+        # @api private
+        #
+        def scope
+          Classifier.constant_lookup(scope_name)
+        end
+
+        # Return method name
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        def method_name
+          match[METHOD_NAME_POSITION].to_sym
+        end
+
+        # Return scope symbol
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        def scope_symbol
+          match[SCOPE_SYMBOL_POSITION]
+        end
+
+        # Return matcher class
+        #
+        # @return [Class:Mutant::Matcher]
+        #
+        # @api private
+        #
+        def methods_matcher
+          TABLE.fetch(scope_symbol).new(scope)
+        end
+        memoize :methods_matcher
+
+      end # Method
+    end # Classifier
+  end # CLI
+end # Mutant

data/lib/mutant/cli/classifier/namespace.rb

@@ -0,0 +1,47 @@
+module Mutant
+  class CLI
+    class Classifier
+
+      # Namespace classifier
+      class Namespace < self
+
+      private
+
+        # Return matcher
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def matcher
+          self.class::MATCHER.new(namespace)
+        end
+
+        # Return namespace
+        #
+        # @return [Class, Module]
+        #
+        # @api private
+        #
+        def namespace
+          Classifier.constant_lookup(match[1].to_s)
+        end
+
+        # Recursive namespace classifier
+        class Recursive < self
+          REGEXP = %r(\A(#{SCOPE_PATTERN})\*\z).freeze
+          MATCHER = Matcher::Namespace
+          register
+        end # Recursive
+
+        # Recursive namespace classifier
+        class Flat < self
+          REGEXP = %r(\A(#{SCOPE_PATTERN})\z).freeze
+          MATCHER = Matcher::Scope
+          register
+        end # Flat
+
+      end # Namespace
+    end # Classifier
+  end # CLI
+end # Mutant

data/lib/mutant/cli/classifier/scope.rb

@@ -0,0 +1,35 @@
+module Mutant
+  class CLI
+    class Classifier
+
+      # Scope classifier
+      class Scope < self
+
+        REGEXP = %r(\A(#{SCOPE_PATTERN})\z).freeze
+
+      private
+
+        # Return matcher
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def matcher
+          Matcher::Scope.new(scope)
+        end
+
+        # Return namespace
+        #
+        # @return [Class, Module]
+        #
+        # @api private
+        #
+        def scope
+          Classifier.constant_lookup(match[1].to_s)
+        end
+
+      end # Scope
+    end # Classifier
+  end # CLI
+end # Mutant

data/lib/mutant/cli/classifier.rb

@@ -0,0 +1,141 @@
+module Mutant
+  class CLI
+    # A classifier for input strings
+    class Classifier < Matcher
+      include AbstractType, Adamantium::Flat, Equalizer.new(:identification)
+
+      SCOPE_NAME_PATTERN  = /[A-Za-z][A-Za-z_0-9]*/.freeze
+      METHOD_NAME_PATTERN = /[_A-Za-z][A-Za-z0-9_]*[!?=]?/.freeze
+      SCOPE_PATTERN       = /(?:::)?#{SCOPE_NAME_PATTERN}(?:::#{SCOPE_NAME_PATTERN})*/.freeze
+
+      SINGLETON_PATTERN   = %r(\A(#{SCOPE_PATTERN})\z).freeze
+
+      REGISTRY = []
+
+      # Register classifier
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.register
+        REGISTRY << self
+      end
+      private_class_method :register
+
+      # Return constant
+      #
+      # @param [String] location
+      #
+      # @return [Class|Module]
+      #
+      # @api private
+      #
+      def self.constant_lookup(location)
+        location.gsub(%r(\A::), '').split('::').inject(::Object) do |parent, name|
+          parent.const_get(name)
+        end
+      end
+
+      # Return matchers for input
+      #
+      # @param [String] input
+      #
+      # @return [Classifier]
+      #   if a classifier handles the input
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      #
+      def self.build(input)
+        classifiers = REGISTRY.map do |descendant|
+          descendant.run(input)
+        end.compact
+
+        raise if classifiers.length > 1
+
+        classifiers.first
+      end
+
+      # Run classifier
+      #
+      # @return [Classifier]
+      #   if input is handled by classifier
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      #
+      def self.run(input)
+        match = self::REGEXP.match(input)
+        return unless match
+
+        new(match)
+      end
+
+      # No protected_class_method in ruby :(
+      class << self; protected :run; end
+
+      # Enumerate subjects
+      #
+      # @return [self]
+      #   if block given
+      #
+      # @return [Enumerator<Subject>]
+      #   otherwise
+      #
+      # @api private
+      #
+      def each(&block)
+        return to_enum unless block_given?
+        matcher.each(&block)
+        self
+      end
+
+      # Return identification
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def identification
+        match.to_s
+      end
+      memoize :identification
+
+    private
+
+      # Initialize object
+      #
+      # @param [MatchData] match
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(match)
+        @match = match
+      end
+
+      # Return match
+      #
+      # @return [MatchData]
+      #
+      # @api private
+      #
+      attr_reader :match
+
+      # Return matcher
+      #
+      # @return [Matcher]
+      #
+      # @api private
+      #
+      abstract_method :matcher
+
+    end # Classifier
+  end # CLI
+end # Mutant