re_template 0.0.1.2

data/README

@@ -0,0 +1,64 @@
+A very simple template engine based on Regular Expressions
+
+
+Features
+========
+
+ * Regular expressions or plain text
+ * Can be used for HTML->HTML (read on)
+ * Tested on Ruby 1.8.7 and 1.9.1
+
+
+
+Usage
+=====
+
+  template = ReTemplate::Text.new
+  template.expressions = {/\{foo\}/ => :foo, /\{bar\}/ => :bar}
+  template.parse! 'A {foo} is not a {bar}.'
+  template.render :foo => 'plant', :bar => 'rhinocerous', :other_expression => 'ignored'
+   => 'A plant is not a rhinocerous.'
+
+Expressions must be set before parsing.
+Multiple calls to parse! can be done with the same expressions (this may change).
+Multiple calls to 'render' will work by design.
+It also works with HTML:
+
+  template = ReTemplate::Html.new
+  template.add_text_expressions '<foo>' => :foo, '|lang|' => :lang
+  template.parse! '<p>&lt;foo&gt; is not a valid |lang| tag.</p>'
+  template.render :foo => '<bar>', :lang => 'HTML'
+   => '<p>&lt;bar&gt; is not a valid HTML tag.</p>'
+
+Actually, I lied, as this will currently attach a doctype, and wrap things in html and body tags, if any of these things are missing. I blame Nokogiri.
+
+Read the specs for more.
+
+
+
+Motivation/Examples
+===================
+
+Mail merge. A user can prepare an email like this, in their mail client:
+
+Dear {customer_name},
+    Lorem ipsum dolor sit amet...
+
+The curly brackets are merely a convention, because {user} is unlikely to be intended in the body of a message. The important point is that this can also be applied to an HTML message, even if the pattern or replacement text is not valid HTML. For example:
+
+Dear <customer_name>,
+
+A simple text replacement would only see &lt;user&gt;. While we're at it, the replacement text is automatically escaped.
+
+I also looked at Liquid. It is very cool, but it was overkill for this project, and it didn't look like it would behave well with WYSIWYG-generated HTML.
+
+
+
+CAVEATS
+=======
+
+This is brand spanking this-afternoon new. The API is pretty much guaranteed to change. If you're using this for anything important, either fork it or lock to a specific version.
+
+The expressions hash is unordered. If you have a chunk of text that could match two different regular expressions, one of them is going to be applied first, and it's undefined which one. If this matters to you, you're probably using the wrong tool -- personally, I won't be using the regexes directly at all, they just seem to be faster (for some bizarre reason) than string#split.
+
+Someone MUST have done a better job of this somewhere. If you find it, let me know!

data/lib/re_template.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'autoloader'
+require 'pathname'
+AutoLoader << Pathname(__FILE__).dirname
+
+class ReTemplate
+  include AutoLoader
+
+  attr_accessor :nodes
+  attr_writer :expressions
+  def expressions
+    @expressions ||= {}
+  end
+  
+  def add_text_expressions *args
+    hash = args.last.kind_of?(Hash) ? args.pop : {}
+    args.each do |field|
+      hash[field] = field
+    end
+    hash.each_pair do |key, value|
+      self.expressions[/#{Regexp.escape key}/] = value
+    end
+  end
+end

data/lib/re_template/html.rb

@@ -0,0 +1,49 @@
+require 'nokogiri'
+
+class ReTemplate::Html < ReTemplate
+  attr_accessor :doc
+  def parse! given_doc
+    if given_doc.kind_of? String
+      self.doc = Nokogiri::HTML.parse(given_doc)
+    else
+      self.doc = given_doc.dup
+    end
+    
+    self.nodes = []
+    
+    parse_children! doc
+  end
+  
+  def render values
+    nodes.each do |node|
+      node.render! values
+    end
+    doc.dup
+  end
+  
+  class SubTemplate < Text
+    attr_accessor :node
+    def initialize node, expressions
+      self.node = node
+      self.expressions = expressions
+      self.parse! node.text
+    end
+    
+    def render! values
+      new_node = Nokogiri::XML::Text.new(render(values), node.document)
+      node.replace(new_node)
+      self.node = new_node
+    end
+  end
+  
+  protected
+    def parse_children! node
+      if node.kind_of? Nokogiri::XML::Text
+        nodes << SubTemplate.new(node, expressions)
+      else
+        node.children.each do |n|
+          parse_children! n
+        end
+      end
+    end
+end

data/lib/re_template/text.rb

@@ -0,0 +1,35 @@
+class ReTemplate::Text < ReTemplate
+  def parse! string
+    self.nodes = [string]
+    expressions.each_key do |expression|
+      self.nodes = self.nodes.map do |node|
+        if node.kind_of? String
+          result = []
+          rest = node
+          while match = expression.match(rest)
+            result << match.pre_match
+            result << expression
+            rest = match.post_match
+          end
+          result << rest
+          result.reject{|x| x == ''}
+        else
+          # It's not a string, so leave it alone
+          node
+        end
+      end.flatten
+    end
+  end
+  
+  def render values
+    result = ''
+    nodes.each do |node|
+      if node.kind_of? String
+        result << node
+      else
+        result << values[expressions[node]]
+      end
+    end
+    result
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: re_template
+version: !ruby/object:Gem::Version 
+  version: 0.0.1.2
+platform: ruby
+authors: 
+- David Masover
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-15 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: autoloader
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.4"
+    version: 
+description: Intelligently handles HTML input, and is meant to safely handle untrusted templates and substitution variables. Basically, it's designed for mail merge.
+email: ninja@slaphack.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/re_template.rb
+- lib/re_template/text.rb
+- lib/re_template/html.rb
+has_rdoc: true
+homepage: http://github.com/masover/re_template
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: Simple, Regular Expression powered template engine.
+test_files: []
+