radius 0.7.5 → 0.8.0

data/lib/radius/parser/JavaScanner.rl

@@ -3,20 +3,37 @@
 	
 	action _prefix { mark_pfx = p; }
 	action prefix {
-    prefix = input.substring(mark_pfx, p);
+    prefix = String.valueOf(input.substring(mark_pfx, p));
 	}
   action _check_prefix {
 	  if ( !prefix.equals(tag_prefix) ) {
-      // have to manually add ':' / Sep
-      // pass the text through & reset state
-      pass_through(input.substring(tagstart, p) + ":");
+      // Pass through the entire tag markup as text
+      pass_through(input.substring(tagstart, p + 1));
+      // Reset all state
       prefix = "";
+      name = "";
+      attributes = RubyHash.newHash(runtime);
+      flavor = RubySymbol.newSymbol(runtime, "tasteless".intern());
+      tagstart = p + 1;
       fgoto main;
     }
   }
 
 	action _starttag { mark_stg = p; }
-	action starttag { name = input.substring(mark_stg, p); }
+	action starttag {
+    name = String.valueOf(input.substring(mark_stg, p));
+    if (name == null || name.trim().isEmpty()) {
+      // Pass through the entire tag markup as text
+      pass_through(input.substring(tagstart, p + 1));
+      // Reset all state
+      prefix = "";
+      name = "";
+      attributes = RubyHash.newHash(runtime);
+      flavor = RubySymbol.newSymbol(runtime, "tasteless".intern());
+      tagstart = p + 1;
+      fgoto main;
+    }
+	}
 	action _attr { mark_attr = p; }
 	action attr {
     attributes.op_aset(
@@ -40,7 +57,7 @@
 	# words
 	PrefixChar = [\-A-Za-z0-9._?] ;
 	NameChar = [\-A-Za-z0-9._:?] ;
-	TagName = NameChar+ >_starttag %starttag;
+	TagName = ([\-A-Za-z0-9._?]+ (':' [\-A-Za-z0-9._?]+)*) >_starttag %starttag;
 	Prefix = PrefixChar+ >_prefix %prefix;
   Open = "<";
   Sep = ":" >_check_prefix;
@@ -111,11 +128,23 @@ public class JavaScanner {
   }
 
   void tag(String prefix, String name, RubyHash attr, RubySymbol flavor) {
+    // Validate both prefix and name
+    if ((prefix == null || prefix.trim().isEmpty()) && 
+        (name == null || name.trim().isEmpty())) {
+        pass_through("<");
+        return;
+    }
+    
+    if (name == null || name.trim().isEmpty()) {
+        pass_through("<" + prefix + ":");
+        return;
+    }
+
     RubyHash tag = RubyHash.newHash(runtime);
     tag.op_aset(
       runtime.getCurrentContext(),
       RubySymbol.newSymbol(runtime, "prefix"),
-      RubyString.newString(runtime, prefix)
+      RubyString.newString(runtime, prefix != null ? prefix : "")
     );
     tag.op_aset(
       runtime.getCurrentContext(),

data/lib/radius/parser.rb

@@ -17,63 +17,92 @@ module Radius
   
     # 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, (context[:context] || context['context'])
-      end
-      options = Utility.symbolize_keys(options)
-      self.context = context ? context.dup : Context.new
-      self.tag_prefix = options[:tag_prefix] || 'radius'
-      self.scanner = options[:scanner] || default_scanner
+      context, options = normalize_initialization_params(context, options)
+      @context = context ? context.dup : Context.new
+      @tag_prefix = options[:tag_prefix] || 'radius'
+      @scanner = options[:scanner] || default_scanner
+      @stack = nil # Pre-initialize stack
     end
     
     # Parses string for tags, expands them, and returns the result.
     def parse(string)
-      @stack = [ ParseContainerTag.new { |t| Utility.array_to_s(t.contents) } ]
-      tokenize(string)
-      stack_up
+      @stack = [create_root_container]
+      process_tokens(scanner.operate(tag_prefix, string))
       @stack.last.to_s
     end
     
-    protected
-    # Convert the string into a list of text blocks and scanners (tokens)
-    def tokenize(string)
-      @tokens = scanner.operate(tag_prefix, string)
+    private
+
+    def normalize_initialization_params(context, options)
+      return [context['context'] || context[:context], context] if context.is_a?(Hash) && options.empty?
+      [context, Utility.symbolize_keys(options)]
     end
-    
-    def stack_up
-      @tokens.each do |t|
-        if t.is_a? String
-          @stack.last.contents << t
-          next
-        end
-        case t[:flavor]
-        when :open
-          @stack.push(ParseContainerTag.new(t[:name], t[:attrs]))
-        when :self
-          @stack.last.contents << ParseTag.new {@context.render_tag(t[:name], t[:attrs])}
-        when :close
-          popped = @stack.pop
-          raise WrongEndTagError.new(popped.name, t[:name], @stack) if popped.name != t[:name]
-          popped.on_parse { |b| @context.render_tag(popped.name, popped.attributes) { Utility.array_to_s(b.contents) } }
-          @stack.last.contents << popped
-        when :tasteless
-          raise TastelessTagError.new(t, @stack)
-        else
-          raise UndefinedFlavorError.new(t, @stack)
-        end
+
+    def create_root_container
+      ParseContainerTag.new { |t| Utility.array_to_s(t.contents) }
+    end
+
+    def process_tokens(tokens)
+      tokens.each { |token| process_token(token) }
+      validate_final_stack
+    end
+
+    def process_token(token)
+      return @stack.last.contents << token if token.is_a?(String)
+
+      case token[:flavor]
+      when :open    then handle_open_tag(token)
+      when :self    then handle_self_tag(token)
+      when :close   then handle_close_tag(token)
+      when :tasteless then raise TastelessTagError.new(token, @stack)
+      else raise UndefinedFlavorError.new(token, @stack)
       end
+    end
+
+    def handle_open_tag(token)
+      @stack.push(ParseContainerTag.new(token[:name], token[:attrs]))
+    end
+
+    def handle_self_tag(token)
+      @stack.last.contents << ParseTag.new { @context.render_tag(token[:name], token[:attrs]) }
+    end
+
+    def handle_close_tag(token)
+      popped = @stack.pop
+      validate_tag_match(popped, token[:name])
+      wrap_and_push_tag(popped)
+    end
+
+    def validate_tag_match(popped, name)
+      raise WrongEndTagError.new(popped.name, name, @stack) if popped.name != name
+    end
+
+    def wrap_and_push_tag(tag)
+      tag.on_parse { |b| @context.render_tag(tag.name, tag.attributes) { Utility.array_to_s(b.contents) } }
+      @stack.last.contents << tag
+    end
+
+    def validate_final_stack
       raise MissingEndTagError.new(@stack.last.name, @stack) if @stack.length != 1
     end
 
     def default_scanner
       if RUBY_PLATFORM == 'java'
-        require 'java'
-        require 'radius/parser/java_scanner.jar'
-        ::Radius.send(:include_package, 'radius.parser')
-        Radius::JavaScanner.new(JRuby.runtime)
+        load_java_scanner
       else
         Radius::Scanner.new
       end
     end
+
+    def load_java_scanner
+      if Gem::Version.new(JRUBY_VERSION) >= Gem::Version.new('9.3')
+        require 'jruby'
+      else
+        require 'java'
+      end
+      require 'radius/parser/java_scanner.jar'
+      ::Radius.send(:include_package, 'radius.parser')
+      Radius::JavaScanner.new(JRuby.runtime)
+    end
   end
 end

data/lib/radius/utility.rb

@@ -22,22 +22,13 @@ module Radius
     end
     
     def self.camelize(underscored_string)
-      string = ''
-      underscored_string.split('_').each { |part| string << part.capitalize }
-      string
+      underscored_string.split('_').map(&:capitalize).join
     end
 
-    if RUBY_VERSION[0,3] == '1.8'
-      def self.array_to_s(c)
-        c.to_s
-      end
-    else
-      def self.array_to_s(c)
-        c.map do |x| 
-          res = (x.is_a?(Array) ? array_to_s(x) : x.to_s)
-          (res.frozen? ? res.dup : res).force_encoding(Encoding::UTF_8) 
-        end.join
-      end
+    def self.array_to_s(c)
+      +c.map do |x|
+        x.is_a?(Array) ? array_to_s(x) : x.to_s
+      end.join
     end
   end
 end

data/lib/radius/version.rb

@@ -1,5 +1,5 @@
 module Radius #:nodoc:
-  VERSION = "0.7.5"
+  VERSION = "0.8.0"
   def self.version
     VERSION
   end

data/lib/radius.rb

@@ -1,11 +1,11 @@
-require 'radius/version'
-require 'radius/error'
-require 'radius/tag_definitions'
-require 'radius/delegating_open_struct'
-require 'radius/tag_binding'
-require 'radius/context'
-require 'radius/parse_tag'
-require 'radius/ord_string'
-require 'radius/parser/scanner'
-require 'radius/parser'
-require 'radius/utility'
+require_relative "radius/version"
+require_relative "radius/error"
+require_relative "radius/tag_definitions"
+require_relative "radius/delegating_open_struct"
+require_relative "radius/tag_binding"
+require_relative "radius/context"
+require_relative "radius/parse_tag"
+require_relative "radius/ord_string"
+require_relative "radius/parser/scanner"
+require_relative "radius/parser"
+require_relative "radius/utility"

data/radius.gemspec

@@ -2,13 +2,15 @@
 
 require File.join(File.dirname(__FILE__), 'lib', 'radius', 'version')
 Gem::Specification.new do |s|
-  s.name = %q{radius}
+  s.name = "radius"
   s.version = ::Radius.version
+  s.licenses = ["MIT"]
 
-  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{John W. Long (me@johnwlong.com)}, %q{David Chelimsky (dchelimsky@gmail.com)}, %q{Bryce Kerley (bkerley@brycekerley.net)}]
+  s.required_ruby_version = ">= 2.6.0"
+
+  s.authors = ["John W. Long", "David Chelimsky", "Bryce Kerley"]
   s.description = %q{Radius is a powerful tag-based template language for Ruby inspired by the template languages used in MovableType and TextPattern. It uses tags similar to XML, but can be used to generate any form of plain text (HTML, e-mail, etc...).}
-  s.email = %q{me@johnwlong.com}
+  s.email = ["me@johnwlong.com", "dchelimsky@gmail.com", "bkerley@brycekerley.net"]
   s.extra_rdoc_files = [
     "CHANGELOG",
     "CONTRIBUTORS",
@@ -22,5 +24,11 @@ Gem::Specification.new do |s|
 
   s.homepage = %q{http://github.com/jlong/radius}
   s.summary = %q{A tag-based templating language for Ruby.}
+
+  s.metadata = {
+    "homepage_uri" => "https://github.com/jlong/radius",
+    "changelog_uri" => "https://github.com/jlong/radius/blob/master/CHANGELOG",
+    "bug_tracker_uri" => "https://github.com/jlong/radius/issues"
+  }
 end
 

data/test/context_test.rb

@@ -1,6 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+require 'test_helper'
 
-class RadiusContextTest < Test::Unit::TestCase
+class RadiusContextTest < Minitest::Test
   include RadiusTestHelper
   
   class SuperContext < Radius::Context
@@ -24,7 +24,7 @@ class RadiusContextTest < Test::Unit::TestCase
       assert_kind_of Radius::Context, c
       c.define_tag('test') { 'just a test' }
     end
-    assert_not_equal Hash.new, @context.definitions
+    refute_equal Hash.new, @context.definitions
   end
   
   def test_initialize_with_arguments
@@ -35,6 +35,14 @@ class RadiusContextTest < Test::Unit::TestCase
     assert_equal 'arg', @context.name
   end
   
+  def test_dup_preserves_delegated_values
+    @context = Radius::Context.new
+    @context.globals.object = Object.new.tap { |o| def o.special_method; "special"; end }
+    duped = @context.dup
+
+    assert_equal "special", duped.globals.special_method, "Duped context should preserve delegated object methods"
+  end
+
   def test_with
     got = @context.with do |c|
       assert_equal @context, c
@@ -58,13 +66,13 @@ class RadiusContextTest < Test::Unit::TestCase
   def test_tag_missing
     class << @context
       def tag_missing(tag, attr, &block)
-        "undefined tag `#{tag}' with attributes #{attr.inspect}"
+        "undefined tag `#{tag}' with attributes #{attr.inspect.sub(" => ", "=>")}"
       end
     end
     
     text = ''
     expected = %{undefined tag `undefined_tag' with attributes {"cool"=>"beans"}}
-    assert_nothing_raised { text = @context.render_tag('undefined_tag', 'cool' => 'beans') }
+    text = @context.render_tag('undefined_tag', 'cool' => 'beans')
     assert_equal expected, text
   end
   

data/test/multithreaded_test.rb

@@ -1,11 +1,12 @@
 require 'thread'
-require 'test/unit'
+require 'test_helper'
 require 'radius'
+require 'etc'
 
-class MultithreadTest < Test::Unit::TestCase
+class MultithreadTest < Minitest::Test
 
   def setup
-    Thread.abort_on_exception
+    Thread.abort_on_exception = true
     @context = Radius::Context.new do |c|
       c.define_tag('thread') do |tag|
         "#{tag.locals.thread_id} / #{tag.globals.object_id}"
@@ -13,51 +14,67 @@ class MultithreadTest < Test::Unit::TestCase
     end
   end
 
-  if RUBY_PLATFORM == 'java'
-    require 'java'
-    # call once before the thread to keep from using hidden require in a thread
-    Radius::Parser.new
-    def test_runs_multithreaded
-      lock = java.lang.String.new("lock")
-      threads = []
-      1000.times do |t|
-        thread = Thread.new do
-                   parser = Radius::Parser.new(@context, :tag_prefix => 'r')
-                   parser.context.globals.thread_id = Thread.current.object_id
-                   expected = "#{Thread.current.object_id} / "+
-                              "#{parser.context.globals.object_id}"
-                   actual = parser.parse('<r:thread />')
-                   assert_equal expected, actual
-                 end
-        lock.synchronized do
-          threads << thread
+  def test_runs_multithreaded
+    thread_count = [Etc.nprocessors, 16].min
+    iterations_per_thread = 500
+    failures = Queue.new
+    results = Array.new(thread_count) { [] }
+    threads = []
+
+    thread_count.times do |i|
+      threads << Thread.new do
+        local_results = []
+        iterations_per_thread.times do
+          begin
+            thread_context = @context.dup
+            parser = Radius::Parser.new(thread_context, :tag_prefix => 'r')
+            parser.context.globals.thread_id = Thread.current.object_id
+            expected = "#{Thread.current.object_id} / #{parser.context.globals.object_id}"
+            result = parser.parse('<r:thread />')
+
+            local_results << {
+              result: result,
+              thread_id: Thread.current.object_id,
+              iteration: local_results.size
+            }
+
+            failures << "Expected: #{expected}, Got: #{result}" unless result == expected
+          rescue => e
+            failures << "Thread #{Thread.current.object_id} failed: #{e.message}\n#{e.backtrace.join("\n")}"
+          end
         end
-      end
-      lock.synchronized do
-        threads.each{|t| t.join }
+        results[i] = local_results
       end
     end
-  else
-    def test_runs_multithreaded
-      threads = []
-      mute = Mutex.new
-      1000.times do |t|
-        thread = Thread.new do
-                   parser = Radius::Parser.new(@context, :tag_prefix => 'r')
-                   parser.context.globals.thread_id = Thread.current.object_id
-                   expected = "#{Thread.current.object_id} / "+
-                              "#{parser.context.globals.object_id}"
-                   actual = parser.parse('<r:thread />')
-                   assert_equal expected, actual
-                 end
-        mute.synchronize do
-          threads << thread
-        end
-      end
-      mute.synchronize do
-        threads.each{|t| t.join }
+
+    threads.each(&:join)
+
+    # Only try to show failures if there are any
+    failure_message = if failures.empty?
+      nil
+    else
+      failed_items = []
+      5.times { failed_items << failures.pop unless failures.empty? }
+      "Thread failures detected:\n#{failures.size} times:\n#{failed_items.join("\n")}"
+    end
+
+    assert(failures.empty?, failure_message)
+    total_results = results.flatten.uniq.size
+    expected_unique_results = thread_count * iterations_per_thread
+
+    if total_results != expected_unique_results
+      duplicates = results.flatten.group_by { |r| r[:result] }
+                         .select { |_, v| v.size > 1 }
+
+      puts "\nDuplicates found:"
+      duplicates.each do |result, occurrences|
+        puts "\nResult: #{result[:result]}"
+        occurrences.each { |o| puts "  Thread: #{o[:thread_id]}, Iteration: #{o[:iteration]}" }
       end
     end
+
+    assert_equal expected_unique_results, total_results,
+      "Expected #{expected_unique_results} unique results (#{thread_count} threads × #{iterations_per_thread} iterations)"
   end
 
 end

data/test/ord_string_test.rb

@@ -1,7 +1,7 @@
-require 'test/unit'
+require 'test_helper'
 require 'radius'
 
-class RadiusOrdStringTest < Test::Unit::TestCase
+class RadiusOrdStringTest < Minitest::Test
 
   def test_string_slice_integer
     str = Radius::OrdString.new "abc"
@@ -15,4 +15,4 @@ class RadiusOrdStringTest < Test::Unit::TestCase
     assert_equal str[0..-1], "abc"
   end
 
-end
+end

data/test/parser_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
-class RadiusParserTest < Test::Unit::TestCase
+class RadiusParserTest < Minitest::Test
   include RadiusTestHelper
   
   def setup
@@ -211,11 +211,11 @@ class RadiusParserTest < Test::Unit::TestCase
     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
+    assert ->{
       Timeout.timeout(10) do
         assert_parse_output " false", %{<r:set value="false" #{multiplier} /> <r:var />}
       end
-    end
+    }.call
   end
   
   def test_tag_option_for

data/test/quickstart_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 
-class QuickstartTest < Test::Unit::TestCase
+class QuickstartTest < Minitest::Test
 
   def test_hello_world
     context = Radius::Context.new
@@ -83,7 +83,7 @@ class QuickstartTest < Test::Unit::TestCase
   
   class LazyContext < Radius::Context
     def tag_missing(tag, attr, &block)
-      "<strong>ERROR: Undefined tag `#{tag}' with attributes #{attr.inspect}</strong>"
+      "<strong>ERROR: Undefined tag `#{tag}' with attributes #{attr.inspect.sub(" => ", "=>")}</strong>"
     end
   end
   def test_tag_missing_example

data/test/squiggle_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/test_helper')
 require 'radius/parser/squiggle_scanner'
 
-class RadiusSquiggleTest < Test::Unit::TestCase
+class RadiusSquiggleTest < Minitest::Test
   include RadiusTestHelper
   
   def setup
@@ -181,11 +181,11 @@ class RadiusSquiggleTest < Test::Unit::TestCase
     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
+    assert ->{
       Timeout.timeout(10) do
         assert_parse_output " false", %[{set value="false" #{multiplier} /} {var /}]
       end
-    end
+    }.call
   end
   
   def test_tag_option_for

data/test/test_helper.rb

@@ -1,3 +1,4 @@
+require 'timeout'
 require 'simplecov'
 SimpleCov.start do
   add_filter 'test'
@@ -8,38 +9,32 @@ if ENV['COVERALLS']
   Coveralls.wear!
 end
 
-require 'timeout'
-
-unless defined? RADIUS_LIB
-
-  RADIUS_LIB = File.join(File.dirname(__FILE__), '..', 'lib')
-  $LOAD_PATH << RADIUS_LIB
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
 
-  require 'radius'
-  require 'test/unit'
+require 'radius'
 
-  module RadiusTestHelper
-    class TestContext < Radius::Context; end
+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("echo"      ) { |tag| tag.attr['value']  }
-        c.define_tag("wrap"      ) { |tag| "[#{tag.expand}]"  }
-        c.define_tag("attr") do |tag|
-          kv = tag.attr.keys.sort.collect{|k| "#{k.inspect}=>#{tag[k].inspect}"}
-          "{#{kv.join(', ')}}"
-        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("echo"      ) { |tag| tag.attr['value']  }
+      c.define_tag("wrap"      ) { |tag| "[#{tag.expand}]"  }
+      c.define_tag("attr") do |tag|
+        kv = tag.attr.keys.sort.collect{|k| "#{k.inspect}=>#{tag[k].inspect}"}
+        "{#{kv.join(', ')}}"
       end
     end
+  end
 
-    def define_tag(name, options = {}, &block)
-      @parser.context.define_tag name, options, &block
-    end
+  def define_tag(name, options = {}, &block)
+    @parser.context.define_tag name, options, &block
+  end
 
-    def define_global_tag(name, options = {}, &block)
-      @context.define_tag name, options, &block
-    end
+  def define_global_tag(name, options = {}, &block)
+    @context.define_tag name, options, &block
   end
 end
+require 'minitest/autorun'

data/test/utility_test.rb

@@ -1,7 +1,7 @@
-require 'test/unit'
+require 'test_helper'
 require 'radius'
 
-class RadiusUtilityTest < Test::Unit::TestCase
+class RadiusUtilityTest < Minitest::Test
   
   def test_symbolize_keys
     h = Radius::Utility.symbolize_keys({ 'a' => 1, :b => 2 })
@@ -27,4 +27,4 @@ class RadiusUtilityTest < Test::Unit::TestCase
   def test_array_to_s
     assert_equal Radius::Utility.array_to_s(['a', 1, [:c], 'brain'.freeze]), 'a1cbrain'
   end
-end
+end