rubyoshka 0.6.1 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae561e0250334107b9b82a72fc72ab672622a7f037044e8e18154e79b71a54b5
-  data.tar.gz: e5cddea7df6231799b38339bc014373a6c9d6a96bb60d3c7b7107e48321b3c6d
+  metadata.gz: 82ae63e4b9ff27ff20f8635c7e619b4a1dd88c1a6b2e1e7c4a7dbdad64381b40
+  data.tar.gz: ff00cf661c6394e2cd00443cbc7204dff6bbff434d9602cb244a274b257f1059
 SHA512:
-  metadata.gz: 675b83551aa791f6bb1539c80c40d267e3caa1aceed3748af04ca1d2a49bcac3ad237a8d8c0f0dd69d24714eadbb47bf4a929af77c3ef2c71155e806ff611c66
-  data.tar.gz: 7dd19daa9df716417c894130ff8fdae0505f83a63de17709634b2c7c83384f56453c13adbee109e4961f44a64f1c46e151752d1fc5bf690ad6738402b023f9bf
+  metadata.gz: 8a2aff7151025e7a83466da15c21878868bc1160bb6bab37396a38ce6ecad08a49c807c8177bc153f22785ff6e6cdfe2eadb82950d4b06cc4d492d5654aa37b0
+  data.tar.gz: f11bfa4d801a259d0825f91267217009be156feba3fc567ea68de4941779fa40c07755a63a2f9812507c2858d7fb54d0d78f5601546003165fe27b912caf6f1e

data/CHANGELOG.md

@@ -1,41 +1,39 @@
-0.6.1 2021-03-03
-----------------
+## 0.7 2021-09-29
 
-* Remove support for Ruby 2.6
+- Add `#emit_yield` for rendering layouts
+- Add experimental template compilation (WIP)
 
-0.6 2021-03-03
---------------
+## 0.6.1 2021-03-03
 
-* Fix Rubyoshka on Ruby 3.0
-* Refactor and add more tests
+- Remove support for Ruby 2.6
 
-0.5 2021-02-27
---------------
+## 0.6 2021-03-03
 
-* Add support for rendering XML
-* Add Rubyoshka.component method
-* Remove Modulation dependency
+- Fix Rubyoshka on Ruby 3.0
+- Refactor and add more tests
 
-0.4 2019-02-05
---------------
+## 0.5 2021-02-27
 
-* Add support for emitting component modules
+- Add support for rendering XML
+- Add Rubyoshka.component method
+- Remove Modulation dependency
 
-0.3 2019-01-13
---------------
+## 0.4 2019-02-05
 
-* Implement caching
-* Improve performance
-* Handle attributes with `false` value correctly
+- Add support for emitting component modules
 
-0.2 2019-01-07
---------------
+## 0.3 2019-01-13
 
-* Better documentation
-* Fix #text
-* Add local context
+- Implement caching
+- Improve performance
+- Handle attributes with `false` value correctly
 
-0.1 2019-01-06
---------------
+## 0.2 2019-01-07
 
-* First working version
+- Better documentation
+- Fix #text
+- Add local context
+
+## 0.1 2019-01-06
+
+- First working version

data/README.md

@@ -284,6 +284,43 @@ H {
 }
 ```
 
+## Layout templates
+
+Rubyoshka templates can also be used to implement layout templates by using
+`#emit_yield`:
+
+```ruby
+layout = H {
+  html5 {
+    head { ... }
+    body {
+      header { ... }
+      body {
+        emit_yield
+      }
+      footer { ... }
+    }
+  }
+}
+```
+
+To use the layout, supply a block when calling `#render`:
+
+```ruby
+layout.render {
+  h1 'foo'
+  p 'bar'
+}
+
+# you can also pass a template as the block
+inner = H {
+  h1 'foo'
+  p 'bar'
+}
+
+layout.render(&inner)
+```
+
 ## Fragment caching
 
 Any part of a Rubyoshka template can be cached - a fragment, a component, or a

data/lib/rubyoshka/compiler.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+class Rubyoshka
+  # The Compiler class compiles Rubyoshka templates
+  class Compiler
+    DEFAULT_CODE_BUFFER_CAPACITY = 8192
+    DEFAULT_EMIT_BUFFER_CAPACITY = 4096
+
+    def initialize
+      @level = 1
+      @code_buffer = String.new(capacity: DEFAULT_CODE_BUFFER_CAPACITY)
+    end
+
+    def emit_output
+      @output_mode = true
+      yield
+      @output_mode = false
+    end
+
+    def emit_code_line_break
+      return if @code_buffer.empty?
+
+      @code_buffer << "\n" if @code_buffer[-1] != "\n"
+      @line_break = nil
+    end
+
+    def emit_literal(lit)
+      if @output_mode
+        emit_code_line_break if @line_break
+        @emit_buffer ||= String.new(capacity: DEFAULT_EMIT_BUFFER_CAPACITY)
+        @emit_buffer << lit
+      else
+        emit_code(lit)
+      end
+    end
+
+    def emit_text(str, encoding: :html)
+      emit_code_line_break if @line_break
+      @emit_buffer ||= String.new(capacity: DEFAULT_EMIT_BUFFER_CAPACITY)
+      @emit_buffer << encode(str, encoding).inspect[1..-2]
+    end
+
+    def encode(str, encoding)
+      case encoding
+      when :html
+        __html_encode__(str)
+      when :uri
+        __uri_encode__(str)
+      else
+        raise "Invalid encoding #{encoding.inspect}"
+      end
+    end
+
+    def emit_expression
+      if @output_mode
+        emit_literal('#{__html_encode__(')
+        yield
+        emit_literal(')}')
+      else
+        yield
+      end
+    end
+
+    def flush_emit_buffer
+      return if !@emit_buffer
+
+      @code_buffer << "#{'  ' * @level}__buffer__ << \"#{@emit_buffer}\"\n"
+      @emit_buffer = nil
+      true
+    end
+
+    def emit_code(code)
+      if flush_emit_buffer || @line_break
+        emit_code_line_break if @line_break
+        @code_buffer << "#{'  ' * @level}#{code}"
+      else
+        if @code_buffer.empty? || (@code_buffer[-1] == "\n")
+          @code_buffer << "#{'  ' * @level}#{code}"
+        else
+          @code_buffer << "#{code}"
+        end
+      end
+    end
+
+    def compile(template)
+      @block = template.to_proc
+      ast = RubyVM::AbstractSyntaxTree.of(@block)
+      # Compiler.pp_ast(ast)
+      parse(ast)
+      flush_emit_buffer
+      self
+    end
+
+    attr_reader :code_buffer
+
+    def to_code
+      "->(__buffer__, __context__) do\n#{@code_buffer}end"
+    end
+
+    def to_proc
+      @block.binding.eval(to_code)
+    end
+
+    def parse(node)
+      @line_break = @last_node && node.first_lineno != @last_node.first_lineno
+      @last_node = node
+      # puts "- parse(#{node.type}) (break: #{@line_break.inspect})"
+      send(:"parse_#{node.type.downcase}", node)
+    end
+
+    def parse_scope(node)
+      parse(node.children[2])
+    end
+
+    def parse_iter(node)
+      call, scope = node.children
+      if call.type == :FCALL
+        parse_fcall(call, scope)
+      else
+        parse(call)
+        emit_code(" do")
+        args = scope.children[0]
+        emit_code(" |#{args.join(', ')}|") if args
+        emit_code("\n")
+        @level += 1
+        parse(scope)
+        flush_emit_buffer
+        @level -= 1
+        emit_code("end\n")
+      end
+    end
+
+    def parse_ivar(node)
+      ivar = node.children.first.match(/^@(.+)*/)[1]
+      emit_literal("__context__[:#{ivar}]")
+    end
+
+    def parse_fcall(node, block = nil)
+      tag, args = node.children
+      args = args.children.compact if args
+      text = fcall_inner_text_from_args(args)
+      atts = fcall_attributes_from_args(args)
+      if block
+        emit_tag(tag, atts) { parse(block) }
+      elsif text
+        emit_tag(tag, atts) do
+          emit_output do
+            if text.is_a?(String)
+              emit_text(text)
+            else
+              emit_expression { parse(text) }
+            end
+          end
+        end
+      else
+        emit_tag(tag, atts)
+      end
+    end
+
+    def fcall_inner_text_from_args(args)
+      return nil if !args
+
+      first = args.first
+      case first.type
+      when :STR
+        first.children.first
+      when :LIT
+        first.children.first.to_s
+      when :HASH
+        nil
+      else
+        first
+      end
+    end
+
+    def fcall_attributes_from_args(args)
+      return nil if !args
+
+      last = args.last
+      (last.type == :HASH) ? last : nil
+    end
+
+    def emit_tag(tag, atts, &block)
+      emit_output do
+        if atts
+          emit_literal("<#{tag}")
+          emit_tag_attributes(atts)
+          emit_literal(block ? '>' : '/>')
+        else
+          emit_literal(block ? "<#{tag}>" : "<#{tag}/>")
+        end
+      end
+      if block
+        block.call
+        emit_output { emit_literal("</#{tag}>") }
+      end
+    end
+
+    def emit_tag_attributes(atts)
+      list = atts.children.first.children
+      while true
+        key = list.shift
+        break unless key
+
+        value = list.shift
+        value_type = value.type
+        case value_type
+        when :FALSE, :NIL
+          next
+        end
+
+        emit_literal(' ')
+        emit_tag_attribute_key(key)
+        next if value_type == :TRUE
+        
+        emit_literal('=\"')
+        emit_tag_attribute_value(value, key)
+        emit_literal('\"')
+      end
+    end
+
+    def emit_tag_attribute_key(key)
+      case key.type
+      when :STR
+        emit_literal(key.children.first)
+      when :LIT
+        emit_literal(key.children.first.to_s)
+      when :NIL
+        emit_literal('nil')
+      else
+        emit_expression { parse(key) }
+      end
+    end
+
+    def emit_tag_attribute_value(value, key)
+      case value.type
+      when :STR
+        encoding = (key.type == :LIT) && (key.children.first == :href) ? :uri : :html
+        emit_text(value.children.first, encoding: encoding)
+      when :LIT
+        emit_text(value.children.first.to_s)
+      else
+        parse(value)
+      end
+    end
+
+    def parse_call(node)
+      receiver, method, args = node.children
+      if receiver.type == :VCALL && receiver.children == [:context]
+        emit_literal('__context__')
+      else
+        parse(receiver)
+      end
+      if method == :[]
+        emit_literal('[')
+        args = args.children.compact
+        while true
+          arg = args.shift
+          break unless arg
+
+          parse(arg)
+          emit_literal(', ') if !args.empty?
+        end
+        emit_literal(']')
+      else
+        emit_literal('.')
+        emit_literal(method.to_s)
+        if args
+          emit_literal('(')
+          args = args.children.compact
+          while true
+            arg = args.shift
+            break unless arg
+
+            parse(arg)
+            emit_literal(', ') if !args.empty?
+          end
+          emit_literal(')')
+        end
+      end
+    end
+
+    def parse_str(node)
+      str = node.children.first
+      emit_literal(str.inspect)
+    end
+
+    def parse_lit(node)
+      value = node.children.first
+      emit_literal(value.inspect)
+    end
+
+    def parse_true(node)
+      emit_expression { emit_literal('true') }
+    end
+
+    def parse_false(node)
+      emit_expression { emit_literal('true') }
+    end
+
+    def parse_list(node)
+      emit_literal('[')
+      items = node.children.compact
+      while true
+        item = items.shift
+        break unless item
+
+        parse(item)
+        emit_literal(', ') if !items.empty?
+      end
+      emit_literal(']')
+    end
+
+    def parse_vcall(node)
+      tag = node.children.first
+      emit_tag(tag, nil)
+    end
+
+    def parse_opcall(node)
+      left, op, right = node.children
+      parse(left)
+      emit_literal(" #{op} ")
+      right.children.compact.each { |c| parse(c) }
+    end
+
+    def parse_block(node)
+      node.children.each { |c| parse(c) }
+    end
+
+    def parse_if(node)
+      cond, then_branch, else_branch = node.children
+      if @output_mode
+        emit_if_output(cond, then_branch, else_branch)
+      else
+        emit_if_code(cond, then_branch, else_branch)
+      end
+    end
+
+    def parse_unless(node)
+      cond, then_branch, else_branch = node.children
+      if @output_mode
+        emit_unless_output(cond, then_branch, else_branch)
+      else
+        emit_unless_code(cond, then_branch, else_branch)
+      end
+    end
+
+    def emit_if_output(cond, then_branch, else_branch)
+      parse(cond)
+      emit_literal(" ? ")
+      parse(then_branch)
+      emit_literal(" : ")
+      if else_branch
+        parse(else_branch)
+      else
+        emit_literal(nil)
+      end
+    end
+
+    def emit_unless_output(cond, then_branch, else_branch)
+      parse(cond)
+      emit_literal(" ? ")
+      if else_branch
+        parse(else_branch)
+      else
+        emit_literal(nil)
+      end
+      emit_literal(" : ")
+      parse(then_branch)
+    end
+
+    def emit_if_code(cond, then_branch, else_branch)
+      emit_code('if ')
+      parse(cond)
+      emit_code("\n")
+      @level += 1
+      parse(then_branch)
+      flush_emit_buffer
+      @level -= 1
+      if else_branch
+        emit_code("else\n")
+        @level += 1
+        parse(else_branch)
+        flush_emit_buffer
+        @level -= 1
+      end
+      emit_code("end\n")
+    end
+
+    def emit_unless_code(cond, then_branch, else_branch)
+      emit_code('unless ')
+      parse(cond)
+      emit_code("\n")
+      @level += 1
+      parse(then_branch)
+      flush_emit_buffer
+      @level -= 1
+      if else_branch
+        emit_code("else\n")
+        @level += 1
+        parse(else_branch)
+        flush_emit_buffer
+        @level -= 1
+      end
+      emit_code("end\n")
+    end
+
+    def parse_dvar(node)
+      
+      emit_literal(node.children.first.to_s)
+    end
+
+    def self.pp_ast(node, level = 0)
+      case node
+      when RubyVM::AbstractSyntaxTree::Node
+        puts "#{'  ' * level}#{node.type.inspect}"
+        node.children.each { |c| pp_ast(c, level + 1) }
+      when Array
+        puts "#{'  ' * level}["
+        node.each { |c| pp_ast(c, level + 1) }
+        puts "#{'  ' * level}]"
+      else
+        puts "#{'  ' * level}#{node.inspect}"
+        return
+      end
+    end
+  end
+end

data/lib/rubyoshka/renderer.rb

@@ -11,10 +11,10 @@ class Rubyoshka
     # @param context [Hash] rendering context
     # @param block [Proc] template block
     # @return [void]
-    def initialize(context, &block)
+    def initialize(context, template)
       @context = context
       @buffer = +''
-      instance_eval(&block)
+      instance_eval(&template)
     end
   
     # Returns the result of the rendering
@@ -74,7 +74,6 @@ class Rubyoshka
         case o
         when ::Proc
           self.class.define_method(sym) { |*a, **c, &b| emit(o.(*a, **c, &b)) }
-          STDOUT.puts({o: o, args: args, opts: opts, block: block}.inspect)
           emit(o.(*args, **opts, &block))
         when Rubyoshka
           self.class.define_method(sym) do |**ctx|
@@ -104,7 +103,7 @@ class Rubyoshka
       when ::Proc
         instance_eval(&o)
       when Rubyoshka
-        instance_eval(&o.block)
+        instance_eval(&o.template)
       when Module
         # If module is given, the component is expected to be a const inside the module
         emit(o::Component)
@@ -114,6 +113,13 @@ class Rubyoshka
       end
     end
     alias_method :e, :emit
+
+    def emit_yield
+      block = @context[:__block__]
+      raise LocalJumpError, "no block given (emit_yield)" unless block
+
+      instance_eval(&block)
+    end
   
     S_LT              = '<'
     S_GT              = '>'

data/lib/rubyoshka/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Rubyoshka
-  VERSION = '0.6.1'
+  VERSION = '0.7'
 end

data/lib/rubyoshka.rb

@@ -3,10 +3,21 @@
 require 'escape_utils'
 
 require_relative 'rubyoshka/renderer'
+require_relative 'rubyoshka/compiler'
 
 # A Rubyoshka is a template representing a piece of HTML
 class Rubyoshka
-  attr_reader :block
+  module Encoding
+    def __html_encode__(text)
+      EscapeUtils.escape_html(text.to_s)
+    end
+
+    def __uri_encode__(text)
+      EscapeUtils.escape_uri(text.to_s)
+    end
+  end  
+  
+  attr_reader :template
 
   # Initializes a Rubyoshka with the given block
   # @param ctx [Hash] local context
@@ -14,7 +25,7 @@ class Rubyoshka
   # @param [void]
   def initialize(mode: :html, **ctx, &block)
     @mode = mode
-    @block = ctx.empty? ? block : proc { with(**ctx, &block) }
+    @template = ctx.empty? ? block : proc { with(**ctx, &block) }
   end
 
   H_EMPTY = {}.freeze
@@ -22,8 +33,12 @@ class Rubyoshka
   # Renders the associated block and returns the string result
   # @param context [Hash] context
   # @return [String]
-  def render(context = H_EMPTY)
-    renderer_class.new(context, &block).to_s
+  def render(context = H_EMPTY, &block)
+    if block
+      context = context.dup if context.frozen?
+      context[:__block__] = block
+    end
+    renderer_class.new(context, @template).to_s
   end
 
   def renderer_class
@@ -37,6 +52,14 @@ class Rubyoshka
     end
   end
 
+  def compile
+    Rubyoshka::Compiler.new.compile(self)
+  end
+
+  def to_proc
+    @template
+  end
+
   @@cache = {}
 
   def self.cache
@@ -53,12 +76,18 @@ class Rubyoshka
 end
 ::H = Rubyoshka
 
+# Kernel extensions
 module ::Kernel
   # Convenience method for creating a new Rubyoshka
   # @param ctx [Hash] local context
-  # @param block [Proc] nested block
+  # @param template [Proc] template block
   # @return [Rubyoshka] Rubyoshka template
-  def H(**ctx, &block)
-    Rubyoshka.new(**ctx, &block)
+  def H(**ctx, &template)
+    Rubyoshka.new(**ctx, &template)
   end
-end
+end
+
+# Object extensions
+class Object
+  include Rubyoshka::Encoding
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubyoshka
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: '0.7'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-03 00:00:00.000000000 Z
+date: 2021-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: escape_utils
@@ -90,6 +90,7 @@ files:
 - CHANGELOG.md
 - README.md
 - lib/rubyoshka.rb
+- lib/rubyoshka/compiler.rb
 - lib/rubyoshka/html.rb
 - lib/rubyoshka/renderer.rb
 - lib/rubyoshka/version.rb