mutant 0.11.17 → 0.11.18

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for named groups
-        class NamedGroup < self
-          register :regexp_named_group
-
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-
-            # Transform named group into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(expression.name, *children))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include NamedChildren
-
-            children :name
-
-          private
-
-            def transform
-              named_group.tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-
-            def subexpressions
-              remaining_children.map(&Regexp.public_method(:to_expression))
-            end
-
-            def named_group
-              ::Regexp::Expression::Group::Named.new(
-                ::Regexp::Token.new(:group, :named, "(?<#{name}>")
-              )
-            end
-          end # ASTToExpression
-        end # NamedGroup
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for option groups
-        class OptionsGroup < self
-          register :regexp_options_group
-          register :regexp_options_switch_group
-
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-
-            # Transform options group into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(expression.option_changes, *children))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include NamedChildren
-
-            children :option_changes
-
-          private
-
-            def transform
-              options_group.tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-
-            def subexpressions
-              remaining_children.map(&Regexp.public_method(:to_expression))
-            end
-
-            def options_group
-              ::Regexp::Expression::Group::Options.new(
-                ::Regexp::Token.new(:group, type, text)
-              )
-            end
-
-            def type
-              {
-                regexp_options_group:        :options,
-                regexp_options_switch_group: :options_switch
-              }.fetch(node.type)
-            end
-
-            def text
-              pos, neg = option_changes.partition { |_opt, val| val }.map do |arr|
-                arr.map(&:first).join
-              end
-              neg_opt_sep = '-' unless neg.empty?
-              content_sep = ':' unless type.equal?(:options_switch)
-
-              "(?#{pos}#{neg_opt_sep}#{neg}#{content_sep}"
-            end
-          end # ASTToExpression
-        end # OptionsGroup
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for regexp quantifiers
-        class Quantifier < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform quantifier into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              ast(expression.min, expression.max)
-            end
-
-          private
-
-            def type
-              :"regexp_#{expression.mode}_#{expression.token}"
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include NamedChildren
-
-            children :min, :max, :subject
-
-            Quantifier = Class.new.include(Concord::Public.new(:type, :suffix, :mode))
-
-            QUANTIFIER_MAP = {
-              regexp_greedy_zero_or_more:     [:zero_or_more, '*',  :greedy],
-              regexp_greedy_one_or_more:      [:one_or_more,  '+',  :greedy],
-              regexp_greedy_zero_or_one:      [:zero_or_one,  '?',  :greedy],
-              regexp_possessive_zero_or_one:  [:zero_or_one,  '?+', :possessive],
-              regexp_reluctant_zero_or_more:  [:zero_or_more, '*?', :reluctant],
-              regexp_reluctant_one_or_more:   [:one_or_more,  '+?', :reluctant],
-              regexp_possessive_zero_or_more: [:zero_or_more, '*+', :possessive],
-              regexp_possessive_one_or_more:  [:one_or_more,  '++', :possessive],
-              regexp_greedy_interval:         [:interval,     '',   :greedy],
-              regexp_reluctant_interval:      [:interval,     '?',  :reluctant],
-              regexp_possessive_interval:     [:interval,     '+',  :possessive]
-            }.transform_values { |arguments| Quantifier.new(*arguments) }
-              .to_h
-              .freeze
-
-          private
-
-            def transform
-              Regexp.to_expression(subject).dup.tap do |expression|
-                expression.quantify(type, text, min, max, mode)
-              end
-            end
-
-            def text
-              if type.equal?(:interval)
-                interval_text + suffix
-              else
-                suffix
-              end
-            end
-
-            def type
-              quantifier.type
-            end
-
-            def suffix
-              quantifier.suffix
-            end
-
-            def mode
-              quantifier.mode
-            end
-
-            def quantifier
-              QUANTIFIER_MAP.fetch(node.type)
-            end
-
-            def interval_text
-              interval = [min, max].map { |num| num if num.positive? }.uniq
-              "{#{interval.join(',')}}"
-            end
-          end # ASTToExpression
-
-          ASTToExpression::QUANTIFIER_MAP.keys.each(&method(:register))
-        end # Quantifier
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for nodes with children
-        class Recursive < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform expression and children into nodes
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(*children))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include LookupTable
-
-            # Expression::Sequence represents conditional branches, alternation branches, and intersection branches
-            # rubocop:disable Layout/LineLength
-            TABLE = Table.create(
-              [:regexp_alternation_meta,      [:meta,        :alternation,  '|'],    ::Regexp::Expression::Alternation],
-              [:regexp_atomic_group,          [:group,       :atomic,       '(?>'],  ::Regexp::Expression::Group::Atomic],
-              [:regexp_capture_group,         [:group,       :capture,      '('],    ::Regexp::Expression::Group::Capture],
-              [:regexp_character_set,         [:set,         :character,    '['],    ::Regexp::Expression::CharacterSet],
-              [:regexp_intersection_set,      [:set,         :intersection, '&&'],   ::Regexp::Expression::CharacterSet::Intersection],
-              [:regexp_lookahead_assertion,   [:assertion,   :lookahead,    '(?='],  ::Regexp::Expression::Assertion::Lookahead],
-              [:regexp_lookbehind_assertion,  [:assertion,   :lookbehind,   '(?<='], ::Regexp::Expression::Assertion::Lookbehind],
-              [:regexp_nlookahead_assertion,  [:assertion,   :nlookahead,   '(?!'],  ::Regexp::Expression::Assertion::NegativeLookahead],
-              [:regexp_nlookbehind_assertion, [:assertion,   :nlookbehind,  '(?<!'], ::Regexp::Expression::Assertion::NegativeLookbehind],
-              [:regexp_open_conditional,      [:conditional, :open,         '(?'],   ::Regexp::Expression::Conditional::Expression],
-              [:regexp_passive_group,         [:group,       :passive,      '(?:'],  ::Regexp::Expression::Group::Passive],
-              [:regexp_range_set,             [:set,         :range,        '-'],    ::Regexp::Expression::CharacterSet::Range],
-              [:regexp_sequence_expression,   [:expression,  :sequence,     ''],     ::Regexp::Expression::Sequence]
-            )
-          # rubocop:enable Layout/LineLength
-
-          private
-
-            def transform
-              expression_class.new(expression_token).tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-          end # ASTToExpression
-
-          ASTToExpression::TABLE.types.each(&method(:register))
-        end # Recursive
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Transformer for root nodes
-        class Root < self
-          register :regexp_root_expression
-
-          ExpressionToAST = Class.new(Recursive::ExpressionToAST)
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-
-          private
-
-            def transform
-              ::Regexp::Expression::Root.build.tap do |root|
-                root.expressions = subexpressions
-              end
-            end
-          end # ASTToExpression
-        end # Root
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  class AST
-    module Regexp
-      class Transformer
-        # Regexp AST transformer for nodes that encode a text value
-        class Text < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform expression into node preserving text value
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast(expression.text))
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include LookupTable
-
-            # rubocop:disable Layout/LineLength
-            TABLE = Table.create(
-              [:regexp_literal_literal,       %i[literal literal],       ::Regexp::Expression::Literal],
-              [:regexp_comment_group,         %i[group comment],         ::Regexp::Expression::Group::Comment],
-              [:regexp_number_backref,        %i[backref number],        ::Regexp::Expression::Backreference::Number],
-              [:regexp_name_call_backref,     %i[backref name_call],     ::Regexp::Expression::Backreference::NameCall],
-              [:regexp_whitespace_free_space, %i[free_space whitespace], ::Regexp::Expression::WhiteSpace],
-              [:regexp_comment_free_space,    %i[free_space comment],    ::Regexp::Expression::WhiteSpace],
-              [:regexp_hex_escape,            %i[escape hex],            ::Regexp::Expression::EscapeSequence::Hex],
-              [:regexp_octal_escape,          %i[escape octal],          ::Regexp::Expression::EscapeSequence::Octal],
-              [:regexp_literal_escape,        %i[escape literal],        ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_backslash_escape,      %i[escape backslash],      ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_tab_escape,            %i[escape tab],            ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_codepoint_list_escape, %i[escape codepoint_list], ::Regexp::Expression::EscapeSequence::CodepointList],
-              [:regexp_codepoint_escape,      %i[escape codepoint],      ::Regexp::Expression::EscapeSequence::Codepoint],
-              [:regexp_control_escape,        %i[escape control],        ::Regexp::Expression::EscapeSequence::Control],
-              [:regexp_meta_sequence_escape,  %i[escape meta_sequence],  ::Regexp::Expression::EscapeSequence::Control],
-              [:regexp_condition_conditional, %i[conditional condition], ::Regexp::Expression::Conditional::Condition]
-            )
-          # rubocop:enable Layout/LineLength
-
-          private
-
-            def transform
-              token = expression_token.dup
-              token.text = Util.one(node.children)
-              expression_class.new(token)
-            end
-          end # ASTToExpression
-
-          ASTToExpression::TABLE.types.each(&method(:register))
-        end # Text
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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