radius19-radiant 1.0.0

data/lib/radius/dostruct.rb

@@ -0,0 +1,31 @@
+module Radius
+  class DelegatingOpenStruct # :nodoc:
+    attr_accessor :object
+
+    def initialize(object = nil)
+      @object = object
+      @hash = {}
+    end
+
+    def method_missing(method, *args, &block)
+      symbol = (method.to_s =~ /^(.*?)=$/) ? $1.intern : method
+      if (0..1).include?(args.size)
+        if args.size == 1
+          @hash[symbol] = args.first
+        else
+          if @hash.has_key?(symbol)
+            @hash[symbol]
+          else
+            unless object.nil?
+              @object.send(method, *args, &block)
+            else
+              nil
+            end
+          end
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/lib/radius/errors.rb

@@ -0,0 +1,24 @@
+module Radius
+
+  # Abstract base class for all parsing errors.
+  class ParseError < StandardError
+  end
+
+  # Occurs when Parser cannot find an end tag for a given tag in a template or when
+  # tags are miss-matched in a template.
+  class MissingEndTagError < ParseError
+    # Create a new MissingEndTagError object for +tag_name+.
+    def initialize(tag_name)
+      super("end tag not found for start tag `#{tag_name}'")
+    end
+  end
+
+  # Occurs when Context#render_tag cannot find the specified tag on a Context.
+  class UndefinedTagError < ParseError
+    # Create a new UndefinedTagError object for +tag_name+.
+    def initialize(tag_name)
+      super("undefined tag `#{tag_name}'")
+    end
+  end
+
+end

data/lib/radius/parser.rb

@@ -0,0 +1,95 @@
+module Radius
+  #
+  # The Radius parser. Initialize a parser with a Context object that
+  # defines how tags should be expanded. See the QUICKSTART[link:files/QUICKSTART.html]
+  # for a detailed explaination of its usage.
+  #
+  class Parser
+    # The Context object used to expand template tags.
+    attr_accessor :context
+
+    # The string that prefixes all tags that are expanded by a parser
+    # (the part in the tag name before the first colon).
+    attr_accessor :tag_prefix
+
+    # Creates a new parser object initialized with a Context.
+    def initialize(context = Context.new, options = {})
+      if context.kind_of?(Hash) and options.empty?
+        options = context
+        context = options[:context] || options['context'] || Context.new
+      end
+      options = Util.symbolize_keys(options)
+      @context = context
+      @tag_prefix = options[:tag_prefix]
+    end
+
+    # Parses string for tags, expands them, and returns the result.
+    def parse(string)
+      @stack = [ParseContainerTag.new { |t| Util.recurring_array_to_s(t.contents) }]
+      pre_parse(string)
+      @stack.last.to_s
+    end
+
+    protected
+
+    def pre_parse(text) # :nodoc:
+      re = %r{<#{@tag_prefix}:([\w:]+?)(\s+(?:\w+\s*=\s*(?:"[^"]*?"|'[^']*?')\s*)*|)>|</#{@tag_prefix}:([\w:]+?)\s*>}
+      if md = re.match(text)
+        start_tag, attr, end_tag = $1, $2, $3
+        @stack.last.contents << ParseTag.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 << ParseTag.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(ParseContainerTag.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 do |t|
+          @context.render_tag(popped.name, popped.attributes) { Util.recurring_array_to_s(t.contents) }
+        end
+        tag = @stack.last
+        tag.contents << popped
+        pre_parse(remaining)
+      else
+        raise MissingEndTagError.new(popped.name)
+      end
+    end
+
+    def parse_individual(text) # :nodoc:
+      re = %r{<#{@tag_prefix}:([\w:]+?)(\s+(?:\w+\s*=\s*(?:"[^"]*?"|'[^']*?')\s*)*|)/>}
+      if md = re.match(text)
+        attr = parse_attributes($2)
+        replace = @context.render_tag($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/lib/radius/parsetag.rb

@@ -0,0 +1,23 @@
+class ParseTag # :nodoc:
+  def initialize(&b)
+    @block = b
+  end
+
+  def on_parse(&b)
+    @block = b
+  end
+
+  def to_s
+    @block.call(self)
+  end
+end
+
+class ParseContainerTag < ParseTag # :nodoc:
+  attr_accessor :name, :attributes, :contents
+
+  def initialize(name = "", attributes = {}, contents = [], &b)
+    @name, @attributes, @contents = name, attributes, contents
+    super(&b)
+  end
+end
+

data/lib/radius/tagbinding.rb

@@ -0,0 +1,66 @@
+module Radius
+  #
+  # A tag binding is passed into each tag definition and contains helper methods for working
+  # with tags. Use it to gain access to the attributes that were passed to the tag, to
+  # render the tag contents, and to do other tasks.
+  #
+  class TagBinding
+    # The Context that the TagBinding is associated with. Used internally. Try not to use
+    # this object directly.
+    attr_reader :context
+
+    # The locals object for the current tag.
+    attr_reader :locals
+
+    # The name of the tag (as used in a template string).
+    attr_reader :name
+
+    # The attributes of the tag. Also aliased as TagBinding#attr.
+    attr_reader :attributes
+    alias :attr :attributes
+
+    # The render block. When called expands the contents of the tag. Use TagBinding#expand
+    # instead.
+    attr_reader :block
+
+    # Creates a new TagBinding object.
+    def initialize(context, locals, name, attributes, block)
+      @context, @locals, @name, @attributes, @block = context, locals, name, attributes, block
+    end
+
+    # Evaluates the current tag and returns the rendered contents.
+    def expand
+      double? ? block.call : ''
+    end
+
+    # Returns true if the current tag is a single tag.
+    def single?
+      block.nil?
+    end
+
+    # Returns true if the current tag is a container tag.
+    def double?
+      not single?
+    end
+
+    # The globals object from which all locals objects ultimately inherit their values.
+    def globals
+      @context.globals
+    end
+
+    # Returns a list of the way tags are nested around the current tag as a string.
+    def nesting
+      @context.current_nesting
+    end
+
+    # Fires off Context#tag_missing for the current tag.
+    def missing!
+      @context.tag_missing(name, attributes, &block)
+    end
+
+    # Renders the tag using the current context .
+    def render(tag, attributes = {}, &block)
+      @context.render_tag(tag, attributes, &block)
+    end
+  end
+end

data/lib/radius/tagdefs.rb

@@ -0,0 +1,78 @@
+module Radius
+  module TagDefinitions # :nodoc:
+    class TagFactory # :nodoc:
+      def initialize(context)
+        @context = context
+      end
+
+      def define_tag(name, options, &block)
+        options = prepare_options(name, options)
+        validate_params(name, options, &block)
+        construct_tag_set(name, options, &block)
+        expose_methods_as_tags(name, options)
+      end
+
+      protected
+
+      # Normalizes options pased to tag definition. Override in decendants to preform
+      # additional normalization.
+      def prepare_options(name, options)
+        options = Util.symbolize_keys(options)
+        options[:expose] = expand_array_option(options[:expose])
+        object = options[:for]
+        options[:attributes] = object.respond_to?(:attributes) unless options.has_key? :attributes
+        options[:expose] += object.attributes.keys if options[:attributes]
+        options
+      end
+
+      # Validates parameters passed to tag definition. Override in decendants to add custom
+      # validations.
+      def validate_params(name, options, &block)
+        unless options.has_key? :for
+          raise ArgumentError.new("tag definition must contain a :for option or a block") unless block
+          raise ArgumentError.new("tag definition must contain a :for option when used with the :expose option") unless options[:expose].empty?
+        end
+      end
+
+      # Adds the tag definition to the context. Override in subclasses to add additional tags
+      # (child tags) when the tag is created.
+      def construct_tag_set(name, options, &block)
+        if block
+          @context.definitions[name.to_s] = block
+        else
+          lp = last_part(name)
+          @context.define_tag(name) do |tag|
+            if tag.single?
+              options[:for]
+            else
+              tag.locals.send("#{ lp }=", options[:for]) unless options[:for].nil?
+              tag.expand
+            end
+          end
+        end
+      end
+
+      # Exposes the methods of an object as child tags.
+      def expose_methods_as_tags(name, options)
+        options[:expose].each do |method|
+          tag_name = "#{name}:#{method}"
+          lp = last_part(name)
+          @context.define_tag(tag_name) do |tag|
+            object = tag.locals.send(lp)
+            object.send(method)
+          end
+        end
+      end
+
+      protected
+
+      def expand_array_option(value)
+        [*value].compact.map { |m| m.to_s.intern }
+      end
+
+      def last_part(name)
+        name.split(':').last
+      end
+    end
+  end
+end

data/lib/radius/util.rb

@@ -0,0 +1,34 @@
+module Radius
+  module Util # :nodoc:
+    def self.symbolize_keys(hash)
+      new_hash = {}
+      hash.keys.each do |k|
+        new_hash[k.to_s.intern] = hash[k]
+      end
+      new_hash
+    end
+
+    def self.impartial_hash_delete(hash, key)
+      string = key.to_s
+      symbol = string.intern
+      value1 = hash.delete(symbol)
+      value2 = hash.delete(string)
+      value1 || value2
+    end
+
+    def self.constantize(camelized_string)
+      raise "invalid constant name `#{camelized_string}'" unless camelized_string.split('::').all? { |part| part =~ /^[A-Za-z]+$/ }
+      Object.module_eval(camelized_string)
+    end
+
+    def self.camelize(underscored_string)
+      string = ''
+      underscored_string.split('_').each { |part| string << part.capitalize }
+      string
+    end
+
+    def self.recurring_array_to_s(ary)
+      ary.map{|x| x.is_a?(Array) ? recurring_array_to_s(x) : x.to_s }.join
+    end
+  end
+end

data/lib/radius19.rb

@@ -0,0 +1,24 @@
+#--
+# Copyright (c) 2006, John W. Long
+#
+# 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.
+#++
+
+dir = File.join(File.dirname(__FILE__), 'radius')
+require_files = %w{errors tagdefs dostruct tagbinding context parsetag parser util}
+require_files.each {|f| require File.join(dir, f)}

data/test/context_test.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class RadiusContextTest < Test::Unit::TestCase
+  include RadiusTestHelper
+
+  def setup
+    @context = new_context
+  end
+
+  def test_initialize
+    @context = Radius::Context.new
+  end
+
+  def test_initialize_with_block
+    @context = Radius::Context.new do |c|
+      assert_kind_of Radius::Context, c
+      c.define_tag('test') { 'just a test' }
+    end
+    assert_not_equal Hash.new, @context.definitions
+  end
+
+  def test_with
+    got = @context.with do |c|
+      assert_equal @context, c
+    end
+    assert_equal @context, got
+  end
+
+  def test_render_tag
+    define_tag "hello" do |tag|
+      "Hello #{tag.attr['name'] || 'World'}!"
+    end
+    assert_render_tag_output 'Hello World!', 'hello'
+    assert_render_tag_output 'Hello John!', 'hello', 'name' => 'John'
+  end
+
+  def test_render_tag__undefined_tag
+    e = assert_raises(Radius::UndefinedTagError) { @context.render_tag('undefined_tag') }
+    assert_equal "undefined tag `undefined_tag'", e.message
+  end
+
+  def test_tag_missing
+    class << @context
+      def tag_missing(tag, attr, &block)
+        "undefined tag `#{tag}' with attributes #{attr.inspect}"
+      end
+    end
+
+    text = ''
+    expected = %{undefined tag `undefined_tag' with attributes {"cool"=>"beans"}}
+    assert_nothing_raised { text = @context.render_tag('undefined_tag', 'cool' => 'beans') }
+    assert_equal expected, text
+  end
+
+  private
+
+    def assert_render_tag_output(output, *render_tag_params)
+      assert_equal output, @context.render_tag(*render_tag_params)
+    end
+
+end