mutest 0.0.1 → 0.0.2

data/lib/mutest/expression.rb

@@ -0,0 +1,55 @@
+module Mutest
+  # Abstract base class for match expression
+  class Expression
+    include AbstractType, Adamantium::Flat
+
+    fragment             = /[A-Za-z][A-Za-z\d_]*/
+    SCOPE_NAME_PATTERN   = /(?<scope_name>#{fragment}(?:#{SCOPE_OPERATOR}#{fragment})*)/
+    SCOPE_SYMBOL_PATTERN = '(?<scope_symbol>[.#])'.freeze
+
+    private_constant(*constants(false))
+
+    # Syntax of expression
+    #
+    # @return [String]
+    abstract_method :syntax
+
+    # Match length with other expression
+    #
+    # @param [Expression] other
+    #
+    # @return [Fixnum]
+    def match_length(other)
+      if eql?(other)
+        syntax.length
+      else
+        0
+      end
+    end
+
+    # Test if expression is prefix
+    #
+    # @param [Expression] other
+    #
+    # @return [Boolean]
+    def prefix?(other)
+      !match_length(other).zero?
+    end
+
+    # Try to parse input into expression of receiver class
+    #
+    # @param [String] input
+    #
+    # @return [Expression]
+    #   when successful
+    #
+    # @return [nil]
+    #   otherwise
+    def self.try_parse(input)
+      match = self::REGEXP.match(input)
+      return unless match
+      names = anima.attribute_names
+      new(Hash[names.zip(names.map(&match.method(:[])))])
+    end
+  end # Expression
+end # Mutest

data/lib/mutest/expression/method.rb

@@ -0,0 +1,54 @@
+module Mutest
+  class Expression
+    # Explicit method expression
+    class Method < self
+      include Anima.new(
+        :method_name,
+        :scope_name,
+        :scope_symbol
+      )
+
+      private(*anima.attribute_names)
+
+      MATCHERS = IceNine.deep_freeze(
+        '.' => Matcher::Methods::Singleton,
+        '#' => Matcher::Methods::Instance
+      )
+
+      METHOD_NAME_PATTERN = Regexp.union(
+        /(?<method_name>[A-Za-z_][A-Za-z\d_]*[!?=]?)/,
+        *AST::Types::OPERATOR_METHODS.map(&:to_s)
+      ).freeze
+
+      private_constant(*constants(false))
+
+      REGEXP = /\A#{SCOPE_NAME_PATTERN}#{SCOPE_SYMBOL_PATTERN}#{METHOD_NAME_PATTERN}\z/
+
+      # Syntax of expression
+      #
+      # @return [String]
+      def syntax
+        [scope_name, scope_symbol, method_name].join
+      end
+      memoize :syntax
+
+      # Matcher for expression
+      #
+      # @return [Matcher]
+      def matcher
+        methods_matcher = MATCHERS.fetch(scope_symbol).new(scope)
+
+        Matcher::Filter.new(methods_matcher, ->(subject) { subject.expression.eql?(self) })
+      end
+
+      private
+
+      # Scope object
+      #
+      # @return [Class, Method]
+      def scope
+        Object.const_get(scope_name)
+      end
+    end # Method
+  end # Expression
+end # Mutest

data/lib/mutest/expression/methods.rb

@@ -0,0 +1,58 @@
+module Mutest
+  class Expression
+    # Abstract base class for methods expression
+    class Methods < self
+      include Anima.new(
+        :scope_name,
+        :scope_symbol
+      )
+
+      private(*anima.attribute_names)
+
+      MATCHERS = IceNine.deep_freeze(
+        '.' => Matcher::Methods::Singleton,
+        '#' => Matcher::Methods::Instance
+      )
+      private_constant(*constants(false))
+
+      REGEXP = /\A#{SCOPE_NAME_PATTERN}#{SCOPE_SYMBOL_PATTERN}\z/
+
+      # Syntax of expression
+      #
+      # @return [String]
+      def syntax
+        [scope_name, scope_symbol].join
+      end
+      memoize :syntax
+
+      # Matcher on expression
+      #
+      # @return [Matcher::Method]
+      def matcher
+        MATCHERS.fetch(scope_symbol).new(scope)
+      end
+
+      # Length of match with other expression
+      #
+      # @param [Expression] expression
+      #
+      # @return [Fixnum]
+      def match_length(expression)
+        if expression.syntax.start_with?(syntax)
+          syntax.length
+        else
+          0
+        end
+      end
+
+      private
+
+      # Scope object
+      #
+      # @return [Class, Method]
+      def scope
+        Object.const_get(scope_name)
+      end
+    end # Methods
+  end # Expression
+end # Mutest

data/lib/mutest/expression/namespace.rb

@@ -0,0 +1,75 @@
+module Mutest
+  class Expression
+    # Abstract base class for expressions matching namespaces
+    class Namespace < self
+      include AbstractType, Anima.new(:scope_name)
+      private(*anima.attribute_names)
+
+      # Recursive namespace expression
+      class Recursive < self
+        REGEXP = /\A#{SCOPE_NAME_PATTERN}?\*\z/
+
+        # Initialize object
+        #
+        # @return [undefined]
+        def initialize(*)
+          super
+          @recursion_pattern = Regexp.union(
+            /\A#{scope_name}\z/,
+            /\A#{scope_name}::/,
+            /\A#{scope_name}[.#]/
+          )
+        end
+
+        # Syntax for expression
+        #
+        # @return [String]
+        def syntax
+          "#{scope_name}*"
+        end
+        memoize :syntax
+
+        # Matcher for expression
+        #
+        # @return [Matcher]
+        def matcher
+          Matcher::Namespace.new(self)
+        end
+
+        # Length of match with other expression
+        #
+        # @param [Expression] expression
+        #
+        # @return [Fixnum]
+        def match_length(expression)
+          if @recursion_pattern =~ expression.syntax
+            scope_name.length
+          else
+            0
+          end
+        end
+      end # Recursive
+
+      # Exact namespace expression
+      class Exact < self
+        MATCHER = Matcher::Scope
+        private_constant(*constants(false))
+
+        REGEXP = /\A#{SCOPE_NAME_PATTERN}\z/
+
+        # Matcher matcher on expression
+        #
+        # @return [Matcher]
+        def matcher
+          Matcher::Scope.new(Object.const_get(scope_name))
+        end
+
+        # Syntax for expression
+        #
+        # @return [String]
+        alias_method :syntax, :scope_name
+        public :syntax
+      end # Exact
+    end # Namespace
+  end # Expression
+end # Mutest

data/lib/mutest/expression/parser.rb

@@ -0,0 +1,64 @@
+module Mutest
+  class Expression
+    class Parser
+      include Concord.new(:types)
+
+      class ParserError < RuntimeError
+        include AbstractType
+      end # ParserError
+
+      # Error raised on invalid expressions
+      class InvalidExpressionError < ParserError; end
+
+      # Error raised on ambiguous expressions
+      class AmbiguousExpressionError < ParserError; end
+
+      # Parse input into expression or raise
+      #
+      # @param [String] syntax
+      #
+      # @return [Expression]
+      #   if expression is valid
+      #
+      # @raise [ParserError]
+      #   otherwise
+      def call(input)
+        try_parse(input) or fail InvalidExpressionError, "Expression: #{input.inspect} is not valid"
+      end
+
+      # Try to parse input into expression
+      #
+      # @param [String] input
+      #
+      # @return [Expression]
+      #   if expression is valid
+      #
+      # @return [nil]
+      #   otherwise
+      def try_parse(input)
+        expressions = expressions(input)
+        case expressions.length
+        when 0, 1
+          expressions.first
+        else
+          fail AmbiguousExpressionError, "Ambiguous expression: #{input.inspect}"
+        end
+      end
+
+      private
+
+      # Expressions parsed from input
+      #
+      # @param [String] input
+      #
+      # @return [Array<Expression>]
+      #   if expressions can be parsed from input
+      def expressions(input)
+        types.each_with_object([]) do |type, aggregate|
+          expression = type.try_parse(input)
+          aggregate << expression if expression
+        end
+      end
+    end # Parser
+  end # Expression
+end # Mutest

data/lib/mutest/integration.rb

@@ -0,0 +1,75 @@
+module Mutest
+  # Abstract base class mutest test framework integrations
+  class Integration
+    include AbstractType, Adamantium::Flat, Concord.new(:config)
+
+    # Setup integration
+    #
+    # Integrations are supposed to define a constant under
+    # Mutest::Integration named after the capitalized +name+
+    # parameter.
+    #
+    # This avoids having to maintain a mutable registry.
+    #
+    # @param kernel [Kernel]
+    # @param name [String]
+    #
+    # @return [Class<Integration>]
+    def self.setup(kernel, name)
+      kernel.require("mutest/integration/#{name}")
+      const_get(name.capitalize)
+    end
+
+    # Perform integration setup
+    #
+    # @return [self]
+    def setup
+      self
+    end
+
+    # Run a collection of tests
+    #
+    # @param [Enumerable<Test>] tests
+    #
+    # @return [Result::Test]
+    abstract_method :call
+
+    # Available tests for integration
+    #
+    # @return [Enumerable<Test>]
+    abstract_method :all_tests
+
+    private
+
+    # Expression parser
+    #
+    # @return [Expression::Parser]
+    def expression_parser
+      config.expression_parser
+    end
+
+    # Null integration that never kills a mutation
+    class Null < self
+      # Available tests for integration
+      #
+      # @return [Enumerable<Test>]
+      def all_tests
+        EMPTY_ARRAY
+      end
+
+      # Run a collection of tests
+      #
+      # @param [Enumerable<Mutest::Test>] tests
+      #
+      # @return [Result::Test]
+      def call(tests)
+        Result::Test.new(
+          output:  '',
+          passed:  true,
+          runtime: 0.0,
+          tests:   tests
+        )
+      end
+    end # Null
+  end # Integration
+end # Mutest

data/lib/mutest/isolation.rb

@@ -0,0 +1,11 @@
+module Mutest
+  class Isolation
+    include AbstractType
+
+    # Call block in isolation
+    #
+    # @return [Object]
+    #   the blocks result
+    abstract_method :call
+  end # Isolation
+end # Mutest

data/lib/mutest/isolation/fork.rb

@@ -0,0 +1,72 @@
+module Mutest
+  class Isolation
+    # Isolation via the fork(2) systemcall.
+    #
+    # We do inject so many globals and common patterns to make this unit
+    # specifiable without mocking the globals and more important: Not having
+    # mutations that bypass mocks into a real world side effect.
+    class Fork < self
+      include Anima.new(:process, :stderr, :stdout, :io, :devnull, :marshal)
+
+      # Prevent mutation from `process.fork` to `fork` to call Kernel#fork
+      undef_method :fork
+
+      # Call block in isolation
+      #
+      # @return [Object]
+      #   returns block execution result
+      #
+      # @raise [Error]
+      #   if block terminates abnormal
+      def call(&block)
+        io.pipe(binmode: true) do |pipes|
+          parent(*pipes, &block)
+        end
+      rescue => exception
+        raise Error, exception
+      end
+
+      # Handle parent process
+      #
+      # @param [IO] reader
+      # @param [IO] writer
+      #
+      # @return [undefined]
+      def parent(reader, writer, &block)
+        pid =
+          process.fork do
+            child(reader, writer, &block)
+          end
+
+        writer.close
+        marshal.load(reader)
+      ensure
+        process.waitpid(pid) if pid
+      end
+
+      # Handle child process
+      #
+      # @param [IO] reader
+      # @param [IO] writer
+      #
+      # @return [undefined]
+      def child(reader, writer, &block)
+        reader.close
+        writer.binmode
+        writer.syswrite(marshal.dump(result(&block)))
+        writer.close
+      end
+
+      # The block result computed under silencing
+      #
+      # @return [Object]
+      def result
+        devnull.call do |null|
+          stderr.reopen(null)
+          stdout.reopen(null)
+          yield
+        end
+      end
+    end # Fork
+  end # Isolation
+end # Mutest