mutest 0.0.1 → 0.0.2

data/lib/mutest/ast/meta.rb

@@ -0,0 +1,7 @@
+module Mutest
+  module AST
+    # Node meta information mixin
+    module Meta
+    end # Meta
+  end # AST
+end # Mutest

data/lib/mutest/ast/meta/const.rb

@@ -0,0 +1,22 @@
+module Mutest
+  module AST
+    # Node meta information mixin
+    module Meta
+      # Metadata for const nodes
+      class Const
+        include NamedChildren, Concord.new(:node), NodePredicates
+
+        children :base, :name
+
+        public :base, :name
+
+        # Test if AST node is possibly a top level constant
+        #
+        # @return [Boolean]
+        def possible_top_level?
+          base.nil? || n_cbase?(base)
+        end
+      end # Const
+    end # Meta
+  end # AST
+end # Mutest

data/lib/mutest/ast/meta/optarg.rb

@@ -0,0 +1,24 @@
+module Mutest
+  module AST
+    # Node meta information mixin
+    module Meta
+      # Metadata for optional argument nodes
+      class Optarg
+        include NamedChildren, Concord.new(:node)
+
+        UNDERSCORE = '_'.freeze
+
+        children :name, :default_value
+
+        public :name, :default_value
+
+        # Test if optarg definition intends to be used
+        #
+        # @return [Boolean]
+        def used?
+          !name.to_s.start_with?(UNDERSCORE)
+        end
+      end # Optarg
+    end # Meta
+  end # AST
+end # Mutest

data/lib/mutest/ast/meta/resbody.rb

@@ -0,0 +1,15 @@
+module Mutest
+  module AST
+    # Node meta information mixin
+    module Meta
+      # Metadata for resbody nodes
+      class Resbody
+        include NamedChildren, Concord.new(:node)
+
+        children :captures, :assignment, :body
+
+        public :captures, :assignment, :body
+      end # Resbody
+    end # Meta
+  end # AST
+end # Mutest

data/lib/mutest/ast/meta/restarg.rb

@@ -0,0 +1,15 @@
+module Mutest
+  module AST
+    # Node meta information mixin
+    module Meta
+      # Metadata for restarg nodes
+      class Restarg
+        include NamedChildren, Concord.new(:node)
+
+        children :name
+
+        public :name
+      end # Restarg
+    end # Meta
+  end # AST
+end # Mutest

data/lib/mutest/ast/meta/send.rb

@@ -0,0 +1,89 @@
+module Mutest
+  module AST
+    # Node meta information mixin
+    module Meta
+      # Metadata for send nodes
+      class Send
+        include NamedChildren, Concord.new(:node), NodePredicates
+
+        children :receiver, :selector
+
+        public :receiver, :selector
+
+        INDEX_ASSIGNMENT_SELECTOR            = :[]=
+        ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX = '='.freeze
+
+        # Arguments of mutated node
+        #
+        # @return [Enumerable<Parser::AST::Node>]
+        alias_method :arguments, :remaining_children
+
+        public :arguments
+
+        # Test if node is defining a proc
+        #
+        # @return [Boolean]
+        def proc?
+          naked_proc? || proc_new?
+        end
+
+        # Test if AST node is a valid assignment target
+        #
+        # @return [Boolean]
+        def assignment?
+          index_assignment? || attribute_assignment?
+        end
+
+        # Test if AST node is an attribute assignment?
+        #
+        # @return [Boolean]
+        def attribute_assignment?
+          !Types::METHOD_OPERATORS.include?(selector) &&
+            selector.to_s.end_with?(ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX)
+        end
+
+        # Test if AST node is an index assign
+        #
+        # @return [Boolean]
+        def index_assignment?
+          selector.equal?(INDEX_ASSIGNMENT_SELECTOR)
+        end
+
+        # Test for binary operator implemented as method
+        #
+        # @return [Boolean]
+        def binary_method_operator?
+          Types::BINARY_METHOD_OPERATORS.include?(selector)
+        end
+
+        # Test if receiver is possibly a top level constant
+        #
+        # @return [Boolean]
+        def receiver_possible_top_level_const?
+          return false unless receiver && n_const?(receiver)
+
+          Const.new(receiver).possible_top_level?
+        end
+
+        private
+
+        # Test if node is `proc { ... }`
+        #
+        # @return [Boolean]
+        def naked_proc?
+          !receiver && selector.equal?(:proc)
+        end
+
+        # Test if node is `Proc.new { ... }`
+        #
+        # @return [Boolean]
+        def proc_new?
+          receiver                &&
+            selector.equal?(:new) &&
+            n_const?(receiver)    &&
+            Const.new(receiver).name.equal?(:Proc)
+        end
+      end # Send
+    end # Meta
+  end # AST
+end # Mutest

data/lib/mutest/ast/meta/symbol.rb

@@ -0,0 +1,15 @@
+module Mutest
+  module AST
+    # Node meta information mixin
+    module Meta
+      # Metadata for symbol nodes
+      class Symbol
+        include NamedChildren, Concord.new(:node)
+
+        children :name
+
+        public :name
+      end # Symbol
+    end # Meta
+  end # AST
+end # Mutest

data/lib/mutest/ast/named_children.rb

@@ -0,0 +1,86 @@
+module Mutest
+  module AST
+    # Helper methods to define named children
+    module NamedChildren
+      # Hook called when module gets included
+      #
+      # @param [Class, Module] host
+      #
+      # @return [undefined]
+      def self.included(host)
+        host.class_eval do
+          include InstanceMethods
+          extend ClassMethods
+        end
+      end
+
+      # Methods mixed int ot instance level
+      module InstanceMethods
+        private
+
+        # Mutated nodes children
+        #
+        # @return [Array<Parser::AST::Node]
+        def children
+          node.children
+        end
+      end # InstanceMethods
+
+      # Methods mixed in at class level
+      module ClassMethods
+        private
+
+        # Define named child
+        #
+        # @param [Symbol] name
+        # @param [Fixnum] index
+        #
+        # @return [undefined]
+        def define_named_child(name, index)
+          define_private_method(name) do
+            children.at(index)
+          end
+        end
+
+        # Define remaining children
+        #
+        # @param [Array<Symbol>] names
+        #
+        # @return [undefined]
+        def define_remaining_children(names)
+          define_private_method(:remaining_children_with_index) do
+            children.each_with_index.drop(names.length)
+          end
+
+          define_private_method(:remaining_children_indices) do
+            children.each_index.drop(names.length)
+          end
+
+          define_private_method(:remaining_children) do
+            children.drop(names.length)
+          end
+        end
+
+        # Create name helpers
+        #
+        # @return [undefined]
+        def children(*names)
+          names.each_with_index do |name, index|
+            define_named_child(name, index)
+          end
+          define_remaining_children(names)
+        end
+
+        # Define private method
+        #
+        # @param [Symbol] name
+        #
+        # @return [undefined]
+        def define_private_method(name, &block)
+          define_method(name, &block)
+          private(name)
+        end
+      end # ClassMethods
+    end # NamedChildren
+  end # AST
+end # Mutest

data/lib/mutest/ast/node_predicates.rb

@@ -0,0 +1,17 @@
+module Mutest
+  module AST
+    # Module for node predicates
+    module NodePredicates
+      Types::ALL.each do |type|
+        fail "method: #{type} is already defined" if instance_methods(true).include?(type)
+
+        name = "n_#{type.to_s.chomp('?')}?"
+
+        define_method(name) do |node|
+          node.type.equal?(type)
+        end
+        private name
+      end
+    end # NodePredicates
+  end # AST
+end # Mutest

data/lib/mutest/ast/nodes.rb

@@ -0,0 +1,22 @@
+module Mutest
+  module AST
+    # Singleton nodes
+    #
+    # :reek:TooManyConstants
+    module Nodes
+      extend Sexp
+
+      N_NAN               = s(:send, s(:float,  0.0), :/, s(:float, 0.0))
+      N_INFINITY          = s(:send, s(:float,  1.0), :/, s(:float, 0.0))
+      N_NEGATIVE_INFINITY = s(:send, s(:float, -1.0), :/, s(:float, 0.0))
+      N_RAISE             = s(:send, nil, :raise)
+      N_TRUE              = s(:true)
+      N_FALSE             = s(:false)
+      N_NIL               = s(:nil)
+      N_EMPTY             = s(:empty)
+      N_SELF              = s(:self)
+      N_ZSUPER            = s(:zsuper)
+      N_EMPTY_SUPER       = s(:super)
+    end # Nodes
+  end # AST
+end # Mutest

data/lib/mutest/ast/regexp.rb

@@ -0,0 +1,50 @@
+module Mutest
+  module AST
+    # Regexp source mapper
+    module Regexp
+      UNSUPPORTED_EXPRESSION_TYPE = :conditional
+
+      private_constant(*constants(false))
+
+      # Parse regex string into expression
+      #
+      # @param regexp [String]
+      #
+      # @return [Regexp::Expression]
+      def self.parse(regexp)
+        ::Regexp::Parser.parse(regexp)
+      end
+
+      # Check if expression is supported by mapper
+      #
+      # @param expression [Regexp::Expression]
+      #
+      # @return [Boolean]
+      def self.supported?(expression)
+        expression.terminal? || expression.all? do |subexp|
+          !subexp.type.equal?(UNSUPPORTED_EXPRESSION_TYPE) && supported?(subexp)
+        end
+      end
+
+      # Convert expression into ast node
+      #
+      # @param expression [Regexp::Expression]
+      #
+      # @return [Parser::AST::Node]
+      def self.to_ast(expression)
+        ast_type = :"regexp_#{expression.token}_#{expression.type}"
+
+        Transformer.lookup(ast_type).to_ast(expression)
+      end
+
+      # Convert node into expression
+      #
+      # @param node [Parser::AST::Node]
+      #
+      # @return [Regexp::Expression]
+      def self.to_expression(node)
+        Transformer.lookup(node.type).to_expression(node)
+      end
+    end # Regexp
+  end # AST
+end # Mutest

data/lib/mutest/ast/regexp/transformer.rb

@@ -0,0 +1,184 @@
+module Mutest
+  module AST
+    module Regexp
+      # Regexp bijective mapper
+      #
+      # Transforms parsed regular expression representation from
+      # `Regexp::Expression` instances (provided by `regexp_parser`) into
+      # equivalent representations using `Parser::AST::Node`
+      class Transformer
+        include AbstractType
+
+        REGISTRY = Registry.new
+
+        # Lookup transformer class for regular expression node type
+        #
+        # @param type [Symbol]
+        #
+        # @return [Class<Transformer>]
+        def self.lookup(type)
+          REGISTRY.lookup(type)
+        end
+
+        # Register transformer class as responsible for handling node type
+        #
+        # @param type [Symbol]
+        #
+        # @return [undefined]
+        def self.register(type)
+          REGISTRY.register(type, self)
+        end
+        private_class_method :register
+
+        # Transform expression
+        #
+        # @param expression [Regexp::Expression]
+        #
+        # @return [Parser::AST::Node]
+        def self.to_ast(expression)
+          self::ExpressionToAST.call(expression)
+        end
+
+        # Transform node
+        #
+        # @param node [Parser::AST::Node]
+        #
+        # @return [Regexp::Expression]
+        def self.to_expression(node)
+          self::ASTToExpression.call(node)
+        end
+
+        # Abstract expression transformer
+        class ExpressionToAST
+          PREFIX = :regexp
+
+          include Concord.new(:expression), Procto.call, AST::Sexp, AbstractType, Adamantium
+
+          private
+
+          # Node with provided children using node type constructed in `type`
+          #
+          # @param [Object,Parser::AST::Node] child of node
+          #
+          # @return [Parser::AST::Node]
+          def ast(*children)
+            s(type, *children)
+          end
+
+          # Wrap provided node in a quantifier
+          #
+          # @param node [Parser::AST::Node]
+          #
+          # @return [Parser::AST::Node]
+          #   quantifier node wrapping provided node if expression is quantified
+          #
+          # @return [Parser::AST::Node]
+          #   original node otherwise
+          def quantify(node)
+            return node unless expression.quantified?
+
+            Quantifier.to_ast(expression.quantifier).append(node)
+          end
+
+          # Transformed children of expression
+          #
+          # @return [Array<Parser::AST::Node>]
+          def children
+            expression.expressions.map(&Regexp.method(:to_ast))
+          end
+
+          # Node type constructed from token and type of `Regexp::Expression`
+          #
+          # @return [Symbol]
+          def type
+            :"#{PREFIX}_#{expression.token}_#{expression.type}"
+          end
+        end # ExpressionToAST
+
+        # Abstract node transformer
+        class ASTToExpression
+          include Concord.new(:node), Procto.call, AbstractType, Adamantium
+
+          # Call generic transform method and freeze result
+          #
+          # @return [Regexp::Expression]
+          def call
+            transform.freeze
+          end
+
+          private
+
+          # Transformation of ast into expression
+          #
+          # @return [Regexp::Expression]
+          abstract_method :transform
+
+          # Transformed children of node
+          #
+          # @return [Array<Regexp::Expression>]
+          def subexpressions
+            node.children.map(&Regexp.public_method(:to_expression))
+          end
+        end # ASTToExpression
+
+        # Mixin for node transformers
+        #
+        # Helps construct a mapping from Parser::AST::Node domain to
+        # Regexp::Expression domain
+        module LookupTable
+          Mapping = Class.new.include(Concord::Public.new(:token, :regexp_class))
+
+          # Table mapping ast types to object information for regexp domain
+          class Table
+            # Coerce array of mapping information into structured table
+            #
+            # @param [Array(Symbol, Array, Class<Regexp::Expression>)]
+            #
+            # @return [Table]
+            def self.create(*rows)
+              table = rows.map do |ast_type, token, klass|
+                [ast_type, Mapping.new(::Regexp::Token.new(*token), klass)]
+              end.to_h
+
+              new(table)
+            end
+
+            include Concord.new(:table), Adamantium
+
+            # Types defined by the table
+            #
+            # @return [Array<Symbol>]
+            def types
+              table.keys
+            end
+
+            # Lookup mapping information given an ast node type
+            #
+            # @param type [Symbol]
+            #
+            # @return [Mapping]
+            def lookup(type)
+              table.fetch(type)
+            end
+          end # Table
+
+          private
+
+          # Lookup expression token given node type
+          #
+          # @return [Regexp::Token]
+          def expression_token
+            self.class::TABLE.lookup(node.type).token
+          end
+
+          # Lookup regexp class given node type
+          #
+          # @return [Class<Regexp::Expression>]
+          def expression_class
+            self.class::TABLE.lookup(node.type).regexp_class
+          end
+        end # LookupTable
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutest