skylinecms 3.1.0 → 3.2.0

data/vendor/digitpaint/personify/lib/parser/personify.treetop

@@ -1,126 +0,0 @@
-grammar PersonifyLanguage
-  rule template
-    (part)* {
-      def eval(env={})
-        elements.map{|e| e.eval(env) }.join("")
-      end
-    }
-  end
-  
-  rule part
-    text / substitutable / tail_part
-  end
-  
-  rule tail_part
-    '[' part {
-      def eval(env)
-        "[" + part.eval(env)
-      end
-    }
-  end
-
-  rule substitutable
-    '[' space expressions space ']' {
-      def eval(env)
-        last_eval = expressions.eval(env)
-        if last_eval.nil?
-          text_value
-        else
-          last_eval
-        end
-      end
-    }
-  end
-  
-  rule expressions
-     expression alternatives:(space "|" space expression_or_string)* {
-      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
-  
-  rule expression
-    function / key
-  end
-  
-  rule expression_or_string
-    expression / string
-  end
-  
-  rule function
-    key space "(" space parameters space ")" {
-      def eval(env={})
-        if fn = key.eval(env)
-          if fn.respond_to?(:call)
-            values = parameters.eval(env)
-            fn.call(*values)
-          else
-            fn
-          end
-        end
-      end
-    }
-  end
-  
-  rule parameters 
-    expression_or_string more_expressions:(space "," space expression_or_string)* {
-      def eval(env={})
-        self.parameters.map{|param| param.eval(env) }
-      end
-      def parameters
-        [expression_or_string] + more_expressions.elements.map {|elt| elt.expression_or_string}
-      end
-    }
-  end
-  
-  rule key
-    [A-Z] [A-Z0-9]+ {      
-      def eval(env)
-        env[self.to_s]
-      end
-            
-      def name
-        text_value
-      end
-      
-      def to_s
-        self.name.downcase.to_s
-      end
-    }
-  end  
-  
-  rule string
-    '"' string_value '"' {
-      def eval(env={})
-        string_value.eval(env)
-      end
-    }
-    /
-    implicit_string
-  end
-  
-  rule implicit_string
-    [^|\],)]* <Literal>
-  end
-  
-  rule string_value
-    [^"]* <Literal>
-  end
-  
-  rule text
-    [^\[] [^\[]* <Literal>
-  end
-  
-  rule space
-    [ \n]*
-  end
-end

data/vendor/digitpaint/personify/lib/parser/personify_node_classes.rb

@@ -1,7 +0,0 @@
-module PersonifyLanguage
-  class Literal < Treetop::Runtime::SyntaxNode
-    def eval(env={})
-      text_value
-    end
-  end
-end

data/vendor/digitpaint/personify/lib/template.rb

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

data/vendor/digitpaint/personify/personify.rb

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

data/vendor/digitpaint/personify/script/generate_parser.rb

@@ -1,6 +0,0 @@
-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/vendor/digitpaint/personify/test/fixtures/multiple_tags.txt

@@ -1,8 +0,0 @@
-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/vendor/digitpaint/personify/test/parse_runner.rb

@@ -1,25 +0,0 @@
-require File.dirname(__FILE__) + "/../vendor/treetop/lib/treetop"
-
-require '../lib/parser/personify_node_classes'
-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"
-@parser = PersonifyLanguageParser.new
-
-if result = @parser.parse(STR)
-  puts "done"
-  puts result  
-  puts result.inspect
-  puts result.eval(
-    :t1 => "tt",
-    :tag => "henk", 
-    :ab => Proc.new{|p| p.inspect },
-    :and => Proc.new{|*c| c.join(" & ") }
-    ).inspect
-else
-  puts "FAIL"
-  puts @parser.inspect
-  puts @parser.terminal_failures.join("\n")
-end

data/vendor/digitpaint/personify/test/parser_test.rb

@@ -1,109 +0,0 @@
-require 'test_helper'
-require File.dirname(__FILE__) + "/../vendor/treetop/lib/treetop"
-Treetop.load "../lib/parser/personify"
-# require File.dirname(__FILE__) + "/../personify"
-
-class ParserTest < Test::Unit::TestCase
-  include ParserTestHelper
-  context "The parser" do
-    setup do
-      @parser = PersonifyLanguageParser.new
-    end
-    context "parsing text" do
-      should "eval text" do
-        assert_equal "text", parse("text").eval()
-        assert_equal "t", parse("t").eval()
-        assert_equal "t\n1\n2", parse("t\n1\n2").eval()       
-      end
-      
-      should "eval UTF8 text" do
-        assert_equal "financiële", parse("financiële").eval()
-      end
-  
-      should "eval empty text" do
-        assert_equal "", parse("").eval()
-      end
-  
-      should "eval '[bla]' as text" do
-        assert_equal "[bla]", parse("[bla]").eval()
-      end
-
-      should "eval '[KE bla' as text" do
-        assert_equal "[KE bla", parse("[KE bla").eval()
-      end
-
-      should "eval nested brackets as text" do
-        assert_equal "[[BLA]]", parse("[[BLA]]").eval
-      end
-
-      should "eval '[BLA]' as text on nil 'bla' " do
-        assert_equal "[BLA]", parse("[BLA]").eval()
-      end
-    end
-    context "parsing expressions" do  
-      should "eval simple expression" do
-        assert_equal "var", parse("[VAR]").eval("var" => "var")
-        assert_equal "a var b", parse("a [VAR] b").eval("var" => "var")
-        assert_equal "var\nvar", parse("[VAR]\n[VAR]").eval("var" => "var")              
-      end
-      
-      should "eval simple expression with empty substitution" do
-        assert_equal "", parse("[VAR]").eval("var" => "")
-      end
-      
-      should "eval expressions careless of whitespace" do
-        assert_equal "k1",parse("[ K1]").eval("k1" => "k1")
-        assert_equal "k1",parse("[ K1 ]").eval("k1" => "k1")
-        assert_equal "k1",parse("[K1 | K2]").eval("k1" => "k1")
-      end   
-     
-      context "with alternatives" do    
-        should "eval alternative expression on first empty" do       
-          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
-          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
-          assert_equal "k3", parse("[K1|K2|K3]").eval("k1" => nil,"k2" => nil, "k3" => "k3")
-        end
-
-        should "eval first expression on first nonempty" do       
-          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
-          assert_equal "k2", parse("[K1|K2]").eval("k2" => "k2")
-          assert_equal "k3", parse("[K1|K2|K3]").eval("k2" => nil, "k3" => "k3")
-        end     
-
-        should "eval strings in alternative expression" do 
-          assert_equal "str", parse("[K1|str]").eval
-          assert_equal "str", parse("[K1|\"str\"]").eval
-          assert_equal "str", parse("[K1|\"str\"]").eval          
-          assert_equal " str", parse("[K1|\" str\"]").eval
-        end
-        
-        should "eval implicit strings in alternative expression" do 
-          assert_equal "str", parse("[K1|str]").eval
-        end        
-      end
-      
-      context "with function" do
-        should "eval with single parameter" do
-          assert_equal "v", parse("[FUNC(K1)]").eval("func" => Proc.new{|v| v }, "k1" => "v")
-        end
-        should "eval with multiple parameters" do
-          assert_equal "v1v2", parse("[FUNC(K1,K2)]").eval("func" => Proc.new{|*v| v.join }, "k1" => "v1", "k2" => "v2")
-        end
-        should "eval with string parameters" do
-          assert_equal "str", parse("[FUNC(\"str\")]").eval("func" => Proc.new{|v| v }, "k1" => "v1", "k2" => "v2")
-        end
-        should "eval with implicit string parameters" do
-          assert_equal "str", parse("[FUNC(str)]").eval("func" => Proc.new{|v| v }, "k1" => "v1", "k2" => "v2")
-        end        
-        should "eval with too much parameters" do
-          assert_equal "v1+v2v3", parse("[FUNC(\"v1\",\"v2\",\"v3\")]").eval("func" => Proc.new{|v1,*v2| v1 + "+" + v2.join })
-        end
-        should "eval with alternative expression" do
-          assert_equal "fb", parse("[FUNC()|\"fb\"]").eval("func" => Proc.new{ false })
-          assert_equal "fb", parse("[FUNC()|\"fb\"]").eval("func" => Proc.new{ nil })
-        end
-      end
-      
-    end
-  end
-end

data/vendor/digitpaint/personify/test/test_helper.rb

@@ -1,16 +0,0 @@
-require 'rubygems'
-require 'shoulda'
-require File.dirname(__FILE__) + "/../personify"
-
-require 'test/unit'
-
-module ParserTestHelper
-  def parse(input)
-    result = @parser.parse(input)
-    unless result
-      puts @parser.terminal_failures.join("\n")
-    end
-    assert !result.nil?
-    result
-  end
-end

data/vendor/digitpaint/personify/vendor/treetop/.gitignore

@@ -1,5 +0,0 @@
-*.gem
-*.iml
-*.iws
-*.ipr
-doc/site/*.*

data/vendor/digitpaint/personify/vendor/treetop/History.txt

@@ -1,9 +0,0 @@
-== 1.2.5 2009-03-10
-
-* 1 minor enhancement:
-  * Extensions may always be modules, instead of sometimes modules, sometimes classes
-
-== 0.0.1 2008-05-21
-
-* 1 major enhancement:
-  * Initial release

data/vendor/digitpaint/personify/vendor/treetop/README

@@ -1,164 +0,0 @@
-Tutorial
-========
-Languages can be split into two components, their *syntax* and their *semantics*. It's your understanding of English syntax that tells you the stream of words "Sleep furiously green ideas colorless" is not a valid sentence. Semantics is deeper. Even if we rearrange the above sentence to be "Colorless green ideas sleep furiously", which is syntactically correct, it remains nonsensical on a semantic level. With Treetop, you'll be dealing with languages that are much simpler than English, but these basic concepts apply. Your programs will need to address both the syntax and the semantics of the languages they interpret.
-
-Treetop equips you with powerful tools for each of these two aspects of interpreter writing. You'll describe the syntax of your language with a *parsing expression grammar*. From this description, Treetop will generate a Ruby parser that transforms streams of characters written into your language into *abstract syntax trees* representing their structure. You'll then describe the semantics of your language in Ruby by defining methods on the syntax trees the parser generates.
-
-Parsing Expression Grammars, The Basics
-=======================================
-The first step in using Treetop is defining a grammar in a file with the `.treetop` extension. Here's a grammar that's useless because it's empty:
-    
-    # my_grammar.treetop
-    grammar MyGrammar
-    end
-
-Next, you start filling your grammar with rules. Each rule associates a name with a parsing expression, like the following:
-
-    # my_grammar.treetop
-    # You can use a .tt extension instead if you wish
-    grammar MyGrammar
-      rule hello
-        'hello chomsky'
-      end
-    end
-
-The first rule becomes the *root* of the grammar, causing its expression to be matched when a parser for the grammar is fed a string. The above grammar can now be used in a Ruby program. Notice how a string matching the first rule parses successfully, but a second nonmatching string does not.
-
-    # use_grammar.rb
-    require 'rubygems'
-    require 'treetop'
-    Treetop.load 'my_grammar'
-    # or just:
-    # require 'my_grammar'                     # This works because Polyglot hooks "require" to find and load Treetop files
-    
-    parser = MyGrammarParser.new
-    puts parser.parse('hello chomsky')         # => Treetop::Runtime::SyntaxNode
-    puts parser.parse('silly generativists!')  # => nil
-
-Users of *regular expressions* will find parsing expressions familiar. They share the same basic purpose, matching strings against patterns. However, parsing expressions can recognize a broader category of languages than their less expressive brethren. Before we get into demonstrating that, lets cover some basics. At first parsing expressions won't seem much different. Trust that they are.
-
-Terminal Symbols
-----------------
-The expression in the grammar above is a terminal symbol. It will only match a string that matches it exactly. There are two other kinds of terminal symbols, which we'll revisit later. Terminals are called *atomic expressions* because they aren't composed of smaller expressions.
-
-Ordered Choices
----------------
-Ordered choices are *composite expressions*, which allow for any of several subexpressions to be matched. These should be familiar from regular expressions, but in parsing expressions, they are delimited by the `/` character. Its important to note that the choices are prioritized in the order they appear. If an earlier expression is matched, no subsequent expressions are tried. Here's an example:
-
-    # my_grammar.treetop
-    grammar MyGrammar
-      rule hello
-        'hello chomsky' / 'hello lambek'
-      end
-    end
-    
-    # fragment of use_grammar.rb
-    puts parser.parse('hello chomsky')         # => Treetop::Runtime::SyntaxNode
-    puts parser.parse('hello lambek')          # => Treetop::Runtime::SyntaxNode
-    puts parser.parse('silly generativists!')  # => nil
-
-Note that once a choice rule has matched the text using a particular alternative at a particular location in the input and hence has succeeded, that choice will never be reconsidered, even if the chosen alternative causes another rule to fail where a later alternative wouldn't have. It's always a later alternative, since the first to succeed is final - why keep looking when you've found what you wanted? This is a feature of PEG parsers that you need to understand if you're going to succeed in using Treetop. In order to memoize success and failures, such decisions cannot be reversed. Luckily Treetop provides a variety of clever ways you can tell it to avoid making the wrong decisions. But more on that later.
-
-Sequences
----------
-Sequences are composed of other parsing expressions separated by spaces. Using sequences, we can tighten up the above grammar.
-
-    # my_grammar.treetop
-    grammar MyGrammar
-      rule hello
-        'hello ' ('chomsky' / 'lambek')
-      end
-    end
-
-Note the use of parentheses to override the default precedence rules, which bind sequences more tightly than choices.
-
-Once the whole sequence has been matched, the result is memoized and the details of the match will not be reconsidered for that location in the input.
-
-Nonterminal Symbols
--------------------
-Here we leave regular expressions behind. Nonterminals allow expressions to refer to other expressions by name. A trivial use of this facility would allow us to make the above grammar more readable should the list of names grow longer.
-
-    # my_grammar.treetop
-    grammar MyGrammar
-      rule hello
-        'hello ' linguist
-      end
-      
-      rule linguist
-        'chomsky' / 'lambek' / 'jacobsen' / 'frege'
-      end
-    end
-
-The true power of this facility, however, is unleashed when writing *recursive expressions*. Here is a self-referential expression that can match any number of open parentheses followed by any number of closed parentheses. This is theoretically impossible with regular expressions due to the *pumping lemma*.
-
-    # parentheses.treetop
-    grammar Parentheses
-      rule parens
-        '(' parens ')' / ''
-      end
-    end
-
-
-The `parens` expression simply states that a `parens` is a set of parentheses surrounding another `parens` expression or, if that doesn't match, the empty string. If you are uncomfortable with recursion, its time to get comfortable, because it is the basis of language. Here's a tip: Don't try and imagine the parser circling round and round through the same rule. Instead, imagine the rule is *already* defined while you are defining it. If you imagine that `parens` already matches a string of matching parentheses, then its easy to think of `parens` as an open and closing parentheses around another set of matching parentheses, which conveniently, you happen to be defining. You know that `parens` is supposed to represent a string of matched parentheses, so trust in that meaning, even if you haven't fully implemented it yet.
-
-Repetition
-----------
-Any item in a rule may be followed by a '+' or a '*' character, signifying one-or-more and zero-or-more occurrences of that item. Beware though; the match is greedy, and if it matches too many items and causes subsequent items in the sequence to fail, the number matched will never be reconsidered. Here's a simple example of a rule that will never succeed:
-
-    # toogreedy.treetop
-    grammar TooGreedy
-      rule a_s
-      	'a'* 'a'
-      end
-    end
-
-The 'a'* will always eat up any 'a's that follow, and the subsequent 'a' will find none there, so the whole rule will fail. You might need to use lookahead to avoid matching too much.
-
-Negative Lookahead
-------------------
-
-When you need to ensure that the following item *doesn't* match in some case where it might otherwise, you can use negat!ve lookahead, which is an item preceeded by a ! - here's an example:
-
-    # postcondition.treetop
-    grammar PostCondition
-      rule conditional_sentence
-        ( !conditional_keyword word )+ conditional_keyword [ \t]+ word*
-      end
-
-      rule word
-        ([a-zA-Z]+ [ \t]+) 
-      end
-
-      rule conditional_keyword
-        'if' / 'while' / 'until'
-      end
-    end
-
-Even though the rule `word` would match any of the conditional keywords, the first words of a conditional_sentence must not be conditional_keywords. The negative lookahead prevents that matching, and prevents the repetition from matching too much input. Note that the lookahead may be a grammar rule of any complexity, including one that isn't used elsewhere in your grammar.
-
-Positive lookahead
-------------------
-
-Sometimes you want an item to match, but only if the *following* text would match some pattern. You don't want to consume that following text, but if it's not there, you want this rule to fail. You can append a positive lookahead like this to a rule by appending the lookahead rule preceeded by an & character.
-
-
-
-Features to cover in the talk
-=============================
-
-* Treetop files
-* Grammar definition
-* Rules
-* Loading a grammar
-* Compiling a grammar with the `tt` command
-* Accessing a parser for the grammar from Ruby
-* Parsing Expressions of all kinds
-? Left recursion and factorization
-  - Here I can talk about function application, discussing how the operator
-    could be an arbitrary expression
-* Inline node class eval blocks
-* Node class declarations
-* Labels
-* Use of super within within labels
-* Grammar composition with include
-* Use of super with grammar composition