mutest 0.0.1 → 0.0.2

data/lib/mutest/isolation/none.rb

@@ -0,0 +1,23 @@
+module Mutest
+  # Module providing isolation
+  class Isolation
+    Error = Class.new(RuntimeError)
+
+    # Absolutly no isolation
+    #
+    # Only useful for debugging.
+    class None < self
+      # Call block in no isolation
+      #
+      # @return [Object]
+      #
+      # @raise [Error]
+      #   if block terminates abnormal
+      def call
+        yield
+      rescue => exception
+        raise Error, exception
+      end
+    end # None
+  end # Isolation
+end # Mutest

data/lib/mutest/loader.rb

@@ -0,0 +1,27 @@
+module Mutest
+  # Base class for code loaders
+  class Loader
+    include Anima.new(:binding, :kernel, :node, :subject)
+
+    # Call loader
+    #
+    # @return [self]
+    def self.call(*arguments)
+      new(*arguments).call
+    end
+
+    # Call loader
+    #
+    # One off the very few valid uses of eval
+    #
+    # @return [undefined]
+    def call
+      kernel.eval(
+        Unparser.unparse(node),
+        binding,
+        subject.source_path.to_s,
+        subject.source_line
+      )
+    end
+  end # Loader
+end # Mutest

data/lib/mutest/matcher.rb

@@ -0,0 +1,14 @@
+module Mutest
+  # Abstract matcher to find subjects to mutate
+  class Matcher
+    include Adamantium::Flat, AbstractType
+
+    # Call matcher
+    #
+    # @param [Env::Bootstrap] env
+    #
+    # @return [Enumerable<Subject>]
+    #
+    abstract_method :call
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/chain.rb

@@ -0,0 +1,19 @@
+module Mutest
+  class Matcher
+    # Matcher chaining results of other matchers together
+    class Chain < self
+      include Concord.new(:matchers)
+
+      # Call matcher
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [Enumerable<Subject>]
+      def call(env)
+        matchers.flat_map do |matcher|
+          matcher.call(env)
+        end
+      end
+    end # Chain
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/compiler.rb

@@ -0,0 +1,55 @@
+module Mutest
+  class Matcher
+    # Compiler for complex matchers
+    class Compiler
+      include Concord.new(:config), AST::Sexp, Procto.call(:result)
+
+      # Generated matcher
+      #
+      # @return [Matcher]
+      def result
+        Filter.new(
+          Chain.new(config.match_expressions.map(&:matcher)),
+          Morpher::Evaluator::Predicate::Boolean::And.new(
+            [
+              ignored_subjects,
+              filtered_subjects
+            ]
+          )
+        )
+      end
+
+      # Subject expression prefix predicate
+      class SubjectPrefix
+        include Concord.new(:expression)
+
+        # Test if subject expression is matched by prefix
+        #
+        # @return [Boolean]
+        def call(subject)
+          expression.prefix?(subject.expression)
+        end
+      end # SubjectPrefix
+
+      private
+
+      # Predicate returning false on expression ignored subject
+      #
+      # @return [#call]
+      def ignored_subjects
+        Morpher::Evaluator::Predicate::Boolean::Negation.new(
+          Morpher::Evaluator::Predicate::Boolean::Or.new(
+            config.ignore_expressions.map(&SubjectPrefix.method(:new))
+          )
+        )
+      end
+
+      # Predicate returning false on filtered subject
+      #
+      # @return [#call]
+      def filtered_subjects
+        Morpher::Evaluator::Predicate::Boolean::And.new(config.subject_filters)
+      end
+    end # Compiler
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/config.rb

@@ -0,0 +1,81 @@
+module Mutest
+  class Matcher
+    # Subject matcher configuration
+    #
+    # :reek:TooManyConstants
+    class Config
+      include Adamantium, Anima.new(
+        :ignore_expressions,
+        :match_expressions,
+        :subject_filters
+      )
+
+      INSPECT_FORMAT      = "#<#{self} %s>".freeze
+      ATTRIBUTE_DELIMITER = ' '.freeze
+      ATTRIBUTE_FORMAT    = '%s: [%s]'.freeze
+      ENUM_DELIMITER      = ','.freeze
+      EMPTY_ATTRIBUTES    = 'empty'.freeze
+      PRESENTATIONS       = IceNine.deep_freeze(
+        ignore_expressions: :syntax,
+        match_expressions:  :syntax,
+        subject_filters:    :inspect
+      )
+      private_constant(*constants(false))
+
+      DEFAULT = new(Hash[anima.attribute_names.map { |name| [name, []] }])
+
+      # Inspection string
+      #
+      # @return [String]
+      def inspect
+        INSPECT_FORMAT % inspect_attributes
+      end
+      memoize :inspect
+
+      # Add value to configurable collection
+      #
+      # @param [Symbol] attribute
+      # @param [Object] value
+      #
+      # @return [Config]
+      def add(attribute, value)
+        with(attribute => public_send(attribute) + [value])
+      end
+
+      private
+
+      # Present attributes
+      #
+      # @return [Array<Symbol>]
+      def present_attributes
+        to_h.reject { |_key, value| value.empty? }.keys
+      end
+
+      # Formatted attributes
+      #
+      # @return [String]
+      def inspect_attributes
+        attributes = present_attributes
+          .map(&method(:format_attribute))
+          .join(ATTRIBUTE_DELIMITER)
+
+        attributes.empty? ? EMPTY_ATTRIBUTES : attributes
+      end
+
+      # Format attribute
+      #
+      # @param [Symbol] attribute_name
+      #
+      # @return [String]
+      def format_attribute(attribute_name)
+        format(
+          ATTRIBUTE_FORMAT,
+          attribute_name,
+          public_send(attribute_name)
+            .map(&PRESENTATIONS.fetch(attribute_name))
+            .join(ENUM_DELIMITER)
+        )
+      end
+    end # Config
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/filter.rb

@@ -0,0 +1,19 @@
+module Mutest
+  class Matcher
+    # Matcher filter
+    class Filter < self
+      include Concord.new(:matcher, :predicate)
+
+      # Enumerate matches
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [Enumerable<Subject>]
+      def call(env)
+        matcher
+          .call(env)
+          .select(&predicate.method(:call))
+      end
+    end # Filter
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/method.rb

@@ -0,0 +1,138 @@
+module Mutest
+  class Matcher
+    # Abstract base class for method matchers
+    #
+    # :reek:TooManyMethods { max_methods: 11 }
+    class Method < self
+      include AbstractType,
+              Adamantium::Flat,
+              Concord::Public.new(:scope, :target_method, :evaluator)
+
+      # Methods within rbx kernel directory are precompiled and their source
+      # cannot be accessed via reading source location. Same for methods created by eval.
+      BLACKLIST = %r{\A(kernel/|\(eval\)\z)}
+
+      SOURCE_LOCATION_WARNING_FORMAT =
+        '%s does not have a valid source location, unable to emit subject'.freeze
+
+      CLOSURE_WARNING_FORMAT =
+        '%s is dynamically defined in a closure, unable to emit subject'.freeze
+
+      # Matched subjects
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [Enumerable<Subject>]
+      def call(env)
+        evaluator.call(scope, target_method, env)
+      end
+
+      # Abstract method match evaluator
+      #
+      # Present to avoid passing the env argument around in case the
+      # logic would be implemented directly on the Matcher::Method
+      # instance
+      class Evaluator
+        include AbstractType,
+                Adamantium,
+                Concord.new(:scope, :target_method, :env),
+                Procto.call,
+                AST::NodePredicates
+
+        # Matched subjects
+        #
+        # @return [Enumerable<Subject>]
+        def call
+          return EMPTY_ARRAY if skip?
+
+          [subject].compact
+        end
+
+        private
+
+        # Test if method should be skipped
+        #
+        # @return [Truthy]
+        def skip?
+          location = source_location
+          if location.nil? || BLACKLIST.match(location.first)
+            env.warn(SOURCE_LOCATION_WARNING_FORMAT % target_method)
+          elsif matched_node_path.any?(&method(:n_block?))
+            env.warn(CLOSURE_WARNING_FORMAT % target_method)
+          end
+        end
+
+        # Target method name
+        #
+        # @return [String]
+        def method_name
+          target_method.name
+        end
+
+        # Target context
+        #
+        # @return [Context]
+        def context
+          Context.new(scope, source_file)
+        end
+
+        # Root source node
+        #
+        # @return [Parser::AST::Node]
+        def ast
+          source_file.ast
+        end
+
+        def source_file
+          env.parser.open(source_path)
+        end
+        memoize :source_file
+
+        # Path to source
+        #
+        # @return [Pathname]
+        def source_path
+          env.config.pathname.new(source_location.first)
+        end
+        memoize :source_path
+
+        # Source file line
+        #
+        # @return [Fixnum]
+        def source_line
+          source_location.last
+        end
+
+        # Full source location
+        #
+        # @return [Array{String,Fixnum}]
+        def source_location
+          target_method.source_location
+        end
+
+        # Matched subject
+        #
+        # @return [Subject]
+        #   if there is a matched node
+        #
+        # @return [nil]
+        #   otherwise
+        def subject
+          node = matched_node_path.last || return
+          self.class::SUBJECT_CLASS.new(context, node)
+        end
+        memoize :subject
+
+        # Matched node path
+        #
+        # @return [Array<Parser::AST::Node>]
+        def matched_node_path
+          AST.find_last_path(ast, &method(:match?))
+        end
+        memoize :matched_node_path
+      end # Evaluator
+
+      private_constant(*constants(false))
+    end # Method
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/method/instance.rb

@@ -0,0 +1,63 @@
+module Mutest
+  class Matcher
+    class Method
+      # Matcher for instance methods
+      class Instance < self
+        # Dispatching builder, detects memoizable case
+        #
+        # @param [Class, Module] scope
+        # @param [UnboundMethod] method
+        #
+        # @return [Matcher::Method::Instance]
+        def self.new(scope, target_method)
+          name = target_method.name
+          evaluator =
+            if scope.include?(Memoizable) && scope.memoized?(name)
+              Evaluator::Memoized
+            else
+              Evaluator
+            end
+
+          super(scope, target_method, evaluator)
+        end
+
+        # Instance method specific evaluator
+        class Evaluator < Evaluator
+          SUBJECT_CLASS = Subject::Method::Instance
+          NAME_INDEX    = 0
+
+          private
+
+          # Check if node is matched
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          def match?(node)
+            n_def?(node) &&
+              node.location.line.equal?(source_line) &&
+              node.children.fetch(NAME_INDEX).equal?(method_name)
+          end
+
+          # Evaluator specialized for memoized instance methods
+          class Memoized < self
+            SUBJECT_CLASS = Subject::Method::Instance::Memoized
+
+            private
+
+            # Source location
+            #
+            # @return [Array{String,Fixnum}]
+            def source_location
+              scope
+                .unmemoized_instance_method(method_name)
+                .source_location
+            end
+          end # Memoized
+        end # Evaluator
+
+        private_constant(*constants(false))
+      end # Instance
+    end # Method
+  end # Matcher
+end # Mutest