Research for compiling to method

Author: noteflakes

TODO.md

@@ -1,13 +1,68 @@
 ## Immediate
 
-- [ ] - Fix bad compiled source generation ternary op:
+## Switch code generation to generating a method
 
-  ```ruby
-  -> (p) {
-    p ? a('<', href: p, class: 'prev') : span(class: 'prev')
+Benchmarks show a significant performance increase when instead of creating a
+compiled lambda, we create a method that is invoked directly. Take the following
+example:
+
+```ruby
+t = ->(foo, bar) {
+  div {
+    h1 foo
+    h2 bar
   }
-  ```
+}
+```
+
+The compiled form currently is:
+
+```ruby
+->(__buffer__, foo, bar) {
+  __buffer__
+    .<<("<div><h1>")
+    .<<(ERB::Escape.html_escape((foo)))
+    .<<("</h1><h2>")
+    .<<(ERB::Escape.html_escape((bar)))
+    .<<("</h2></div>")
+  __buffer__
+}
+```
+
+Instead, we can define a method on the template itself:
 
+```ruby
+def t.__papercraft_render_html(__buffer__, foo, bar)
+  __buffer__
+    .<<("<div><h1>")
+    .<<(ERB::Escape.html_escape((foo)))
+    .<<("</h1><h2>")
+    .<<(ERB::Escape.html_escape((bar)))
+    .<<("</h2></div>")
+  __buffer__
+end
+```
+
+And then, we change `Papercraft.html` to do:
+
+```ruby
+def Papercraft.html(template, *, **, &)
+  template.__papercraft_render_html(+'', *, **, &)
+rescue => e
+  translate_backtrace(e)
+end
+```
+
+The default impl for `__papercraft_render_html` can be:
+
+```ruby
+class ::Proc
+  def __papercraft_render_html(*, **, &)
+    Papercraft.compile_render_html_method(self)
+    __papercraft_render_html(*, **, &)
+  end
+end
+```
 
 ## Support for inlining
 

examples/perf_instance_eval.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+pr = proc {}
+
+Benchmark.ips do |x|
+  x.report("call") { pr.call }
+  x.report("i_eval") { instance_eval(&pr) }
+
+  x.compare!(order: :baseline)
+end

examples/perf_optimized.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile do
+  gem 'papercraft', path: '.'
+  gem 'benchmark'
+  gem 'benchmark-ips', '>= 2.14.0'
+end
+
+require 'papercraft/proc'
+require 'erb'
+require 'benchmark/ips'
+
+TemplatePapercraft = ->(foo, bar) {
+  div {
+    h1 foo
+    h2 bar
+  }
+}
+
+TemplateERB = <<~ERB
+  <div>
+    <h1><%= ERB::Escape.html_escape(foo) %></h1>
+    <p><%= ERB::Escape.html_escape(bar) %></p>
+  </div>
+ERB
+
+def render_papercraft(foo, bar)
+  TemplatePapercraft.__papercraft_compiled_proc.(+'', foo, bar)
+end
+
+def render_papercraft_optimized(foo, bar)
+  TemplatePapercraft.__optimized_html(+'', foo, bar)
+rescue => e
+  p e
+end
+
+puts
+TemplatePapercraft.singleton_class.class_eval <<~RUBY.tap { puts it }
+  # frozen_string_literal: true
+  def __optimized_html(__buffer__, foo, bar)
+    __buffer__.<<("<div><h1>").<<(
+    ERB::Escape.html_escape((foo))).<<("</h1><h2>").<<(
+    ERB::Escape.html_escape((bar))).<<("</h2></div>")
+    __buffer__
+  end
+RUBY
+puts
+
+puts
+singleton_class.class_eval <<~RUBY.tap { puts it }
+  # frozen_string_literal: true
+  def render_optimized(foo, bar)
+    __buffer__ = +''
+    __buffer__.<<("<div><h1>").<<(
+    ERB::Escape.html_escape((foo))).<<("</h1><h2>").<<(
+    ERB::Escape.html_escape((bar))).<<("</h2></div>")
+    __buffer__
+  end
+RUBY
+puts
+
+puts
+singleton_class.class_eval <<~RUBY.tap { puts it }
+  # frozen_string_literal: true
+  def render_erb(foo, bar)
+    #{ERB.new(TemplateERB).src}
+  rescue => e
+    raise e
+  end
+RUBY
+puts
+
+def render_erb_indirect(foo, bar)
+  render_erb(foo, bar)
+end
+
+puts
+puts TemplatePapercraft.compiled_code
+puts
+
+puts render_erb('FOO', 'BAR')
+puts render_papercraft('FOO', 'BAR')
+puts render_optimized('FOO', 'BAR')
+puts render_papercraft_optimized('FOO', 'BAR')
+puts 
+
+# puts '* ERB:'
+# puts r.render_erb_app.gsub(/\n\s+/, '')
+
+# puts '* ERUBI (raw):'
+# puts r.render_erubi_app.gsub(/\n\s+/, '')
+
+res = Benchmark.ips do |x|
+  # x.config(:time => 5, :warmup => 2)
+
+  x.report("erb") { render_erb('FOO', 'BAR') }
+  x.report("erb_indirect") { render_erb_indirect('FOO', 'BAR') }
+  x.report("papercraft") { render_papercraft('FOO', 'BAR') }
+  x.report("papercraft_optimized") { render_papercraft_optimized('FOO', 'BAR') }
+  x.report("optimized") { render_optimized('FOO', 'BAR') }
+
+  x.compare!(order: :baseline)
+end
+
+
+p res

examples/perf_raw.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'benchmark/ips'
+
+TEMPLATE_ERB = <<~HTML
+  <div>
+    <h1><%= 'foo' %></h1>
+    <p><%= 'bar' %></p>
+  </div>
+HTML
+
+TEMPLATE_DSL = proc {
+  div {
+    h1 'foo'
+    p 'bar'
+  }
+}
+
+class Renderer
+  def render_dsl(template)
+    @buffer = +''
+    instance_eval(&template)
+    @buffer
+  end
+
+  def div(&block)
+    @buffer << '<div>'
+    instance_eval(&block)
+    @buffer << '</div>'
+  end
+
+  def h1(text)
+    @buffer << "<h1>#{text}</h1>"
+  end
+
+  def p(text)
+    @buffer << "<p>#{text}</p>"
+  end
+
+  class_eval(c = <<~RUBY)
+    # frozen_string_literal: true
+    def render_erb
+      #{ERB.new(TEMPLATE_ERB).src}
+    end
+  RUBY
+end
+
+r = Renderer.new
+
+puts '* ERB:'
+puts r.render_erb
+puts
+
+puts '* DSL:'
+puts r.render_dsl(TEMPLATE_DSL)
+puts
+
+puts
+puts ERB.new(TEMPLATE_ERB).src
+puts
+
+Benchmark.ips do |x|
+  # x.config(:time => 5, :warmup => 2)
+
+  x.report("ERB") { r.render_erb }
+  x.report("DSL") { r.render_dsl(TEMPLATE_DSL) }
+
+  x.compare!(order: :baseline)
+end