mutant 0.8.10 → 0.8.11

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

@@ -0,0 +1,39 @@
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for Regexp `alternative` nodes
+        #
+        # This transformer is very similar to the generic recursive mapper
+        # except for the fact that the `Regexp::Expression` class for
+        # `alternative` nodes has a unique constructor
+        class Alternative < self
+          register :regexp_sequence_expression
+
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          ExpressionToAST = Class.new(Recursive::ExpressionToAST)
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            # Alternative instance with dummy values for `level`, `set_level`,
+            # and `conditional_level`. These values do not affect unparsing
+            ALTERNATIVE = IceNine.deep_freeze(
+              ::Regexp::Expression::Alternative.new(0, 0, 0)
+            )
+
+          private
+
+            # Transform ast into expression
+            #
+            # @return [Regexp::Expression::Alternative]
+            def transform
+              ALTERNATIVE.dup.tap do |alt|
+                alt.expressions = subexpressions
+              end
+            end
+          end # ASTToExpression
+        end # Alternative
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,46 @@
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for character sets
+        #
+        # The `Regexp::Expression` representation of a character set
+        # is unique due to its usage of the `#members` attribute which
+        # is why it gets its own transformer
+        class CharacterSet < self
+          register :regexp_character_set
+
+          # Mapper from `Regexp::Expression` to `Parser::AST::Node`
+          class ExpressionToAST < Transformer::ExpressionToAST
+            # Transform character set expression into node
+            #
+            # @return [Parser::AST::Node]
+            def call
+              quantify(ast(*expression.members))
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            CHARACTER_SET = IceNine.deep_freeze(
+              ::Regexp::Expression::CharacterSet.new(
+                ::Regexp::Token.new(:set, :character, '[')
+              )
+            )
+
+          private
+
+            # Transform node into expression
+            #
+            # @return [Regexp::Expression]
+            def transform
+              CHARACTER_SET.dup.tap do |expression|
+                expression.members = node.children
+              end
+            end
+          end # ASTToExpression
+        end # CharacterSet
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,99 @@
+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_one_or_more_escape,       [:escape,   :one_or_more,      '\+'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_zero_or_one_escape,       [:escape,   :zero_or_one,      '\?'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_alternation_escape,       [:escape,   :alternation,      '\|'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_group_open_escape,        [:escape,   :group_open,       '\('],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_group_close_escape,       [:escape,   :group_close,      '\)'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_interval_open_escape,     [:escape,   :interval_open,    '\{'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_interval_close_escape,    [:escape,   :interval_close,   '\}'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_newline_escape,           [:escape,   :newline,          '\n'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_zero_or_more_escape,      [:escape,   :zero_or_more,     '\*'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_carriage_escape,          [:escape,   :carriage,         '\r'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_dot_escape,               [:escape,   :dot,              '\.'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_set_open_escape,          [:escape,   :set_open,         '\['],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_set_close_escape,         [:escape,   :set_close,        '\]'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_eol_escape,               [:escape,   :eol,              '\$'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_bell_escape,              [:escape,   :bell,             '\a'],           ::Regexp::Expression::EscapeSequence::Literal],
+              [:regexp_escape_escape,            [:escape,   :escape,           '\e'],           ::Regexp::Expression::EscapeSequence::AsciiEscape],
+              [:regexp_form_feed_escape,         [:escape,   :form_feed,        '\f'],           ::Regexp::Expression::EscapeSequence::FormFeed],
+              [:regexp_vertical_tab_escape,      [:escape,   :vertical_tab,     '\v'],           ::Regexp::Expression::EscapeSequence::VerticalTab],
+              [:regexp_mark_keep,                [:keep,     :mark,             '\K'],           ::Regexp::Expression::Keep::Mark],
+              [:regexp_bos_anchor,               [:anchor,   :bos,              '\\A'],          ::Regexp::Expression::Anchor::BeginningOfString],
+              [:regexp_match_start_anchor,       [:anchor,   :match_start,      '\\G'],          ::Regexp::Expression::Anchor::MatchStart],
+              [:regexp_word_boundary_anchor,     [:anchor,   :word_boundary,    '\b'],           ::Regexp::Expression::Anchor::WordBoundary],
+              [:regexp_eos_ob_eol_anchor,        [:anchor,   :eos_ob_eol,       '\\Z'],          ::Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine],
+              [:regexp_eos_anchor,               [:anchor,   :eos,              '\\z'],          ::Regexp::Expression::Anchor::EndOfString],
+              [:regexp_bol_anchor,               [:anchor,   :bol,              '^'],            ::Regexp::Expression::Anchor::BeginningOfLine],
+              [:regexp_eol_anchor,               [:anchor,   :eol,              '$'],            ::Regexp::Expression::Anchor::EndOfLine],
+              [:regexp_nonword_boundary_anchor,  [:anchor,   :nonword_boundary, '\\B'],          ::Regexp::Expression::Anchor::NonWordBoundary],
+              [:regexp_alpha_property,           [:property, :alpha,            '\p{Alpha}'],    ::Regexp::Expression::UnicodeProperty::Alpha],
+              [:regexp_script_arabic_property,   [:property, :script_arabic,    '\p{Arabic}'],   ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_script_hangul_property,   [:property, :script_hangul,    '\p{Hangul}'],   ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_script_han_property,      [:property, :script_han,       '\p{Han}'],      ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_script_hiragana_property, [:property, :script_hiragana,  '\p{Hiragana}'], ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_script_katakana_property, [:property, :script_katakana,  '\p{Katakana}'], ::Regexp::Expression::UnicodeProperty::Script],
+              [:regexp_letter_any_property,      [:property, :letter_any,       '\p{L}'],        ::Regexp::Expression::UnicodeProperty::Letter::Any],
+              [:regexp_digit_type,               [:type,     :digit,            '\d'],           ::Regexp::Expression::CharacterType::Digit],
+              [:regexp_space_type,               [:type,     :space,            '\s'],           ::Regexp::Expression::CharacterType::Space],
+              [:regexp_word_type,                [:type,     :word,             '\w'],           ::Regexp::Expression::CharacterType::Word],
+              [:regexp_hex_type,                 [:type,     :hex,              '\h'],           ::Regexp::Expression::CharacterType::Hex],
+              [:regexp_nonhex_type,              [:type,     :nonhex,           '\H'],           ::Regexp::Expression::CharacterType::NonHex],
+              [:regexp_nondigit_type,            [:type,     :nondigit,         '\D'],           ::Regexp::Expression::CharacterType::NonDigit],
+              [:regexp_nonspace_type,            [:type,     :nonspace,         '\S'],           ::Regexp::Expression::CharacterType::NonSpace],
+              [:regexp_nonword_type,             [:type,     :nonword,          '\W'],           ::Regexp::Expression::CharacterType::NonWord],
+              [:regexp_dot_meta,                 [:meta,     :dot,              '.'],            ::Regexp::Expression::CharacterType::Any]
+            )
+
+          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/options_group.rb

@@ -0,0 +1,66 @@
+module Mutant
+  module AST
+    module Regexp
+      class Transformer
+        # Transformer for option groups
+        class OptionsGroup < self
+          register :regexp_options_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.options, *children))
+            end
+          end # ExpressionToAST
+
+          # Mapper from `Parser::AST::Node` to `Regexp::Expression`
+          class ASTToExpression < Transformer::ASTToExpression
+            include NamedChildren
+
+            children :options
+
+          private
+
+            # Covnert 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, :options, text)
+              )
+            end
+
+            # Flag text constructed from enabled options
+            #
+            # @return [String]
+            def text
+              flags = options.map { |key, value| key if value }.join
+
+              "(?#{flags}-:"
+            end
+          end # ASTToExpression
+        end # OptionsGroup
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant

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

@@ -0,0 +1,112 @@
+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 > 0 }.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

@@ -0,0 +1,50 @@
+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
+            TABLE = Table.create(
+              [:regexp_alternation_meta,      [:meta,      :alternation, '|'],    ::Regexp::Expression::Alternation],
+              [:regexp_nlookahead_assertion,  [:assertion, :nlookahead,  '(?!'],  ::Regexp::Expression::Assertion::NegativeLookahead],
+              [:regexp_passive_group,         [:group,     :passive,     '(?:'],  ::Regexp::Expression::Group::Passive],
+              [:regexp_nlookbehind_assertion, [:assertion, :nlookbehind, '(?<!'], ::Regexp::Expression::Assertion::NegativeLookbehind],
+              [:regexp_lookbehind_assertion,  [:assertion, :lookbehind,  '(?<='], ::Regexp::Expression::Assertion::Lookbehind],
+              [:regexp_lookahead_assertion,   [:assertion, :lookahead,   '(?='],  ::Regexp::Expression::Assertion::Lookahead],
+              [:regexp_atomic_group,          [:group,     :atomic,      '(?>'],  ::Regexp::Expression::Group::Atomic],
+              [:regexp_capture_group,         [:group,     :capture,     '('],    ::Regexp::Expression::Group::Capture]
+            )
+
+          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

@@ -0,0 +1,29 @@
+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.new.tap do |root|
+                root.expressions = subexpressions
+              end
+            end
+          end # ASTToExpression
+        end # Root
+      end # Transformer
+    end # Regexp
+  end # AST
+end # Mutant