personify 1.0.0

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Digitpaint, Flurin Egger
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,172 @@
+Personify : personalisation template language
+=============================================
+
+Personfify is meant for use in environments where templates just need
+to be personalized.
+
+Basic syntax
+------------
+
+Alle expressions are wrapped in brackets ([ ]). All code outside
+of brackets will not be evaluated.
+
+If the return statement of an expression is nil, it won't be replaced
+by it's output.
+
+All whitespace within expressions is ignored.
+
+Simple substitution
+-------------------
+
+The simplest use of the personify template language is to just use
+the standard substitution expressions. A substitution expression
+exists of a key which will be replaced if it's found in the context.
+
+#### Examples:
+
+With context:
+
+    {"key" => "value"}
+
+Example:
+
+    [KEY] => value
+    [UNKNOWN] => [UNKNOWN]
+    
+Substitutions with fallback
+--------------------------- 
+
+A more advanced feature is to use fallbacks on missing keys. If a key can't
+be found in the context, all alternative keys (separated by a pipe (|))
+will be tried until a non-nil value is found. If a the last alternative
+returns nil, the original expression won't be replaced.
+
+You can also specify strings as fallbacks, they will always return the string.
+See also the note on strings below.
+
+
+#### Examples: 
+
+With context:
+
+    {"key" => "value"}
+
+Example:
+    
+    [UNKNOWN | KEY] => value
+    [UNKNOWN1 | UNKNOWN2 | "default"] => default
+    [UNKNOWN1 | UNKNOWN2 | default] => default
+    
+Boolean logic
+-------------
+
+You can use boolean logic parameters && (and) and || (or) to implement simple logic. The logic can be used
+anywhere where you can use a substitution, which means you can use it as a standalone subsitition, within a function
+parameter or as an alternative.
+
+**Attention!** We currently do not support operator precedence and parenthesis, the logic will be evaluated
+backwards so the statement A && B || C will actually be evaluated as A && (B || C).
+
+#### Examples: 
+
+with context:
+    
+    {
+      "a" => "a",
+      "b" => "b",
+      "c" => "c",
+      "d" => nil
+    }
+    
+Example:
+
+    [A && B] => a
+    [A && D | "default"] => default
+    
+    [A || B] => a
+    [B || A] => b
+    [D || A] => a
+    
+    [A && B || C] => a
+    [A && D || C] => c
+    
+    [A || B && C] => a
+    [D || B && C || "default"] => default
+
+
+Function calls
+--------------
+
+For more flexibility, it is possible to put functions in
+the context by means of lamda's and procs. However you need to be very
+carefull with accepting parameters as Personify will just splat all
+parameters into the proc's call method. If an expected function
+doesn't respond to a call method, it just works like a normal substitution.
+
+### Simple Syntax
+
+#### Examples:
+
+With context:
+
+    {
+      "key1" => "v1", 
+      "key2" => "v2" 
+      "ampersandize" => Proc.new{|*c| c.join(" & ") }
+    }
+
+Example:
+    
+    [AMPERSANDIZE(KEY1,KEY2)] => v1 & v2
+    [AMPERSANDIZE(KEY1 , "default")] => v1 & default
+    [AMPERSANDIZE("1","2","3")] => 1 & 2 & 3
+    [AMPERSANDIZE("1",2,3)] => 1 & 2 & 3    
+
+### Block Syntax
+
+You can also use a block-style syntax with functions. The content of the block will be passed
+to the function as the last parameter.
+
+#### Example: Simple function substitution
+
+    [FUN(VAR) DO]
+    content passed to the IF fn as last parameter, the whole block will be substituted.
+    for example lambda{|var,glob| var > 1 ? glob : "" }
+    [END]
+
+#### Example: Function as alternative
+
+    [FIRST | FUN() DO]
+    if FIRST is available do that, if not pass this text to FUN() call.
+    Always replace this text.
+    [END]
+
+#### Example: Function as an alternative with a fallback string
+
+    [FIRST | FUN() DO]
+    First check FIRST, then try to call the FUN with this content, as a last resort use the 
+    fallback string
+    [END | "fallback"]
+
+#### Example: Function as an alternative with another function as fallback
+
+    [FUN() DO]
+    Pass this to FUN and if it returns non false/nil we show the return value
+    [END | FUN2() DO]
+    If FUN() return a false/nil value we pass this to FUN2() and show it's return value
+    [END]
+
+
+Strings
+-------
+
+Strings can be used either as parameters for a function or in an expression
+as an alternative. Strings don't necessarily need to be quoted as long
+as they don't contain any of these characters: "]),|
+
+Strings cannot ever contain double qoutes (").
+
+
+Copyright
+---------
+Copyright (c) 2011 Digitpaint, Flurin Egger. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "personify"
+    gem.summary = %Q{A personalisation template language}
+    gem.description = %Q{Personfify is meant for use in environments where templates just need to be personalized.}
+    gem.email = "flurin@digitpaint.nl"
+    gem.homepage = "http://github.com/digitpaint/personify"
+    gem.authors = ["Flurin Egger"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "personify #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/doc/syntax_ideas.md

@@ -0,0 +1,141 @@
+Current state
+=============
+
+## String
+["string"]
+
+## Substitution
+[SUBSTITUTE]
+
+## Substitution with alternatives
+[SUBSTITUTE | ALT]
+
+## Function with substitution parameters
+[FUN(SUBSTITUTE)]
+
+## Function with string parameter
+[FUN("string")]
+
+## !? Does this work?
+[FUN(1)]
+
+
+Proposals for block syntax
+==========================
+
+[FUN() DO]
+passed to function as last parameter
+[END]
+
+[START:FUN]
+pass to block?
+[STOP:FUN]
+
+[FUN<]
+[>]
+
+[VAR<]
+[>VAR]
+
+[VAR]
+[/VAR]
+
+[FUN>
+some weird stuff
+<]
+
+[SUBSTITUTE | >
+
+<]
+
+[SUBSTITUTE | FUN() >
+<]
+
+[FUN()] 
+passed to function as last parameter
+[/]
+
+[FUN(){
+passed to function as last parameter
+}]
+
+[VAR{
+show text if VAR == true
+}]
+
+# Context
+{
+  :subscriber => {
+    :email => "flurin@digitpaint.nl",
+    :token => "abcdef",
+    :id => 201,
+    :newsletters => {
+      1 => {
+        :frequency => "day"
+      },
+      5 => {
+        :frequency => "day"
+      }
+    }
+  }
+}
+# /Context
+
+[SUBSCRIBER.EMAIL] #=> "flurin@digitpaint.nl"
+[SUBSCRIBER.NEWSLETTER.1.FREQUENCY] #=> "day"
+
+[IF SUBSCRIBER.NEWSLETTER.1]
+...
+[END]
+
+# Capture content to pass to function
+[FUN(VAR) DO]
+content passed to the IF fn as last parameter, the whole block will be substituted.
+for example lambda{|var,glob| var > 1 ? glob : "" }
+[END]
+
+[FIRST | FUN() DO]
+if FIRST is available do that, if not pass this text to FUN() call.
+Always replace this text.
+[END]
+
+[FIRST | FUN() DO]
+First check FIRST, then try to call the FUN with this content, as a last resort use the 
+fallback string
+[END | "fallback"]
+
+[FUN() DO]
+Pass this to FUN and if it returns non false/nil we show the return value
+[END | FUN2() DO]
+If FUN() return a false/nil value we pass this to FUN2() and show it's return value
+[END]
+
+[VAR DO]
+invalid syntax will not substitue
+[END]
+
+# IF as a language construct with ELSIF and ELSE
+[IF EXPR1]
+if EXPR is true do this
+[ELSIF EXPR2]
+if EXPR1 is false and EXPR2 is true, do this
+[ELSE]
+all other cases do this
+[END]
+
+COMPARATORS
+
+A == "b"
+A > 1
+A < 1
+A <= 1
+A >= 1
+FN(A) == true 
+
+
+
+[IF(VAR){
+
+[} ELSE {]
+
+[}]

data/lib/personify/context.rb

@@ -0,0 +1,55 @@
+module Personify
+  # This specifies the context we can evaluate in 
+  class Context
+    
+    class << self
+      def allowed_context_methods
+        @allowed_methods ||= []
+      end
+      
+      def context_method(method_name)
+        self.allowed_context_methods << method_name.to_s if self.instance_methods.include?(method_name.to_s)
+      end
+      
+      def allow_method?(method_name)
+        self.allowed_context_methods.include?(method_name.to_s)
+      end
+    end
+
+    def allow_method?(method_name)
+      self.class.allow_method?(method_name)
+    end
+    
+    def local_assigns=(assigns)
+      @local_assigns = assigns
+    end
+    
+    def local_assigns
+      @local_assigns ||= {}
+    end
+    
+    def [](k)
+      self.local_assigns[k]
+    end
+    
+    def has_key?(k)
+      self.local_assigns.has_key?(k)
+    end
+      
+    
+    
+  end
+  
+  class DefaultContext < Context
+    
+    def if(statement, value)    
+      if statement
+        value
+      else
+        nil
+      end
+    end
+    context_method :if
+    
+  end
+end