radius 0.5.1 → 0.6.1

data/lib/radius/parser/scan.rl

@@ -0,0 +1,123 @@
+%%{
+	machine parser;
+	
+	
+	action _prefix { mark_pfx = p }
+	action prefix {
+	  if data[mark_pfx..p-1] != @prefix
+      @nodes.last << data[mark_pfx-1..p]
+	    fbreak;
+    end
+	}
+	action _starttag { mark_stg = p }
+	action starttag { @starttag = data[mark_stg..p-1] }
+	action _attr { mark_attr = p }
+	action attr {
+	  @attrs[@nat] = @vat 
+	}
+	
+	action prematch {
+	  @prematch_end = p
+	  @prematch = data[0..p] if p > 0
+	}
+	
+	action _nameattr { mark_nat = p }
+	action nameattr { @nat = data[mark_nat..p-1] }
+	action _valattr { mark_vat = p }
+	action valattr { @vat = data[mark_vat..p-1] }
+	
+	action opentag  { @flavor = :open }
+	action selftag  { @flavor = :self }
+	action closetag { @flavor = :close }
+	
+	action stopparse {
+	  @cursor = p;
+	  fbreak;
+	}
+	
+	
+	Closeout := empty;
+	
+	# words
+	PrefixChar = [\-A-Za-z0-9._?] ;
+	NameChar = [\-A-Za-z0-9._:?] ;
+	TagName = NameChar+ >_starttag %starttag;
+	Prefix = PrefixChar+ >_prefix %prefix;
+	
+	Name = Prefix ":" TagName;
+	
+	NameAttr = NameChar+ >_nameattr %nameattr;
+  Q1Char = ( "\\\'" | [^'] ) ;
+  Q1Attr = Q1Char* >_valattr %valattr;
+  Q2Char = ( "\\\"" | [^"] ) ;
+  Q2Attr = Q2Char* >_valattr %valattr;
+ 
+  Attr =  NameAttr space* "=" space* ('"' Q2Attr '"' | "'" Q1Attr "'") space* >_attr %attr;
+  Attrs = (space+ Attr* | empty);
+  
+  CloseTrailer = "/>" %selftag;
+  OpenTrailer = ">" %opentag;
+  
+  Trailer = (OpenTrailer | CloseTrailer);
+  
+	OpenOrSelfTag = Name Attrs? Trailer;
+	CloseTag = "/" Name space* ">" %closetag;
+	
+	SomeTag = '<' (OpenOrSelfTag | CloseTag);
+	
+	main := |*
+	  SomeTag => {
+	    tag = {:prefix=>@prefix, :name=>@starttag, :flavor => @flavor, :attrs => @attrs}
+	    @prefix = nil
+	    @name = nil
+	    @flavor = :tasteless
+	    @attrs = {}
+	    @nodes << tag << ''
+      fbreak;
+	  };
+	  any => {
+	    @nodes.last << data[p]
+	    @tagstart = p
+	  };
+	*|;
+}%%
+
+module Radius
+  class Scanner
+    def self.operate(prefix, data)
+      buf = ""
+      csel = ""
+      @prematch = ''
+      @starttag = nil
+      @attrs = {}
+      @flavor = :tasteless
+      @cursor = 0
+      @tagstart = 0
+      @nodes = ['']
+      remainder = data.dup
+
+      until remainder.length == 0
+        p = perform_parse(prefix, remainder)
+        remainder = remainder[p..-1]
+      end
+
+      return @nodes
+    end
+    
+    private
+    def self.perform_parse(prefix, data)
+      stack = []
+      p = 0
+      ts = 0
+      te = 0
+      act = 0
+      eof = data.length
+      
+      @prefix = prefix
+      %% write data;
+      %% write init;
+      %% write exec;
+      return p
+    end
+  end
+end

data/lib/radius/tag_binding.rb

@@ -0,0 +1,71 @@
+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
+  
+    # Shortcut for accessing tag.attr[key]
+    def [](key)
+      attr[key]
+    end
+  end
+end

data/lib/radius/tag_definitions.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
+      
+        # 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
+        
+        # Normalizes options pased to tag definition. Override in decendants to preform
+        # additional normalization.
+        def prepare_options(name, options)
+          options = Utility.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
+        
+        # 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/utility.rb

@@ -0,0 +1,30 @@
+module Radius
+  module Utility # :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
+  end
+end

data/lib/radius/version.rb

@@ -0,0 +1,14 @@
+module Radius
+  module Version
+    Major = '0'
+    Minor = '6'
+    Tiny  = '1'
+    
+    class << self
+      def to_s
+        [Major, Minor, Tiny].join('.')
+      end
+      alias :to_str :to_s
+    end
+  end
+end

data/tasks/scan.rake

@@ -0,0 +1,27 @@
+namespace :scan do
+  desc 'Generate the parser'
+  task 'build' => ['lib/radius/parser/scan.rb']
+  
+  desc 'Generate a PDF state graph from the parser'
+  task 'graph' => ['doc/scan.pdf']
+  
+  desc 'turn the scan.rl file into a ruby file'
+  file 'lib/radius/parser/scan.rb' => ['lib/radius/parser/scan.rl'] do |t|
+    cd 'lib/radius/parser' do
+      sh "ragel -R scan.rl"
+    end
+  end
+
+  desc 'pdf of the ragel scanner'
+  file 'doc/scan.pdf' => 'lib/radius/parser/scan.dot' do |t|
+    cd 'lib/radius/parser' do
+      sh "dot -Tpdf -o ../../../doc/scan.pdf scan.dot"
+    end
+  end
+
+  file 'lib/radius/parser/scan.dot' => ['lib/radius/parser/scan.rl'] do |t|
+    cd 'lib/radius/parser' do
+      sh "ragel -Vp scan.rl > scan.dot"
+    end
+  end
+end

data/test/context_test.rb

@@ -0,0 +1,61 @@
+require File.join(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

data/test/{radius_test.rb → parser_test.rb}

@@ -1,83 +1,4 @@
-require 'test/unit'
-require 'radius'
-
-module RadiusTestHelper
-  class TestContext < Radius::Context; end
-  
-  def new_context
-    Radius::Context.new do |c|
-      c.define_tag("reverse"   ) { |tag| tag.expand.reverse }
-      c.define_tag("capitalize") { |tag| tag.expand.upcase  }
-      c.define_tag("attr"      ) { |tag| tag.attr.inspect   }
-      c.define_tag("echo"      ) { |tag| tag.attr['value']  }
-      c.define_tag("wrap"      ) { |tag| "[#{tag.expand}]"  }
-    end
-  end
-  
-  def define_tag(name, options = {}, &block)
-    @context.define_tag name, options, &block
-  end
-end
-
-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
+require File.join(File.dirname(__FILE__), 'test_helper')
 
 class RadiusParserTest < Test::Unit::TestCase
   include RadiusTestHelper
@@ -145,6 +66,11 @@ class RadiusParserTest < Test::Unit::TestCase
       assert_parsed_is_unchanged "<r:attr#{middle}>"
     end
   end
+  
+  def test_tags_inside_html_tags
+    assert_parse_output %{<div class="xzibit">tags in yo tags</div>},
+      %{<div class="<r:reverse>tibizx</r:reverse>">tags in yo tags</div>}
+  end
     
   def test_parse_result_is_always_a_string
     define_tag("twelve") { 12 }
@@ -191,12 +117,23 @@ class RadiusParserTest < Test::Unit::TestCase
     e = assert_raises(Radius::UndefinedTagError) { @parser.parse("<r:test />") }
     assert_equal "undefined tag `test'", e.message
   end
-  
+
+  def test_parse_chirpy_bird
+    # :> chirp chirp
+    assert_parse_output "<:", "<:"
+  end
+
   def test_parse_tag__binding_render_tag
     define_tag('test') { |tag| "Hello #{tag.attr['name']}!" }
     define_tag('hello') { |tag| tag.render('test', tag.attr) }
     assert_parse_output 'Hello John!', '<r:hello name="John" />'
   end
+  
+  def test_accessing_tag_attributes_through_tag_indexer
+    define_tag('test') { |tag| "Hello #{tag['name']}!" }
+    assert_parse_output 'Hello John!', '<r:test name="John" />'
+  end
+  
   def test_parse_tag__binding_render_tag_with_block
     define_tag('test') { |tag| "Hello #{tag.expand}!" }
     define_tag('hello') { |tag| tag.render('test') { tag.expand } }
@@ -248,6 +185,23 @@ class RadiusParserTest < Test::Unit::TestCase
     assert_parse_output %{Three Stooges: "Larry", "Moe", "Curly"}, %{Three Stooges: <r:each between=", ">"<r:item />"</r:each>}
   end
   
+  def test_parse_speed
+    define_tag "set" do |tag|
+      tag.globals.var = tag.attr['value']
+      ''
+    end
+    define_tag "var" do |tag|
+      tag.globals.var
+    end
+    parts = %w{decima nobis augue at facer processus commodo legentis odio lectorum dolore nulla esse lius qui nonummy ullamcorper erat ii notare}
+    multiplier = parts.map{|p| "#{p}=\"#{rand}\""}.join(' ')
+    assert_nothing_raised do
+      Timeout.timeout(10) do
+        assert_parse_output " false", %{<r:set value="false" #{multiplier} /> <r:var />}
+      end
+    end
+  end
+  
   def test_tag_option_for
     define_tag 'fun', :for => 'just for kicks'
     assert_parse_output 'just for kicks', '<r:fun />'
@@ -277,7 +231,22 @@ class RadiusParserTest < Test::Unit::TestCase
   
   def test_parse_fail_on_missing_end_tag
     assert_raises(Radius::MissingEndTagError) { @parser.parse("<r:reverse>") }
-    assert_raises(Radius::MissingEndTagError) { @parser.parse("<r:reverse><r:capitalize></r:reverse>") }
+  end
+  
+  def test_parse_fail_on_wrong_end_tag
+    assert_raises(Radius::WrongEndTagError) { @parser.parse("<r:reverse><r:capitalize></r:reverse>") }
+  end
+  
+  def test_parse_with_default_tag_prefix
+    define_tag("hello") { |tag| "Hello world!" }
+    @parser = Radius::Parser.new(@context)
+    assert_equal "<p>Hello world!</p>", @parser.parse('<p><radius:hello /></p>')
+  end
+  
+  def test_parse_with_other_radius_like_tags
+    define_tag('hello') { "hello" }
+    @parser = Radius::Parser.new(@context, :tag_prefix => "ralph")
+    assert_equal "<r:ralph:hello />", @parser.parse("<r:ralph:hello />")
   end
   
   protected