renshi 0.0.8 → 0.0.9

data/README

@@ -21,8 +21,7 @@ $[end]
 
 Attribute Expressions
 ===================
-The $ syntax will give you everything ERB does, with less typing. But Renshi also has 'attribute expressions',
-which can be inserted into a HTML element as an attribute - e.g. <span r:if="user.is_administrator">...</span>. 
+The $ syntax will give you everything ERB does, with less typing. But Renshi also has 'attribute expressions', which can be inserted into a HTML element as an attribute - e.g. <span r:if="user.is_administrator">...</span>. After Renshi::Parser interprets an attribute expression it removes it from the HTML output; the code is unobtrusive.
 
 r:expression_name="expression" - the expression value is treated as a Ruby expression .
 
@@ -103,7 +102,8 @@ hello99
 * Each
 The expression takes the object and then any arguments for the each block after a comma; so you can do anything with it that each supports.
 
-r:each="foos, |k,v|", r:each="foos, |foo|"..
+r:each="foos, |k,v|" to iterate over a hash
+r:each="foos, |foo|" to iterate over an array
 
 <div id="content$foo" r:each="foos, |foo|">
 hello$foo
@@ -117,7 +117,11 @@ hello0
 hello99
 </div>
 
-Further elements will appear as I have time to make them or others want to contribute them. There isn't much to making them. 
+Further elements will appear as I have time to make them or others want to contribute them. 
+There isn't much to making them. If there's one you'd especially like, let me know on lighthouse and I'll see about adding it.
+
+The one restriction is that I want to limit attribute expressions to one key and value combination on the element (everything fits into r:foo="expression").
+I want to avoid complexity like "<span r:foo='..' r:params="k,v" />" for example - see r:each for the workaround.
 
 See renshi/lib/renshi/attribute_expressions for how they work.
 
@@ -133,6 +137,10 @@ Renshi documents are appended with the suffix of .ren
 
 e.g. index.html.ren or index.ren 
 
+Installation
+============
+Renshi is hosted on Rubyforge so 'sudo gem install renshi'. Alternatively, use github to do what you want with it.
+
 
 Framework Integration
 =====================
@@ -142,13 +150,30 @@ Simply require the renshi gem in your code, and Renshi will make itself availabl
 
 There is a Rails 2.3.2 example app in the examples directory. Go there, start up the application, and visit http://localhost:3000/hello
 
-I'd welcome integrations for Sinatra and Merb or XYZ framework. See renshi/lib/renshi/frameworks 
+I'd welcome integrations for Sinatra or Merb or XYZ framework. See renshi/lib/renshi/frameworks (see below - How Fast Is It?)
 
 
-Installation
-============
-Renshi is hosted on Rubyforge so 'sudo gem install renshi'. Alternatively, use github to do what you want with it.
+How Fast Is It? - Compilable Templates
+======================================
+I don't know - I've not benchmarked it yet. It's built solely on Nokogiri, which is very fast. To a certain extent it's an irrelevant question, given that Renshi compiles .ren documents into chunks of ruby code, which are kept in memory and reused. This was written specifically for the Rails notion of compilable templates (see ActionView::TemplateHandlers::Compilable and Renshi::Frameworks::Rails).
+
+ERB and HAML also do this (in fact I worked from the source code of both). It means, essentially, that a foo.html.ren document is compiled once into ruby, and each presentation of the template is then a matter of using the generated code (not reading the template).
+
+Thus, n requests for the template mean 1 call to Renshi to generate the necessary code, which is then reused. At some stage I might benchmark this raw ruby - but I've written it with an eye on efficiency as it's generated and so far it seems very fast. If someone enjoys benchmarking then please jump in.
+
+When integrating this feature with other frameworks, simply use a delegate object to hold the compiled code and evaluate it against the binding you want to use (see the spec.s for this). 
+
+E.g. some helper methods in the spec_helper.rb might get you started. For the integration you'd keep memory of which files had been compiled (only call compile_file once).
+
+def compile_file(file)
+  compiled = Renshi::Parser.parse(read_file(file))  
+end
+
+def interpret(file, context)
+  eval(compile_file(file), context)
+end
 
+rendered_template = interpret("index.html.ren", binding)
 
 Development
 ===========
@@ -164,10 +189,9 @@ But ...
 
 I've always found ERB to be a bit cumbersome - <%= is quite tiring to type out when you realise it could be much shorter. I used to think that Velocity, in Java, was the most fun templating language I'd used, and I had wanted something equally as concise for Ruby.
 
-A real need for it emerged in a project which relied upon an external design house handing us HTML. Converting it incessantly into HAML was nightmarish. A colleague mentioned Genshi in Python as ideal, which was when the idea of Renshi was conceived.
+A real need for it emerged in a project which relied upon an external design house handing us HTML. Converting it incessantly into HAML was a headache. A colleague mentioned Genshi in Python as ideal, which was when the idea of Renshi was conceived.
 
-It should give the developer power to do what they want, without being restrictive. You can throw $ statements around the place in a document
-or use attribute expressions to preserve a strict xhtml layout.
+It should give the developer power to do what they want, without being restrictive. You can throw $ statements around the place in a document or use attribute expressions to preserve a strict xhtml layout.
 
 English to Japanese
 ===================

data/lib/renshi/frameworks/generic.rb

@@ -0,0 +1,7 @@
+module Renshi
+  module Frameworks
+    module Generic
+    end
+  end
+end
+

data/lib/renshi/frameworks/rails.rb

@@ -2,6 +2,8 @@ module Renshi
   module Frameworks
     module Rails
       if defined? ActionView::TemplateHandler
+        #this is an old, first try of integrating with Rails, without compilable templates
+        #use it for older Rails versions (pre 2.2.0, I think). 
         class Plugin < ActionView::TemplateHandler
           def self.call(template)
             "#{name}.new(self).render(template, local_assigns)"

data/lib/renshi/parser.rb

@@ -5,11 +5,13 @@ module Renshi
   # the document, which are finally compiled into Ruby.
   
   class Parser
-    STRING_END = "^R_END^" #maybe replace this with a funky unicode char
-    STRING_START = "^R_START^" #maybe replace this with a funky unicode char
+    STRING_END = "^R_END" #maybe replace this with a funky unicode char
+    STRING_START = "^R_START" #maybe replace this with a funky unicode char
     BUFFER_CONCAT_OPEN = "@output_buffer.concat(\""
     BUFFER_CONCAT_CLOSE = "\");"
     NEW_LINE = "@output_buffer.concat('\n');"
+    INSTRUCTION_START = "^R_INSTR_IDX_START^"
+    INSTRUCTION_END = "^R_INSTR_IDX_END^"
     
     #these symbols cannot be normally escaped, as we need to differentiate between < as an
     #escaped string, to be left in the document, and < as a boolean operator
@@ -19,18 +21,31 @@ module Renshi
     
     def self.parse(xhtml)
       doc = Nokogiri::HTML.fragment(xhtml)
-
-      doc.children.each do |node|
+      
+      parser = self.new(doc)
+      out = parser.parse
+      
+      return out
+    end
+    
+    def initialize(nokogiri_node)
+      @doc = nokogiri_node
+      @instructions = []
+      @instr_idx = 0
+    end
+    
+    def parse
+      @doc.children.each do |node|
        transform_node(node)
       end      
-      
-      inner_html = doc.inner_html
+
+      inner_html = @doc.inner_html
       compiled = compile_to_buffer(inner_html) if inner_html
        # puts "\n", compiled, "\n"
       return compiled
     end
 
-    def self.transform_node(node)
+    def transform_node(node)
       if node.attributes
         expressions = node.commands
         for expression in expressions 
@@ -51,13 +66,20 @@ module Renshi
       #compile text in nodes, e.g. <p>*</p>
       if node.text?
         compiled = compile(node.text)
-        node.content = compiled if compiled
+        if compiled
+          @instructions << compiled
+          key = "#{INSTRUCTION_START}#{@instr_idx}#{INSTRUCTION_END}"
+          @instr_idx = @instr_idx + 1
+          # node.content = compiled if compiled
+          node.content = key
+        end
       end
 
       node.children.each {|child| transform_node(child)}
     end
-    
-    def self.compile(text)
+ 
+
+    def compile(text)
       idx = text.index("$")
       return text if idx.nil?
       
@@ -66,8 +88,10 @@ module Renshi
       
       while idx != nil do
         next_char = text[(idx + 1)..(idx + 1)]
-
-        if next_char == "(" 
+    
+        if next_char == " "          
+          raise SyntaxError, "Floating $ - use $$ to output '$': #{text[(idx +1)..-1]}", caller
+        elsif next_char == "(" 
           #this may be jquery, etc. $(...) 
           end_statement_idx = (idx + 2)
           bits << text[idx..(idx + 1)]    
@@ -79,25 +103,28 @@ module Renshi
           #${...}
         elsif next_char == "{"
           begin
-            closing_brace_idx = text.rindex("}")
+            #scan for the next $ in this block
+            closing_brace_idx = close_of_phrase_ending_with("}", text, idx)
             statement_str = text[(idx + 2)..(closing_brace_idx -1)]
             statement = Renshi::Statement.new(statement_str)
             bits << statement.compile_to_print!
             end_statement_idx = closing_brace_idx + 1
-          rescue Renshi::StandardError
-            raise SyntaxError, "No closing brace: #{text[(idx +1)..-1]}", caller
+          rescue StandardError
+            raise SyntaxError, "No closing brace: #{text}", caller
           end
           
           #$[...]
         elsif next_char == "["
           begin
-            closing_brace_idx = text.rindex("]")
+
+            # closing_brace_idx = text.rindex("]")
+            closing_brace_idx = close_of_phrase_ending_with("]", text, idx)
             statement_str = text[(idx + 2)..(closing_brace_idx -1)]
             statement = Renshi::Statement.new(statement_str)
             bits << statement.compile_to_expression!
             end_statement_idx = closing_brace_idx + 1
-          rescue Renshi::StandardError
-            raise SyntaxError, "No closing bracket: #{text[(idx +1)..-1]}", caller
+          rescue StandardError
+            raise SyntaxError, "No closing bracket: #{text}", caller
           end          
         else #$foo
           words = text[(idx +1)..-1].split(/\s/)
@@ -107,7 +134,7 @@ module Renshi
           bits << statement.compile_to_print!
           end_statement_idx = (words.first.length) + 1 + idx
         end
-
+    
         next_statement_idx = text.index("$", end_statement_idx)
         
         if next_statement_idx
@@ -118,26 +145,55 @@ module Renshi
         end
         idx = next_statement_idx
       end       
-
+    
       return bits.join
     end
+
     
-    def self.compile_to_buffer(str)
+    def close_of_phrase_ending_with(char, text, idx)
+      phrase_end = (text[(idx + 1)..-1].index("$")) 
+      
+      if phrase_end.nil?
+        phrase_end = text.length 
+      else
+        phrase_end = phrase_end + idx
+      end
+      closing_brace_idx = text[idx...phrase_end].rindex(char) + idx
+      return closing_brace_idx
+    end
+    
+    def compile_to_buffer(str)
       compiled = "@output_buffer ='';" << BUFFER_CONCAT_OPEN      
       str = compile_print_flags(str)    
       compiled = "#{compiled}#{str}" << BUFFER_CONCAT_CLOSE
     end
     
-    def self.compile_print_flags(str)
+    def compile_print_flags(str)
       #now we parse for RENSHI::STRING_END and RENSHI::STRING_START
       #and ensure natural strings are buffered
       str.gsub!("\"", "\\\"")
-      str.gsub!(STRING_END, BUFFER_CONCAT_CLOSE)
-      str.gsub!(STRING_START, BUFFER_CONCAT_OPEN)
       str.gsub!(XML_GT, ">")
       str.gsub!(XML_LT, "<")
       str.gsub!(XML_AMP, "&")
       
+      #restore instructions in the string      
+      bits = []
+      str.split(INSTRUCTION_START).each do |bit|
+        if bit.index(INSTRUCTION_END)
+          index = bit[0..0] 
+          instruction = @instructions[index.to_i]
+          
+          bit.gsub!("#{index}#{INSTRUCTION_END}", instruction)
+        end
+        
+        bits << bit
+      end
+      
+      str = bits.join
+      
+      str.gsub!(STRING_END, BUFFER_CONCAT_CLOSE)
+      str.gsub!(STRING_START, BUFFER_CONCAT_OPEN)
+
       return str
     end
   end

data/lib/renshi.rb

@@ -9,7 +9,7 @@ require 'renshi/attribute_expressions'
 require 'renshi/frameworks'
 
 module Renshi
-  VERSION="0.0.8"
+  VERSION="0.0.9"
   
   class SyntaxError < StandardError; end
 end

data/spec/data/attribute_values_parsed.ren

@@ -1,4 +1,4 @@
 <body>
-  $[$i = 1] 
+  $[i = 1] 
   <div id='content$i'>hello</div>
 <body>

data/spec/data/inner_braces.ren

@@ -0,0 +1,7 @@
+<html>
+  <body>
+    <div id="content">
+      ${display({:a => "1", :b =>  "flew", :c =>  "over", {:d => "the", :e => "cuckoo's"},  :f => "nest"})}
+    </div>
+  </body>
+</html>

data/spec/data/multiple_statements.ren

@@ -0,0 +1,11 @@
+<html>
+  <body>
+    <div id="content">
+      ${foo "1", "2"}, ${foo "3", "4"}
+    </div>
+    <div id="content2">
+      $[a = 1], $[b = 2]
+      ${a}, $b
+    </div>    
+  </body>
+</html>

data/spec/data/quots.ren

@@ -0,0 +1,7 @@
+<html>
+  <body>
+    <div id="content">
+      ${foo "1", "2"}
+    </div>
+  </body>
+</html>

data/spec/data/quots2.ren

@@ -0,0 +1,10 @@
+<html>
+  <body>
+    <div id="content">
+      ${foo "1", "2"}
+    </div>
+    <div id="content2">
+      ${foo "a", "2"}
+    </div>    
+  </body>
+</html>

data/spec/parser_spec.rb

@@ -33,4 +33,43 @@ describe Renshi::Parser do
       html = N(html)
       (html/"div[@id='content1']").text.strip.should =~ /hello/      
     end
+    
+    def foo(one, two, three = {})
+      "#{one}, #{two}"
+    end
+    
+    it "should understand double quotations marks within ruby code!" do
+      #${link_to "alter this template", edit_cms_page_template_path(PageTemplate.find_by_file_name("default.html.erb"))}       
+      raw = compile_file("data/quots.ren")
+      html = eval(raw, binding)
+      html = N(html)
+      (html/"div[@id='content']").text.strip.should =~ /1, 2/      
+    end
+    
+    it "should understand double quotations marks within ruby code!" do
+      #${link_to "alter this template", edit_cms_page_template_path(PageTemplate.find_by_file_name("default.html.erb"))}       
+      raw = compile_file("data/quots2.ren")
+      html = eval(raw, binding)
+      html = N(html)
+      (html/"div[@id='content']").text.strip.should =~ /1, 2/      
+      (html/"div[@id='content2']").text.strip.should =~ /a, 2/      
+    end
+    
+    it "should understand double quotations marks within ruby code! 2" do
+      doc = Nokogiri::HTML(%Q!<p>${foo "1", foo("3", "4")}</p>!)
+      
+      puts doc.root
+    
+      body = doc.root.children.first
+      node = body.children.first
+      eval(deliver_compiled(node), binding).should eql "1, 3, 4"
+    end
+    
+    it "should understand multiple statements on the same line" do    
+      raw = compile_file("data/multiple_statements.ren")
+      html = eval(raw, binding)
+      html = N(html)
+      (html/"div[@id='content']").text.strip.should =~ /1, 2, 3, 4/      
+      (html/"div[@id='content2']").text.strip.should =~ /1, 2/      
+    end
 end

data/spec/spec_helper.rb

@@ -17,8 +17,7 @@ def interpret(file, context)
 end
 
 def deliver_compiled(node)
-  raw = Renshi::Parser.compile(node.text)
-  raw = Renshi::Parser.compile_to_buffer(raw)    
+  raw = Renshi::Parser.parse(node.text)
 end
 
 def N(str)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: renshi
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors: 
 - Nicholas Faiz
@@ -9,7 +9,7 @@ autorequire: renshi
 bindir: bin
 cert_chain: []
 
-date: 2009-07-13 00:00:00 +10:00
+date: 2009-08-11 00:00:00 +10:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -31,8 +31,6 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
-- lib/renshi
-- lib/renshi/attribute_expressions
 - lib/renshi/attribute_expressions/each.rb
 - lib/renshi/attribute_expressions/else.rb
 - lib/renshi/attribute_expressions/elsif.rb
@@ -41,7 +39,7 @@ files:
 - lib/renshi/attribute_expressions/unless.rb
 - lib/renshi/attribute_expressions/while.rb
 - lib/renshi/attribute_expressions.rb
-- lib/renshi/frameworks
+- lib/renshi/frameworks/generic.rb
 - lib/renshi/frameworks/rails.rb
 - lib/renshi/frameworks.rb
 - lib/renshi/node.rb
@@ -51,6 +49,8 @@ files:
 - README
 has_rdoc: true
 homepage: http://treefallinginthewoods.com
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -71,12 +71,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Renshi is a lightweight XHTML template language, inspired by Python's Genshi and build on Nokogiri.
 test_files: 
-- spec/data
 - spec/data/attribute_values_parsed.ren
 - spec/data/for.ren
 - spec/data/hello_world1.ren
@@ -85,6 +84,10 @@ test_files:
 - spec/data/if_3.ren
 - spec/data/ifelse.ren
 - spec/data/ifelsifelse.ren
+- spec/data/inner_braces.ren
+- spec/data/multiple_statements.ren
+- spec/data/quots.ren
+- spec/data/quots2.ren
 - spec/data/while.ren
 - spec/data/while_lt.ren
 - spec/data/white_space.ren