plasma 0.0.1 → 0.1.0

data/Rakefile

@@ -7,12 +7,12 @@ require 'rake/gempackagetask'
 
 gemspec = Gem::Specification.new do |s|
   s.name = "plasma"
-  s.version = "0.0.1"
+  s.version = "0.1.0"
   s.author = "Ryan Spangler"
   s.email = "patch_work8848@yahoo.com"
   s.homepage = "http://kaleidomedallion.com/plasma/"
   s.platform = Gem::Platform::RUBY
-  s.summary = "plasma --- a lightweight interpreted templating language in ruby"
+  s.summary = "plasma --- a lightweight interpreted templating language in treetop and ruby"
   s.files = FileList['README', 'Rakefile', "{test,lib,bin,doc,examples}/**/*"].to_a
   s.bindir = 'bin'
   s.executables = ['plasma']

data/lib/extras/plasma_view.rb

@@ -12,7 +12,13 @@ class PlasmaView
     end
     assigns.merge!(local_assigns)
     
-    plasma = Plasma::Template::PlasmaTemplate.parse(template)
-    plasma.render(assigns)
+    plasma = Plasma::Interpreter::PlasmaGrammarParser.new
+    env = Plasma::Interpreter::Env.new(assigns)
+
+    tree = plasma.parse(template)
+    tree.evaluate(env)
   end
 end
+
+
+

data/lib/plasma.rb

@@ -2,10 +2,12 @@ require 'rubygems'
 
 dir = File.dirname(__FILE__)
 
+PLASMA_LIB = dir
 PLASMA_ROOT = File.join(dir, 'plasma')
 PLASMA_PACKAGE_ROOT = File.expand_path(dir + '/..')
+PLASMA_TEST = File.join(PLASMA_PACKAGE_ROOT, 'test')
 
 require File.join(PLASMA_ROOT, 'interpreter')
-require File.join(PLASMA_ROOT, 'template')
+require File.join(PLASMA_LIB, 'extras/plasma_view')
 
 $LOAD_PATH.unshift(dir)

data/lib/plasma/include/plasma_core.rb

@@ -17,6 +17,10 @@ module Plasma
             else
               interp.evaluate(quote)
             end
+          end,
+
+          :parse => RubyClosure.new('parse', interp) do |code|
+            interp.parse(code)
           end
         }
       end

data/lib/plasma/interpreter/plasma_grammar.rb

@@ -4,7 +4,260 @@ module Plasma
       include Treetop::Runtime
 
       def root
-        @root || :plasma
+        @root || :template
+      end
+
+      module Template0
+        def macro
+          elements[0]
+        end
+
+        def tail
+          elements[1]
+        end
+      end
+
+      module Template1
+        def head
+          elements[0]
+        end
+
+        def body
+          elements[1]
+        end
+      end
+
+      def _nt_template
+        start_index = index
+        if node_cache[:template].has_key?(index)
+          cached = node_cache[:template][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0, s0 = index, []
+        s1, i1 = [], index
+        loop do
+          r2 = _nt_plain
+          if r2
+            s1 << r2
+          else
+            break
+          end
+        end
+        r1 = SyntaxNode.new(input, i1...index, s1)
+        s0 << r1
+        if r1
+          s3, i3 = [], index
+          loop do
+            i4, s4 = index, []
+            r5 = _nt_macro
+            s4 << r5
+            if r5
+              s6, i6 = [], index
+              loop do
+                r7 = _nt_plain
+                if r7
+                  s6 << r7
+                else
+                  break
+                end
+              end
+              r6 = SyntaxNode.new(input, i6...index, s6)
+              s4 << r6
+            end
+            if s4.last
+              r4 = (SyntaxNode).new(input, i4...index, s4)
+              r4.extend(Template0)
+            else
+              self.index = i4
+              r4 = nil
+            end
+            if r4
+              s3 << r4
+            else
+              break
+            end
+          end
+          r3 = SyntaxNode.new(input, i3...index, s3)
+          s0 << r3
+        end
+        if s0.last
+          r0 = (TemplateNode).new(input, i0...index, s0)
+          r0.extend(Template1)
+        else
+          self.index = i0
+          r0 = nil
+        end
+
+        node_cache[:template][start_index] = r0
+
+        return r0
+      end
+
+      def _nt_plain
+        start_index = index
+        if node_cache[:plain].has_key?(index)
+          cached = node_cache[:plain][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        if input.index(Regexp.new('[^\\[\\]`\']'), index) == index
+          r0 = (SyntaxNode).new(input, index...(index + 1))
+          @index += 1
+        else
+          r0 = nil
+        end
+
+        node_cache[:plain][start_index] = r0
+
+        return r0
+      end
+
+      def _nt_macro
+        start_index = index
+        if node_cache[:macro].has_key?(index)
+          cached = node_cache[:macro][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0 = index
+        r1 = _nt_quote
+        if r1
+          r0 = r1
+        else
+          r2 = _nt_expansion
+          if r2
+            r0 = r2
+          else
+            self.index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:macro][start_index] = r0
+
+        return r0
+      end
+
+      module Quote0
+        def template
+          elements[1]
+        end
+
+      end
+
+      def _nt_quote
+        start_index = index
+        if node_cache[:quote].has_key?(index)
+          cached = node_cache[:quote][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0, s0 = index, []
+        if input.index('`', index) == index
+          r1 = (SyntaxNode).new(input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('`')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          r2 = _nt_template
+          s0 << r2
+          if r2
+            if input.index('\'', index) == index
+              r3 = (SyntaxNode).new(input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('\'')
+              r3 = nil
+            end
+            s0 << r3
+          end
+        end
+        if s0.last
+          r0 = (QuoteNode).new(input, i0...index, s0)
+          r0.extend(Quote0)
+        else
+          self.index = i0
+          r0 = nil
+        end
+
+        node_cache[:quote][start_index] = r0
+
+        return r0
+      end
+
+      module Expansion0
+        def x
+          elements[1]
+        end
+
+        def plasma
+          elements[2]
+        end
+
+        def x
+          elements[3]
+        end
+
+      end
+
+      def _nt_expansion
+        start_index = index
+        if node_cache[:expansion].has_key?(index)
+          cached = node_cache[:expansion][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0, s0 = index, []
+        if input.index('[', index) == index
+          r1 = (SyntaxNode).new(input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('[')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          r2 = _nt_x
+          s0 << r2
+          if r2
+            r3 = _nt_plasma
+            s0 << r3
+            if r3
+              r4 = _nt_x
+              s0 << r4
+              if r4
+                if input.index(']', index) == index
+                  r5 = (SyntaxNode).new(input, index...(index + 1))
+                  @index += 1
+                else
+                  terminal_parse_failure(']')
+                  r5 = nil
+                end
+                s0 << r5
+              end
+            end
+          end
+        end
+        if s0.last
+          r0 = (ExpansionNode).new(input, i0...index, s0)
+          r0.extend(Expansion0)
+        else
+          self.index = i0
+          r0 = nil
+        end
+
+        node_cache[:expansion][start_index] = r0
+
+        return r0
       end
 
       def _nt_plasma
@@ -64,24 +317,29 @@ module Plasma
                               if r12
                                 r0 = r12
                               else
-                                r13 = _nt_date
+                                r13 = _nt_regex
                                 if r13
                                   r0 = r13
                                 else
-                                  r14 = _nt_time
+                                  r14 = _nt_date
                                   if r14
                                     r0 = r14
                                   else
-                                    r15 = _nt_str
+                                    r15 = _nt_time
                                     if r15
                                       r0 = r15
                                     else
-                                      r16 = _nt_num
+                                      r16 = _nt_str
                                       if r16
                                         r0 = r16
                                       else
-                                        self.index = i0
-                                        r0 = nil
+                                        r17 = _nt_num
+                                        if r17
+                                          r0 = r17
+                                        else
+                                          self.index = i0
+                                          r0 = nil
+                                        end
                                       end
                                     end
                                   end
@@ -364,46 +622,6 @@ module Plasma
         return r0
       end
 
-      module Quote0
-        def plasma
-          elements[1]
-        end
-      end
-
-      def _nt_quote
-        start_index = index
-        if node_cache[:quote].has_key?(index)
-          cached = node_cache[:quote][index]
-          @index = cached.interval.end if cached
-          return cached
-        end
-
-        i0, s0 = index, []
-        if input.index("'", index) == index
-          r1 = (SyntaxNode).new(input, index...(index + 1))
-          @index += 1
-        else
-          terminal_parse_failure("'")
-          r1 = nil
-        end
-        s0 << r1
-        if r1
-          r2 = _nt_plasma
-          s0 << r2
-        end
-        if s0.last
-          r0 = (QuoteNode).new(input, i0...index, s0)
-          r0.extend(Quote0)
-        else
-          self.index = i0
-          r0 = nil
-        end
-
-        node_cache[:quote][start_index] = r0
-
-        return r0
-      end
-
       module Defun0
         def x
           elements[1]
@@ -1171,7 +1389,7 @@ module Plasma
 
         s0, i0 = [], index
         loop do
-          if input.index(Regexp.new('[a-z+!/\\^&@?*%<>=_-]'), index) == index
+          if input.index(Regexp.new('[a-z+!\\^&@?*%<>=_-]'), index) == index
             r1 = (SyntaxNode).new(input, index...(index + 1))
             @index += 1
           else
@@ -1483,6 +1701,104 @@ module Plasma
         return r0
       end
 
+      module Regex0
+        def body
+          elements[1]
+        end
+
+      end
+
+      def _nt_regex
+        start_index = index
+        if node_cache[:regex].has_key?(index)
+          cached = node_cache[:regex][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0, s0 = index, []
+        if input.index('/', index) == index
+          r1 = (SyntaxNode).new(input, index...(index + 1))
+          @index += 1
+        else
+          terminal_parse_failure('/')
+          r1 = nil
+        end
+        s0 << r1
+        if r1
+          s2, i2 = [], index
+          loop do
+            r3 = _nt_regex_char
+            if r3
+              s2 << r3
+            else
+              break
+            end
+          end
+          r2 = SyntaxNode.new(input, i2...index, s2)
+          s0 << r2
+          if r2
+            if input.index('/', index) == index
+              r4 = (SyntaxNode).new(input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('/')
+              r4 = nil
+            end
+            s0 << r4
+          end
+        end
+        if s0.last
+          r0 = (RegexNode).new(input, i0...index, s0)
+          r0.extend(Regex0)
+        else
+          self.index = i0
+          r0 = nil
+        end
+
+        node_cache[:regex][start_index] = r0
+
+        return r0
+      end
+
+      def _nt_regex_char
+        start_index = index
+        if node_cache[:regex_char].has_key?(index)
+          cached = node_cache[:regex_char][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0 = index
+        if input.index('\\/', index) == index
+          r1 = (SyntaxNode).new(input, index...(index + 2))
+          @index += 2
+        else
+          terminal_parse_failure('\\/')
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          if input.index(Regexp.new('[^/]'), index) == index
+            r2 = (SyntaxNode).new(input, index...(index + 1))
+            @index += 1
+          else
+            r2 = nil
+          end
+          if r2
+            r0 = r2
+          else
+            self.index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:regex_char][start_index] = r0
+
+        return r0
+      end
+
       module Date0
         def s
           elements[0]
@@ -1747,14 +2063,10 @@ module Plasma
       end
 
       module Str0
-        def first
+        def body
           elements[1]
         end
 
-        def rest
-          elements[2]
-        end
-
       end
 
       def _nt_str
@@ -1775,45 +2087,26 @@ module Plasma
         end
         s0 << r1
         if r1
-          if input.index(Regexp.new('[^"]'), index) == index
-            r3 = (SyntaxNode).new(input, index...(index + 1))
-            @index += 1
-          else
-            r3 = nil
-          end
-          if r3
-            r2 = r3
-          else
-            r2 = SyntaxNode.new(input, index...index)
+          s2, i2 = [], index
+          loop do
+            r3 = _nt_str_char
+            if r3
+              s2 << r3
+            else
+              break
+            end
           end
+          r2 = SyntaxNode.new(input, i2...index, s2)
           s0 << r2
           if r2
-            s4, i4 = [], index
-            loop do
-              if input.index(Regexp.new('[^"]'), index) == index
-                r5 = (SyntaxNode).new(input, index...(index + 1))
-                @index += 1
-              else
-                r5 = nil
-              end
-              if r5
-                s4 << r5
-              else
-                break
-              end
+            if input.index('"', index) == index
+              r4 = (SyntaxNode).new(input, index...(index + 1))
+              @index += 1
+            else
+              terminal_parse_failure('"')
+              r4 = nil
             end
-            r4 = SyntaxNode.new(input, i4...index, s4)
             s0 << r4
-            if r4
-              if input.index('"', index) == index
-                r6 = (SyntaxNode).new(input, index...(index + 1))
-                @index += 1
-              else
-                terminal_parse_failure('"')
-                r6 = nil
-              end
-              s0 << r6
-            end
           end
         end
         if s0.last
@@ -1829,6 +2122,44 @@ module Plasma
         return r0
       end
 
+      def _nt_str_char
+        start_index = index
+        if node_cache[:str_char].has_key?(index)
+          cached = node_cache[:str_char][index]
+          @index = cached.interval.end if cached
+          return cached
+        end
+
+        i0 = index
+        if input.index('\\"', index) == index
+          r1 = (SyntaxNode).new(input, index...(index + 2))
+          @index += 2
+        else
+          terminal_parse_failure('\\"')
+          r1 = nil
+        end
+        if r1
+          r0 = r1
+        else
+          if input.index(Regexp.new('[^"]'), index) == index
+            r2 = (SyntaxNode).new(input, index...(index + 1))
+            @index += 1
+          else
+            r2 = nil
+          end
+          if r2
+            r0 = r2
+          else
+            self.index = i0
+            r0 = nil
+          end
+        end
+
+        node_cache[:str_char][start_index] = r0
+
+        return r0
+      end
+
       module Num0
       end
 
@@ -1837,7 +2168,7 @@ module Plasma
           elements[0]
         end
 
-        def expansion
+        def decimal
           elements[1]
         end
       end

data/lib/plasma/interpreter/plasma_grammar.treetop

@@ -1,8 +1,28 @@
 module Plasma
   module Interpreter
     grammar PlasmaGrammar
+      rule template
+        head:(plain)* body:(macro tail:(plain)*)* <TemplateNode>
+      end
+
+      rule plain
+        [^\[\]`']     #`
+      end
+
+      rule macro
+        quote / expansion
+      end
+
+      rule quote
+        '`' template '\'' <QuoteNode>
+      end
+
+      rule expansion
+        '[' x plasma x ']' <ExpansionNode>
+      end
+
       rule plasma
-        decl / seq / quote / defun / def / fun / if / apply / bool / sym / hash / list / date / time / str / num
+        decl / seq / quote / defun / def / fun / if / apply / bool / sym / hash / list / regex / date / time / str / num
       end
 
       rule decl
@@ -13,10 +33,6 @@ module Plasma
         '(' x first:plasma? rest:(s '|' s plasma)* x ')' <SeqNode>
       end
 
-      rule quote
-        "'" plasma <QuoteNode>
-      end
-
       rule defun
         '(' x 'defun' s params s plasma x ')' <DefunNode>
       end
@@ -46,7 +62,7 @@ module Plasma
       end
 
       rule sym
-        [a-z+!/\^&@?*%<>=_-]+  <SymNode>
+        [a-z+!\^&@?*%<>=_-]+  <SymNode>
       end
 
       rule hash
@@ -61,6 +77,14 @@ module Plasma
         '[' x first:plasma? rest:(s plasma)* x ']' <ListNode>
       end
 
+      rule regex
+        '/' body:(regex_char)* '/' <RegexNode>
+      end
+
+      rule regex_char
+        '\\/' / [^/]
+      end
+
       rule date
         year [-] month:dual [-] day:dual (s time)? <DateNode>
       end
@@ -78,11 +102,15 @@ module Plasma
       end
 
       rule str
-        '"' first:([^"])? rest:([^"])* '"' <StrNode>
+        '"' body:(str_char)* '"' <StrNode>
+      end
+
+      rule str_char
+        '\\"' / [^"]         #"
       end
 
       rule num
-        whole:([0-9]+) expansion:('.' [0-9]+)? <NumNode>
+        whole:([0-9]+) decimal:('.' [0-9]+)? <NumNode>
       end
 
       rule x

data/lib/plasma/interpreter/plasma_grammarnode.rb

@@ -37,6 +37,20 @@ module Plasma
         self
       end
 
+      def scope(inner={})
+        self.scope!(inner)
+
+        begin
+          value = yield self
+          self.release!
+
+          return value
+        rescue => detail
+          self.release!
+          detail
+        end
+      end
+
       def resolve(key)
         @state.reverse_each do |layer|
           return layer[key] if layer.include?(key)
@@ -55,11 +69,11 @@ module Plasma
       end
 
       def unquote(env)
-        @unevaluated.eval(env)
+        @unevaluated.evaluate(env)
       end
 
       def to_plasma
-        "'#{@unevaluated.text_value}"
+        "`#{@unevaluated.text_value}'"
       end
     end
 
@@ -80,11 +94,9 @@ module Plasma
         zipped.merge!(:env => @env)
 
         if left.empty?
-          @env.scope!(zipped)
-          value = @body.evaluate(@env)
-          @env.release!()
-
-          return value
+          @env.scope(zipped) do |env|
+            @body.evaluate(env)
+          end
         else
           return Closure.new(@env.dup.merge!(zipped), left, body)
         end
@@ -121,7 +133,7 @@ module Plasma
           keys = fresh.keys.join(' ')
           env = Env.new(fresh.merge(@name => self))
 
-          interp.interpret("fun (#{params}) ((#{@name} #{keys} #{params}))", env)
+          interp.interpret("fun (#{params}) (#{@name} #{keys} #{params})", env)
         end
       end
     end
@@ -174,30 +186,57 @@ module Plasma
       end
     end
 
-    class DeclNode < ColNode
+    class Treetop::Runtime::SyntaxNode
+      def to_s
+        text_value
+      end
+    end
+
+    class TemplateNode < PlasmaNode
       def evaluate(env)
-        value = col.inject(nil) do |value, statement|
-          statement.evaluate(env)
+        value = body.empty? ? '' : body.elements.inject('') do |so_far, el|
+          macro_value = el.macro.is_a?(ExpansionNode) ? el.macro.evaluate(env).to_s : el.macro.template.text_value
+          tail_value = el.respond_to?(:tail) ? el.tail.text_value : ''
+
+          so_far + macro_value + tail_value
         end
-        value
+        head.text_value + value
       end
     end
 
-    class SeqNode < ColNode
+    class PlainNode < PlasmaNode
       def evaluate(env)
-        env.scope!
-        value = col.inject(nil) do |value, statement|
+        self.text_value
+      end
+    end
+
+    class QuoteNode < PlasmaNode
+      def evaluate(env)
+        template.evaluate(env)
+      end
+    end
+
+    class ExpansionNode < PlasmaNode
+      def evaluate(env)
+        plasma.evaluate(env)
+      end
+    end
+
+    class DeclNode < ColNode
+      def evaluate(env)
+        col.inject(nil) do |value, statement|
           statement.evaluate(env)
         end
-        env.release!
-
-        value
       end
     end
 
-    class QuoteNode < PlasmaNode
+    class SeqNode < ColNode
       def evaluate(env)
-        plasma
+        env.scope do |env|
+          col.inject(nil) do |value, statement|
+            statement.evaluate(env)
+          end
+        end
       end
     end
 
@@ -207,7 +246,7 @@ module Plasma
         closure = Closure.new(env, syms.slice(1..syms.length), plasma)
         closure.env.merge!(syms[0] => closure)
         env.bind!(syms[0], closure)
-        closure
+        ''
       end
     end
 
@@ -215,7 +254,7 @@ module Plasma
       def evaluate(env)
         value = plasma.evaluate(env)
         env.bind!(sym.text_value.to_sym, value)
-        value
+        ''
       end
     end
 
@@ -305,6 +344,12 @@ module Plasma
       end
     end
 
+    class RegexNode < PlasmaNode
+      def evaluate(env)
+        Regexp.new(body.text_value)
+      end
+    end
+
     class DateNode < PlasmaNode
       def evaluate(env)
       end
@@ -315,15 +360,19 @@ module Plasma
       end
     end
 
-    class StrNode < ColNode
+    class StrNode < PlasmaNode
       def evaluate(env)
-        self.text_value.slice(1...self.text_value.length-1)
+        body.text_value
       end
     end
 
     class NumNode < PlasmaNode
       def evaluate(env)
-        text_value.to_f
+        if self.respond_to?(:decimal)
+          text_value.to_f
+        else
+          text_value.to_i
+        end
       end
     end
   end

data/lib/plasma/interpreter/plasma_interpreter.rb

@@ -5,6 +5,8 @@ module Plasma
 
       def initialize
         @prompt = "-----|  "
+        @comment = /##*[^#]+##*/
+
         @dir = File.dirname(__FILE__)
         @load_path = [File.join(PLASMA_ROOT, 'include'), PLASMA_PACKAGE_ROOT, @dir]
 
@@ -67,6 +69,10 @@ module Plasma
         raise NoSuchSourceException.new(plasma), "no such source #{plasma}", caller
       end
       
+      def strip(code)
+        code.gsub(@comment, '').strip
+      end
+
       def parse(code)
         tree = @plasma.parse(code)
         raise FailedToParseException.new, "failed to parse #{code}", caller if tree.nil? 
@@ -75,12 +81,12 @@ module Plasma
       end
 
       def evaluate(tree, env=nil)
-        env = @env if env.nil?
+        env ||= @env
         tree.evaluate(env)
       end
 
       def interpret(code, env=nil)
-        tree = parse(code)
+        tree = parse(strip(code))
         evaluate(tree, env)
       end
 
@@ -88,14 +94,18 @@ module Plasma
         while true
           begin
             STDOUT.write(@prompt)
+
             input = STDIN.readline.strip
-            break if input == 'quit' or input == 'exit'
+            unless input.empty?
 
-            value = interpret input
+              value = interpret input
 
-            STDOUT.write("  #{value.to_plasma}\n")
+              STDOUT.write("  #{value.to_plasma}\n")
+            end
+          rescue EOFError => e
+            break
           rescue Exception => e
-            STDOUT.write("  #{e.to_s}\n")
+            STDOUT.write("  #{e}\n")
           end
         end
       end

data/lib/plasma/interpreter/polychoron_grammar.treetop

@@ -0,0 +1,19 @@
+module Plasma
+  module Interpreter
+    grammar PolychoronGrammar
+      include plasma
+
+      rule template
+        first:plain? rest:('[' s body:polychoron s ']' tail:plain?)* <TemplateNode>
+      end
+
+      rule plain
+        [^[`]+ <PlainNode>                 #`
+      end
+
+      rule polychoron
+        plasma
+      end
+    end
+  end
+end

data/lib/plasma/template/plasma_template.rb

@@ -1,7 +1,9 @@
 module Plasma
   module Template
     class PlasmaTemplate
-      @@separator = /\|\|/
+      attr_accessor :plasma
+
+      @@separator = /##*[^#]+##*/
 
       def self.parse(template)
         return PlasmaTemplate.new(template)
@@ -40,8 +42,8 @@ module Plasma
         end
       end
 
-      def render(env={})
-        @plasma.env.merge!(env)
+      def render(rel={})
+        @plasma.env.merge!(rel)
         evaluated = @plasmic.map{|p| @plasma.evaluate(p)}
 
         rendered = ''
@@ -55,3 +57,5 @@ module Plasma
     end
   end
 end
+
+

data/test/hanoi.plasma

@@ -0,0 +1,18 @@
+[(def move 
+   (fun (a b) `move disk from [a] to [b]
+' ))]
+
+[(def do_hanoi 
+   (fun (a b c d) 
+     (if (<= a 1) 
+      then (move b c)
+      else `[(do_hanoi (- a 1) b d c)][(move b c)][(do_hanoi (- a 1) d c b)]')))]
+
+[(def hanoi 
+   (fun (n) 
+     (do_hanoi n "source" "destination" "auxillary"))) ]
+
+[(def levels 5)]
+
+Tower of Hanoi ([levels] levels)
+[(hanoi 5)]

data/test/parse_test.rb

@@ -0,0 +1,49 @@
+require 'lib/plasma.rb'
+
+plasma = Plasma::Interpreter::PlasmaGrammarParser.new
+
+decl = "[| `eiii' | 1233333 | def xxx 5 |]"
+declb = "[xxx]"
+seq = "[(`oeheo' | 238 | 11)]"
+quote = "[`(333333)']"
+define = "[(def a 2121212 | a)]"
+defun = "[(defun (ff x) (* x 13) | (ff 14))]"
+fun = "[(fun (x c) (+ x c))]"
+apply1 = "[(+ 11 14)]"
+apply2 = "[((fun (x c) (+ x c)) 11 14)]"
+curry = "[(def aaa ((fun (a b) (* a b)) 3) | (aaa 11))]"
+sym = "[(def tatao+ht-o*he<>i==== 555 | tatao+ht-o*he<>i====)]"
+hash = "[{yayay:77777 rrr:111}]"
+list = "[[11 33 449]]"
+regex = "[/[^7]*777\\/88?/]"
+date = "[3409-65-22]"
+time = "[55:32:18]"
+str = '["yaodui iw\"fhoeo"]'
+num = "[444.22]"
+test = "[| def yar (fun (x) (* 3 x)) |
+  def peanut (fun (y z) (/ (- y z) z)) |
+  (peanut (yar 66) 12) |]"
+bad = "[(999)(888)]"
+cond = "[(if (> xxx 13) then 12 else [3 3 5 3])]"
+
+template = "ol[(* 3 8)] weee!  [(* \"okok\" 5)] okoko NO   no way okay but [\"how about now\"] yes?"    #"
+template2 = "yayayay``nonono'ya'yayay"
+
+env = Plasma::Interpreter::Env.new
+
+
+statements = []
+statements += [seq, quote, define, defun, fun, apply1, apply2, 
+               sym, hash, list, regex, date, time, str, num, test, 
+               decl, declb, defun, bad, curry, cond]
+
+statements += [template, template2]
+
+
+
+statements.each do |statement|
+  parsed = plasma.parse(statement)
+  evaluated = parsed.nil? ? "does not parse" : parsed.evaluate(env).to_plasma
+
+  puts "#{statement} -> #{parsed.class} : #{evaluated}"
+end

data/test/template_test.plasma

@@ -0,0 +1,42 @@
+okay so we are starting out clear 
+
+[( def fi 3 )]
+[( def ya (fun (x) (* x 3)) )]
+[( def ikik (map ["rrr" "uiowoyqpp i " fi "nogo deetdelowu"] ya) )]
+[( * 55 12 )]
+[( join ikik " " )]
+
+continuing on now...  maybe I will throw in a [(* 3 5)] just for fun.  Yes?
+what about Ifs, and loops?  All about control flow.
+
+[( if (true) 
+   then `what??  [(* "yes" 14)] Really?'
+   else `yes really.' )] 
+
+So that almost makes sense.  The grouping should really be more clear though.
+maybe something with a directional brace, something like {{ maybe? }}
+
+no.
+
+[( def new (fun (x) (x "lalala")) )]
+[( def thing (fun (y) (concat (* y 3) " dogono")) )]
+[( def x "palatial" )]
+
+So it will go like this... [( new thing )] and maybe another 
+[( if (> x "borox") 
+   then `this could happen if [ x ] was defined they would all be substit[`u']ted' 
+   else (* 3 11) )]
+And maybe a function could go 
+[( def follow (fun (x) `okay now this is plain text again?  How did [x] that happen?  I guess in the quote???') )]
+now we go along for a while and end up with a call to [( follow 3 )] and end up with something significant?  So the scopes switch back and forth?  That cant be right!
+
+Okay, calling the macro and quoting are two different things.  They must be treated differently.   Okay
+
+
+Now for some tricky shit:
+
+[( def dog `now a thing for [( thing `yes maybe just [x] ' )] and some more' )]
+[( dog )]
+
+
+

data/test/template_test.rb

@@ -0,0 +1,9 @@
+require 'lib/plasma.rb'
+
+template = File.open(File.join(PLASMA_TEST, ARGV[0])).read
+plasma = Plasma::Interpreter::PlasmaGrammarParser.new
+
+env = Plasma::Interpreter::Env.new
+
+p = plasma.parse template
+puts p.evaluate(env)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: plasma
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - Ryan Spangler
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-04 00:00:00 -07:00
+date: 2008-08-18 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,9 +32,12 @@ extra_rdoc_files: []
 files: 
 - README
 - Rakefile
+- test/hanoi.plasma
 - test/import_test.plasma
-- test/plasmatest.rb
+- test/parse_test.rb
 - test/plasmic.plasma
+- test/template_test.plasma
+- test/template_test.rb
 - lib/extras
 - lib/extras/plasma_view.rb
 - lib/plasma
@@ -47,6 +50,7 @@ files:
 - lib/plasma/interpreter/plasma_grammar.treetop
 - lib/plasma/interpreter/plasma_grammarnode.rb
 - lib/plasma/interpreter/plasma_interpreter.rb
+- lib/plasma/interpreter/polychoron_grammar.treetop
 - lib/plasma/interpreter.rb
 - lib/plasma/template
 - lib/plasma/template/plasma_template.rb
@@ -78,6 +82,6 @@ rubyforge_project: plasma
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
-summary: plasma --- a lightweight interpreted templating language in ruby
+summary: plasma --- a lightweight interpreted templating language in treetop and ruby
 test_files: []
 

data/test/plasmatest.rb

@@ -1,37 +0,0 @@
-require 'lib/plasma.rb'
-
-plasma = Plasma::Interpreter::PlasmaGrammarParser.new
-
-decl = "| 'eiii | 1233333 | (def xxx 5) |"
-declb = "xxx"
-seq = "('oeheo | 238 | 11)"
-quote = "'(333333)"
-define = "((def a 2121212) | a)"
-defun = "(defun (ff x) (* x 13))"
-fun = "(fun (x c) (+ x c))"
-apply1 = "(+ 11 14)"
-apply2 = "((fun (x c) (+ x c)) 11 14)"
-curry = "((def aaa ((fun (a b) (* a b)) 3)) | (aaa 11))"
-sym = "((def tatao+ht-o*he<>i==== 555) | tatao+ht-o*he<>i====)"
-hash = "{yayay:77777 rrr:111}"
-list = "[11 33 449]"
-date = "3409-65-22"
-time = "55:32:18"
-str = '"yaodui iwfhoeo"'
-num = "444.22"
-test = "| (def yar (fun (x) (* 3 x))) |
-  (def peanut (fun (y z) (/ (- y z) z))) |
-  (peanut (yar 66) 12) |"
-bad = "(999)(888)"
-env = Plasma::Interpreter::Env.new
-
-
-statements = [seq, quote, define, defun, fun, apply1, apply2, 
-              sym, hash, list, date, time, str, num, test, 
-              decl, declb, defun, bad, curry]
-statements.each do |statement|
-  parsed = plasma.parse(statement)
-  evaluated = parsed.nil? ? "does not parse" : parsed.evaluate(env).to_plasma
-
-  puts "#{statement} -> #{parsed} : #{evaluated}"
-end