mutest 0.0.1 → 0.0.2

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

@@ -0,0 +1,88 @@
+module Mutest
+  class Matcher
+    class Method
+      # Matcher for singleton methods
+      class Singleton < self
+        # New singleton method matcher
+        #
+        # @param [Class, Module] scope
+        # @param [Symbol] method_name
+        #
+        # @return [Matcher::Method::Singleton]
+        def self.new(scope, method_name)
+          super(scope, method_name, Evaluator)
+        end
+
+        # Singleton method evaluator
+        class Evaluator < Evaluator
+          SUBJECT_CLASS    = Subject::Method::Singleton
+          RECEIVER_INDEX   = 0
+          NAME_INDEX       = 1
+          RECEIVER_WARNING = 'Can only match :defs on :self or :const got %p unable to match'.freeze
+
+          private
+
+          # Test for node match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          def match?(node)
+            n_defs?(node) && line?(node) && name?(node) && receiver?(node)
+          end
+
+          # Test for line match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          def line?(node)
+            node
+              .location
+              .line
+              .equal?(source_line)
+          end
+
+          # Test for name match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          def name?(node)
+            node.children.fetch(NAME_INDEX).equal?(method_name)
+          end
+
+          # Test for receiver match
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          def receiver?(node)
+            receiver = node.children.fetch(RECEIVER_INDEX)
+            case receiver.type
+            when :self
+              true
+            when :const
+              receiver_name?(receiver)
+            else
+              env.warn(RECEIVER_WARNING % receiver.type)
+              nil
+            end
+          end
+
+          # Test if receiver name matches context
+          #
+          # @param [Parser::AST::Node] node
+          #
+          # @return [Boolean]
+          def receiver_name?(node)
+            name = node.children.fetch(NAME_INDEX)
+            name.to_s.eql?(context.unqualified_name)
+          end
+        end # Evaluator
+
+        private_constant(*constants(false))
+      end # Singleton
+    end # Method
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/methods.rb

@@ -0,0 +1,109 @@
+module Mutest
+  class Matcher
+    # Abstract base class for matcher that returns method subjects from scope
+    class Methods < self
+      include AbstractType, Concord.new(:scope)
+
+      CANDIDATE_NAMES = IceNine.deep_freeze(%i[
+        public_instance_methods
+        private_instance_methods
+        protected_instance_methods
+      ])
+
+      private_constant(*constants(false))
+
+      # Enumerate subjects
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [Enumerable<Subject>]
+      def call(env)
+        Chain.new(
+          methods.map { |method| matcher.new(scope, method) }
+        ).call(env)
+      end
+
+      private
+
+      # method matcher class
+      #
+      # @return [Class:Matcher::Method]
+      def matcher
+        self.class::MATCHER
+      end
+
+      # Available methods scope
+      #
+      # @return [Enumerable<Method, UnboundMethod>]
+      def methods
+        candidate_names.each_with_object([]) do |name, methods|
+          method = access(name)
+          methods << method if method.owner.equal?(candidate_scope)
+        end
+      end
+      memoize :methods
+
+      # Candidate method names on target scope
+      #
+      # @return [Enumerable<Symbol>]
+      def candidate_names
+        CANDIDATE_NAMES
+          .map(&candidate_scope.method(:public_send))
+          .reduce(:+)
+          .sort
+      end
+
+      # Candidate scope
+      #
+      # @return [Class, Module]
+      abstract_method :candidate_scope
+
+      # Matcher for singleton methods
+      class Singleton < self
+        MATCHER = Matcher::Method::Singleton
+
+        private
+
+        # Method object on scope
+        #
+        # @param [Symbol] method_name
+        #
+        # @return [Method]
+        def access(method_name)
+          scope.method(method_name)
+        end
+
+        # Candidate scope
+        #
+        # @return [Class]
+        def candidate_scope
+          scope.singleton_class
+        end
+        memoize :candidate_scope, freezer: :noop
+      end # Singleton
+
+      # Matcher for instance methods
+      class Instance < self
+        MATCHER = Matcher::Method::Instance
+
+        private
+
+        # Method object on scope
+        #
+        # @param [Symbol] method_name
+        #
+        # @return [UnboundMethod]
+        def access(method_name)
+          scope.instance_method(method_name)
+        end
+
+        # Candidate scope
+        #
+        # @return [Class, Module]
+        def candidate_scope
+          scope
+        end
+      end # Instance
+    end # Methods
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/namespace.rb

@@ -0,0 +1,41 @@
+module Mutest
+  class Matcher
+    # Matcher for specific namespace
+    class Namespace < self
+      include Concord::Public.new(:expression)
+
+      # Enumerate subjects
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [Enumerable<Subject>]
+      def call(env)
+        Chain.new(
+          matched_scopes(env).map { |scope| Scope.new(scope.raw) }
+        ).call(env)
+      end
+
+      private
+
+      # The matched scopes
+      #
+      # @param [Env] env
+      #
+      # @return [Enumerable<Scope>]
+      def matched_scopes(env)
+        env
+          .matchable_scopes
+          .select(&method(:match?))
+      end
+
+      # Test scope if matches expression
+      #
+      # @param [Scope] scope
+      #
+      # @return [Boolean]
+      def match?(scope)
+        expression.prefix?(scope.expression)
+      end
+    end # Namespace
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/null.rb

@@ -0,0 +1,17 @@
+module Mutest
+  class Matcher
+    # A null matcher, that does not match any subjects
+    class Null < self
+      include Concord.new
+
+      # Enumerate subjects
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [Enumerable<Subject>]
+      def call(_env)
+        EMPTY_ARRAY
+      end
+    end # Null
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/scope.rb

@@ -0,0 +1,38 @@
+module Mutest
+  class Matcher
+    # Matcher expanding Mutest::Scope objects into method matches
+    # at singleton or instance level
+    #
+    # If we *ever* get other subjects than methods, its likely the place
+    # to hook in custom matchers. In that case the scope matchers to expand
+    # should be passed as arguments to the constructor.
+    class Scope < self
+      include Concord.new(:scope)
+
+      MATCHERS = [
+        Matcher::Methods::Singleton,
+        Matcher::Methods::Instance
+      ].freeze
+
+      private_constant(*constants(false))
+
+      # Matched subjects
+      #
+      # @param [Env::Bootstrap] env
+      #
+      # @return [Enumerable<Subject>]
+      def call(env)
+        Chain.new(effective_matchers).call(env)
+      end
+
+      private
+
+      # Effective matchers
+      #
+      # @return [Enumerable<Matcher>]
+      def effective_matchers
+        MATCHERS.map { |matcher| matcher.new(scope) }
+      end
+    end # Scope
+  end # Matcher
+end # Mutest

data/lib/mutest/matcher/static.rb

@@ -0,0 +1,15 @@
+module Mutest
+  class Matcher
+    # Matcher returning subjects already known at its creation time
+    class Static
+      include Concord.new(:subjects)
+
+      # Call matcher
+      #
+      # @return [Enumerable<Subject>]
+      def call(_env)
+        subjects
+      end
+    end # Static
+  end # Matcher
+end # Mutest

data/lib/mutest/meta.rb

@@ -0,0 +1,33 @@
+module Mutest
+  # Namespace for mutest metadata
+  module Meta
+    require 'mutest/meta/example'
+    require 'mutest/meta/example/dsl'
+    require 'mutest/meta/example/verification'
+
+    # Mutation example
+    class Example
+      # rubocop:disable MutableConstant
+      ALL = []
+
+      # Add example
+      #
+      # @return [undefined]
+      def self.add(type, &block)
+        file = caller.first.split(':in', 2).first
+        ALL << DSL.call(file, type, block)
+      end
+
+      Pathname.glob(Pathname.new(__dir__).parent.parent.join('meta', '*.rb'))
+        .sort
+        .each(&method(:require))
+
+      ALL.freeze
+
+      # Remove mutation method only present for DSL executions from meta/**/*.rb
+      class << self
+        undef_method :add
+      end
+    end # Example
+  end # Meta
+end # Mutest

data/lib/mutest/meta/example.rb

@@ -0,0 +1,32 @@
+module Mutest
+  module Meta
+    class Example
+      include Adamantium, Anima.new(:file, :node, :node_type, :expected)
+
+      # Verification instance for example
+      #
+      # @return [Verification]
+      def verification
+        Verification.new(self, generated)
+      end
+
+      # Normalized source
+      #
+      # @return [String]
+      def source
+        Unparser.unparse(node)
+      end
+      memoize :source
+
+      # Generated mutations on example source
+      #
+      # @return [Enumerable<Mutest::Mutation>]
+      def generated
+        Mutator.mutate(node).map do |node|
+          Mutation::Evil.new(self, node)
+        end
+      end
+      memoize :generated
+    end # Example
+  end # Meta
+end # Mutest

data/lib/mutest/meta/example/dsl.rb

@@ -0,0 +1,107 @@
+module Mutest
+  module Meta
+    class Example
+      # Example DSL
+      class DSL
+        include AST::Sexp
+
+        # Run DSL on block
+        #
+        # @return [Example]
+        def self.call(file, type, block)
+          instance = new(file, type)
+          instance.instance_eval(&block)
+          instance.example
+        end
+
+        private_class_method :new
+
+        # Initialize object
+        #
+        # @return [undefined]
+        def initialize(file, type)
+          @file     = file
+          @type     = type
+          @node     = nil
+          @expected = []
+        end
+
+        # Example captured by DSL
+        #
+        # @return [Example]
+        #
+        # @raise [RuntimeError]
+        #   in case example cannot be build
+        def example
+          fail 'source not defined' unless @node
+          Example.new(
+            file:      @file,
+            node:      @node,
+            node_type: @type,
+            expected:  @expected
+          )
+        end
+
+        private
+
+        # Set original source
+        #
+        # @param [String,Parser::AST::Node] input
+        #
+        # @return [undefined]
+        def source(input)
+          fail 'source already defined' if @node
+          @node = node(input)
+        end
+
+        # Add expected mutation
+        #
+        # @param [String,Parser::AST::Node] input
+        #
+        # @return [undefined]
+        def mutation(input)
+          node = node(input)
+          if @expected.include?(node)
+            fail "Mutation for input: #{input.inspect} is already expected"
+          end
+          @expected << node
+        end
+
+        # Add singleton mutations
+        #
+        # @return [undefined]
+        def singleton_mutations
+          mutation('nil')
+          mutation('self')
+        end
+
+        # Add regexp mutations
+        #
+        # @return [undefined]
+        def regexp_mutations
+          mutation('//')
+          mutation('/nomatch\A/')
+        end
+
+        # Helper method to coerce input to node
+        #
+        # @param [String,Parser::AST::Node] input
+        #
+        # @return [Parser::AST::Node]
+        #
+        # @raise [RuntimeError]
+        #   in case input cannot be coerced
+        def node(input)
+          case input
+          when String
+            Unparser::Preprocessor.run(::Parser::CurrentRuby.parse(input))
+          when ::Parser::AST::Node
+            input
+          else
+            fail "Cannot coerce to node: #{input.inspect}"
+          end
+        end
+      end # DSL
+    end # Example
+  end # Meta
+end # Mutest