fumbler 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fumbler.gemspec
+gemspec

data/README.md

@@ -0,0 +1,98 @@
+Fumbler
+=======
+
+This is the start of a ruby template engine based on the Tumblr syntax.
+
+It's not production ready, and this is my first gem so please try it out and let me know if I'm doing anything wrong.
+
+Some better examples are coming, checkout the specs for basic usage.
+
+
+Overview
+--------
+
+The aim is to create a safe-evaluating template engine based on the designer friendly Tumblr syntax. It will be a lot more restrictive than ERB and even Liquid, but slightly more evaluating than Mustache. 
+
+It will enable you to give the designer limited control flow, safely evaluating contexts, nest-able blocks, and a few extensions to make things easier.
+
+
+Whats Implemented
+-----------------
+
+
+###Model
+
+Inherit from the Model class to create your context which the template can access, it includes a little attr_reader style helper called 'fumbleable' to make stuff available to the template so you can apply it to existing classes and not worry about giving access to db saves etc. 
+
+
+
+    class Cage < Fumbler::Model
+      fumbleable :inside,:current
+      
+      def initialize(c)
+        @current = c
+      end
+      
+      def inside
+        "im trapped"
+      end
+      
+      def current
+        @current
+      end
+    end
+      
+    class Context < Fumbler::Model
+      
+      fumbleable :you, :cage, :cages
+      
+      def you
+        "dave"
+      end
+      
+      def hidden
+        "you cant access me"
+      end
+          
+      def cage
+        Cage.new(0)
+      end
+      
+      def cages
+        [Cage.new(1),Cage.new(2)]
+      end
+    end
+    @context = Context.new
+
+
+
+###Template
+
+This is based on [Tilt](https://github.com/rtomayko/tilt) but not everything is implemented yet.
+
+The current syntax supports basic {tags} and {block:items}{tagsinparent}or{tagsinhere}{/block:items}, blocks can be nested and will always look to the parent for missing tags.
+
+    t = Fumbler::Template.new {"hello {you}, {block:cage}{current}{/block:cage}  {block:cages}{you}{current},{/block:cages}]"}
+    t.render(@context)
+
+
+
+TODO
+----
+
+* Attributes
+* Meta-settings
+* Partials
+* Layout Inheritance
+* File handling
+* Rails Integration via Tilt
+* Re-write the regex as a token scanner
+* Lots More!
+
+
+
+Acknowledgements
+----------------
+
+This is based on the [Temple](https://github.com/judofyr/temple) framework, taking a few tips from [Mustache](https://github.com/defunkt/mustache). The syntax aims to resemble that of [Tumblr](http://www.tumblr.com) and (Posterous)[http://www.posterous.com].
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/fumbler.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fumbler/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fumbler"
+  s.version     = Fumbler::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Anthony Corcutt"]
+  s.email       = ["acorcutt@me.com"]
+  s.homepage    = "https://github.com/acorcutt/fumbler"
+  s.summary     = %q{Tumblr style template engine for ruby}
+
+  s.rubyforge_project = "fumbler"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency("temple")
+  s.add_dependency("tilt")
+  
+  s.add_development_dependency("rspec", ["~> 2.4"])
+end

data/lib/fumbler.rb

@@ -0,0 +1,9 @@
+require 'fumbler/version'
+
+module Fumbler
+  autoload :Engine,     'fumbler/engine'
+  autoload :Parser,     'fumbler/parser'
+  autoload :Filter,     'fumbler/filter'
+  autoload :Template,   'fumbler/template'
+  autoload :Model,      'fumbler/model'
+end

data/lib/fumbler/engine.rb

@@ -0,0 +1,16 @@
+require 'temple'
+require 'fumbler'
+
+module Fumbler
+  class Engine < Temple::Engine
+    use Fumbler::Parser
+    use Fumbler::Filter
+
+    #filter :EscapeHTML, :use_html_safe  
+    filter :MultiFlattener
+    filter :StaticMerger
+    filter :DynamicInliner
+    
+    generator :ArrayBuffer
+  end
+end

data/lib/fumbler/filter.rb

@@ -0,0 +1,45 @@
+require 'temple'
+
+module Fumbler
+  # 
+  # We just take our array and turn it into something Temple understands
+  #
+  # We prefix any calls with fumble_ which will be defined in our context class, and any children
+  #
+  #
+  class Filter < Temple::Filter
+    def on_multi(*exps) 
+      exps.each_with_index do |exp,i|
+        name = exp[1]
+        case exp[0].to_sym
+        when :dynamic
+          exps[i] = [:dynamic,"fumble_#{name}"]
+        when :block
+          if exp[1] == "end"
+            #just strip any attributes and double up end tags to match block
+            exps[i] = [:block,"end;end"]          
+          else
+            exps[i]=[:static,"block"]
+
+            # TODO - attributes, first we need to fix the parser to grab the whole attribute including quotes, also allow fumble_*params
+            atr = exp[2..-1] 
+
+            # TODO - handle Arrays - think we just need to add it and also end;end above? or inject :multi
+            exps[i]= [:block,<<-code]
+              c = #{name}
+              c = [c] unless c.is_a?(Array) 
+              c.each do |b|
+                b.fumble(self) do
+            code
+          end
+        end
+      end
+      return [:multi, *exps]
+    end
+    
+    # Create evaluating string
+    def ev(s)
+      "#\{#{s}}"
+    end
+  end
+end

data/lib/fumbler/model.rb

@@ -0,0 +1,41 @@
+module Fumbler
+
+  class Model
+   
+    def self.fumbleable(*accessors)
+      accessors.each do |m|
+        class_eval <<-EOS
+          def fumble_#{m}
+            self.#{m}
+          end
+        EOS
+      end
+    end
+
+    # What I'm trying todo is make blocks work inside blocks, and still be able to access
+    # the parents attributes, instance_eval lets us do something similar to javascripts with(o){}
+    # In this example we cant access 'you' inside the cage context how we would like to
+    # as its not a local, but see how 'outside' works. So we need to catch the missing_method
+    # and push send up to the parent, which might be a bit slow but it simplifies the block filter.
+    #
+    #      @context.fumble(self){        
+    #        puts you   #defined in root context class 
+    #        outside = "outside"        
+    #        cage.fumble(self){
+    #          puts outside
+    #          puts inside #defined in cage class        
+    #          puts you #this errors unless we catch method_missing
+    #        }   
+    #      }       
+    def fumble(parent,&block)
+      @parent = parent
+      instance_eval &block
+    end
+    
+    def method_missing(sym, *args,&block)
+      if @parent
+        @parent.send(sym, *args,&block) 
+      end
+    end
+  end
+end

data/lib/fumbler/parser.rb

@@ -0,0 +1,86 @@
+require 'temple'
+
+module Fumbler
+  #
+  # Handles parsing of our template string
+  #
+  # The Basics:
+  # 
+  #
+  # Display something:
+  #
+  #   {title}
+  #
+  # Blocks:
+  #
+  # {block:item limit="10"}
+  #   {title}      
+  # {/block:item}
+  #
+  #
+  # We allow a few tag formats and special html style wrapper to hide from rich html editors
+  # {block:items} {{block:items}} <{block:items}> <!--{block:items}--> are all equivelant, 
+  # The surrounding tag will always be stripped from the output.
+  #
+  # Escape things with 
+  # {{{ <{im}> {escaped} .css{color:red} }}}
+  #
+  # TODO - make tag patterns customizable so we can do ${tag} etc.
+  # TODO - combine the block and tag pattern, then allow tag & block delimiters to be differerent e.g. erb style
+  # TODO - or switch to scanning for opening and closing tags so we can do things like {block:tag a="{" b="}"} and ignore {tag}} 
+    
+  class Parser
+    include Temple::Mixins::Options
+    
+    TAG_PATTERN = /{{{(.*?)}}}|({|{{|<{|<!--{)\s*?(\/?\b.+?)\s*?(}-->|}>|}}|})/m #order of the { {{ <{ <!--{ tag groups is important
+    
+    BLOCK_PATTERN = /(\/?\b\w+\b)\s*?:\s*?(\b\w+\b)\s*?(.*)/m
+    
+    ATTRIBUTE_PATTERN = /\s+(\b\w+\b)\s*=\s*(?:(['"])(.*?)\2)/m #a='1' b="2"
+    
+    def compile(input)
+      result = [:multi]
+      return result unless input
+
+      pos = 0
+      blocks = 0
+      input.scan(TAG_PATTERN) do |escaped,s, tag, e|
+        m = Regexp.last_match
+        text = input[pos...m.begin(0)]
+        pos  = m.end(0)
+        result << [:static, text] if !text.empty?
+        if escaped
+          result << [:static, escaped]  
+        else      
+          m = tag.match(BLOCK_PATTERN)
+          if m
+            t = m[2]
+            a = []
+            m[3].scan(ATTRIBUTE_PATTERN) do |key,q,value|
+              a << [key,value]
+            end
+            case m[1]
+            when "block"
+              result << [:block,t,a]
+              blocks+=1
+            when "/block"
+              result << [:block,"end"]
+              blocks-=1
+            end
+          else
+            result << [:dynamic,tag]
+          end
+        end
+      end
+      text = input[pos..-1]
+      result << [:static, text] if !text.empty?      
+  
+      #close any blocks left over
+      blocks.times do
+        result << [:block,"end"]
+      end
+
+      result
+    end
+  end
+end

data/lib/fumbler/template.rb

@@ -0,0 +1,8 @@
+require 'temple'
+require 'fumbler'
+
+module Fumbler
+  class Template < Temple::Template
+    engine Fumbler::Engine
+  end
+end

data/lib/fumbler/version.rb

@@ -0,0 +1,3 @@
+module Fumbler
+  VERSION = "0.0.1"
+end

data/spec/fumbler_model_spec.rb

@@ -0,0 +1,44 @@
+require 'fumbler/model'
+
+describe Fumbler::Model do
+    before(:all) do
+            
+      class Context < Fumbler::Model
+        
+        fumbleable :you, :cage
+        
+        def you
+          "dave"
+        end
+                
+        class Cage < Fumbler::Model
+          fumbleable :inside
+          
+          def inside
+            "im trapped"
+          end
+        end
+        
+        def cage
+          Cage.new
+        end
+      end
+
+
+    end
+
+    it "should find all attributes" do
+      @context = Context.new
+      
+      @context.fumble(self){        
+        you.inspect    
+        outside = "outside"        
+        cage.fumble(self){
+          outside.inspect    
+          inside.inspect             
+          you.inspect    
+        }   
+      }   
+    end
+
+end

data/spec/fumbler_parser_spec.rb

@@ -0,0 +1,51 @@
+require 'fumbler/engine'
+require 'fumbler/parser'
+
+describe Fumbler::Engine do
+    it "should make a new temple engine" do
+      Fumbler::Engine.new
+    end
+end
+
+describe Fumbler::Parser do
+    it "should make a new parser" do
+      Fumbler::Parser.new
+    end
+    
+    it "should parse empty string" do
+      Fumbler::Parser.new.compile("").should eql([:multi]) 
+    end
+
+    it "should parse some static text" do
+      Fumbler::Parser.new.compile("some text").should eql([:multi,[:static,"some text"]]) 
+    end
+
+    it "should parse escaped tags" do
+      Fumbler::Parser.new.compile("hello {{{ <{im}> {escaped} .css{color:red} }}}").should eql([:multi,[:static,"hello "],[:static," <{im}> {escaped} .css{color:red} "]]) 
+    end
+
+    it "should parse a text tag" do
+      Fumbler::Parser.new.compile("hello {name}-{ age }").should eql([:multi,[:static,"hello "],[:dynamic,"name"],[:static,"-"],[:dynamic,"age"]]) 
+    end
+
+    it "should parse a text tag across multi-lines" do
+      Fumbler::Parser.new.compile("hello {name\nhere}").should eql([:multi,[:static,"hello "],[:dynamic, "name\nhere"]]) 
+    end
+
+    it "should parse a text tag in all tag formats" do
+      Fumbler::Parser.new.compile("hello {a}{{b}}<{c}><!--{d}-->").should eql([:multi,[:static,"hello "],[:dynamic,"a"],[:dynamic,"b"],[:dynamic,"c"],[:dynamic,"d"]]) 
+    end
+
+    it "should parse a block tag" do
+      Fumbler::Parser.new.compile("hello {block:item}{name}{/block:item}").should eql([:multi,[:static,"hello "],[:block,"item",[]],[:dynamic,"name"],[:block,"end"]]) 
+    end
+
+    it "should parse a spaced block tag" do
+      Fumbler::Parser.new.compile("hello { block : item}{name}{/block : item  }").should eql([:multi,[:static,"hello "],[:block,"item",[]],[:dynamic,"name"],[:block,"end"]]) 
+    end
+
+    it "should parse a block tag with attributes" do
+      Fumbler::Parser.new.compile("hello {block:item a=\"1\" b='2'}{name}{/block:item}").should eql([:multi,[:static,"hello "],[:block,"item",[["a","1"],["b","2"]]],[:dynamic,"name"],[:block,"end"]]) 
+    end
+    
+end

data/spec/fumbler_templater_spec.rb

@@ -0,0 +1,69 @@
+require 'fumbler/template'
+require 'fumbler/model'
+
+describe Fumbler::Template do
+    before(:all) do
+      class Context < Fumbler::Model
+        
+        fumbleable :you, :cage, :cages
+        
+        def you
+          "dave"
+        end
+        
+        def hidden
+          "you cant access me"
+        end
+        
+        class Cage < Fumbler::Model
+          fumbleable :inside,:current
+          
+          def initialize(c)
+            @current = c
+          end
+          
+          def inside
+            "im trapped"
+          end
+          
+          def current
+            @current
+          end
+        end
+        
+        def cage
+          Cage.new(0)
+        end
+        
+        def cages
+          [Cage.new(1),Cage.new(2)]
+        end
+      end
+      @context = Context.new
+
+    end
+
+    it "should make a new temple" do
+      Fumbler::Template.new {}
+    end
+
+    it "should render some static text" do
+      Fumbler::Template.new{"hello from template"}.render.should eql("hello from template")
+    end
+
+    it "should render a tag" do
+      t = Fumbler::Template.new {"hello {you}"}
+      t.render(@context).should eql("hello dave")
+    end    
+
+    it "should render a block" do
+      t = Fumbler::Template.new {"hello {you}, {block:cage}{you} {inside}{/block:cage}"}
+      t.render(@context).should eql("hello dave, dave im trapped")
+    end    
+
+    it "should render a block a few times" do
+      t = Fumbler::Template.new {"hello {you}, [{block:cages}{you}{current},{/block:cages}]"}
+      t.render(@context).should eql("hello dave, [dave1,dave2,]")
+    end    
+
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: fumbler
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Anthony Corcutt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-06 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: temple
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: tilt
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.4"
+  type: :development
+  version_requirements: *id003
+description: 
+email: 
+- acorcutt@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- fumbler.gemspec
+- lib/fumbler.rb
+- lib/fumbler/engine.rb
+- lib/fumbler/filter.rb
+- lib/fumbler/model.rb
+- lib/fumbler/parser.rb
+- lib/fumbler/template.rb
+- lib/fumbler/version.rb
+- spec/fumbler_model_spec.rb
+- spec/fumbler_parser_spec.rb
+- spec/fumbler_templater_spec.rb
+has_rdoc: true
+homepage: https://github.com/acorcutt/fumbler
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: fumbler
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: Tumblr style template engine for ruby
+test_files: 
+- spec/fumbler_model_spec.rb
+- spec/fumbler_parser_spec.rb
+- spec/fumbler_templater_spec.rb