radius 0.0.1

data/DSL-SPEC

@@ -0,0 +1,151 @@
+=DSL Specification
+
+I haven't implemented a domain specific languages for Contexts yet, but I am hoping to
+do so in a future release. Below are some thoughts (in code) for how I would like it to
+work. Note that with a robust DSL you will be able to define that certain tags are
+only valid within certain containing tags.
+
+  class StoreContext < Radius::Context
+    def initialize(options)
+      @prefix = "r" # all tags must be prefixed with "r"
+      @user = options[:user]
+      @cart = options[:cart]
+      @session = options[:session]
+    end
+  
+    # expose the @user object variable
+    container(:user, :exposes => :user) do
+      # Use protect() on an object that has been exposed to prevent access to
+      # an attribute in a template. Conversely you could use the expose() method
+      # to expose specific attributes to the template and protect all others.
+      protect :password
+    
+      # add a single tag that returns the session_id
+      tag :session_id do |attributes|
+        @session.id
+      end
+    end
+  
+    # expose the @cart object as the basket tag
+    container(:basket, :exposes => :cart) do
+      expand do |attributes|
+        #
+        # some initialization code with attributes before handling
+        # content block
+        #
+        yeild
+      end
+    
+      container(:items, :exposes => :item) do
+        expand do |attributes|
+          @cart.items.each do |@item|
+            yield
+          end
+        end
+      end
+    end
+  
+    container :cart do
+      expand do |attributes|
+        yield
+      end
+    end
+  end
+
+  class User
+    attr_accessor :name, :login, :password, :email
+    def initialize(name, login, password, email)
+      @name, @login, @password, @email = name, login, password, email
+    end
+  end
+
+  class Session
+    attr_accessor :id
+    def initialize(id)
+      @id = id
+    end
+  end
+
+  class Cart
+    attr_accessor :items
+  
+    def initialize(*items)
+      @items = [items].flatten
+    end
+  
+    def total
+      @items.map { |line_item| line_item.total }
+    end
+  end
+
+  class LineItem
+    attr_accessor :name, :description, :quantity, :item_price
+    def intialize(name, description, price, quantity)
+      @name, @description, @price, @quantity = name, description, price, quantity
+    end
+    def full_price
+      @price * @quantity
+    end
+  end
+
+  receipt = <<-RECEIPT
+  <p><r:user:name />, thank you for shopping with us! An order summary
+    is printed below for your convinience. Please print a copy for your records.</p>
+  <r:cart>
+    <table>
+      <thead>
+        <tr>
+          <td>Product</td>
+          <td>Price</td>
+          <td>Quantity</td>
+          <td>Totals</td>
+        </tr>
+      </thead>
+      <tbody>
+        <r:items>
+          <tr>
+            <td>
+              <strong><r:name /></strong><br >
+              <r:description />
+            </td>
+            <td><r:price /></td>
+            <td><r:quanity /></td>
+            <td><r:full_price /></td>
+          </tr>
+        </r:items>
+      </tbody>
+      <tr>
+        <td colspan="3">Total</td>
+        <td><r:total /></td>
+      </tr>
+    </table>
+  </r:cart>
+  RECEIPT
+
+  user = User.new('John', 'johnboy', 'm@x!mu5', 'johnboy@maximus.com')
+  cart = Cart.new(
+    LineItem.new('15in PowerBook', "Apple's premium notebook computer.", 1995.98, 1),
+    LineItem.new('Mac Notebook Case', "A beautiful black notebook case designed for Apple Powerbooks.", 54.05, 1)
+  )
+  session = Session.new('a4bd386e512bacd581')
+
+  context = StoreContext.new(
+    :user => user,
+    :cart => cart,
+    :session => session
+  )
+
+  template = Radius::Template.new(
+    :text => receipt,
+    :context => context
+  )
+
+  template.compile! # based on context parses text into abstract syntax tree
+  puts template.expand # outputs expanded template
+
+  # alternate usage
+  parser = Radius::Parser.new(context)
+  puts parser.parse(receipt) # compiles and outputs expanded template
+
+  # another alternate
+  puts Radius.parse(receipt, context)

data/QUICKSTART

@@ -0,0 +1,98 @@
+=Quick Start
+
+Before you can parse a template with Radius you need to create a Context object which defines
+the tags that will be used in the template. This is pretty simple:
+
+  require 'radius'
+  
+  class MyContext < Radius::Context
+    def hello(attr)
+      "Hello #{attr['name'] || 'World'}!"
+    end
+  end
+
+Once you have defined a context you can create a Parser and parse to your heart's content:
+
+  parser = Radius::Parser.new(MyContext.new)
+  puts parser.parse('<p><radius:hello /></p>')
+  puts parser.parse('<p><radius:hello name="John" /></p>')
+
+This will output:
+
+  <p>Hello World!</p>
+  <p>Hello John!</p>
+
+Note how you can pass attributes from the template to the context using the attributes hash
+(which is passed in as the first parameter.). Above the first tag that was parsed didn't have
+a name attribute so the code in the +hello+ method uses "World" instead. The second time the
+tag is parsed the name attribute is set to "John" which is used to create the string "Hello
+John!".
+
+Radius also allows you to define "container" tags. That is, tags that contain content and
+that may optionally manipulate it in some way. For example, if you have RedCloth installed
+you could define another tag to parse and create Textile output:
+
+  require 'redcloth'
+  
+  class MyContext < Radius::Context
+    def textile(attr)
+      contents = yield
+      RedCloth.new(contents).to_html
+    end
+  end
+
+With the code above your parser can easily handle Textile:
+
+  parser.parse('<radius:textile>h1. Hello **World**!</radius:textile>')
+
+This will output:
+
+  <h1>Hello <strong>World</strong>!</h1>
+
+But wait!--it gets better. Because container tags can manipulate what they contain you can use
+them to iterate over collections:
+
+  class ThreeStoogesContext < Radius::Context
+    def initialize
+      @prefix = 'ts'
+    end
+    def stooge(attr)
+      content = ''
+      ["Larry", "Moe", "Curly"].each do |name|
+        @name = name
+        content << yield
+      end
+      content
+    end
+    def name(attr)
+      @name
+    end
+  end
+  
+  parser = Radius::Parser.new(ThreeStoogesContext.new)
+  
+  template = <<-TEMPLATE
+  <ul>
+  <ts:stooge>
+  <li><ts:name /></li>
+  </ts:stooge>
+  </ul>
+  TEMPLATE
+  
+  puts parser.parse(template)
+  
+This will output:
+
+  <ul>
+  
+    <li>Larry</li>
+  
+    <li>Moe</li>
+  
+    <li>Curly</li>
+  
+  </ul>
+
+The above code also illustrates how you can set the prefix instance variable to control the
+string that prefixes Radius tags. By setting the prefix to "ts" our tags must begin with "ts"
+instead of "radius" like they did in the other examples.

data/README

@@ -0,0 +1,49 @@
+= Radius -- Powerful Tag-Based Templates
+
+Radius is a small, but powerful template language for Ruby inspired by the template languages
+used in MovableType <http://www.movabletype.org> and TextPattern <http://www.textpattern.com>.
+It uses tags similar to HTML, but can be used to generate any form of plain text (XML, e-mail,
+etc...).
+
+
+== Download
+
+The latest version of Radius can be found on RubyForge:
+
+http://rubyforge.org/projects/radius/
+
+
+== Installation
+
+It is recommended that you install Radius using the RubyGems packaging system:
+
+  % gem install --remote radius
+
+You can also install Radius by copying radius.rb into the Ruby load path.
+
+== License
+
+Radius is free software and may be redistributed under the same terms and Ruby itself. For
+more details, see the readme file in the Ruby distribution.
+
+
+== Quick Start
+
+To get up and running fast with Radius read:
+
+link:files/QUICKSTART.html
+
+
+== A Call to Action
+
+Radius is still very much in the development stages. Take a look at the roadmap to see where
+we want to go:
+
+link:files/ROADMAP.html
+
+If you are a smart developer with a passion for excellence, now is the time to jump on board.
+Contact me and we'll talk. :)
+
+--
+
+John Long :: http://wiseheartdesign.com

data/ROADMAP

@@ -0,0 +1,18 @@
+= Roadmap
+
+This is a prioritized roadmap for future releases:
+
+1. Clean up the current code base.
+
+2. Add support for multi-level contexts: tags should be able to be
+   defined to only be valid within other sets of tags.
+
+3. Create a simple DSL for defining contexts. I had done some thinking
+   about this in the past. This thread on Ruby-Talk defined part of it:
+
+   http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/127640/
+
+   Update: See link:files/DSL-SPEC.html for a fuller explanation of how
+   the DSL should behave.
+
+4. Optimize for speed. Incorporate strscan?

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+task :default => :test
+
+Rake::TestTask.new do |t| 
+  t.pattern = 'test/**/*_test.rb'
+end
+
+Rake::RDocTask.new do |rd|
+  rd.title = 'Radius -- Powerful Tag-Based Templates'
+  rd.main = "README"
+  rd.rdoc_files.include("README", "QUICKSTART", "ROADMAP", "DSL-SPEC", "lib/**/*.rb")
+  rd.rdoc_dir = 'doc'
+end
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Powerful tag-based template system."
+  s.name = 'radius'
+  s.version = '0.0.1'
+  s.requirements << 'none'
+  s.require_path = 'lib'
+  s.autorequire = 'radius'
+  s.has_rdoc = true
+  s.rdoc_options << '--title' << 'Radius -- Powerful Tag-Based Templates' <<
+                    '--main' << 'README' <<
+                    '--line-numbers' << 'ROADMAP' <<
+                    'QUICKSTART' << 'DSL-SPEC' << 'README'
+  files = FileList['**/*']
+  files.exclude 'doc'
+  s.files = files.to_a
+  s.description = "Radius is a small, but powerful tag-based template language inspired\nby the template languages used in MovableType and TextPattern."
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/lib/radius.rb

@@ -0,0 +1,126 @@
+module Radius
+  class ParseError < StandardError # :nodoc:
+  end
+  
+  class MissingEndTagError < ParseError # :nodoc:
+    def initialize(tag_name)
+      super("end tag not found for start tag `#{tag_name}'")
+    end
+  end
+  
+  #
+  # An abstract class for creating a Context. A context defines the tags that
+  # are available for use in a template.
+  #
+  class Context
+    # The prefix attribute controls the string of text that is helps the parser
+    # identify template tags. By default this attribute is set to "radius", but
+    # you may want to override this for your own contexts.
+    attr_accessor :prefix
+    
+    # Creates a new Context object.
+    def initialize
+      @prefix = 'radius'
+    end
+  end
+  
+  class Tag # :nodoc:
+    def initialize(&b)
+      @block = b
+    end
+    def on_parse(&b)
+      @block = b
+    end
+    def to_s
+      @block.call(self)
+    end
+  end
+
+  class ContainerTag < Tag # :nodoc:
+    attr_accessor :name, :attributes, :contents
+    
+    def initialize(name="", attributes={}, contents=[], &b)
+      @name, @attributes, @contents = name, attributes, contents
+      super(&b)
+    end
+  end
+  
+  #
+  # The Radius parser. Initialize a parser with the Context object that defines
+  # how tags should be expanded.
+  #
+  class Parser
+    # The Context object used to expand template tags.
+    attr_accessor :context
+    
+    # Creates a new parser object initialized with a context.
+    def initialize(context = Context.new)
+      @context = context
+    end
+
+    # Parse string for tags, expand them, and return the result.
+    def parse(string)
+      @stack = [ContainerTag.new { |t| t.contents.to_s }]
+      pre_parse(string)
+      @stack.last.to_s
+    end
+    
+    def pre_parse(text) # :nodoc:
+      re = %r{<#{@context.prefix}:(\w+?)(?:\s+?([^/>]*?)|)>|</#{@context.prefix}:(\w+?)\s*?>}
+      if md = re.match(text)
+        start_tag, attr, end_tag = $1, $2, $3
+        @stack.last.contents << Tag.new { parse_individual(md.pre_match) }
+        remaining = md.post_match
+        if start_tag
+          parse_start_tag(start_tag, attr, remaining)
+        else
+          parse_end_tag(end_tag, remaining)
+        end
+      else
+        if @stack.length == 1
+          @stack.last.contents << Tag.new { parse_individual(text) }
+        else
+          raise MissingEndTagError.new(@stack.last.name)
+        end
+      end
+    end
+    
+    def parse_start_tag(start_tag, attr, remaining) # :nodoc:
+      @stack.push(ContainerTag.new(start_tag, parse_attributes(attr)))
+      pre_parse(remaining)
+    end
+
+    def parse_end_tag(end_tag, remaining) # :nodoc:
+      popped = @stack.pop
+      if popped.name == end_tag
+        popped.on_parse { |t| @context.send(popped.name, popped.attributes) { t.contents.to_s } }
+        tag = @stack.last
+        tag.contents << popped
+        pre_parse(remaining)
+      else
+        raise MissingEndTagError.new(popped.name)
+      end
+    end
+    
+    def parse_individual(text) # :nodoc:
+      re = /<#{@context.prefix}:(\w+?)\s+?(.*?)\s*?\/>/
+      if md = re.match(text)
+        attr = parse_attributes($2)
+        replace = @context.send($1, attr)
+        md.pre_match + replace + parse_individual(md.post_match)
+      else
+        text || ''
+      end
+    end
+    
+    def parse_attributes(text) # :nodoc:
+      attr = {}
+      re = /(\w+?)\s*=\s*('|")(.*?)\2/
+      while md = re.match(text)
+        attr[$1] = $3
+        text = md.post_match
+      end
+      attr
+    end
+  end
+end

data/test/radius_test.rb

@@ -0,0 +1,122 @@
+require 'test/unit'
+require 'radius'
+
+class ContextTest < Test::Unit::TestCase
+  def test_initialize
+    c = Radius::Context.new
+    assert_equal 'radius', c.prefix
+  end
+end
+
+class RadiusTest < Test::Unit::TestCase
+  class TestContext < Radius::Context
+    def initialize
+      @prefix = "test"
+      @items = ["Larry", "Moe", "Curly"]
+    end
+    
+    def echo(attr)
+      attr["text"]
+    end
+    
+    def add(attr)
+      (attr["param1"].to_i + attr["param2"].to_i).to_s
+    end
+    
+    def reverse(attr)
+      yield.reverse
+    end
+    
+    def capitalize(attr)
+      yield.upcase
+    end
+    
+    def count(attr)
+      case
+      when attr["set"]
+        @count = attr["set"].to_i
+        ""
+      when attr["inc"] == "true"
+        @count = (@count || 0) + 1
+        ""
+      else
+        @count.to_s       
+      end
+    end
+    
+    def loop(attr)
+      t = attr["times"].to_i
+      result = ""
+      t.times { result += yield }
+      result
+    end
+    
+    def each_item(attr)
+      result = []
+      @items.each { |@item| result << yield }
+      @item = nil
+      result.join(attr["between"] || "")
+    end
+    
+    def item(attr)
+      @item
+    end
+  end
+  
+  def setup
+    @t = Radius::Parser.new(TestContext.new )
+  end
+  
+  def test_parse_individual
+    r = @t.parse_individual(%{<<test:echo text="hello world!" />>})
+    assert_equal("<hello world!>", r)
+
+    r = @t.parse_individual(%{<test:add param1="1" param2='2'/>})
+    assert_equal("3", r)
+
+    r = @t.parse_individual(%{a <test:echo text="3 + 1 =" /> <test:add param1="3" param2="1"/> b})
+    assert_equal("a 3 + 1 = 4 b", r)
+  end
+  
+  def test_parse_attributes
+    r = @t.parse_attributes(%{ a="1" b='2'c="3"d="'" })
+    assert_equal({"a" => "1", "b" => "2", "c" => "3", "d" => "'"}, r)
+  end
+  
+  def test_parse
+    r = @t.parse(%{<<test:echo text="hello world!" />>})
+    assert_equal("<hello world!>", r)
+
+    r = @t.parse("<test:reverse>test</test:reverse>")
+    assert_equal("test".reverse, r)
+
+    r = @t.parse("<test:reverse>test</test:reverse> <test:capitalize>test</test:capitalize>")
+    assert_equal("tset TEST", r)
+    
+    r = @t.parse("<test:echo text='hello world!' /> cool: <test:reverse>a <test:capitalize>test</test:capitalize> b</test:reverse> !")
+    assert_equal("hello world! cool: b TSET a !", r)
+    
+    r = @t.parse("<test:reverse><test:echo text='hello world!' /></test:reverse>")
+    assert_equal("!dlrow olleh", r)
+
+    r = @t.parse("<test:reverse><test:capitalize>test</test:capitalize> <test:echo text='hello world!' /></test:reverse>")
+    assert_equal("!dlrow olleh TSET", r)
+
+    r = @t.parse("<test:reverse>12<test:capitalize>at</test:capitalize>34</test:reverse>")
+    assert_equal("43TA21", r)
+  end
+  def test_parse__loop
+    r = @t.parse(%{<test:count set="0" /><test:loop times="5"><test:count inc="true" /><test:count /></test:loop>})
+    assert_equal("12345", r)
+
+    r = @t.parse(%{Three Stooges: <test:each_item between=", ">"<test:item />"</test:each_item>})
+    assert_equal(%{Three Stooges: "Larry", "Moe", "Curly"}, r)
+  end
+  
+  def test_parse__fail_on_no_end_tag
+    assert_raises(Radius::MissingEndTagError) { @t.parse("<test:reverse>") }
+  end
+  def test_parse__fail_on_no_end_tag_2
+    assert_raises(Radius::MissingEndTagError) { @t.parse("<test:reverse><test:capitalize></test:reverse>") }
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: radius
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-01-21
+summary: Powerful tag-based template system.
+require_paths: 
+  - lib
+email: 
+homepage: 
+rubyforge_project: 
+description: "Radius is a small, but powerful tag-based template language inspired by the
+  template languages used in MovableType and TextPattern."
+autorequire: radius
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: []
+files: 
+  - DSL-SPEC
+  - lib
+  - QUICKSTART
+  - Rakefile
+  - README
+  - ROADMAP
+  - test
+  - lib/radius.rb
+  - test/radius_test.rb
+test_files: []
+rdoc_options: 
+  - "--title"
+  - "Radius -- Powerful Tag-Based Templates"
+  - "--main"
+  - README
+  - "--line-numbers"
+  - ROADMAP
+  - QUICKSTART
+  - DSL-SPEC
+  - README
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: 
+  - none
+dependencies: []