better_html 0.0.12 → 1.0.0

data/lib/better_html/node_iterator.rb

@@ -1,144 +0,0 @@
-require_relative 'node_iterator/javascript_erb'
-require_relative 'node_iterator/html_erb'
-require_relative 'node_iterator/html_lodash'
-require_relative 'node_iterator/cdata'
-require_relative 'node_iterator/comment'
-require_relative 'node_iterator/element'
-require_relative 'node_iterator/attribute'
-require_relative 'node_iterator/text'
-
-module BetterHtml
-  class NodeIterator
-    attr_reader :nodes, :template_language
-
-    delegate :each, :each_with_index, :[], to: :nodes
-    delegate :parser, to: :@erb, allow_nil: true
-    delegate :errors, to: :parser, allow_nil: true, prefix: true
-
-    def initialize(document, template_language: :html)
-      @document = document
-      @template_language = template_language
-      @erb = case template_language
-      when :html
-        HtmlErb.new(@document)
-      when :lodash
-        HtmlLodash.new(@document)
-      when :javascript
-        JavascriptErb.new(@document)
-      else
-        raise ArgumentError, "template_language can be :html or :javascript"
-      end
-      @nodes = parse!
-    end
-
-    private
-
-    def parse!
-      nodes = []
-      tokens = @erb.tokens.dup
-      while token = tokens[0]
-        case token.type
-        when :cdata_start
-          tokens.shift
-          nodes << consume_cdata(tokens)
-        when :comment_start
-          tokens.shift
-          nodes << consume_comment(tokens)
-        when :tag_start
-          tokens.shift
-          nodes << consume_element(tokens)
-        when :text, :stmt, :expr_literal, :expr_escaped
-          nodes << consume_text(tokens)
-        else
-          raise RuntimeError, "Unhandled token #{token.type} line #{token.location.line} column #{token.location.column}"
-        end
-      end
-      nodes
-    end
-
-    def consume_cdata(tokens)
-      node = CData.new
-      while tokens.any? && tokens[0].type != :cdata_end
-        node.content_parts << tokens.shift
-      end
-      tokens.shift if tokens.any? && tokens[0].type == :cdata_end
-      node
-    end
-
-    def consume_comment(tokens)
-      node = Comment.new
-      while tokens.any? && tokens[0].type != :comment_end
-        node.content_parts << tokens.shift
-      end
-      tokens.shift if tokens.any? && tokens[0].type == :comment_end
-      node
-    end
-
-    def consume_element(tokens)
-      node = Element.new
-      if tokens.any? && tokens[0].type == :solidus
-        tokens.shift
-        node.closing = true
-      end
-      while tokens.any? && [:tag_name, :stmt, :expr_literal, :expr_escaped].include?(tokens[0].type)
-        node.name_parts << tokens.shift
-      end
-      while tokens.any?
-        token = tokens[0]
-        if token.type == :attribute_name
-          node.attributes << consume_attribute(tokens)
-        elsif token.type == :attribute_quoted_value_start
-          node.attributes << consume_attribute_value(tokens)
-        elsif token.type == :tag_end
-          tokens.shift
-          node.self_closing = token.self_closing
-          break
-        else
-          tokens.shift
-        end
-      end
-      node
-    end
-
-    def consume_attribute(tokens)
-      node = Attribute.new
-      while tokens.any? && [:attribute_name, :stmt, :expr_literal, :expr_escaped].include?(tokens[0].type)
-        node.name_parts << tokens.shift
-      end
-      return node unless consume_equal?(tokens)
-      while tokens.any? && [
-          :attribute_quoted_value_start, :attribute_quoted_value,
-          :attribute_quoted_value_end, :attribute_unquoted_value,
-          :stmt, :expr_literal, :expr_escaped].include?(tokens[0].type)
-        node.value_parts << tokens.shift
-      end
-      node
-    end
-
-    def consume_attribute_value(tokens)
-      node = Attribute.new
-      while tokens.any? && [
-          :attribute_quoted_value_start, :attribute_quoted_value,
-          :attribute_quoted_value_end, :attribute_unquoted_value,
-          :stmt, :expr_literal, :expr_escaped].include?(tokens[0].type)
-        node.value_parts << tokens.shift
-      end
-      node
-    end
-
-    def consume_equal?(tokens)
-      while tokens.any? && [:whitespace, :equal].include?(tokens[0].type)
-        return true if tokens.shift.type == :equal
-      end
-      false
-    end
-
-    def consume_text(tokens)
-      node = Text.new
-      while tokens.any? && [:text, :stmt, :expr_literal, :expr_escaped].include?(tokens[0].type)
-        node.content_parts << tokens.shift
-      end
-      node
-    end
-  end
-end

data/lib/better_html/node_iterator/attribute.rb

@@ -1,34 +0,0 @@
-require_relative 'base'
-
-module BetterHtml
-  class NodeIterator
-    class Attribute < Base
-      tokenized_attribute :name
-      tokenized_attribute :value
-
-      def initialize
-        @name_parts = []
-        @value_parts = []
-      end
-
-      def unescaped_value_parts
-        value_parts.map do |part|
-          next if ["'", '"'].include?(part.text)
-          if [:attribute_quoted_value, :attribute_unquoted_value].include?(part.type)
-            CGI.unescapeHTML(part.text)
-          else
-            part.text
-          end
-        end.compact
-      end
-
-      def unescaped_value
-        unescaped_value_parts.join
-      end
-
-      def value_without_quotes
-        value_parts.map{ |s| ["'", '"'].include?(s.text) ? '' : s.text }.join
-      end
-    end
-  end
-end

data/lib/better_html/node_iterator/base.rb

@@ -1,27 +0,0 @@
-module BetterHtml
-  class NodeIterator
-    class Base
-      def self.tokenized_attribute(name)
-        class_eval <<~RUBY
-          attr_reader :#{name}_parts
-
-          def #{name}
-            #{name}_parts.map(&:text).join
-          end
-        RUBY
-      end
-
-      def node_type
-        self.class.name.split('::').last.downcase.to_sym
-      end
-
-      %w(text cdata comment element).each do |name|
-        class_eval <<~RUBY
-          def #{name}?
-            node_type == :#{name}
-          end
-        RUBY
-      end
-    end
-  end
-end

data/lib/better_html/node_iterator/cdata.rb

@@ -1,8 +0,0 @@
-require_relative 'content_node'
-
-module BetterHtml
-  class NodeIterator
-    class CData < ContentNode
-    end
-  end
-end

data/lib/better_html/node_iterator/comment.rb

@@ -1,8 +0,0 @@
-require_relative 'content_node'
-
-module BetterHtml
-  class NodeIterator
-    class Comment < ContentNode
-    end
-  end
-end

data/lib/better_html/node_iterator/content_node.rb

@@ -1,13 +0,0 @@
-require_relative 'base'
-
-module BetterHtml
-  class NodeIterator
-    class ContentNode < Base
-      tokenized_attribute :content
-
-      def initialize
-        @content_parts = []
-      end
-    end
-  end
-end

data/lib/better_html/node_iterator/element.rb

@@ -1,26 +0,0 @@
-require_relative 'base'
-
-module BetterHtml
-  class NodeIterator
-    class Element < Base
-      tokenized_attribute :name
-      attr_reader :attributes
-      attr_accessor :closing, :self_closing
-      alias_method :closing?, :closing
-      alias_method :self_closing?, :self_closing
-
-      def initialize
-        @name_parts = []
-        @attributes = []
-      end
-
-      def find_attr(wanted)
-        @attributes.each do |attribute|
-          return attribute if attribute.name == wanted
-        end
-        nil
-      end
-      alias_method :[], :find_attr
-    end
-  end
-end

data/lib/better_html/node_iterator/html_erb.rb

@@ -1,70 +0,0 @@
-require 'erubi'
-require 'html_tokenizer'
-require_relative 'token'
-require_relative 'location'
-
-module BetterHtml
-  class NodeIterator
-    class HtmlErb < ::Erubi::Engine
-      attr_reader :tokens
-      attr_reader :parser
-
-      REGEXP_WITHOUT_TRIM = /<%(={1,2}|-|%)?(.*?)(?:[-=])?()?%>([ \t]*\r?\n)?/m
-
-      def initialize(document)
-        @parser = HtmlTokenizer::Parser.new
-        @tokens = []
-        @document = document
-        super(document, regexp: REGEXP_WITHOUT_TRIM, trim: false)
-      end
-
-      def add_text(text)
-        @parser.parse(text) { |*args| add_tokens(*args) }
-      end
-
-      def add_code(code)
-        text = "<%#{code}%>"
-        start = @parser.document_length
-        stop = start + text.size
-        @tokens << Token.new(
-          type: :stmt,
-          code: code,
-          text: text,
-          location: Location.new(@document, start, stop, @parser.line_number, @parser.column_number),
-          code_location: Location.new(@document, start+2, stop-2, @parser.line_number, @parser.column_number+2)
-        )
-        @parser.append_placeholder(text)
-      end
-
-      def add_expression(indicator, code)
-        text = "<%#{indicator}#{code}%>"
-        start = @parser.document_length
-        stop = start + text.size
-        @tokens << Token.new(
-          type: indicator == '=' ? :expr_literal : :expr_escaped,
-          code: code,
-          text: text,
-          location: Location.new(@document, start, stop, @parser.line_number, @parser.column_number),
-          code_location: Location.new(@document, start+2+indicator.size, stop-2, @parser.line_number, @parser.column_number+2+indicator.size)
-        )
-        @parser.append_placeholder(text)
-      end
-
-      private
-
-      def add_tokens(type, start, stop, line, column)
-        extra_attributes = if type == :tag_end
-          {
-            self_closing: @parser.self_closing_tag?
-          }
-        end
-        @tokens << Token.new(
-          type: type,
-          text: @parser.extract(start, stop),
-          location: Location.new(@document, start, stop, line, column),
-          **(extra_attributes || {})
-        )
-      end
-    end
-  end
-end

data/lib/better_html/node_iterator/javascript_erb.rb

@@ -1,55 +0,0 @@
-require 'erubi'
-require_relative 'token'
-require_relative 'location'
-
-module BetterHtml
-  class NodeIterator
-    class JavascriptErb < ::Erubi::Engine
-      attr_reader :tokens
-
-      def initialize(source)
-        @source = source
-        @parsed_document = ""
-        @tokens = []
-        super(source, regexp: HtmlErb::REGEXP_WITHOUT_TRIM, trim: false)
-      end
-
-      def add_text(text)
-        add_token(:text, text)
-        append(text)
-      end
-
-      def add_code(code)
-        text = "<%#{code}%>"
-        add_token(:stmt, text, code)
-        append(text)
-      end
-
-      def add_expression(indicator, code)
-        text = "<%#{indicator}#{code}%>"
-        add_token(indicator == '=' ? :expr_literal : :expr_escaped, text, code)
-        append(text)
-      end
-
-      private
-
-      def add_token(type, text, code = nil)
-        start = @parsed_document.size
-        stop = start + text.size
-        lines = @parsed_document.split("\n", -1)
-        line = lines.empty? ? 1 : lines.size
-        column = lines.empty? ? 0 : lines.last.size
-        @tokens << Token.new(
-          type: type,
-          text: text,
-          code: code,
-          location: Location.new(@source, start, stop, line, column)
-        )
-      end
-
-      def append(text)
-        @parsed_document << text
-      end
-    end
-  end
-end

data/lib/better_html/node_iterator/text.rb

@@ -1,8 +0,0 @@
-require_relative 'content_node'
-
-module BetterHtml
-  class NodeIterator
-    class Text < ContentNode
-    end
-  end
-end

data/lib/better_html/node_iterator/token.rb

@@ -1,8 +0,0 @@
-require 'ostruct'
-
-module BetterHtml
-  class NodeIterator
-    class Token < OpenStruct
-    end
-  end
-end

data/lib/better_html/tree.rb

@@ -1,113 +0,0 @@
-require 'better_html/node_iterator'
-
-module BetterHtml
-  class Tree
-    attr_reader :errors
-    attr_reader :root
-
-    cattr_accessor :void_elements
-    self.void_elements = %w(area base br col embed hr img
-      input keygen link menuitem meta param source track wbr)
-
-    def initialize(data, **options)
-      @data = data
-      @errors = Errors.new
-      @nodes = BetterHtml::NodeIterator.new(data, **options.slice(:template_language))
-      @root = TreeRoot.new
-      construct!
-      @nodes.parser_errors&.each do |error|
-        @errors.add(error)
-      end
-    end
-
-    private
-
-    class TreeError < HtmlError
-      attr_reader :token
-
-      def initialize(token, message)
-        @token = token
-        super(message)
-      end
-    end
-
-    def add_error(token, message)
-      @errors.add(TreeError.new(token, message))
-    end
-
-    def construct!
-      current = @root
-      @nodes.each do |node|
-        case node.node_type
-        when :text, :comment, :cdata
-          current << node
-        when :element
-          if node.closing?
-            if void_elements.include?(node.name)
-              add_error(node.name_parts.first,
-                "end of tag for void element: </#{node.name}>")
-            elsif current.root?
-              add_error(node.name_parts.first,
-                "mismatched </#{node.name}> at root of tree")
-            else
-              if node.name == current.name
-                current.end_node = node
-                current = current.parent
-              else
-                add_error(node.name_parts.first,
-                  "mismatched </#{node.name}> in <#{current.name}> element")
-              end
-            end
-          else
-            element = Element.new(parent: current, start_node: node)
-            current << element
-            current = element unless element.closed?
-          end
-        end
-      end
-    end
-
-    class NodeContainer
-      attr_accessor :content_nodes
-      delegate :each, :[], :each_with_index, :<<, :push,
-        :size, :empty?, :any?, to: :content_nodes
-
-      def root?
-        false
-      end
-
-      def initialize
-        @content_nodes = []
-      end
-    end
-
-    class TreeRoot < NodeContainer
-      def root?
-        true
-      end
-    end
-
-    class Element < NodeContainer
-      attr_reader :parent
-      attr_accessor :start_node
-      attr_accessor :end_node
-
-      delegate :name, :attributes, :self_closing?, to: :start_node
-      delegate :element?, :text?, :comment?, :cdata?, to: :start_node
-
-      def initialize(parent:, start_node:)
-        super()
-        @parent = parent
-        @start_node = start_node
-      end
-
-      def closed?
-        void? || end_node.present? || self_closing?
-      end
-
-      def void?
-        BetterHtml::Tree.void_elements.include?(name)
-      end
-    end
-  end
-end