lkml 0.1.0 → 0.2.0

data/lib/lkml/tree.rb

@@ -1,319 +1,445 @@
 # frozen_string_literal: true
 
-# Node and token classes that make up the parse tree.
+require_relative "keys"
 
 module Lkml
-  class SyntaxToken
-    attr_reader :value, :line_number, :prefix, :suffix
-
-    def initialize(value, line_number = nil, prefix: '', suffix: '')
-      @value = value
-      @line_number = line_number
-      @prefix = prefix
-      @suffix = suffix
-    end
+  module Tree
+    module_function
 
-    def format_value
-      @value
+    def items_to_str(*items)
+      items.join
     end
 
-    def accept(visitor)
-      visitor.visit_token(self)
-    end
+    module Visitor
+      def visit(_document)
+        raise NotImplementedError
+      end
+
+      def visit_container(_node)
+        raise NotImplementedError
+      end
+
+      def visit_block(_node)
+        raise NotImplementedError
+      end
+
+      def visit_list(_node)
+        raise NotImplementedError
+      end
 
-    def ==(other)
-      if other.is_a?(self.class)
-        instance_variables.all? { |var| instance_variable_get(var) == other.instance_variable_get(var) }
-      elsif other.is_a?(String)
-        @value == other
-      else
-        false
+      def visit_pair(_node)
+        raise NotImplementedError
+      end
+
+      def visit_token(_token)
+        raise NotImplementedError
       end
     end
 
-    def to_s
-      [@prefix, format_value, @suffix].join
+    class SyntaxToken
+      attr_reader :value, :line_number, :prefix, :suffix
+
+      def initialize(value, line_number = nil, prefix = "", suffix = "", expr_suffix: nil)
+        @value = value
+        @line_number = line_number
+        @prefix = prefix
+        @suffix = suffix
+        @expr_suffix = expr_suffix unless expr_suffix.nil?
+        freeze
+      end
+
+      def format_value
+        @value
+      end
+
+      def accept(visitor)
+        visitor.visit_token(self)
+      end
+
+      def ==(other)
+        if instance_of?(other.class)
+          ivars_match?(other)
+        elsif other.is_a?(String)
+          @value == other
+        else
+          false
+        end
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def hash
+        instance_variables.map { |v| instance_variable_get(v) }.hash
+      end
+
+      def to_s
+        Tree.items_to_str(@prefix, format_value, @suffix)
+      end
+
+      def with(**changes)
+        self.class.new(
+          changes.fetch(:value, @value),
+          changes.fetch(:line_number, @line_number),
+          changes.fetch(:prefix, @prefix),
+          changes.fetch(:suffix, @suffix)
+        )
+      end
+
+      protected
+
+      def ivars_match?(other)
+        instance_variables.all? { |v| instance_variable_get(v) == other.instance_variable_get(v) }
+      end
     end
-  end
 
-  class LeftCurlyBrace < SyntaxToken
-    def initialize(*, **)
-      super('{', *, **)
+    class LeftCurlyBrace < SyntaxToken
+      def initialize(value = "{", line_number = nil, prefix = "", suffix = "")
+        super
+      end
     end
-  end
 
-  class RightCurlyBrace < SyntaxToken
-    def initialize(*, **)
-      super('}', *, **)
+    class RightCurlyBrace < SyntaxToken
+      def initialize(value = "}", line_number = nil, prefix = "", suffix = "")
+        super
+      end
     end
-  end
 
-  class Colon < SyntaxToken
-    def initialize(*, **)
-      super(':', *, **)
+    class Colon < SyntaxToken
+      def initialize(value = ":", line_number = nil, prefix = "", suffix = "")
+        super
+      end
     end
-  end
 
-  class LeftBracket < SyntaxToken
-    def initialize(*, **)
-      super('[', *, **)
+    class LeftBracket < SyntaxToken
+      def initialize(value = "[", line_number = nil, prefix = "", suffix = "")
+        super
+      end
     end
-  end
 
-  class RightBracket < SyntaxToken
-    def initialize(*, **)
-      super(']', *, **)
+    class RightBracket < SyntaxToken
+      def initialize(value = "]", line_number = nil, prefix = "", suffix = "")
+        super
+      end
     end
-  end
 
-  class DoubleSemicolon < SyntaxToken
-    def initialize(*, **)
-      super(';;', *, **)
+    class DoubleSemicolon < SyntaxToken
+      def initialize(value = ";;", line_number = nil, prefix = "", suffix = "")
+        super
+      end
     end
-  end
 
-  class Comma < SyntaxToken
-    def initialize(*, **)
-      super(',', *, **)
+    class Comma < SyntaxToken
+      def initialize(value = ",", line_number = nil, prefix = "", suffix = "")
+        super
+      end
     end
-  end
 
-  class QuotedSyntaxToken < SyntaxToken
-    def format_value
-      "\"#{@value.gsub('\"', '"').gsub('"', '\"')}\""
+    class QuotedSyntaxToken < SyntaxToken
+      def format_value
+        "\"#{@value.gsub('\\"', '"').gsub('"', '\\"')}\""
+      end
     end
-  end
 
-  class ExpressionSyntaxToken < SyntaxToken
-    attr_reader :expr_suffix
+    class ExpressionSyntaxToken < SyntaxToken
+      attr_reader :expr_suffix
 
-    def initialize(value, line_number = nil, prefix: ' ', expr_suffix: ' ', suffix: '')
-      super(value, line_number, prefix: prefix, suffix: suffix)
-      @expr_suffix = expr_suffix
-    end
+      def initialize(value, line_number = nil, prefix = " ", suffix = "", expr_suffix = " ")
+        super(value, line_number, prefix, suffix, expr_suffix: expr_suffix)
+      end
 
-    def to_s
-      [@prefix, format_value, @expr_suffix, ';;', @suffix].join
-    end
-  end
+      def with(**changes)
+        ExpressionSyntaxToken.new(
+          changes.fetch(:value, @value),
+          changes.fetch(:line_number, @line_number),
+          changes.fetch(:prefix, @prefix),
+          changes.fetch(:suffix, @suffix),
+          changes.fetch(:expr_suffix, @expr_suffix)
+        )
+      end
 
-  class SyntaxNode
-    def children
-      raise NotImplementedError, 'Subclasses must implement the children method'
+      def to_s
+        Tree.items_to_str(@prefix, format_value, @expr_suffix, ";;", @suffix)
+      end
     end
 
-    def line_number
-      raise NotImplementedError, 'Subclasses must implement the line_number method'
-    end
+    class SyntaxNode
+      def children
+        raise NotImplementedError
+      end
 
-    def accept(visitor)
-      raise NotImplementedError, 'Subclasses must implement the accept method'
-    end
+      def line_number
+        raise NotImplementedError
+      end
 
-    def ==(other)
-      if other.is_a?(self.class)
-        instance_variables.all? { |var| instance_variable_get(var) == other.instance_variable_get(var) }
-      elsif other.is_a?(String)
-        @value == other
-      else
-        false
+      def accept(_visitor)
+        raise NotImplementedError
       end
     end
-  end
 
-  class PairNode < SyntaxNode
-    attr_reader :type, :value, :colon
+    class PairNode < SyntaxNode
+      attr_reader :type, :value, :colon
 
-    def initialize(type, value, colon: Colon.new(suffix: ' '))
-      super()
-      @type = type
-      @value = value
-      @colon = colon
-    end
+      def initialize(type:, value:, colon: nil)
+        super()
+        @type = type
+        @value = value
+        @colon = colon || Colon.new(":", nil, "", " ")
+        freeze
+      end
 
-    def to_s
-      [@type, @colon, @value].join
-    end
+      def inspect
+        "#{self.class.name.split('::').last}(type='#{@type.value}', value='#{@value.value}')"
+      end
 
-    def children
-      nil
-    end
+      def children
+        nil
+      end
 
-    def line_number
-      @type.line_number
-    end
+      def line_number
+        @type.line_number
+      end
 
-    def accept(visitor)
-      visitor.visit_pair(self)
-    end
-  end
+      def accept(visitor)
+        visitor.visit_pair(self)
+      end
 
-  class ListNode < SyntaxNode
-    attr_reader :type, :items, :left_bracket, :right_bracket, :colon, :leading_comma, :trailing_comma
-
-    def initialize(type, items:, left_bracket:, right_bracket:, colon: Colon.new(suffix: ' '), leading_comma: nil, trailing_comma: nil) # rubocop:disable Metrics/ParameterLists,Layout/LineLength
-      super()
-      @type = type
-      @items = items
-      @left_bracket = left_bracket
-      @right_bracket = right_bracket
-      @colon = colon
-      @leading_comma = leading_comma
-      @trailing_comma = trailing_comma
-    end
+      def to_s
+        Tree.items_to_str(@type, @colon, @value)
+      end
 
-    def to_s
-      [
-        @type,
-        @colon,
-        @left_bracket,
-        @leading_comma && @items.any? ? @leading_comma : '',
-        @items.map(&:to_s).join(','),
-        @trailing_comma && @items.any? ? @trailing_comma : '',
-        @right_bracket
-      ].join
-    end
+      def with(**changes)
+        PairNode.new(
+          type: changes.fetch(:type, @type),
+          value: changes.fetch(:value, @value),
+          colon: changes.fetch(:colon, @colon)
+        )
+      end
 
-    def children
-      if @items.any? && @items.first.is_a?(PairNode)
-        @items
-      else
-        []
+      def ==(other)
+        instance_of?(other.class) &&
+          @type == other.type &&
+          @value == other.value &&
+          @colon == other.colon
       end
     end
 
-    def line_number
-      @type.line_number
-    end
+    class ListNode < SyntaxNode
+      attr_reader :type, :items, :left_bracket, :right_bracket, :colon, :leading_comma, :trailing_comma
+
+      def initialize(type:, items:, left_bracket:, right_bracket:, colon: nil, leading_comma: nil,
+                     trailing_comma: nil)
+        super()
+        @type = type
+        @items = items.freeze
+        @left_bracket = left_bracket
+        @right_bracket = right_bracket
+        @colon = colon || Colon.new(":", nil, "", " ")
+        @leading_comma = leading_comma
+        @trailing_comma = trailing_comma
+        freeze
+      end
 
-    def accept(visitor)
-      visitor.visit_list(self)
-    end
-  end
+      def inspect
+        "#{self.class.name.split('::').last}(type='#{@type.value}')"
+      end
+
+      def children
+        return [].freeze if @items.empty?
 
-  class ContainerNode < SyntaxNode
-    attr_reader :items, :top_level
+        @items.first.is_a?(PairNode) ? @items : []
+      end
+
+      def line_number
+        @type.line_number
+      end
+
+      def accept(visitor)
+        visitor.visit_list(self)
+      end
+
+      def to_s
+        mid = @items.join(",")
+        lc = @leading_comma && !@items.empty? ? @leading_comma.to_s : ""
+        tc = @trailing_comma && !@items.empty? ? @trailing_comma.to_s : ""
+        Tree.items_to_str(@type, @colon, @left_bracket, lc, mid, tc, @right_bracket)
+      end
 
-    def initialize(items, top_level: false)
-      super()
-      @items = items
-      @top_level = top_level
-      validate_keys
+      def with(**changes)
+        ListNode.new(
+          type: changes.fetch(:type, @type),
+          items: changes.fetch(:items, @items),
+          left_bracket: changes.fetch(:left_bracket, @left_bracket),
+          right_bracket: changes.fetch(:right_bracket, @right_bracket),
+          colon: changes.fetch(:colon, @colon),
+          leading_comma: changes.fetch(:leading_comma, @leading_comma),
+          trailing_comma: changes.fetch(:trailing_comma, @trailing_comma)
+        )
+      end
+
+      def ==(other)
+        instance_of?(other.class) &&
+          @type == other.type &&
+          @items == other.items &&
+          @left_bracket == other.left_bracket &&
+          @right_bracket == other.right_bracket &&
+          @colon == other.colon &&
+          @leading_comma == other.leading_comma &&
+          @trailing_comma == other.trailing_comma
+      end
     end
 
-    def validate_keys
-      counter = @items.each_with_object(Hash.new(0)) { |item, hash| hash[item.type.value] += 1 }
-      counter.each do |key, count|
-        if !@top_level && count > 1 && !PLURAL_KEYS.include?(key)
-          raise KeyError, "Key \"#{key}\" already exists in tree and would overwrite the existing value."
+    class ContainerNode < SyntaxNode
+      attr_reader :items, :top_level
+
+      def initialize(items:, top_level: false)
+        super()
+        @top_level = top_level
+        @items = items.freeze
+        validate_duplicate_keys!
+        freeze
+      end
+
+      def inspect
+        "#{self.class.name.split('::').last}()"
+      end
+
+      def validate_duplicate_keys!
+        counts = Hash.new(0)
+        @items.each { |item| counts[item.type.value] += 1 }
+        counts.each do |key, count|
+          next if @top_level || count <= 1 || Keys::PLURAL_KEYS.include?(key)
+
+          raise KeyError,
+                "Key \"#{key}\" already exists in tree and would overwrite the " \
+                "existing value."
         end
       end
-    end
 
-    def children
-      @items
-    end
+      def children
+        @items
+      end
 
-    def line_number
-      @items.first&.line_number
-    end
+      def line_number
+        @items[0]&.line_number
+      end
 
-    def accept(visitor)
-      visitor.visit_container(self)
-    end
+      def accept(visitor)
+        visitor.visit_container(self)
+      end
 
-    def to_s
-      @items.map(&:to_s).join
-    end
-  end
+      def to_s
+        Tree.items_to_str(*@items)
+      end
 
-  class BlockNode < SyntaxNode
-    attr_reader :type, :left_brace, :right_brace, :colon, :name, :container
-
-    def initialize(type, left_brace: LeftCurlyBrace.new(suffix: "\n"), right_brace: RightCurlyBrace.new(prefix: "\n"), colon: Colon.new(suffix: ' '), name: nil, container: ContainerNode.new([])) # rubocop:disable Metrics/ParameterLists,Layout/LineLength
-      super()
-      @type = type
-      @left_brace = left_brace
-      @right_brace = right_brace
-      @colon = colon
-      @name = name
-      @container = container
-    end
+      def with(**changes)
+        ContainerNode.new(
+          items: changes.fetch(:items, @items),
+          top_level: changes.fetch(:top_level, @top_level)
+        )
+      end
 
-    def to_s
-      [
-        @type,
-        @colon,
-        @name || '',
-        @left_brace,
-        @container || '',
-        @right_brace
-      ].join
+      def ==(other)
+        instance_of?(other.class) &&
+          @top_level == other.top_level &&
+          @items == other.items
+      end
     end
 
-    def children
-      @container.children
-    end
+    class BlockNode < SyntaxNode
+      attr_reader :type, :left_brace, :right_brace, :colon, :name, :container
 
-    def line_number
-      @type.line_number
-    end
+      def initialize(type:, left_brace: nil, right_brace: nil, colon: nil, name: nil, container: nil)
+        super()
+        @type = type
+        @left_brace = left_brace || LeftCurlyBrace.new("{", nil, "", "\n")
+        @right_brace = right_brace || RightCurlyBrace.new("}", nil, "\n", "")
+        @colon = colon || Colon.new(":", nil, "", " ")
+        @name = name
+        @container = container || ContainerNode.new(items: [])
+        freeze
+      end
 
-    def accept(visitor)
-      visitor.visit_block(self)
-    end
-  end
+      def inspect
+        nm = @name ? "name='#{@name.value}'" : "None"
+        "#{self.class.name.split('::').last}(type='#{@type.value}', #{nm})"
+      end
 
-  class DocumentNode < SyntaxNode
-    attr_reader :container, :prefix, :suffix
+      def children
+        @container.children
+      end
 
-    def initialize(container, prefix: '', suffix: '')
-      super()
-      @container = container
-      @prefix = prefix
-      @suffix = suffix
-    end
+      def line_number
+        @type.line_number
+      end
 
-    def children
-      [@container]
-    end
+      def accept(visitor)
+        visitor.visit_block(self)
+      end
 
-    def line_number
-      1
-    end
+      def to_s
+        nm = @name || ""
+        ctr = @container || ""
+        Tree.items_to_str(@type, @colon, nm, @left_brace, ctr, @right_brace)
+      end
 
-    def accept(visitor)
-      visitor.visit(self)
-    end
+      def with(**changes)
+        BlockNode.new(
+          type: changes.fetch(:type, @type),
+          left_brace: changes.fetch(:left_brace, @left_brace),
+          right_brace: changes.fetch(:right_brace, @right_brace),
+          colon: changes.fetch(:colon, @colon),
+          name: changes.fetch(:name, @name),
+          container: changes.fetch(:container, @container)
+        )
+      end
 
-    def to_s
-      [@prefix, @container, @suffix].join
+      def ==(other)
+        instance_of?(other.class) &&
+          @type == other.type &&
+          @left_brace == other.left_brace &&
+          @right_brace == other.right_brace &&
+          @colon == other.colon &&
+          @name == other.name &&
+          @container == other.container
+      end
     end
-  end
 
-  class Visitor
-    def visit(document)
-      raise NotImplementedError, 'Subclasses must implement the visit method'
-    end
+    class DocumentNode < SyntaxNode
+      attr_reader :container, :prefix, :suffix
 
-    def visit_container(node)
-      raise NotImplementedError, 'Subclasses must implement the visit_container method'
-    end
+      def initialize(container, prefix = "", suffix = "")
+        super()
+        @container = container
+        @prefix = prefix
+        @suffix = suffix
+        freeze
+      end
 
-    def visit_block(node)
-      raise NotImplementedError, 'Subclasses must implement the visit_block method'
-    end
+      def children
+        [@container]
+      end
 
-    def visit_list(node)
-      raise NotImplementedError, 'Subclasses must implement the visit_list method'
-    end
+      def line_number
+        1
+      end
 
-    def visit_pair(node)
-      raise NotImplementedError, 'Subclasses must implement the visit_pair method'
-    end
+      def accept(visitor)
+        visitor.visit(self)
+      end
+
+      def to_s
+        Tree.items_to_str(@prefix, @container, @suffix)
+      end
 
-    def visit_token(token)
-      raise NotImplementedError, 'Subclasses must implement the visit_token method'
+      def with(**changes)
+        DocumentNode.new(
+          changes.fetch(:container, @container),
+          changes.fetch(:prefix, @prefix),
+          changes.fetch(:suffix, @suffix)
+        )
+      end
     end
   end
 end