flavour_saver 0.3.3

data/lib/flavour_saver/parser.rb

@@ -0,0 +1,183 @@
+require 'rltk'
+require 'rltk/ast'
+require 'flavour_saver/nodes'
+
+module FlavourSaver
+  class Parser < RLTK::Parser
+
+    class UnbalancedBlockError < StandardError; end
+
+    class Environment < RLTK::Parser::Environment
+      def push_block block
+        blocks.push(block.name)
+        block
+      end
+
+      def pop_block block
+        b = blocks.pop
+        raise UnbalancedBlockError, "Unable to find matching opening for {{/#{block.name}}}" if b != block.name
+        block
+      end
+
+      def blocks
+        @blocks ||= []
+      end
+    end
+
+    left :DOT
+    right :EQ
+
+    production(:template) do
+      clause('template_items') { |i| TemplateNode.new(i) }
+      clause('') { TemplateNode.new([]) }
+    end
+
+    # empty_list(:template_items, [:output, :expression], 'WHITE?')
+    production(:template_items) do
+      clause('template_item') { |i| [i] }
+      clause('template_items template_item') { |i0,i1| i0 << i1 }
+    end
+
+    production(:template_item) do
+      clause('output') { |e| e }
+      clause('expression') { |e| e }
+    end
+
+    production(:output) do
+      clause('OUT') { |o| OutputNode.new(o) }
+    end
+
+    production(:expression) do
+      clause('block_expression') { |e| e }
+      clause('expr')          { |e| ExpressionNode.new(e) }
+      clause('expr_comment')  { |e| CommentNode.new(e) }
+      clause('expr_safe')     { |e| SafeExpressionNode.new(e) }
+      clause('partial')       { |e| e }
+    end
+
+    production(:partial) do
+      clause('EXPRST WHITE? GT WHITE? IDENT WHITE? EXPRE') { |_,_,_,_,e,_,_| PartialNode.new(e,[]) }
+      clause('EXPRST WHITE? GT WHITE? IDENT WHITE? call WHITE? EXPRE') { |_,_,_,_,e0,_,e1,_,_| PartialNode.new(e0,e1,nil) }
+      clause('EXPRST WHITE? GT WHITE? IDENT WHITE? lit WHITE? EXPRE') { |_,_,_,_,e0,_,e1,_,_| PartialNode.new(e0,[],e1) }
+      clause('EXPRST WHITE? GT WHITE? LITERAL WHITE? EXPRE') { |_,_,_,_,e,_,_| PartialNode.new(e,[]) }
+      clause('EXPRST WHITE? GT WHITE? LITERAL WHITE? call WHITE? EXPRE') { |_,_,_,_,e0,_,e1,_,_| PartialNode.new(e0,e1,nil) }
+      clause('EXPRST WHITE? GT WHITE? LITERAL WHITE? lit WHITE? EXPRE') { |_,_,_,_,e0,_,e1,_,_| PartialNode.new(e0,[],e1) }
+    end
+
+    production(:block_expression) do
+      clause('expr_bl_start template expr_else template expr_bl_end') { |e0,e1,_,e3,e2| BlockExpressionNodeWithElse.new([e0], e1,e2,e3) }
+      clause('expr_bl_start template expr_bl_end') { |e0,e1,e2| BlockExpressionNode.new([e0],e1,e2) }
+      clause('expr_bl_inv_start template expr_else template expr_bl_end') { |e0,e1,_,e3,e2| BlockExpressionNodeWithElse.new([e0], e2,e2,e1) }
+      clause('expr_bl_inv_start template expr_bl_end') { |e0,e1,e2| BlockExpressionNodeWithElse.new([e0],TemplateNode.new([]),e2,e1) }
+    end
+
+    production(:expr_else) do
+      clause('EXPRST WHITE? ELSE WHITE? EXPRE') { |_,_,_,_,_| }
+      clause('EXPRST WHITE? HAT WHITE? EXPRE') { |_,_,_,_,_| }
+    end
+
+    production(:expr) do
+      clause('EXPRST expression_contents EXPRE') { |_,e,_| e }
+    end
+
+    production(:expr_comment) do
+      clause('EXPRST BANG COMMENT EXPRE') { |_,_,e,_| e }
+    end
+
+    production(:expr_safe) do
+      clause('TEXPRST expression_contents TEXPRE') { |_,e,_| e }
+      clause('EXPRST AMP expression_contents EXPRE') { |_,_,e,_| e }
+    end
+
+    production(:expr_bl_start) do
+      clause('EXPRST HASH WHITE? IDENT WHITE? EXPRE') { |_,_,_,e,_,_| push_block CallNode.new(e,[]) }
+      clause('EXPRST HASH WHITE? IDENT WHITE arguments EXPRE') { |_,_,_,e,_,a,_| push_block CallNode.new(e,a) }
+    end
+
+    production(:expr_bl_inv_start) do
+      clause('EXPRST HAT WHITE? IDENT WHITE? EXPRE') { |_,_,_,e,_,_| push_block CallNode.new(e,[]) }
+      clause('EXPRST HAT WHITE? IDENT WHITE arguments EXPRE') { |_,_,_,e,_,a,_| push_block CallNode.new(e,a) }
+    end
+
+    production(:expr_bl_end) do
+      clause('EXPRST FWSL WHITE? IDENT WHITE? EXPRE') { |_,_,_,e,_,_| pop_block CallNode.new(e,[]) }
+    end
+
+    production(:expression_contents) do
+      clause('WHITE? call WHITE?') { |_,e,_| e }
+      clause('WHITE? local WHITE?') { |_,e,_| [e] }
+    end
+
+    production(:call) do
+      clause('object_path') { |e| e }
+      clause('object_path WHITE arguments') { |e0,_,e1| e0.last.arguments = e1; e0 }
+      clause('DOT') { |_| [CallNode.new('this', [])] }
+    end
+
+    production(:local) do
+      clause('AT IDENT') { |_,e| LocalVarNode.new(e) }
+    end
+
+    production('arguments') do
+      clause('argument_list') { |e| e }
+      clause('argument_list hash') { |e0,e1| e0 + [e1] }
+      clause('hash') { |e| [e] }
+    end
+
+    nonempty_list(:argument_list, [:object_path,:lit], :WHITE)
+
+    production(:lit) do
+      clause('string') { |e| e }
+      clause('number') { |e| e }
+      clause('boolean') { |e| e }
+    end
+
+    production(:string) do
+      clause('STRING') { |e| StringNode.new(e) }
+    end
+
+    production(:number) do
+      clause('NUMBER') { |n| NumberNode.new(n) }
+    end
+
+    production(:boolean) do
+      clause('BOOL') { |b| b ? TrueNode.new(true) : FalseNode.new(false) }
+    end
+
+    production(:hash) do
+      clause('hash_item') { |e| e }
+      clause('hash WHITE hash_item') { |e0,_,e1| e0.merge(e1) }
+    end
+
+    production(:hash_item) do
+      clause('IDENT EQ string') { |e0,_,e1| { e0.to_sym => e1 } }
+      clause('IDENT EQ object_path') { |e0,_,e1| { e0.to_sym => e1 } }
+    end
+
+    production(:object_sep) do
+      clause('DOT') { |_| }
+      clause('FWSL') { |_| }
+    end
+
+    nonempty_list(:object_path, :object, :object_sep)
+
+    production(:object) do
+      clause('IDENT') { |e| CallNode.new(e, []) }
+      clause('LITERAL') { |e| LiteralCallNode.new(e, []) }
+      clause('parent_call') { |e| e }
+    end
+
+    production(:parent_call) do
+      clause('backtrack IDENT') { |i,e| ParentCallNode.new(e,[],i) }
+      clause('backtrack LITERAL') { |i,e| ParentCallNode.new(e,[],i) }
+    end
+
+    production(:backtrack) do
+      clause('DOT DOT FWSL') { |_,_,_| 1 }
+      clause('backtrack DOT DOT FWSL') { |i,_,_,_| i += 1 }
+    end
+
+    finalize
+
+  end
+end

data/lib/flavour_saver/partial.rb

@@ -0,0 +1,29 @@
+module FlavourSaver
+  UnknownPartialException = Class.new(StandardError)
+
+  class Partial
+
+    def self.register_partial(name, content=nil, &block)
+      if block.respond_to? :call
+        partials[name.to_s] = block
+      else
+        partials[name.to_s] = Parser.parse(Lexer.lex(content))
+      end
+    end
+    
+    def self.reset_partials
+      @partials = {}
+    end
+
+    def self.partials
+      @partials ||= {}
+    end
+
+    def self.fetch(name)
+      p = partials[name.to_s]
+      raise UnknownPartialException, "I can't find the partial named #{name.inspect}" unless p
+      p
+    end
+
+  end
+end

data/lib/flavour_saver/rails_partial.rb

@@ -0,0 +1,10 @@
+module FlavourSaver
+  class RailsPartial 
+    def self.register_partial(*args)
+      raise RuntimeError, "No need to register partials inside Rails."
+    end
+    def self.reset_partials; end
+    def self.partials; end
+    def self.fetch; end
+  end
+end

data/lib/flavour_saver/runtime.rb

@@ -0,0 +1,269 @@
+require 'cgi'
+
+module FlavourSaver
+  UnknownNodeTypeException          = Class.new(StandardError)
+  UnknownContextException           = Class.new(StandardError)
+  InappropriateUseOfElseException   = Class.new(StandardError)
+  UndefinedPrivateVariableException = Class.new(StandardError)
+  UnknownHelperException            = Class.new(RuntimeError)
+  class Runtime
+
+    attr_accessor :context, :parent, :ast
+
+    def self.run(ast, context, locals={}, helpers=[])
+      self.new(ast, context, locals, helpers).to_s
+    end
+
+    def initialize(ast, context=nil, locals={}, helpers=[],parent=nil)
+      @ast = ast
+      @locals = locals
+      @helpers = helpers
+      @context = context
+      @parent = parent
+      @privates = {}
+    end
+
+    def to_s(tmp_context = nil,privates={})
+      result = nil
+      if tmp_context
+        old_context = @context
+        @context = tmp_context
+        old_privates = @privates
+        @privates = @privates.dup.merge(privates) if privates.any?
+        result = evaluate_node(@ast)
+        @privates = old_privates
+        @context = old_context
+      else
+        result = evaluate_node(@ast)
+      end
+      result
+    end
+
+    def private_variable_set(name,value)
+      @privates[name.to_s] = value
+    end
+
+    def private_variable_get(name)
+      begin
+        @privates.fetch(name)
+      rescue KeyError => e
+        raise UndefinedPrivateVariableException, "private variable not found @#{name}"
+      end
+    end
+
+    def strip(tmp_context = nil)
+      self.to_s(tmp_context).gsub(/[\s\r\n]+/,' ').strip
+    end
+
+    def evaluate_node(node)
+      case node
+      when TemplateNode
+        node.items.map { |n| evaluate_node(n) }.join('')
+      when BlockExpressionNode
+        evaluate_block(node).to_s
+      when OutputNode
+        node.value
+      when NumberNode
+        if node.value =~ /\./
+          node.value.to_f
+        else
+          node.value.to_i
+        end
+      when ValueNode
+        node.value
+      when SafeExpressionNode
+        evaluate_expression(node).to_s
+      when ExpressionNode
+        escape(evaluate_expression(node).to_s)
+      when CallNode
+        evaluate_call(node)
+      when Hash
+        node.each do |key,value|
+          node[key] = evaluate_argument(value)
+        end
+        node
+      when CommentNode
+        ''
+      when PartialNode
+        evaluate_partial(node)
+      else
+        raise UnknownNodeTypeException, "Don't know how to deal with a node of type #{node.class.to_s.inspect}."
+      end
+    end
+
+    def parent
+      raise UnknownContextException, "No parent context in which to evaluate the parentiness of the context" unless @parent
+      @parent
+    end
+
+    def parent?
+      !!@parent
+    end
+
+    def evaluate_partial(node)
+      _context = context
+      _context = evaluate_argument(node.context) if node.context
+      if defined?(::Rails) 
+        context.send(:render, :partial => node.name, :object => _context)
+      else
+        partial = Partial.fetch(node.name)
+        if partial.respond_to? :call
+          partial.call(_context)
+        else
+          create_child_runtime(partial).to_s(_context)
+        end
+      end
+    end
+
+    def evaluate_call(call, context=context, &block)
+      context = Helpers.decorate_with(context,@helpers,@locals) unless context.is_a? Helpers::Decorator
+      case call
+      when ParentCallNode
+        depth = call.depth
+        (2..depth).inject(parent) { |p| p.parent }.evaluate_call(call.to_callnode,&block)
+      when LiteralCallNode
+        result = context.send(:[], call.name)
+        result = result.call(*call.arguments.map { |a| evaluate_argument(a) },&block) if result.respond_to? :call
+        result
+      when LocalVarNode
+        result = private_variable_get(call.name)
+      else
+        raise UnknownHelperException, "Template context doesn't respond to method #{call.name.inspect}." unless context.respond_to? call.name
+        context.public_send(call.name, *call.arguments.map { |a| evaluate_argument(a) }, &block)
+      end
+    end
+
+    def evaluate_argument(arg)
+      if arg.is_a? Array
+        evaluate_object_path(arg)
+      else
+        evaluate_node(arg)
+      end
+    end
+
+    def evaluate_object_path(path, &block)
+      path.inject(context) do |context,call|
+        context = evaluate_call(call, context, &block)
+      end
+    end
+
+    def evaluate_expression(node, &block)
+      evaluate_object_path(node.method)
+    end
+
+    def evaluate_block(node,block_context=@context)
+      call = node.method.first
+      content_runtime = create_child_runtime(node.contents)
+      alternate_runtime = create_child_runtime(node.alternate) if node.respond_to? :alternate
+      block_runtime = BlockRuntime.new(block_context,content_runtime,alternate_runtime)
+
+      result = evaluate_call(call, block_context) { block_runtime }
+
+      # If the helper fails to call it's provided block then all
+      # sorts of wacky default behaviour kicks in. I don't like it,
+      # but that's the spec.
+      if !block_runtime.rendered?
+
+        # If the result is collectiony then act as an implicit
+        # "each"
+        if result && result.respond_to?(:each) 
+          if result.respond_to?(:size) && (result.size > 0)
+            r = []
+            # Not using #each_with_index because the object might
+            # not actually be an Enumerable
+            count = 0
+            result.each do |e| 
+              r << block_runtime.contents(e, {'index' => count}) 
+              count += 1
+            end
+            result = r.join('')
+          else
+            result = block_runtime.inverse
+          end
+
+        # Otherwise it behaves as an implicit "if"
+        elsif result
+          result = block_runtime.contents result
+        else
+          if block_runtime.has_inverse?
+            result = block_runtime.inverse
+          else
+            result = ''
+          end
+        end
+      end
+      result
+    end
+
+    def create_child_runtime(body=[])
+      node = body.is_a?(TemplateNode) ? body : TemplateNode.new(body)
+      Runtime.new(node,nil,@locals,@helpers,self)
+    end
+
+    def inspect
+      "#<FlavourSaver::Runtime contents=#{@ast.inspect}>"
+    end
+
+    class BlockRuntime
+      def initialize(block_context,content_runtime,alternate_runtime=nil)
+        @block_context = block_context
+        @content_runtime = content_runtime
+        @alternate_runtime = alternate_runtime
+        @render_count = 0
+      end
+
+      def contents(context=@block_context,locals={})
+        @render_count += 1
+        @content_runtime.to_s(context,locals) if @content_runtime
+      end
+
+      def inverse(context=@block_context)
+        @render_count += 1
+        @alternate_runtime.to_s(context) if @alternate_runtime
+      end
+
+      def has_inverse?
+        !!@alternate_runtime
+      end
+
+      def rendered?
+        @render_count > 0 ? @render_count : false
+      end
+
+      def rendered!
+        @render_count += 1
+      end
+    end
+
+    private
+
+    def escape(output)
+      if output.respond_to?(:html_safe) && output.html_safe?
+        # If the string is already marked as html_safe then don't
+        # escape it any further.
+        output
+
+      else
+        output = CGI.escapeHTML(output)
+
+        # We can't just use CGI.escapeHTML because Handlebars does extra
+        # escaping for its JavaScript environment. Thems the breaks.
+        output = output.gsub(/(['"`])/) do |match|
+          case match
+          when "'"
+            "&#x27;"
+          when '"'
+            "&quot;"
+            when '`'
+              "&#x60;"
+            end
+        end
+
+        # Mark it as already escaped if we're in Rails
+        output.html_safe if output.respond_to? :html_safe
+
+        output
+      end
+    end
+  end
+end