renshi 0.2.4 → 0.2.5

data/README

@@ -1,18 +1,33 @@
-Renshi is a templating language for Ruby which is versatile and cooperative with HTML. It has a concise syntax and 'attribute expressions', which let you build and combine sets of inline Ruby instructions upon HTML elements.
+Renshi - a templating language which is friendly and powerful with your HTML structures.
+
+Works with Rails and Sinatra - no config.. Just 'require renshi'. In Sinatra use 'ren' where you would have used the 'erb'/'haml' methods. 
+
+index.html.ren means you're working with a Renshi file!
 
-Renshi integrates with Rails and Sinatra transparently. Simply 'require renshi'. In Sinatra use 'ren' where you would have used the 'erb'/'haml' methods. Renshi templates are appended with the suffix of .ren, e.g. index.html.ren or index.ren. 
 
 $ Ruby Interpretation
 =====================
-Like ERB, but less typing.
+$ interprets everything after it as ruby which will be to_stringed until the next $, a newline character, or the end of the element.
+
+e.g. you can do this
+
+  $stylesheet_link_tag "atsida"
+
+e.g. or this
+  <p>$foo $bar</p> 
+
 
-Use $ or ${..} where you would use <%= ... %> . The single $ is used for an unbroken phrase (see below).
+${} delimits where the ruby begins and ends, for inplace insertions"
 
-$foo[0], $1+1, $Time.now - ERB equiv. <%= foo[0] %>, <%= 1+1 %>, <%= Time.now %> 
+e.g.
+  <p>${some_function "takes this string as input"} and this is normal HTML</p>
 
-${some_function "takes this string as input"} (ERB equiv. - <%= some_function "takes this string as input" %>)
+$^ outputs a single phrase:
 
-Use $[] instead of <% ... -%>
+e.g. 
+  <p>What are you doing up at $^Time.now when you should be asleep?</p>
+
+$[] allows ruby src code to be embedded. It's a bad practice (use helpers or something) but we let you do it.
 
 $[if foo]
   $foo
@@ -20,14 +35,14 @@ $[end]
 
 Attribute Expressions
 =====================
-Attr. expressions are insertable into HTML elements as attributes.
+Attribute expressions are insertable into HTML elements.
 
 <p r:if="user.known?">Welcome $user.name</p>
 
 They can be combined on elements and are interpreted in the order of appearance and are cumulative, allowing you to program inline on the HTML structure.
 
 <li r:each="@sphinx.results[:words], |k,v|" r:if="v[:hits].to_i > 0">
-    $k - Hits $v[:hits] in $v[:docs] documents
+    $^k - Hits $^v[:hits] in $^v[:docs] documents
 </li>
 
 In the above, you can see that the if statement is scoped within the preceding each block, so you can reference variables between attr. expressions. Variables within an attr. expression don't need the $ symbol. That's only for setting up Ruby insertions within regular HTML.
@@ -146,7 +161,17 @@ To print a $ use $$, e.g. $$10.95 comes out as $10.95
 
 Because the $foo evaluation can take all sorts of symbols to interpret a Ruby statement, if you are using a special symbol *immediately* before it, you'll have to use ${foo} instead. For example, because $greetings[0].upcase is interpretable, if you want to output "[HELLO]" where the brackets surround the string, you'd use [${greetings[0].upcase}]
 
-The $ parser *delimits* (splits) on any character which is not in this list - . " ' { } ( ) + = * / \ - @ [ ] : ? ! % \w 
+The $^ parser *delimits* (splits) on any character which is not in this list - . " ' { } ( ) + = * / \ - @ [ ] : ? ! % \w 
+
+To output xml elements in a string use the escaped versions - e.g.for 
+
+(incorrect)
+${@page.section.root? ? "<li>Home</li>" : render_breadcrumbs(:from_top => 1)} 
+
+use, instead, 
+
+(correct)
+${@page.section.root? ? "&lt;li&gt;Home&lt;/li&gt;" : render_breadcrumbs(:from_top => 1)}
 
 Installation
 ============

data/lib/renshi/parser.rb

@@ -105,7 +105,7 @@ module Renshi
       
       while idx != nil do
         next_char = text[(idx + 1)..(idx + 1)]
-    
+        
         if next_char == " "          
           raise SyntaxError, "Floating $ - use $$ to output '$': #{text[(idx +1)..-1]}", caller
         elsif next_char == "(" 
@@ -116,7 +116,6 @@ module Renshi
           #an escaped $ - i.e. '$$'
           end_statement_idx = (idx + 2)
           bits << "$"
-          
           #${...}
         elsif next_char == "{"
           begin
@@ -128,8 +127,7 @@ module Renshi
             end_statement_idx = closing_brace_idx + 1
           rescue StandardError
             raise SyntaxError, "No closing brace: #{text}", caller
-          end
-          
+          end      
           #$[...]
         elsif next_char == "["
           begin
@@ -141,16 +139,33 @@ module Renshi
             end_statement_idx = closing_brace_idx + 1
           rescue StandardError
             raise SyntaxError, "No closing bracket: #{text}", caller
-          end          
-        else #$foo
-          #divide with a delimiter for anything which is not a name character - alpa-numeric and underscore
-          words = text[(idx +1)..-1].split(/[^\w."'{}()+=*\/\-@\[\]:?!%]/)
-          words[0] = "'$'" if words[0] == "$"
-          statement_str = words.first
-          statement = Statement.new(statement_str)
-          bits << statement.compile_to_print!
-          end_statement_idx = (words.first.length) + 1 + idx
-        end
+          end
+          elsif next_char == "^" #$!foo
+            #divide with a delimiter for anything which is not a name character - alpa-numeric and underscore
+            words = text[(idx + 2)..-1].split(/[^\w."'{}()+=*\/\-@\[\]:?!%]/)
+            words[0] = "'$'" if words[0] == "$"
+            statement_str = words.first
+            statement = Statement.new(statement_str)
+            bits << statement.compile_to_print!
+            end_statement_idx = (words.first.length) + 2 + idx
+          else #$foo
+            #divide with a delimiter on \n or $ or assume ruby until the end of element
+            words = text[(idx +1)..-1].split(/[\n$]/)
+            words[0] = "'$'" if words[0] == "$"
+
+            #now respect whitespace trailing the word - e.g. $foo $bar should not render as "helloworld"
+            if words.first.index(/\s/)
+              before_whitespace = words.first.rindex(/[^\s]/)              
+              src = words.first[0..(before_whitespace)]
+            else
+              src = words.first
+            end
+            
+            statement_str = src
+            statement = Statement.new(statement_str)
+            bits << statement.compile_to_print!
+            end_statement_idx = (src.length) + 1 + idx
+          end
     
         next_statement_idx = text.index("$", end_statement_idx)
         

data/lib/renshi.rb

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

data/spec/each_spec.rb

@@ -29,6 +29,6 @@ describe Renshi::Parser do
     compiled = Renshi::Parser.parse(str)
     doc = eval(compiled, binding)
     doc = N(doc)
-    (doc/"div[@id='test']").text.strip.should =~ /hello world/    
+    (doc/"div[@id='test']").text.strip.should =~ /hello world/
   end
 end

data/spec/parser_spec.rb

@@ -86,7 +86,7 @@ describe Renshi::Parser do
     it "should interpret all Renshi instructions and remove them from the document" do
       raw = compile_file("data/example1.ren")
       html = eval(raw, binding)
-
+    
       html.should_not =~/R_INSTR_IDX_START/
       html.should_not =~/R_INSTR_IDX_END/
       html.should_not =~/@output_buffer.concat/
@@ -101,8 +101,8 @@ describe Renshi::Parser do
       html.should =~/head/
     end
     
-    it "should interpret single $foos using \W, i.e. $foo$bar should render" do
-      raw = Renshi::Parser.parse("$foo$bar")
+    it "should interpret single $^foos using \W, i.e. $^foo$^bar should render" do
+      raw = Renshi::Parser.parse("$^foo$^bar")
       foo = "hello"
       bar = " world"
       
@@ -118,106 +118,130 @@ class Test
 end
     
     it "should interpret single $foo.bar " do
-      raw = Renshi::Parser.parse("$foo.bar")
-      foo = Test.new
-      html = eval(raw, binding)
-      
-      html.should eql "hello world"
-    end
-    
-    it "should interpret single $1+1 and $2*2 and $3/3 and $4-4 " do
-      raw = Renshi::Parser.parse("$1+1")
-      foo = Test.new
-      html = eval(raw, binding)  
-      html.should eql "2"
-      
-      raw = Renshi::Parser.parse("$2*2")
-      foo = Test.new
-      html = eval(raw, binding)  
-      html.should eql "4"
-
-      raw = Renshi::Parser.parse("$3/3")
-      foo = Test.new
-      html = eval(raw, binding)  
-      html.should eql "1"
-
-      raw = Renshi::Parser.parse("$4-4")
-      foo = Test.new
-      html = eval(raw, binding)  
-      html.should eql "0"
-    end
-    
-    
-    it "should interpret $foo[0] " do
-      raw = Renshi::Parser.parse("$foo[0]")
-      foo = ["hello world"]
-      html = eval(raw, binding)
-      
-      html.should eql "hello world"
-    end
-    
-    
-    it "should interpret \"${@foo}\" " do
-      raw = Renshi::Parser.parse(%Q!"${@foo}"!)
-      puts raw
-      @foo = "hello world"
-      html = eval(raw, binding)
-      
-      html.should eql %Q!"hello world"!
-    end
-
-    class R
-      attr_accessor :path
+       raw = Renshi::Parser.parse("$foo.bar")
+       foo = Test.new
+       html = eval(raw, binding)
+       
+       html.should eql "hello world"
+     end
+     
+     it "should interpret single $1+1 and $2*2 and $3/3 and $4-4 " do
+       raw = Renshi::Parser.parse("$1+1")
+       foo = Test.new
+       html = eval(raw, binding)  
+       html.should eql "2"
+       
+       raw = Renshi::Parser.parse("$2*2")
+       foo = Test.new
+       html = eval(raw, binding)  
+       html.should eql "4"
+    
+       raw = Renshi::Parser.parse("$3/3")
+       foo = Test.new
+       html = eval(raw, binding)  
+       html.should eql "1"
+    
+       raw = Renshi::Parser.parse("$4-4")
+       foo = Test.new
+       html = eval(raw, binding)  
+       html.should eql "0"
+     end
+     
+     
+     it "should interpret $foo[0] " do
+       raw = Renshi::Parser.parse("$foo[0]")
+       foo = ["hello world"]
+       html = eval(raw, binding)
+       
+       html.should eql "hello world"
+     end
+     
+     
+     it "should interpret \"${@foo}\" " do
+       raw = Renshi::Parser.parse(%Q!"${@foo}"!)
+       puts raw
+       @foo = "hello world"
+       html = eval(raw, binding)
+       
+       html.should eql %Q!"hello world"!
+     end
+    
+     class R
+       attr_accessor :path
+       
+       def initialize
+         @path = "/hello/world"
+       end
+     end
+     
+     it "should interpret <a href='{$r.path}'>hello</a>" do
+       r = R.new
+       raw = Renshi::Parser.parse(%Q!<a href="${r.path}">hello</a>!)
+       html = eval(raw, binding)
+       
+       html.should eql "<a href=\"#{r.path}\">hello</a>"
+     end
+     
+     it "should interpret $foo.nil?" do
+       foo = nil
+       raw = Renshi::Parser.parse("$foo.nil?")
+       html = eval(raw, binding)
+       
+       html.should eql true.to_s      
+     end    
+         
+     it "should interpret $@foo.nil?" do
+       @foo = nil
+       raw = Renshi::Parser.parse("$@foo.nil?")
+       html = eval(raw, binding)
+       
+       html.should eql true.to_s      
+     end    
+     
+     it "should interpret $a$b$c" do
+       a = 'a'; b = 'b'; c = 'c';
+       raw = Renshi::Parser.parse("$a$b$c")
+       html = eval(raw, binding)
+       
+       html.should eql "abc"
+     end
+     
+     it "should interpret $'foo'.upcase!" do
+         raw = Renshi::Parser.parse("$'foo'.upcase!")
+         html = eval(raw, binding)
+         
+         html.should eql "FOO"
+       end
+       
+       it "should interpret $Time.now.strftime('%I:%M')" do
+         raw = Renshi::Parser.parse("$Time.now.strftime('%I:%M')")
+         html = eval(raw, binding)
+         
+         html.should =~ /:/
+       end
+       
+       it "should evaluate ternary statements in the curly braces" do
+         foo = nil
+         raw = Renshi::Parser.parse("${foo.nil? ? '&gt;li&lt;hello&gt;/li&lt;' : '&gt;li&lt;goodbye&gt;/li&lt;'}")
+         html = eval(raw, binding)      
+         html.should =~ /hello/      
+         foo = ""
+         html = eval(raw, binding)      
+         html.should =~ /goodbye/            
+       end
+     
+     it "should interpret $foo until \n or end of element as ruby to string" do
+       raw = Renshi::Parser.parse("$'this should output as a string'")
+       html = eval(raw, binding)
+       
+       html.should =~ /this should output as a string/      
+     end
       
-      def initialize
-        @path = "/hello/world"
-      end
-    end
-    
-    it "should interpret <a href='{$r.path}'>hello</a>" do
-      r = R.new
-      raw = Renshi::Parser.parse(%Q!<a href="${r.path}">hello</a>!)
-      html = eval(raw, binding)
-      
-      html.should eql "<a href=\"#{r.path}\">hello</a>"
-    end
-    
-    it "should interpret $foo.nil?" do
-      foo = nil
-      raw = Renshi::Parser.parse("$foo.nil?")
-      html = eval(raw, binding)
-      
-      html.should eql true.to_s      
-    end    
-   
-    it "should interpret $@foo.nil?" do
-      @foo = nil
-      raw = Renshi::Parser.parse("$@foo.nil?")
-      html = eval(raw, binding)
-      
-      html.should eql true.to_s      
-    end    
-    
-    it "should interpret $a$b$c" do
-      a = 'a'; b = 'b'; c = 'c';
-      raw = Renshi::Parser.parse("$a$b$c")
-      html = eval(raw, binding)
-      
-      html.should eql "abc"
-    end
-    
-    it "should interpret $'foo'.upcase!" do
-      raw = Renshi::Parser.parse("$'foo'.upcase!")
-      html = eval(raw, binding)
-      
-      html.should eql "FOO"
-    end
-    
-    it "should interpret $Time.now.strftime('%I:%M')" do
-      raw = Renshi::Parser.parse("$Time.now.strftime('%I:%M')")
-      html = eval(raw, binding)
-      
-      html.should =~ /:/
-    end
-    
+     it "should interpret $^foo as the single phrase" do
+       raw = Renshi::Parser.parse("this should $^foo 'hello'")
+       foo = "say"
+       html = eval(raw, binding)
+       
+       html.should =~ /this should say 'hello'/      
+     end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: renshi
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors: 
 - Nicholas Faiz
@@ -9,7 +9,7 @@ autorequire: renshi
 bindir: bin
 cert_chain: []
 
-date: 2009-09-29 00:00:00 +10:00
+date: 2009-10-06 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency