mutant 0.8.24 → 0.9.0

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

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module AST
-    module Regexp
-      class Transformer
-        # Transformer for nodes which map directly to other domain
-        #
-        # A node maps "directly" to another domain if the node never
-        # has children or text which needs to be preserved for a mapping
-        #
-        # @example direct mapping
-        #
-        #     input      = /\d/
-        #     expression = Regexp::Parser.parse(input).first
-        #     node       = Transformer::Direct.to_ast(expression)
-        #
-        #     # the digit type always has the same text and no children
-        #     expression.text      # => "\\d"
-        #     expression.terminal? # => true
-        #
-        #     # therefore the `Parser::AST::Node` is always the same
-        #     node # => s(:regexp_digit_type)
-        class Direct < self
-          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
-          class ExpressionToAST < Transformer::ExpressionToAST
-            # Transform expression into node
-            #
-            # @return [Parser::AST::Node]
-            def call
-              quantify(ast)
-            end
-          end # ExpressionToAST
-
-          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
-          class ASTToExpression < Transformer::ASTToExpression
-            include LookupTable
-
-            # rubocop:disable LineLength
-            TABLE = Table.create(
-              [:regexp_alnum_posixclass,         [:posixclass,    :alnum,            '[:alnum:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_alpha_posixclass,         [:posixclass,    :alpha,            '[:alpha:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_alpha_property,           [:property,      :alpha,            '\p{Alpha}'],    ::Regexp::Expression::UnicodeProperty::Alpha],
-              [:regexp_alternation_escape,       [:escape,        :alternation,      '\|'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_arabic_property,          [:property,      :arabic,           '\p{Arabic}'],   ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_ascii_posixclass,         [:posixclass,    :ascii,            '[:ascii:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_backspace_escape,         [:escape,        :backspace,        '\b'],           ::Regexp::Expression::EscapeSequence::Backspace],
-              [:regexp_bell_escape,              [:escape,        :bell,             '\a'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_blank_posixclass,         [:posixclass,    :blank,            '[:blank:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_bol_anchor,               [:anchor,        :bol,              '^'],            ::Regexp::Expression::Anchor::BeginningOfLine],
-              [:regexp_bol_escape,               [:escape,        :bol,              '\^'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_bos_anchor,               [:anchor,        :bos,              '\\A'],          ::Regexp::Expression::Anchor::BeginningOfString],
-              [:regexp_carriage_escape,          [:escape,        :carriage,         '\r'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_cntrl_posixclass,         [:posixclass,    :cntrl,            '[:cntrl:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_digit_posixclass,         [:posixclass,    :digit,            '[:digit:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_digit_type,               [:type,          :digit,            '\d'],           ::Regexp::Expression::CharacterType::Digit],
-              [:regexp_dot_escape,               [:escape,        :dot,              '\.'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_dot_meta,                 [:meta,          :dot,              '.'],            ::Regexp::Expression::CharacterType::Any],
-              [:regexp_eol_anchor,               [:anchor,        :eol,              '$'],            ::Regexp::Expression::Anchor::EndOfLine],
-              [:regexp_eol_escape,               [:escape,        :eol,              '\$'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_eos_anchor,               [:anchor,        :eos,              '\\z'],          ::Regexp::Expression::Anchor::EndOfString],
-              [:regexp_eos_ob_eol_anchor,        [:anchor,        :eos_ob_eol,       '\\Z'],          ::Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine],
-              [:regexp_escape_escape,            [:escape,        :escape,           '\e'],           ::Regexp::Expression::EscapeSequence::AsciiEscape],
-              [:regexp_form_feed_escape,         [:escape,        :form_feed,        '\f'],           ::Regexp::Expression::EscapeSequence::FormFeed],
-              [:regexp_graph_posixclass,         [:posixclass,    :graph,            '[:graph:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_group_close_escape,       [:escape,        :group_close,      '\)'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_group_open_escape,        [:escape,        :group_open,       '\('],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_han_property,             [:property,      :han,              '\p{Han}'],      ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_hangul_property,          [:property,      :hangul,           '\p{Hangul}'],   ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_hex_type,                 [:type,          :hex,              '\h'],           ::Regexp::Expression::CharacterType::Hex],
-              [:regexp_hiragana_property,        [:property,      :hiragana,         '\p{Hiragana}'], ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_interval_close_escape,    [:escape,        :interval_close,   '\}'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_interval_open_escape,     [:escape,        :interval_open,    '\{'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_katakana_property,        [:property,      :katakana,         '\p{Katakana}'], ::Regexp::Expression::UnicodeProperty::Script],
-              [:regexp_letter_property,          [:property,      :letter,           '\p{L}'],        ::Regexp::Expression::UnicodeProperty::Letter::Any],
-              [:regexp_linebreak_type,           [:type,          :linebreak,        '\R'],           ::Regexp::Expression::CharacterType::Linebreak],
-              [:regexp_lower_posixclass,         [:posixclass,    :lower,            '[:lower:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_mark_keep,                [:keep,          :mark,             '\K'],           ::Regexp::Expression::Keep::Mark],
-              [:regexp_match_start_anchor,       [:anchor,        :match_start,      '\\G'],          ::Regexp::Expression::Anchor::MatchStart],
-              [:regexp_newline_escape,           [:escape,        :newline,          '\n'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_nondigit_type,            [:type,          :nondigit,         '\D'],           ::Regexp::Expression::CharacterType::NonDigit],
-              [:regexp_nonhex_type,              [:type,          :nonhex,           '\H'],           ::Regexp::Expression::CharacterType::NonHex],
-              [:regexp_nonspace_type,            [:type,          :nonspace,         '\S'],           ::Regexp::Expression::CharacterType::NonSpace],
-              [:regexp_nonword_boundary_anchor,  [:anchor,        :nonword_boundary, '\\B'],          ::Regexp::Expression::Anchor::NonWordBoundary],
-              [:regexp_nonword_type,             [:type,          :nonword,          '\W'],           ::Regexp::Expression::CharacterType::NonWord],
-              [:regexp_one_or_more_escape,       [:escape,        :one_or_more,      '\+'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_print_nonposixclass,      [:nonposixclass, :print,            '[:^print:]'],   ::Regexp::Expression::PosixClass],
-              [:regexp_print_nonproperty,        [:nonproperty,   :print,            '\P{Print}'],    ::Regexp::Expression::UnicodeProperty::Print],
-              [:regexp_print_posixclass,         [:posixclass,    :print,            '[:print:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_print_posixclass,         [:posixclass,    :print,            '[:print:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_print_property,           [:property,      :print,            '\p{Print}'],    ::Regexp::Expression::UnicodeProperty::Print],
-              [:regexp_punct_posixclass,         [:posixclass,    :punct,            '[:punct:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_set_close_escape,         [:escape,        :set_close,        '\]'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_set_open_escape,          [:escape,        :set_open,         '\['],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_space_posixclass,         [:posixclass,    :space,            '[:space:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_space_type,               [:type,          :space,            '\s'],           ::Regexp::Expression::CharacterType::Space],
-              [:regexp_upper_posixclass,         [:posixclass,    :upper,            '[:upper:]'],    ::Regexp::Expression::PosixClass],
-              [:regexp_vertical_tab_escape,      [:escape,        :vertical_tab,     '\v'],           ::Regexp::Expression::EscapeSequence::VerticalTab],
-              [:regexp_word_boundary_anchor,     [:anchor,        :word_boundary,    '\b'],           ::Regexp::Expression::Anchor::WordBoundary],
-              [:regexp_word_posixclass,          [:posixclass,    :word,             '[:word:]'],     ::Regexp::Expression::PosixClass],
-              [:regexp_word_type,                [:type,          :word,             '\w'],           ::Regexp::Expression::CharacterType::Word],
-              [:regexp_xdigit_posixclass,        [:posixclass,    :xdigit,           '[:xdigit:]'],   ::Regexp::Expression::PosixClass],
-              [:regexp_xgrapheme_type,           [:type,          :xgrapheme,        '\X'],           ::Regexp::Expression::CharacterType::ExtendedGrapheme],
-              [:regexp_zero_or_more_escape,      [:escape,        :zero_or_more,     '\*'],           ::Regexp::Expression::EscapeSequence::Literal],
-              [:regexp_zero_or_one_escape,       [:escape,        :zero_or_one,      '\?'],           ::Regexp::Expression::EscapeSequence::Literal]
-            )
-
-          private
-
-            # Transform ast into expression
-            #
-            # @return [Regexp::Expression]
-            def transform
-              expression_class.new(expression_token)
-            end
-          end # ASTToExpression
-
-          ASTToExpression::TABLE.types.each(&method(:register))
-        end # Direct
-      end # Transformer
-    end # Regexp
-  end # AST
-end # Mutant

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module 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
-
-            # Convert node into expression
-            #
-            # @return [Regexp::Expression::Group::Named]
-            def transform
-              named_group.tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-
-            # Recursive mapping of children
-            #
-            # @return [Array<Regexp::Expression>]
-            def subexpressions
-              remaining_children.map(&Regexp.public_method(:to_expression))
-            end
-
-            # Named group instance constructed using name
-            #
-            # @return [Regexp::Expression::Group::Named]
-            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,83 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module 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
-
-            # Convert node into expression
-            #
-            # @return [Regexp::Expression::Group::Options]
-            def transform
-              options_group.tap do |expression|
-                expression.expressions = subexpressions
-              end
-            end
-
-            # Recursive mapping of children
-            #
-            # @return [Array<Regexp::Expression>]
-            def subexpressions
-              remaining_children.map(&Regexp.public_method(:to_expression))
-            end
-
-            # Options group instance constructed from options text
-            #
-            # @return [Regexp::Expression::Group::Options]
-            def options_group
-              ::Regexp::Expression::Group::Options.new(
-                ::Regexp::Token.new(:group, type, text)
-              )
-            end
-
-            # Options group type derived from node type
-            #
-            # @return [Symbol]
-            def type
-              {
-                regexp_options_group:        :options,
-                regexp_options_switch_group: :options_switch
-              }.fetch(node.type)
-            end
-
-            # Flag text constructed from enabled and disabled options
-            #
-            # @return [String]
-            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,114 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module 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
-
-            # Custom `type` for quantifiers which use `mode` instead of `type`
-            #
-            # @return [Symbol]
-            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 = IceNine.deep_freeze({
-              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]
-            }.map { |ast_type, arguments| [ast_type, Quantifier.new(*arguments)] }.to_h)
-
-          private
-
-            # Transform ast into quantifier attached to expression
-            #
-            # @return [Regexp::Expression]
-            def transform
-              Regexp.to_expression(subject).dup.tap do |expression|
-                expression.quantify(type, text, min, max, mode)
-              end
-            end
-
-            # Quantifier text
-            #
-            # @return [String]
-            def text
-              if type.equal?(:interval)
-                interval_text + suffix
-              else
-                suffix
-              end
-            end
-
-            # Type of quantifier
-            #
-            # @return [:zero_or_more,:one_or_more,:interval]
-            def type
-              quantifier.type
-            end
-
-            # Regexp symbols used to specify quantifier
-            #
-            # @return [String]
-            def suffix
-              quantifier.suffix
-            end
-
-            # The quantifier "mode"
-            #
-            # @return [:greedy,:possessive,:reluctant]
-            def mode
-              quantifier.mode
-            end
-
-            # Quantifier mapping information for current node
-            #
-            # @return [Quantifier]
-            def quantifier
-              QUANTIFIER_MAP.fetch(node.type)
-            end
-
-            # Interval text constructed from min and max
-            #
-            # @return [String]
-            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,58 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module 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
-
-            # rubocop:disable LineLength
-            # Expression::Sequence represents conditional branches, alternation branches, and intersection branches
-            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]
-            )
-
-          private
-
-            # Transform nodes and their children into expressions
-            #
-            # @return [Regexp::Expression]
-            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,31 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  module 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
-
-            # Transform node into root expression
-            #
-            # @return [Regexp::Expression::Root]
-            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