w_syntax_tree-erb 0.9.0

data/lib/syntax_tree/erb/nodes.rb

@@ -0,0 +1,511 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module ERB
+    # A Location represents a position for a node in the source file.
+    class Location
+      attr_reader :start_char, :end_char, :start_line, :end_line
+
+      def initialize(start_char:, end_char:, start_line:, end_line:)
+        @start_char = start_char
+        @end_char = end_char
+        @start_line = start_line
+        @end_line = end_line
+      end
+
+      def deconstruct_keys(keys)
+        {
+          start_char: start_char,
+          end_char: end_char,
+          start_line: start_line,
+          end_line: end_line
+        }
+      end
+
+      def to(other)
+        Location.new(
+          start_char: start_char,
+          start_line: start_line,
+          end_char: other.end_char,
+          end_line: other.end_line
+        )
+      end
+
+      def <=>(other)
+        start_char <=> other.start_char
+      end
+
+      def to_s
+        if start_line == end_line
+          "line #{start_line}, char #{start_char}..#{end_char}"
+        else
+          "line #{start_line},char #{start_char} to line #{end_line}, char #{end_char}"
+        end
+      end
+    end
+
+    # A parent node that contains a bit of shared functionality.
+    class Node
+      def format(q)
+        Format.new(q).visit(self)
+      end
+
+      def pretty_print(q)
+        PrettyPrint.new(q).visit(self)
+      end
+    end
+
+    # A Token is any kind of lexical token from the source. It has a type, a
+    # value which is a subset of the source, and an index where it starts in
+    # the source.
+    class Token < Node
+      attr_reader :type, :value, :location
+
+      def initialize(type:, value:, location:)
+        @type = type
+        @value = value
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_token(self)
+      end
+
+      def child_nodes
+        []
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { type: type, value: value, location: location }
+      end
+    end
+
+    # The Document node is the top of the syntax tree.
+    # It contains any number of:
+    # - Text
+    # - HtmlNode
+    # - ErbNodes
+    class Document < Node
+      attr_reader :elements, :location
+
+      def initialize(elements:, location:)
+        @elements = elements
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_document(self)
+      end
+
+      def child_nodes
+        [*elements].compact
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { elements: elements, location: location }
+      end
+    end
+
+    # This is a base class for a block that contains:
+    # - an opening
+    # - optional elements
+    # - optional closing
+    class Block < Node
+      attr_reader(:opening, :elements, :closing, :location)
+      def initialize(opening:, location:, elements: nil, closing: nil)
+        @opening = opening
+        @elements = elements || []
+        @closing = closing
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_block(self)
+      end
+
+      def child_nodes
+        [opening, *elements, closing].compact
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        {
+          opening: opening,
+          content: content,
+          closing: closing,
+          location: location
+        }
+      end
+    end
+
+    # An element is a child of the document. It contains an opening tag, any
+    # optional content within the tag, and a closing tag. It can also
+    # potentially contain an opening tag that self-closes, in which case the
+    # content and closing tag will be nil.
+    class HtmlNode < Block
+      # The opening tag of an element. It contains the opening character (<),
+      # the name of the element, any optional attributes, and the closing
+      # token (either > or />).
+      class OpeningTag < Node
+        attr_reader :opening, :name, :attributes, :closing, :location
+
+        def initialize(opening:, name:, attributes:, closing:, location:)
+          @opening = opening
+          @name = name
+          @attributes = attributes
+          @closing = closing
+          @location = location
+        end
+
+        def accept(visitor)
+          visitor.visit_opening_tag(self)
+        end
+
+        def child_nodes
+          [opening, name, *attributes, closing]
+        end
+
+        alias deconstruct child_nodes
+
+        def deconstruct_keys(keys)
+          {
+            opening: opening,
+            name: name,
+            attributes: attributes,
+            closing: closing,
+            location: location
+          }
+        end
+      end
+
+      # The closing tag of an element. It contains the opening character (<),
+      # the name of the element, and the closing character (>).
+      class ClosingTag < Node
+        attr_reader :opening, :name, :closing, :location
+
+        def initialize(opening:, name:, closing:, location:)
+          @opening = opening
+          @name = name
+          @closing = closing
+          @location = location
+        end
+
+        def accept(visitor)
+          visitor.visit_closing_tag(self)
+        end
+
+        def child_nodes
+          [opening, name, closing]
+        end
+
+        alias deconstruct child_nodes
+
+        def deconstruct_keys(keys)
+          { opening: opening, name: name, closing: closing, location: location }
+        end
+      end
+
+      def accept(visitor)
+        visitor.visit_html(self)
+      end
+    end
+
+    class ErbNode < Node
+      attr_reader :opening_tag, :keyword, :content, :closing_tag, :location
+
+      def initialize(opening_tag:, keyword:, content:, closing_tag:, location:)
+        @opening_tag = opening_tag
+        @keyword = keyword
+        @content = ErbContent.new(value: content.map(&:value).join) if content
+        @closing_tag = closing_tag
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_erb(self)
+      end
+
+      def child_nodes
+        [opening_tag, keyword, content, closing_tag].compact
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        {
+          opening_tag: opening_tag,
+          keyword: keyword,
+          content: content,
+          closing_tag: closing_tag,
+          location: location
+        }
+      end
+    end
+
+    class ErbBlock < Block
+      def accept(visitor)
+        visitor.visit_erb_block(self)
+      end
+    end
+
+    class ErbClose < Node
+      attr_reader :location, :closing
+
+      def initialize(location:, closing:)
+        @location = location
+        @closing = closing
+      end
+
+      def accept(visitor)
+        visitor.visit_erb_close(self)
+      end
+
+      def child_nodes
+        []
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { location: location, closing: closing }
+      end
+    end
+
+    class ErbDoClose < ErbClose
+      def accept(visitor)
+        visitor.visit_erb_do_close(self)
+      end
+    end
+
+    class ErbControl < Block
+    end
+
+    class ErbIf < ErbControl
+      # opening: ErbNode
+      # elements: [[HtmlNode | ErbNode | CharDataNode]]
+      # closing: [nil | ErbElsif | ErbElse]
+      def accept(visitor)
+        visitor.visit_erb_if(self)
+      end
+    end
+
+    class ErbUnless < ErbIf
+      # opening: ErbNode
+      # elements: [[HtmlNode | ErbNode | CharDataNode]]
+      # closing: [nil | ErbElsif | ErbElse]
+      def accept(visitor)
+        visitor.visit_erb_if(self)
+      end
+    end
+
+    class ErbElsif < ErbIf
+      def accept(visitor)
+        visitor.visit_erb_if(self)
+      end
+    end
+
+    class ErbElse < ErbIf
+      def accept(visitor)
+        visitor.visit_erb_if(self)
+      end
+    end
+
+    class ErbEnd < ErbNode
+      def accept(visitor)
+        visitor.visit_erb_end(self)
+      end
+
+      def child_nodes
+        []
+      end
+
+      alias deconstruct child_nodes
+    end
+
+    class ErbCase < ErbControl
+      # opening: ErbNode
+      # elements: [[HtmlNode | ErbNode | CharDataNode]]
+      # closing: [nil | ErbCaseWhen | ErbElse | ErbEnd]
+      def accept(visitor)
+        visitor.visit_erb_case(self)
+      end
+    end
+
+    class ErbCaseWhen < ErbControl
+      # opening: ErbNode
+      # elements: [[HtmlNode | ErbNode | CharDataNode]]
+      # closing: [nil | ErbCaseWhen | ErbElse | ErbEnd]
+      def accept(visitor)
+        visitor.visit_erb_case_when(self)
+      end
+    end
+
+    class ErbContent < Node
+      attr_reader(:value, :unparsed_value)
+
+      def initialize(value:)
+        @unparsed_value = value
+        begin
+          @value = SyntaxTree.parse(value.strip)
+        rescue SyntaxTree::Parser::ParseError
+          # Removes leading and trailing whitespace
+          @value = value&.lstrip&.rstrip
+        end
+      end
+
+      def accept(visitor)
+        visitor.visit_erb_content(self)
+      end
+
+      def child_nodes
+        []
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { value: value }
+      end
+    end
+
+    # An HtmlAttribute is a key-value pair within a tag. It contains the key, the
+    # equals sign, and the value.
+    class HtmlAttribute < Node
+      attr_reader :key, :equals, :value, :location
+
+      def initialize(key:, equals:, value:, location:)
+        @key = key
+        @equals = equals
+        @value = value
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_attribute(self)
+      end
+
+      def child_nodes
+        [key, equals, value]
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { key: key, equals: equals, value: value, location: location }
+      end
+    end
+
+    # A HtmlString can include ERB-tags
+    class HtmlString < Node
+      attr_reader :opening, :contents, :closing, :location
+
+      def initialize(opening:, contents:, closing:, location:)
+        @opening = opening
+        @contents = contents
+        @closing = closing
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_html_string(self)
+      end
+
+      def child_nodes
+        [*contents]
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        {
+          opening: opening,
+          contents: contents,
+          closing: closing,
+          location: location
+        }
+      end
+    end
+
+    class HtmlComment < Node
+      attr_reader :token, :location
+
+      def initialize(token:, location:)
+        @token = token
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_html_comment(self)
+      end
+
+      def child_nodes
+        []
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { token: token, location: location }
+      end
+    end
+
+    # A CharData contains either plain text or whitespace within an element.
+    # It wraps a single token value.
+    class CharData < Node
+      attr_reader :value, :location
+
+      def initialize(value:, location:)
+        @value = value
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_char_data(self)
+      end
+
+      def child_nodes
+        [value]
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { value: value, location: location }
+      end
+    end
+
+    # A document type declaration is a special kind of tag that specifies the
+    # type of the document. It contains an opening declaration, the name of
+    # the document type, an optional external identifier, and a closing of the
+    # tag.
+    class Doctype < Node
+      attr_reader :opening, :name, :closing, :location
+
+      def initialize(opening:, name:, closing:, location:)
+        @opening = opening
+        @name = name
+        @closing = closing
+        @location = location
+      end
+
+      def accept(visitor)
+        visitor.visit_doctype(self)
+      end
+
+      def child_nodes
+        [opening, name, closing].compact
+      end
+
+      alias deconstruct child_nodes
+
+      def deconstruct_keys(keys)
+        { opening: opening, name: name, closing: closing, location: location }
+      end
+    end
+  end
+end