mutant 0.11.16 → 0.11.18

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

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class 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(
-          ->(type) { fail "No regexp transformer registered for: #{type}" }
-        )
-
-        # Lookup transformer class for regular expression node type
-        #
-        # @param type [Symbol]
-        #
-        # @return [Class<Transformer>]
-        def self.lookup(type)
-          REGISTRY.lookup(type)
-        end
-
-        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, AST::Sexp, AbstractType, Adamantium
-
-        private
-
-          def ast(*children)
-            s(type, *children)
-          end
-
-          def quantify(node)
-            return node unless expression.quantified?
-
-            Quantifier.to_ast(expression.quantifier).append(node)
-          end
-
-          def children
-            expression.map(&Regexp.public_method(:to_ast))
-          end
-
-          def type
-            :"#{PREFIX}_#{expression.token}_#{expression.type}"
-          end
-        end # ExpressionToAST
-
-        # Abstract node transformer
-        class ASTToExpression
-          include Concord.new(:node), Procto, AbstractType, Adamantium
-
-          # Call generic transform method and freeze result
-          #
-          # @return [Regexp::Expression]
-          def call
-            transform.freeze
-          end
-
-        private
-
-          abstract_method :transform
-
-          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.to_h do |ast_type, token, klass|
-                [ast_type, Mapping.new(::Regexp::Token.new(*token), klass)]
-              end
-
-              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
-
-          def expression_token
-            self.class::TABLE.lookup(node.type).token
-          end
-
-          def expression_class
-            self.class::TABLE.lookup(node.type).regexp_class
-          end
-        end # LookupTable
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/ast/regexp.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    # Regexp source mapper
-    module Regexp
-      # Parse regex string into expression
-      #
-      # @param regexp [String]
-      #
-      # @return [Regexp::Expression, nil]
-      def self.parse(regexp)
-        ::Regexp::Parser.parse(regexp)
-      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
-
-      # Convert's a `parser` `regexp` node into more fine-grained AST nodes.
-      #
-      # @param node [Parser::AST::Node]
-      #
-      # @return [Parser::AST::Node]
-      def self.expand_regexp_ast(node)
-        *body, _opts = node.children
-
-        # NOTE: We only mutate parts of regexp body if the body is composed of
-        # only strings. Regular expressions with interpolation are skipped
-        return unless body.all? { |child| child.type.equal?(:str) }
-
-        body_expression = parse(body.map(&:children).join)
-
-        to_ast(body_expression)
-      end
-    end # Regexp
-  end # AST
-end # Mutant

data/lib/mutant/mutator/node/regexp/alternation_meta.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for pipe in `/foo|bar/` regexp
-        class AlternationMeta < Node
-          handle(:regexp_alternation_meta)
-
-        private
-
-          def dispatch
-            children.each_index(&method(:delete_child))
-          end
-        end # AlternationMeta
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp/beginning_of_line_anchor.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for beginning of line anchor `^`
-        class BeginningOfLineAnchor < Node
-          handle(:regexp_bol_anchor)
-
-          private
-
-          def dispatch
-            emit(s(:regexp_bos_anchor))
-          end
-        end # BeginningOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp/capture_group.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for regexp capture groups, such as `/(foo)/`
-        class CaptureGroup < Node
-          handle(:regexp_capture_group)
-
-        private
-
-          def dispatch
-            return if children.empty?
-
-            emit(s(:regexp_passive_group, *children))
-            children.each_index(&method(:mutate_child))
-          end
-        end # EndOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp/character_type.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Character type mutator
-        class CharacterType < Node
-          map = {
-            regexp_digit_type:           :regexp_nondigit_type,
-            regexp_hex_type:             :regexp_nonhex_type,
-            regexp_space_type:           :regexp_nonspace_type,
-            regexp_word_boundary_anchor: :regexp_nonword_boundary_anchor,
-            regexp_word_type:            :regexp_nonword_type,
-            regexp_xgrapheme_type:       :regexp_linebreak_type
-          }
-
-          MAP = map.merge(map.invert)
-
-          handle(*MAP.keys)
-
-        private
-
-          def dispatch
-            emit(s(MAP.fetch(node.type)))
-          end
-        end # CharacterType
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp/end_of_line_anchor.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for end of line anchor `$`
-        class EndOfLineAnchor < Node
-          handle(:regexp_eol_anchor)
-
-        private
-
-          def dispatch
-            emit(s(:regexp_eos_anchor))
-          end
-        end # EndOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp/end_of_string_or_before_end_of_line_anchor.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for end of line or before end of string anchor `\Z`
-        class EndOfStringOrBeforeEndOfLineAnchor < Node
-          handle(:regexp_eos_ob_eol_anchor)
-
-        private
-
-          def dispatch
-            emit(s(:regexp_eos_anchor))
-          end
-        end # EndOfStringOrBeforeEndOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp/named_group.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for regexp named capture groups, such as `/(?<foo>bar)/`
-        class NamedGroup < Node
-          handle(:regexp_named_group)
-
-          children :name
-
-        private
-
-          def dispatch
-            return if remaining_children.empty?
-
-            remaining_children_indices.each(&method(:mutate_child))
-
-            # Allows unused captures to be kept and named if they are explicitly prefixed with an
-            # underscore, like we allow with unused local variables.
-            return if name_underscored?
-
-            emit(s(:regexp_passive_group, *remaining_children))
-            emit_name_underscore_mutation
-          end
-
-          def emit_name_underscore_mutation
-            emit_type("_#{name}", *remaining_children)
-          end
-
-          def name_underscored?
-            name.start_with?('_')
-          end
-        end # EndOfLineAnchor
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp/zero_or_more.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for zero-or-more quantifier, `*`
-        class ZeroOrMore < Node
-          MAP = {
-            regexp_greedy_zero_or_more:     :regexp_greedy_one_or_more,
-            regexp_reluctant_zero_or_more:  :regexp_reluctant_one_or_more,
-            regexp_possessive_zero_or_more: :regexp_possessive_one_or_more
-          }.freeze
-
-          handle(*MAP.keys)
-
-          children :min, :max, :subject
-
-          private
-
-          # Replace:
-          # * `/a*/`  with `/a+/`
-          # * `/a*?/` with `/a+?/`
-          # * `/a*+/` with `/a++/`
-          def dispatch
-            emit(s(MAP.fetch(node.type), *children))
-            emit_subject_mutations
-            emit(subject)
-          end
-        end # ZeroOrMore
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant

data/lib/mutant/mutator/node/regexp.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class Mutator
-    class Node
-      module Regexp
-        # Mutator for root expression regexp wrapper
-        class RootExpression < Node
-          handle(:regexp_root_expression)
-
-        private
-
-          def dispatch
-            children.each_index(&method(:mutate_child))
-          end
-        end # RootExpression
-      end # Regexp
-    end # Node
-  end # Mutator
-end # Mutant