herb 0.9.0-arm-linux-gnu → 0.9.2-arm-linux-gnu

data/lib/herb/engine.rb

@@ -55,6 +55,9 @@ module Herb
       @bufvar = properties[:bufvar] || properties[:outvar] || "_buf"
       @escape = properties.fetch(:escape) { properties.fetch(:escape_html, false) }
       @escapefunc = properties.fetch(:escapefunc, @escape ? "__herb.h" : "::Herb::Engine.h")
+      @attrfunc = properties.fetch(:attrfunc, @escape ? "__herb.attr" : "::Herb::Engine.attr")
+      @jsfunc = properties.fetch(:jsfunc, @escape ? "__herb.js" : "::Herb::Engine.js")
+      @cssfunc = properties.fetch(:cssfunc, @escape ? "__herb.css" : "::Herb::Engine.css")
       @src = properties[:src] || String.new
       @chain_appends = properties[:chain_appends]
       @buffer_on_stack = false
@@ -148,15 +151,7 @@ module Herb
       @src << "; ensure\n  #{@bufvar} = __original_outvar\nend\n" if properties[:ensure]
 
       if properties.fetch(:validate_ruby, false)
-        require "prism"
-
-        prism_result = Prism.parse(@src)
-        syntax_errors = prism_result.errors.reject { |e| e.type == :invalid_yield }
-
-        if syntax_errors.any?
-          details = syntax_errors.map { |e| "  - #{e.message} (line #{e.location.start_line})" }.join("\n")
-          raise InvalidRubyError.new("Compiled template produced invalid Ruby:\n#{details}", compiled_source: @src)
-        end
+        ensure_valid_ruby!(@src)
       end
 
       @src.freeze
@@ -238,11 +233,35 @@ module Herb
       @buffer_on_stack = false
     end
 
+    def expression_block?
+      @_in_expression_block || false
+    end
+
     def add_expression(indicator, code)
-      if (indicator == "=") ^ @escape
-        add_expression_result(code)
+      unescaped = (indicator == "=") ^ @escape
+
+      if expression_block?
+        unescaped ? add_expression_block_result(code) : add_expression_block_result_escaped(code)
       else
-        add_expression_result_escaped(code)
+        unescaped ? add_expression_result(code) : add_expression_result_escaped(code)
+      end
+    end
+
+    def add_context_aware_expression(indicator, code, context)
+      escapefunc = context_escape_function(context)
+
+      if escapefunc.nil?
+        add_expression(indicator, code)
+      else
+        with_buffer { @src << " << #{escapefunc}((" << code << trailing_newline(code) << "))" }
+      end
+    end
+
+    def context_escape_function(context)
+      case context
+      when :attribute_value then @attrfunc
+      when :script_content then @jsfunc
+      when :style_content then @cssfunc
       end
     end
 
@@ -259,39 +278,48 @@ module Herb
     end
 
     def add_expression_block(indicator, code)
-      if (indicator == "=") ^ @escape
-        add_expression_block_result(code)
-      else
-        add_expression_block_result_escaped(code)
-      end
+      @_in_expression_block = true
+      @_expression_block_open_paren = false
+
+      add_expression(indicator, code)
+    ensure
+      @_in_expression_block = false
     end
 
     def add_expression_block_result(code)
+      @_expression_block_open_paren = true
+
       with_buffer {
         @src << " << (" << code << trailing_newline(code)
       }
     end
 
     def add_expression_block_result_escaped(code)
+      @_expression_block_open_paren = true
+
       with_buffer {
         @src << " << " << @escapefunc << "((" << code << trailing_newline(code)
       }
     end
 
     def add_expression_block_end(code, escaped: false)
-      terminate_expression
+      if @_expression_block_open_paren
+        terminate_expression
 
-      trailing_newline = code.end_with?("\n")
-      code_stripped = code.chomp
+        trailing_newline = code.end_with?("\n")
+        code_stripped = code.chomp
 
-      @src.chomp! if @src.end_with?("\n") && code_stripped.start_with?(" ")
+        @src.chomp! if @src.end_with?("\n") && code_stripped.start_with?(" ")
 
-      @src << " " << code_stripped
-      @src << "\n" if self.class.comment?(code_stripped)
-      @src << (escaped ? "))" : ")")
-      @src << (trailing_newline ? "\n" : ";")
+        @src << " " << code_stripped
+        @src << "\n" if self.class.comment?(code_stripped)
+        @src << (escaped ? "))" : ")")
+        @src << (trailing_newline ? "\n" : ";")
 
-      @buffer_on_stack = false
+        @buffer_on_stack = false
+      else
+        add_code(code)
+      end
     end
 
     def trailing_newline(code)
@@ -440,5 +468,27 @@ module Herb
     def default_visitors
       []
     end
+
+    def ensure_valid_ruby!(source)
+      RubyVM::InstructionSequence.compile(source)
+    rescue SyntaxError => e
+      return if e.message.include?("Invalid yield")
+
+      begin
+        require "prism"
+      rescue LoadError
+        # Prism not available, fall through
+      end
+
+      raise InvalidRubyError.new("Compiled template produced invalid Ruby:\n  - #{e.message}", compiled_source: @src) unless defined?(Prism)
+
+      prism_result = Prism.parse(@src)
+      syntax_errors = prism_result.errors.reject { |error| error.type == :invalid_yield }
+
+      if syntax_errors.any?
+        details = syntax_errors.map { |err| "  - #{err.message} (line #{err.location.start_line})" }.join("\n")
+        raise InvalidRubyError.new("Compiled template produced invalid Ruby:\n#{details}", compiled_source: @src)
+      end
+    end
   end
 end

data/lib/herb/errors.rb

@@ -1013,5 +1013,250 @@ module Herb
       end
     end
 
+    class RenderAmbiguousLocalsError < Error
+      include Colors
+
+      #|  partial: String?,
+      #| }
+
+      attr_reader :partial #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, partial)
+        super(type, location, message)
+        @partial = partial
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_ambiguous_locals_error
+      def to_hash
+        super.merge(
+          partial: partial
+        ) #: Herb::serialized_render_ambiguous_locals_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── partial: #{green(partial.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderMissingLocalsError < Error
+      include Colors
+
+      #|  partial: String?,
+      #|  keywords: String?,
+      #| }
+
+      attr_reader :partial #: String?
+      attr_reader :keywords #: String?
+
+      #: (String, Location?, String, String, String) -> void
+      def initialize(type, location, message, partial, keywords)
+        super(type, location, message)
+        @partial = partial
+        @keywords = keywords
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_missing_locals_error
+      def to_hash
+        super.merge(
+          partial: partial,
+          keywords: keywords
+        ) #: Herb::serialized_render_missing_locals_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── partial: #{green(partial.inspect)}\n")
+        output += white("└── keywords: #{green(keywords.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderNoArgumentsError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderConflictingPartialError < Error
+      include Colors
+
+      #|  positional_partial: String?,
+      #|  keyword_partial: String?,
+      #| }
+
+      attr_reader :positional_partial #: String?
+      attr_reader :keyword_partial #: String?
+
+      #: (String, Location?, String, String, String) -> void
+      def initialize(type, location, message, positional_partial, keyword_partial)
+        super(type, location, message)
+        @positional_partial = positional_partial
+        @keyword_partial = keyword_partial
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_conflicting_partial_error
+      def to_hash
+        super.merge(
+          positional_partial: positional_partial,
+          keyword_partial: keyword_partial
+        ) #: Herb::serialized_render_conflicting_partial_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("├── positional_partial: #{green(positional_partial.inspect)}\n")
+        output += white("└── keyword_partial: #{green(keyword_partial.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderInvalidAsOptionError < Error
+      include Colors
+
+      #|  as_value: String?,
+      #| }
+
+      attr_reader :as_value #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, as_value)
+        super(type, location, message)
+        @as_value = as_value
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_invalid_as_option_error
+      def to_hash
+        super.merge(
+          as_value: as_value
+        ) #: Herb::serialized_render_invalid_as_option_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── as_value: #{green(as_value.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderObjectAndCollectionError < Error
+      include Colors
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("└── message: #{green(message.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
+    class RenderLayoutWithoutBlockError < Error
+      include Colors
+
+      #|  layout: String?,
+      #| }
+
+      attr_reader :layout #: String?
+
+      #: (String, Location?, String, String) -> void
+      def initialize(type, location, message, layout)
+        super(type, location, message)
+        @layout = layout
+      end
+
+      #: () -> String
+      def inspect
+        tree_inspect.rstrip.gsub(/\s+$/, "")
+      end
+
+      #: () -> serialized_render_layout_without_block_error
+      def to_hash
+        super.merge(
+          layout: layout
+        ) #: Herb::serialized_render_layout_without_block_error
+      end
+
+      #: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect(indent: 0, depth: 0, depth_limit: 25)
+        output = +""
+
+        output += white("@ #{bold(red(error_name))} #{dimmed("(location: #{location&.tree_inspect})\n")}")
+        output += white("├── message: #{green(message.inspect)}\n")
+        output += white("└── layout: #{green(layout.inspect)}\n")
+        output += %(\n)
+
+        output.gsub(/^/, "    " * indent)
+      end
+    end
+
   end
 end

data/lib/herb/parser_options.rb

@@ -6,6 +6,7 @@ module Herb
     attr_reader :track_whitespace #: bool
     attr_reader :analyze #: bool
     attr_reader :action_view_helpers #: bool
+    attr_reader :render_nodes #: bool
     attr_reader :prism_program #: bool
     attr_reader :prism_nodes #: bool
     attr_reader :prism_nodes_deep #: bool
@@ -14,16 +15,18 @@ module Herb
     DEFAULT_TRACK_WHITESPACE = false #: bool
     DEFAULT_ANALYZE = true #: bool
     DEFAULT_ACTION_VIEW_HELPERS = false #: bool
+    DEFAULT_RENDER_NODES = false #: bool
     DEFAULT_PRISM_PROGRAM = false #: bool
     DEFAULT_PRISM_NODES = false #: bool
     DEFAULT_PRISM_NODES_DEEP = false #: bool
 
     #: (?strict: bool, ?track_whitespace: bool, ?analyze: bool, ?action_view_helpers: bool, ?prism_nodes: bool, ?prism_nodes_deep: bool, ?prism_program: bool) -> void
-    def initialize(strict: DEFAULT_STRICT, track_whitespace: DEFAULT_TRACK_WHITESPACE, analyze: DEFAULT_ANALYZE, action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM)
+    def initialize(strict: DEFAULT_STRICT, track_whitespace: DEFAULT_TRACK_WHITESPACE, analyze: DEFAULT_ANALYZE, action_view_helpers: DEFAULT_ACTION_VIEW_HELPERS, render_nodes: DEFAULT_RENDER_NODES, prism_nodes: DEFAULT_PRISM_NODES, prism_nodes_deep: DEFAULT_PRISM_NODES_DEEP, prism_program: DEFAULT_PRISM_PROGRAM)
       @strict = strict
       @track_whitespace = track_whitespace
       @analyze = analyze
       @action_view_helpers = action_view_helpers
+      @render_nodes = render_nodes
       @prism_nodes = prism_nodes
       @prism_nodes_deep = prism_nodes_deep
       @prism_program = prism_program
@@ -36,6 +39,7 @@ module Herb
         track_whitespace: @track_whitespace,
         analyze: @analyze,
         action_view_helpers: @action_view_helpers,
+        render_nodes: @render_nodes,
         prism_nodes: @prism_nodes,
         prism_nodes_deep: @prism_nodes_deep,
         prism_program: @prism_program,
@@ -49,6 +53,7 @@ module Herb
         "track_whitespace=#{@track_whitespace}\n  " \
         "analyze=#{@analyze}\n  " \
         "action_view_helpers=#{@action_view_helpers}\n  " \
+        "render_nodes=#{@render_nodes}\n  " \
         "prism_nodes=#{@prism_nodes}\n  " \
         "prism_nodes_deep=#{@prism_nodes_deep}\n  " \
         "prism_program=#{@prism_program}>"

data/lib/herb/prism_inspect.rb

@@ -9,7 +9,11 @@ module Herb
       def inspect_prism_serialized(serialized_bytes, source, prefix)
         return "∅" unless serialized_bytes
 
-        require "prism"
+        begin
+          require "prism"
+        rescue LoadError
+          return "(#{serialized_bytes.bytesize} bytes, prism gem not available)"
+        end
 
         node = Prism.load(source, serialized_bytes).value
         return "∅" unless node

data/lib/herb/version.rb

@@ -2,5 +2,5 @@
 # typed: true
 
 module Herb
-  VERSION = "0.9.0"
+  VERSION = "0.9.2"
 end

data/lib/herb/visitor.rb

@@ -203,6 +203,16 @@ module Herb
       visit_child_nodes(node)
     end
 
+    #: (Herb::AST::RubyRenderLocalNode) -> void
+    def visit_ruby_render_local_node(node)
+      visit_child_nodes(node)
+    end
+
+    #: (Herb::AST::ERBRenderNode) -> void
+    def visit_erb_render_node(node)
+      visit_child_nodes(node)
+    end
+
     #: (Herb::AST::ERBYieldNode) -> void
     def visit_erb_yield_node(node)
       visit_child_nodes(node)

data/sig/herb/ast/nodes.rbs

@@ -1472,6 +1472,138 @@ module Herb
       def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
     end
 
+    # : type serialized_ruby_render_local_node = {
+    # |  name: Herb::Token?,
+    # |  value: Herb::AST::RubyLiteralNode?,
+    # | }
+    class RubyRenderLocalNode < Node
+      include Colors
+
+      attr_reader name: Herb::Token?
+
+      attr_reader value: Herb::AST::RubyLiteralNode?
+
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::AST::RubyLiteralNode) -> void
+
+      # : () -> serialized_ruby_render_local_node
+      def to_hash: () -> serialized_ruby_render_local_node
+
+      # : (Visitor) -> void
+      def accept: (Visitor) -> void
+
+      # : () -> Array[Herb::AST::Node?]
+      def child_nodes: () -> Array[Herb::AST::Node?]
+
+      # : () -> Array[Herb::AST::Node]
+      def compact_child_nodes: () -> Array[Herb::AST::Node]
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
+    # : type serialized_erb_render_node = {
+    # |  tag_opening: Herb::Token?,
+    # |  content: Herb::Token?,
+    # |  tag_closing: Herb::Token?,
+    # |  analyzed_ruby: nil,
+    # |  prism_node: String?,
+    # |  partial: Herb::Token?,
+    # |  template_path: Herb::Token?,
+    # |  layout: Herb::Token?,
+    # |  file: Herb::Token?,
+    # |  inline_template: Herb::Token?,
+    # |  body: Herb::Token?,
+    # |  plain: Herb::Token?,
+    # |  html: Herb::Token?,
+    # |  renderable: Herb::Token?,
+    # |  collection: Herb::Token?,
+    # |  object: Herb::Token?,
+    # |  as_name: Herb::Token?,
+    # |  spacer_template: Herb::Token?,
+    # |  formats: Herb::Token?,
+    # |  variants: Herb::Token?,
+    # |  handlers: Herb::Token?,
+    # |  content_type: Herb::Token?,
+    # |  locals: Array[Herb::AST::RubyRenderLocalNode]?,
+    # | }
+    class ERBRenderNode < Node
+      include Colors
+
+      attr_reader tag_opening: Herb::Token?
+
+      attr_reader content: Herb::Token?
+
+      attr_reader tag_closing: Herb::Token?
+
+      attr_reader analyzed_ruby: nil
+
+      attr_reader prism_node: String?
+
+      attr_reader partial: Herb::Token?
+
+      attr_reader template_path: Herb::Token?
+
+      attr_reader layout: Herb::Token?
+
+      attr_reader file: Herb::Token?
+
+      attr_reader inline_template: Herb::Token?
+
+      attr_reader body: Herb::Token?
+
+      attr_reader plain: Herb::Token?
+
+      attr_reader html: Herb::Token?
+
+      attr_reader renderable: Herb::Token?
+
+      attr_reader collection: Herb::Token?
+
+      attr_reader object: Herb::Token?
+
+      attr_reader as_name: Herb::Token?
+
+      attr_reader spacer_template: Herb::Token?
+
+      attr_reader formats: Herb::Token?
+
+      attr_reader variants: Herb::Token?
+
+      attr_reader handlers: Herb::Token?
+
+      attr_reader content_type: Herb::Token?
+
+      attr_reader locals: Array[Herb::AST::RubyRenderLocalNode]?
+
+      # : (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
+      def initialize: (String, Location, Array[Herb::Errors::Error], Herb::Token, Herb::Token, Herb::Token, nil, String, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Herb::Token, Array[Herb::AST::RubyRenderLocalNode]) -> void
+
+      # : () -> Prism::node?
+      def deserialized_prism_node: () -> Prism::node?
+
+      # : () -> serialized_erb_render_node
+      def to_hash: () -> serialized_erb_render_node
+
+      # : (Visitor) -> void
+      def accept: (Visitor) -> void
+
+      # : () -> Array[Herb::AST::Node?]
+      def child_nodes: () -> Array[Herb::AST::Node?]
+
+      # : () -> Array[Herb::AST::Node]
+      def compact_child_nodes: () -> Array[Herb::AST::Node]
+
+      # : () -> String
+      def inspect: () -> String
+
+      # : (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+      def tree_inspect: (?indent: Integer, ?depth: Integer, ?depth_limit: Integer) -> String
+    end
+
     # : type serialized_erb_yield_node = {
     # |  tag_opening: Herb::Token?,
     # |  content: Herb::Token?,

data/sig/herb/engine/compiler.rbs

@@ -89,8 +89,6 @@ module Herb
 
       def pop_context: () -> untyped
 
-      def add_context_aware_expression: (untyped code, untyped context) -> untyped
-
       def process_erb_tag: (untyped node, ?skip_comment_check: untyped) -> untyped
 
       def add_text: (untyped text) -> untyped
@@ -119,6 +117,10 @@ module Herb
 
       def process_erb_output: (untyped node, untyped opening, untyped code) -> untyped
 
+      def indicator_for: (untyped type) -> untyped
+
+      def context_aware_context?: (untyped context) -> untyped
+
       def should_escape_output?: (untyped opening) -> untyped
 
       def add_expression_with_escaping: (untyped code, untyped should_escape) -> untyped

data/sig/herb/engine.rbs

@@ -51,8 +51,14 @@ module Herb
 
     def add_code: (untyped code) -> untyped
 
+    def expression_block?: () -> untyped
+
     def add_expression: (untyped indicator, untyped code) -> untyped
 
+    def add_context_aware_expression: (untyped indicator, untyped code, untyped context) -> untyped
+
+    def context_escape_function: (untyped context) -> untyped
+
     def add_expression_result: (untyped code) -> untyped
 
     def add_expression_result_escaped: (untyped code) -> untyped
@@ -89,5 +95,7 @@ module Herb
 
     # : () -> Array[Herb::Visitor]
     def default_visitors: () -> Array[Herb::Visitor]
+
+    def ensure_valid_ruby!: (untyped source) -> untyped
   end
 end