flavour_saver 0.3.3

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/flavour_saver.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/flavour_saver/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["James Harton"]
+  gem.email         = ["james@resistor.io"]
+  gem.description   = %q{FlavourSaver is a pure-ruby implimentation of the Handlebars templating language}
+  gem.summary       = %q{Handlebars.js without the .js}
+  gem.homepage      = "http://jamesotron.github.com/FlavourSaver/"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "flavour_saver"
+  gem.require_paths = ["lib"]
+  gem.version       = FlavourSaver::VERSION
+
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rspec-core'
+  gem.add_development_dependency 'rspec-mocks'
+  gem.add_development_dependency 'rspec-expectations'
+  gem.add_development_dependency 'guard-bundler'
+  gem.add_development_dependency 'activesupport'
+
+  gem.add_dependency 'rltk', '~> 2.2.0'
+  gem.add_dependency 'tilt'
+end

data/lib/flavour_saver/helpers.rb

@@ -0,0 +1,118 @@
+require 'delegate'
+
+module FlavourSaver
+  module Helpers
+    class Defaults
+      def with(args)
+        yield.contents args
+      end
+
+      def each(collection)
+        r = []
+        count = 0
+        collection.each do |element|
+          r << yield.contents(element, 'index' => count)
+          count += 1
+        end
+        yield.rendered!
+        r.join ''
+      end
+
+      def if(truthy)
+        truthy = false if truthy.respond_to?(:size) && (truthy.size == 0)
+        if truthy
+          yield.contents
+        else
+          yield.inverse
+        end
+      end
+
+      def unless(falsy,&b)
+        self.if(!falsy,&b)
+      end
+
+      def this
+        @source || self
+      end
+
+      def log(message)
+        FS.logger.debug("FlavourSaver: #{message}")
+        ''
+      end
+    end
+
+    class Decorator < Defaults
+
+      def initialize(locals, source)
+        @source = source
+        mixin = Module.new do
+          locals.each do |name,impl|
+            define_method name, &impl
+          end
+        end
+        extend(mixin)
+      end
+
+      def array?
+        !!@source.is_a?(Array)
+      end
+
+      def [](accessor)
+        if array?
+          if accessor.match /[0-9]+/
+            return @source.at(accessor.to_i)
+          end
+        end
+        @source[accessor]
+      end
+
+      def respond_to?(name)
+        super || @source.respond_to?(name)
+      end
+
+      def method_missing(name,*args,&b)
+        # I would rather have it raise a NameError, but Moustache
+        # compatibility requires that missing helpers return 
+        # nothing. A good place for bugs to hide.
+        @source.send(name, *args, &b) if @source.respond_to? name
+      end
+    end
+
+    module_function
+
+    def registered_helpers
+      @registered_helpers ||= {}
+    end
+
+    def register_helper(method,&b)
+      if method.respond_to? :name
+        registered_helpers[method.name.to_sym] = method
+      elsif b
+        registered_helpers[method.to_sym] = b
+      end
+    end
+
+    def deregister_helper(*names)
+      names.each do |name|
+        registered_helpers.delete(name.to_sym)
+      end
+    end
+
+    def reset_helpers
+      @registered_helpers = {}
+    end
+
+    def decorate_with(context, helper_names=[], locals={})
+      helpers = if helper_names.any?
+                  helper_names = helper_names.map(&:to_sym)
+                  registered_helpers.select { |k,v| helper_names.member? k }.merge(locals)
+                else
+                  helpers = registered_helpers
+                end
+      helpers = helpers.merge(locals)
+      Decorator.new(helpers, context)
+    end
+
+  end
+end
+

data/lib/flavour_saver/lexer.rb

@@ -0,0 +1,127 @@
+require 'rltk'
+
+module FlavourSaver
+  class Lexer < RLTK::Lexer
+
+    rule /{{{/, :default do
+      push_state :expression
+      :TEXPRST
+    end
+
+    rule /{{/, :default do
+      push_state :expression
+      :EXPRST
+    end
+
+    rule /#/, :expression do
+      :HASH
+    end
+
+    rule /\//, :expression do
+      :FWSL
+    end
+
+    rule /&/, :expression do
+      :AMP
+    end
+
+    rule /\^/, :expression do
+      :HAT
+    end
+
+    rule /@/, :expression do
+      :AT
+    end
+
+    rule />/, :expression do
+      :GT
+    end
+
+    rule /([1-9][0-9]*(\.[0-9]+)?)/, :expression do |n|
+      [ :NUMBER, n ]
+    end
+
+    rule /true/, :expression do |i|
+      [ :BOOL, true ]
+    end
+
+    rule /false/, :expression do |i|
+      [ :BOOL, false ]
+    end
+
+    rule /\!/, :expression do
+      push_state :comment
+      :BANG
+    end
+
+    rule /([^}}]*)/, :comment do |comment|
+      pop_state
+      [ :COMMENT, comment ]
+    end
+
+    rule /else/, :expression do
+      :ELSE
+    end
+
+    rule /([A-Za-z]\w*)/, :expression do |name|
+      [ :IDENT, name ]
+    end
+
+    rule /\./, :expression do 
+      :DOT
+    end
+
+    rule /\=/, :expression do
+      :EQ
+    end
+
+    rule /"/, :expression do
+      push_state :string
+    end
+    
+    rule /(\\"|[^"])*/, :string do |str|
+      [ :STRING, str ]
+    end
+
+    rule /"/, :string do
+      pop_state
+    end
+
+    # Handlebars allows methods with hyphens in them. Ruby doesn't, so
+    # we'll assume you're trying to index the context with the identifier
+    # and call the result.
+    rule /([A-Za-z][a-z0-9_-]*[a-z0-9])/, :expression do |str|
+      [ :LITERAL, str ]
+    end
+
+    rule /\[/, :expression do
+      push_state :segment_literal
+    end
+
+    rule /([^\]]+)/, :segment_literal do |l|
+      [ :LITERAL, l ]
+    end
+
+    rule /]/, :segment_literal do
+      pop_state
+    end
+
+    rule /\s+/, :expression do
+      :WHITE
+    end
+
+    rule /}}}/, :expression do
+      pop_state
+      :TEXPRE
+    end
+
+    rule /}}/, :expression do
+      pop_state
+      :EXPRE
+    end
+
+    rule /.*?(?={{|\z)/m, :default do |output|
+      [ :OUT, output ]
+    end
+  end
+end

data/lib/flavour_saver/nodes.rb

@@ -0,0 +1,177 @@
+require 'rltk'
+require 'rltk/ast'
+require 'flavour_saver/nodes'
+
+module FlavourSaver
+  class Node < RLTK::ASTNode
+    def inspect
+      to_s.inspect
+    end
+  end
+
+  class TemplateItemNode < Node; end
+
+  class TemplateNode < Node
+    child :items, [TemplateItemNode]
+
+    def to_s
+      items.map(&:to_s).join ''
+    end
+  end
+
+  class OutputNode < TemplateItemNode
+    value :value, String
+
+    def to_s
+      value
+    end
+  end
+
+  class ValueNode < Node
+    def to_s
+      value.inspect
+    end
+
+    def inspect
+      value.inspect
+    end
+  end
+
+  class StringNode < ValueNode
+    value :value, String
+  end
+
+  class NumberNode < ValueNode
+    value :value, String
+  end
+
+  class BooleanNode < ValueNode
+  end
+
+  class TrueNode < BooleanNode
+    value :value, TrueClass
+  end
+
+  class FalseNode < BooleanNode
+    value :value, FalseClass
+  end
+
+  class CallNode < Node
+    value :name, String
+    value :arguments, Array
+
+    def arguments_to_str(str='')
+      str = str.dup # RLTK magic?
+      arguments.each do |arg|
+        str << ' '
+        if arg.respond_to? :join
+          str << arg.join('.')
+        elsif arg.respond_to? :keys
+          arg.each do |k,v|
+            str << "#{k}: #{v.inspect}"
+          end
+        else
+          str << arg.inspect
+        end
+      end
+      str
+    end
+
+    def to_s
+      arguments_to_str(name)
+    end
+  end
+  
+  class LocalVarNode < CallNode
+    def to_s
+      arguments_to_str("@#{name}")
+    end
+  end
+
+  class LiteralCallNode < CallNode
+    def to_s
+      arguments_to_str("[#{name.inspect}]")
+    end
+  end
+
+  class ParentCallNode < CallNode
+    value :depth, Fixnum
+
+    def to_callnode
+      CallNode.new(name,arguments)
+    end
+    def to_s
+      "#{'../' * depth}#{super}"
+    end
+  end
+
+  class ExpressionNode < TemplateItemNode
+    child :method, [CallNode]
+    def to_s
+      "{{#{method.map(&:to_s).join '.'}}}"
+    end
+  end
+
+  class BlockExpressionNode < ExpressionNode
+    child :contents, TemplateNode
+    child :closer,   CallNode
+
+    def name
+      method.first.name
+    end
+
+    def to_s
+      "{{##{method.map(&:to_s).join ''}}}#{contents.to_s}{{/#{closer.name}}}"
+    end
+
+    def inspect
+      r = "{{##{method.map(&:to_s).join ''}}}\n"
+      r << "  "
+      r << contents.inspect.split("\n").join("\n  ")
+      r
+    end
+  end
+
+  class BlockExpressionNodeWithElse < BlockExpressionNode
+    child :alternate, TemplateNode
+
+    def to_s
+      "{{##{method.map(&:to_s).join ''}}}#{contents.to_s}{{else}}#{alternate.to_s}{{/#{closer.name}}}"
+    end
+
+    def inspect
+      r = "{{##{method.map(&:to_s).join ''}}}\n"
+      r << contents.inspect.split("\n").join("\n  ")
+      r << "\n  {{else}}\n"
+      r << alternate.inspect.split("\n").join("\n  ")
+      r
+    end
+  end
+
+  class SafeExpressionNode < ExpressionNode
+    def to_s
+      "{{{#{method.map(&:to_s).join '.'}}}}"
+    end
+  end
+
+  class CommentNode < TemplateItemNode
+    value :comment, String
+    def to_s
+      "{{! #{comment.strip}}}"
+    end
+  end
+
+  class PartialNode < TemplateItemNode
+    value :name, String
+    child :context_call, [CallNode]
+    child :context_value, ValueNode
+
+    def context
+      context_call.any? ? context_call : context_value
+    end
+
+    def to_s
+      "{{>#{name}}}"
+    end
+  end
+end