better_html 0.0.3

data/lib/better_html/errors.rb

@@ -0,0 +1,22 @@
+require 'active_support/core_ext/string/output_safety'
+require 'action_view'
+
+module BetterHtml
+  class InterpolatorError < RuntimeError; end
+  class DontInterpolateHere < InterpolatorError; end
+  class UnsafeHtmlError < InterpolatorError; end
+  class HtmlError < RuntimeError; end
+
+  class Errors
+    delegate :[], :each, :size, :first,
+      :empty?, :any?, :present?, to: :@errors
+
+    def initialize
+      @errors = []
+    end
+
+    def add(error)
+      @errors << error
+    end
+  end
+end

data/lib/better_html/helpers.rb

@@ -0,0 +1,5 @@
+module BetterHtml::Helpers
+  def html_attributes(args)
+    BetterHtml::HtmlAttributes.new(args)
+  end
+end

data/lib/better_html/html_attributes.rb

@@ -0,0 +1,26 @@
+module BetterHtml
+  class HtmlAttributes
+    def initialize(data)
+      @data = data.stringify_keys
+    end
+
+    def to_s
+      @data.map do |key, value|
+        unless key =~ BetterHtml.config.partial_attribute_name_pattern
+          raise ArgumentError, "Attribute names must match the pattern #{BetterHtml.config.partial_attribute_name_pattern.inspect}"
+        end
+        if value.nil?
+          "#{key}"
+        else
+          value = value.to_s
+          escaped_value = value.html_safe? ? value : CGI.escapeHTML(value)
+          if escaped_value.include?('"')
+            raise ArgumentError, "The value provided for attribute '#{key}' contains a `\"` "\
+              "character which is not allowed. Did you call .html_safe without properly escaping this data?"
+          end
+          "#{key}=\"#{escaped_value}\""
+        end
+      end.join(" ")
+    end
+  end
+end

data/lib/better_html/node_iterator.rb

@@ -0,0 +1,144 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,27 @@
+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

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

data/lib/better_html/node_iterator/comment.rb

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

data/lib/better_html/node_iterator/content_node.rb

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,78 @@
+require 'erubis/engine/eruby'
+require 'html_tokenizer'
+require_relative 'token'
+require_relative 'location'
+
+module BetterHtml
+  class NodeIterator
+    class HtmlErb < ::Erubis::Eruby
+      attr_reader :tokens
+      attr_reader :parser
+
+      def initialize(document)
+        @parser = HtmlTokenizer::Parser.new
+        @tokens = []
+        super
+      end
+
+      def add_text(src, text)
+        @parser.parse(text) { |*args| add_tokens(*args) }
+      end
+
+      def add_stmt(src, code)
+        text = "<%#{code}%>"
+        start = @parser.document_length
+        stop = start + text.size
+        @tokens << Token.new(
+          type: :stmt,
+          code: code,
+          text: text,
+          location: Location.new(start, stop, @parser.line_number, @parser.column_number)
+        )
+        @parser.append_placeholder(text)
+      end
+
+      def add_expr_literal(src, code)
+        text = "<%=#{code}%>"
+        start = @parser.document_length
+        stop = start + text.size
+        @tokens << Token.new(
+          type: :expr_literal,
+          code: code,
+          text: text,
+          location: Location.new(start, stop, @parser.line_number, @parser.column_number)
+        )
+        @parser.append_placeholder(text)
+      end
+
+      def add_expr_escaped(src, code)
+        text = "<%==#{code}%>"
+        start = @parser.document_length
+        stop = start + text.size
+        @tokens << Token.new(
+          type: :expr_escaped,
+          code: code,
+          text: text,
+          location: Location.new(start, stop, @parser.line_number, @parser.column_number)
+        )
+        @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(start, stop, line, column),
+          **(extra_attributes || {})
+        )
+      end
+    end
+  end
+end

data/lib/better_html/node_iterator/html_lodash.rb

@@ -0,0 +1,101 @@
+require_relative 'token'
+require_relative 'location'
+
+module BetterHtml
+  class NodeIterator
+    class HtmlLodash
+      attr_reader :tokens
+      attr_reader :parser
+
+      cattr_accessor :lodash_escape, :lodash_evaluate, :lodash_interpolate
+      self.lodash_escape = %r{(?:\[\%)=(.+?)(?:\%\])}m
+      self.lodash_evaluate = %r{(?:\[\%)(.+?)(?:\%\])}m
+      self.lodash_interpolate = %r{(?:\[\%)!(.+?)(?:\%\])}m
+
+      def initialize(source)
+        @source = source
+        @scanner = StringScanner.new(source)
+        @parser = HtmlTokenizer::Parser.new
+        @tokens = []
+        scan!
+      end
+
+      private
+
+      def scan!
+        while @scanner.rest?
+          scanned = @scanner.scan_until(scan_pattern)
+          if scanned.present?
+            captures = scan_pattern.match(scanned).captures
+            if pre_match = captures[0]
+              add_text(pre_match) unless pre_match.blank?
+            end
+            match = captures[1]
+            if code = lodash_escape.match(match)
+              add_expr_escape(match, code.captures[0])
+            elsif code = lodash_interpolate.match(match)
+              add_expr_interpolate(match, code.captures[0])
+            elsif code = lodash_evaluate.match(match)
+              add_stmt(match, code.captures[0])
+            else
+              raise RuntimeError, 'unexpected match'
+            end
+          else
+            text = @source[(@scanner.pos)..(@source.size)]
+            add_text(text) unless text.blank?
+            break
+          end
+        end
+      end
+
+      def scan_pattern
+        @scan_pattern ||= begin
+          patterns = [
+            lodash_escape,
+            lodash_interpolate,
+            lodash_evaluate
+          ].map(&:source).join("|")
+          Regexp.new("(?<pre_patch>.*?)(?<match>" + patterns + ")", Regexp::MULTILINE)
+        end
+      end
+
+      def add_text(text)
+        @parser.parse(text) do |type, start, stop, line, column|
+          add_token(type, @parser.extract(start, stop), start: start, stop: stop, line: line, column: column)
+        end
+      end
+
+      def add_stmt(text, code)
+        add_token(:stmt, text, code: code)
+        @parser.append_placeholder(text)
+      end
+
+      def add_expr_interpolate(text, code)
+        add_token(:expr_escaped, text, code: code)
+        @parser.append_placeholder(text)
+      end
+
+      def add_expr_escape(text, code)
+        add_token(:expr_literal, text, code: code)
+        @parser.append_placeholder(text)
+      end
+
+      def add_token(type, text, code: nil, start: nil, stop: nil, line: nil, column: nil)
+        start ||= @parser.document_length
+        stop ||= start + text.size
+        extra_attributes = if type == :tag_end
+          {
+            self_closing: @parser.self_closing_tag?
+          }
+        end
+        @tokens << Token.new(
+          type: type,
+          text: text,
+          code: code,
+          location: Location.new(start, stop, line || @parser.line_number, column || @parser.column_number),
+          **(extra_attributes || {})
+        )
+      end
+    end
+  end
+end