personify 1.0.0

data/lib/personify/parser/personify.treetop

@@ -0,0 +1,107 @@
+grammar PersonifyLanguage
+
+  ##################
+  # Template parts
+  
+  rule template
+    (parts_including_tail)* <Template>
+  end
+  
+  rule parts_including_tail
+    part / tail_part
+  end
+  
+  rule part
+    text / substitutable
+  end
+  
+  rule tail_part
+    '[' part <TailPart>
+  end
+
+  
+  ##################
+  # Substitutable
+    
+  rule substitutable
+    '[' space expressions space ']' <Substitutable>
+  end
+  
+  ##################
+  # Blocks
+  
+  rule block
+    'DO' space ']' block_content '[' space 'END' <Block>
+  end
+  
+  rule block_content
+    (part)* <Literal>
+  end
+  
+  ##################
+  # Expressions
+  
+  rule expressions
+     expression alternatives:(space "|" space expression_or_string)* <Expressions>
+  end
+  
+  rule expression
+    function / logical / key / string
+  end
+  
+  rule expression_or_string
+    expression / implicit_string
+  end
+  
+  ##################
+  # Functions  
+  
+  rule function
+    key space "(" space parameters space ")" space block:(block)? <Function>
+  end
+      
+  rule parameters 
+    first_param:(expression_or_string)? more_expressions:(space "," space expression_or_string)* <Parameter>
+  end
+  
+  ##################
+  # Logical  
+  
+  rule logical
+    first_expression:(function / key / string) space operator:("||" / "&&") space next_expression:(expression) <Logical>
+  end
+  
+  ##################
+  # Keys  
+  
+  rule key
+    !reserved ([A-Z0-9] [A-Z0-9._]*) <Key>      
+  end
+  
+  rule reserved
+   "END" / "DO"
+  end
+  
+  ##################
+  # Literals
+  
+  rule string
+    '"' string_value '"' <PString>
+  end
+  
+  rule implicit_string
+    [^|\],)]+ <Literal>
+  end
+  
+  rule string_value
+    [^"]* <Literal>
+  end
+  
+  rule text
+    [^\[] [^\[]* <Literal>
+  end
+  
+  rule space
+    [ \n]*
+  end
+end

data/lib/personify/parser/personify_node_classes.rb

@@ -0,0 +1,121 @@
+module PersonifyLanguage
+  class Template < Treetop::Runtime::SyntaxNode
+    def eval(env={})
+      elements.map{|e| e.eval(env) }.join("")
+    end    
+  end
+
+  class TailPart  < Treetop::Runtime::SyntaxNode
+    def eval(env)
+      "[" + part.eval(env)
+    end
+  end
+  
+  class Substitutable < Treetop::Runtime::SyntaxNode
+    def eval(env)
+      # puts expressions.inspect
+      last_eval = expressions.eval(env)
+      if last_eval.nil?
+        text_value
+      else
+        last_eval
+      end
+    end    
+  end
+  
+  class Expressions < Treetop::Runtime::SyntaxNode
+    def eval(env)
+      last_value = nil
+      expressions.detect do |exp|
+        last_value = exp.eval(env)
+      end
+      last_value
+    end
+    
+    def expressions
+      [expression] + alternatives.elements.map {|elt| elt.expression_or_string}
+    end    
+  end
+  
+  class Key < Treetop::Runtime::SyntaxNode
+    def eval(env)
+      keys = self.to_s.split(".")
+      keys.inject(env){|acc,k| acc && acc[k] }
+    end
+          
+    def name
+      text_value
+    end
+    
+    def to_s
+      self.name.downcase.to_s
+    end    
+  end
+  
+  class PString < Treetop::Runtime::SyntaxNode
+    def eval(env={})
+      string_value.eval(env)
+    end    
+  end
+  
+  class Literal < Treetop::Runtime::SyntaxNode
+    def eval(env={})
+      text_value
+    end
+    
+    def to_s
+      text_value
+    end
+  end
+  
+  class Logical < Treetop::Runtime::SyntaxNode
+    def eval(env)
+      fe = first_expression.eval(env)
+      ne = next_expression.eval(env)
+      
+      case operator.text_value
+        when "&&" : fe && ne
+        when "||" : fe || ne
+      end
+    end    
+  end
+  
+  class Function < Treetop::Runtime::SyntaxNode
+    def eval(env={})
+      if env.respond_to?(:allow_method?) && env.allow_method?(key.to_s)
+        fn = env.method(key.to_s)
+      else 
+        fn = self.key.eval(env)
+      end
+      
+      if fn && fn.respond_to?(:call)
+        fn.call(*self.function_parameters(env))
+      else
+        fn
+      end
+    rescue StandardError
+      return nil
+    end
+    
+    def function_parameters(env)
+      values = parameters.eval(env)
+      values << self.block.eval(env) if self.block.kind_of?(Block)
+      values    
+    end     
+  end
+  
+  class Parameter < Treetop::Runtime::SyntaxNode
+    def eval(env={})
+      self.parameters.map{|param| param.eval(env) }
+    end
+    def parameters
+      (self.first_param.respond_to?(:eval) ? [first_param] : []) + more_expressions.elements.map {|elt| elt.expression_or_string}
+    end    
+  end
+  
+  class Block < Treetop::Runtime::SyntaxNode
+    def eval(env={})
+      block_content.to_s
+    end
+  end
+end

data/lib/personify/template.rb

@@ -0,0 +1,17 @@
+module Personify
+  class Template
+    
+    attr_reader :template
+    
+    def initialize(template)
+      parser = PersonifyLanguageParser.new
+      @template = parser.parse(template)
+    end
+    
+    def render(local_assigns={}, context = DefaultContext.new)
+      context.local_assigns = local_assigns
+      @template.eval(context)
+    end
+    
+  end
+end

data/lib/personify.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/../vendor/treetop/lib/treetop'
+require File.dirname(__FILE__) + '/personify/parser/personify_node_classes'
+require File.dirname(__FILE__) + '/personify/parser/personify'
+require File.dirname(__FILE__) + '/personify/template'
+require File.dirname(__FILE__) + '/personify/context'
+
+module Personify
+end

data/script/generate_parser.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + "/../vendor/treetop/lib/treetop"
+
+target_dir = File.dirname(__FILE__) + "/../lib/parser/"
+
+compiler = Treetop::Compiler::GrammarCompiler.new
+compiler.compile(File.join(target_dir,"personify.treetop"), File.join(target_dir,"personify.rb"))

data/test/context_test.rb

@@ -0,0 +1,122 @@
+require 'test_helper'
+require File.dirname(__FILE__) + "/../vendor/treetop/lib/treetop"
+Treetop.load "../lib/personify/parser/personify"
+# require File.dirname(__FILE__) + "/../personify"
+
+class ContextTest < Test::Unit::TestCase
+  include ParserTestHelper
+  
+  context "A Context class" do
+    setup do
+      @parser = PersonifyLanguageParser.new
+      
+      @c = Class.new(Personify::Context) do
+        def true
+          "true"
+        end
+        context_method :true
+        
+        def block(blk)
+          "|#{blk}|"
+        end
+        context_method :block
+        
+        def do_not_call
+          raise
+        end
+        
+      end
+    end
+    
+    
+    should "allow setting of local_assigns" do
+      @i = @c.new
+      assert @i.local_assigns = {:key => "value"}
+      assert @i.has_key?(:key)
+      assert_equal "value", @i[:key]
+    end
+    
+    should "allow calling of a context method" do
+      assert_equal "true", parse("[TRUE()]").eval(@c.new)
+    end
+    
+    should "not allow calling of non context methods" do
+      assert_equal "[DO_NOT_CALL()]", parse("[DO_NOT_CALL()]").eval(@c.new)
+    end
+    
+    should "allow calling of a context method with block" do
+      assert_equal "|out|", parse("[BLOCK(\"out\")]").eval(@c.new)
+      assert_equal "|out|", parse("[BLOCK() DO]out[END]").eval(@c.new)      
+    end
+    
+  end
+  
+  
+  context "The DefaultContext" do
+    setup do
+      @context = Personify::DefaultContext.new
+      @context.local_assigns = {"value" => "value", "empty" => "", "nil" => nil, "false" => false}
+      
+      @parser = PersonifyLanguageParser.new
+    end
+
+    context "if method" do
+          
+      should "accept 2 arguments" do
+        assert_equal "out", parse("[IF(\"true\", \"out\")]").eval(@context)
+        assert_equal "out", parse("[IF(\"true\") DO]out[END]").eval(@context)
+      end
+      
+      should "not raise exception with 1 argument" do
+        assert_nothing_raised do
+          parse("[IF(\"out\")]").eval(@context)
+        end
+      end
+            
+      should "not raise exception with more than 2 arguments" do
+        assert_nothing_raised do
+          parse("[IF(\"out\", \"2\", \"3\")]").eval(@context)
+        end
+      end
+            
+      should "return nil with one argument" do
+        assert_equal "[IF(\"out\")]", parse("[IF(\"out\")]").eval(@context)
+      end
+      
+      should "return nil with more than 2 arguments" do
+        assert_equal "[IF(\"out\", \"2\", \"3\")]", parse("[IF(\"out\", \"2\", \"3\")]").eval(@context)
+        assert_equal "test", parse("[IF(\"out\", \"2\", \"3\") | \"test\"]").eval(@context)        
+        assert_equal "[IF(\"out\",\"2\") DO]3[END]", parse("[IF(\"out\",\"2\") DO]3[END]").eval(@context)
+      end
+      
+      should "return second argument if first argument is not empty" do
+        assert_equal "out", parse("[IF(\"true\", \"out\")]").eval(@context)
+        assert_equal "out", parse("[IF(\"true\") DO]out[END]").eval(@context)        
+        assert_equal "out", parse("[IF(VALUE) DO]out[END]").eval(@context)
+        assert_equal "out", parse("[IF(EMPTY) DO]out[END]").eval(@context)        
+      end
+      
+      should "return nil if first argument is false" do
+        assert_equal "[IF(NIL) DO]out[END]", parse("[IF(NIL) DO]out[END]").eval(@context)
+        assert_equal "[IF(FALSE) DO]out[END]", parse("[IF(FALSE) DO]out[END]").eval(@context)
+        assert_equal "", parse("[IF(FALSE) DO]out[END | \"\"]").eval(@context)        
+      end
+      
+      should "be able to do if-elsif-else with | operator" do
+        templ = "[IF(THIS) DO]this[END | IF(THAT) DO]that[END | \"other\"]"
+
+        @context.local_assigns = {"this" => true, "that" => true}
+        assert_equal "this", parse(templ).eval(@context)
+        
+        @context.local_assigns = {"this" => false, "that" => true}
+        assert_equal "that", parse(templ).eval(@context)
+
+        @context.local_assigns = {"this" => false, "that" => false}
+        assert_equal "other", parse(templ).eval(@context)        
+      end
+      
+    end
+    
+  end
+  
+end

data/test/fixtures/multiple_tags.txt

@@ -0,0 +1,8 @@
+Lorem ipsum dolor sit amet, consectetuer adipiscing elit. In tristique sapien in tellus dapibus tincidunt. Ut eu tortor vitae quam eleifend lacinia. Nulla facilisi. Vivamus purus. Integer ultrices commodo pede. Sed rutrum, sapien vel tempor porta, turpis justo malesuada nisl, quis vestibulum leo augue laoreet [TAG3] lacus. Pellentesque mollis, ante ut sodales ullamcorper, erat tellus facilisis ipsum, et ornare urna nunc quis est. Etiam nibh elit, consectetuer nec, pretium eu, rutrum sed, arcu. Nunc sit amet metus nec orci consequat semper. Nullam iaculis felis vitae metus. Pellentesque molestie. Sed quis nisi ut eros placerat posuere. Aenean pellentesque nunc non arcu. Vivamus mauris. Nulla lorem. Curabitur tellus nisl, porta eget, vehicula eu, consequat id, tortor. Sed vitae est. Donec id diam eu tellus faucibus commodo. Aliquam vel turpis vel urna blandit malesuada. Nulla dui. "[TAG1]"
+
+Cras sit amet ante sit amet elit tincidunt fermentum. Vivamus hendrerit, nulla non elementum rutrum, nulla libero auctor nunc, vulputate malesuada nisi sapien non velit. Nam eu felis. Vivamus ac mi et ipsum egestas congue. Pellentesque eu odio vitae diam molestie venenatis. Sed eleifend nulla ut ipsum. Nam tincidunt ultrices neque. Duis erat. Sed ipsum arcu, laoreet eget, rutrum quis, accumsan at, arcu. Pellentesque eu ipsum a felis pulvinar laoreet.[TAG4] Sed viverra est vitae turpis. Maecenas tortor metus, aliquet et, ullamcorper auctor, mattis quis, leo. Lorem ipsum dolor sit amet, consectetuer adipiscing elit. [TAG3] Mauris ut eros sed ipsum facilisis nonummy. Fusce pretium, magna vestibulum semper nonummy, purus eros scelerisque mi, id luctus est nulla eget ante. Suspendisse quis nibh. Nullam pharetra tristique augue. Integer porta luctus ligula. Sed tincidunt.
+
+Fusce varius commodo lacus. Nullam tincidunt [TAG2] massa lobortis sapien. Sed turpis erat, hendrerit nec, fringilla eu, congue semper, tortor. Ut eget tellus sed mauris pellentesque imperdiet. Sed elementum dictum ipsum. Ut pharetra. Sed eleifend cras amet. 
+[TAG1][TAG1][TAG1][TAG1][TAG1][TAG1][TAG1][TAG1][TAG1][TAG1][TAG1][TAG1]
+
+[NONEXISTANT][NONEXISTANT][NONEXISTANT][NONEXISTANT][NONEXISTANT][NONEXISTANT]

data/test/parse_runner.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + "/../vendor/treetop/lib/treetop"
+
+require '../lib/parser/personify_node_classes'
+require '../lib/context'
+Treetop.load "../lib/parser/personify"
+
+# STR = "a [TAG] is never [TAG] with [TAG2] and [troepie] bla"
+# STR = "[A1|B1|\"str\"] [A1|B1|str] [AB(T1)]"
+# STR = "[AND(\"1\", 2,3)] <a href=\"http://mlr1.nl/r/[TOKEN]/539\"> financiële"
+# STR = "[FUN() DO]\nvalue\n[T1]\n[END | \"bla\"] bla [FUN() DO]OER![END | '']"
+# STR = "[IF(DETECT(FALSE,FALSE, TRUE)) DO]yes[END | \"\"]"
+STR = "[A || B]"
+# STR = "[TRUE DO]bla[END]"
+# STR = "[FUN()]"
+@parser = PersonifyLanguageParser.new
+
+class TheContext < Personify::DefaultContext
+  
+  context_method :if
+  
+  def detect(*statements)
+    statements.detect{|s| s }
+  end
+  context_method :detect  
+end
+
+def clean_tree(root_node)
+   return if(root_node.elements.nil?)
+   root_node.elements.delete_if{|node| node.class.name == "Treetop::Runtime::SyntaxNode" }
+   root_node.elements.each {|node| clean_tree(node) }
+end
+
+if result = @parser.parse(STR)
+  puts "done"
+  puts result  
+  puts "=" * 50  
+  # clean_tree(result)
+  puts result.inspect
+  puts "=" * 50
+  
+  t = TheContext.new
+  t.local_assigns  = {
+      "a" => "lA",
+      "b" => "lB",
+      "fun" => Proc.new{|p| "--#{p}--" },
+      "true" => true,
+      "false" => false,
+      "t1" => "tt",
+      "tag" => "henk", 
+      "ab" => Proc.new{|p| p.inspect },
+      "and" => Proc.new{|*c| c.join(" & ") }
+  }
+    
+  puts result.eval(t).inspect
+else
+  puts "FAIL"
+  puts @parser.inspect
+  puts "=" * 50
+  puts @parser.terminal_failures.join("\n")
+end