th-bbcode 0.4.0

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in bbcode.gemspec
+gemspec

data/README.md

@@ -0,0 +1,78 @@
+A BBcode parser designed to be used with Ruby on Rails
+======================================================
+A bbcode parser gem you can include in your rails app to parse bbcode-formatted
+strings to HTML or any other format you like.
+
+The bbcode gem consists of 4 parts:
+
+- The `Tokenizer`-class, which converts the bbcode-formatted string to a stream
+  of tokens.
+- The `Parser`-class, which attempts to pair bbcode tags to bbcode elements.
+- The `Handler`-class, which converts bbcode elements anyway you like.
+- The `Helpers`-module, which adds a method to String, allowing you to convert
+  bbcode-formatted strings with a registered handler.
+
+Additionally, a `HtmlHandler` class is available. This class is a Handler
+designed to convert bbcode elements to HTML more easily.
+
+Installation:
+-------------
+Add the gem to the gemfile of your project.
+(todo: add examples)
+
+Usage:
+------
+Create and register a handler. In this example, I'm creating a HtmlHandler and
+I'm going to register it as `:html`.
+
+```ruby
+Bbcode::Base.register_handler :html, Bbcode::HtmlHandler.new(
+	:b => :strong,
+	:i => :em,
+	:url => [ :a, { :href => "%{0}" } ],
+	:txt => ->(element){ "#{element.content.source}" },
+	:img => ->(element){ %(<img src="#{CGI.escapeHTML(element.content.source)}">) },
+	:color => [ :span, { :style => "color: %{0};" } ]
+)
+```
+
+That's it! You can now parse any string as bbcode and convert it to html with
+the `:html`-handler like this:
+
+```ruby
+"[b]Hello, bold world![/]".as_bbcode.to :html
+# => <strong>Hello, bold world!</strong>
+```
+
+If you're using this gem in a rails project, I would recommend registering your
+handlers in an initializer.
+
+See examples in `spec/` folder for detailed examples of usage.
+
+Features:
+---------
+* Parsing regular bbcode tags like `[b]` and `[/b]`.
+* Parsing anonymous closing bbcode tags like `[/]`.
+* Parsing bbcode tags with arguments like `[a=foo, bar]`, `[a foo=1 bar:2]`,
+  `[a=foo, bar bar:1 foo=2]` and `[a="foo" b='bar']`.
+* Parsing nested bbcode elements like `[b]bold[i]and italic[/]only bold[/]`,
+  which might result to `<b>bold<i>and italic</i>only bold</b>`.
+* Parsing incorrectly nested bbcode elements like `[b]bold[i]and italic[/b]only
+  italic[/]`, which might result to `<b>bold<i>and italic</i></b><i>only
+  italic</i>`.
+
+Todo:
+-----
+* An easier way to handle text around bbcode tags to, for example, add smileys
+  and wrap hyperlinks to URLs. Currently, the only way to achieve this is by
+  adding a `:"#text"`-handler to your handler and adding the functionality
+  yourself.
+* An easier way to include the content, source or content-source in the
+  `HtmlHandler`-class.
+* Review handleability of element interrupts.
+* Review regular expression matching bbcode tags to allow tags having names
+  containing characters other than `A-Z`, `0-9`, `_` and `-`, possibly based on
+  the current registered tags.
+* Add CDATA-like feature for bbcode tags to allow tags to be ignored within
+  certain elements. Useful for `[code]`-tags.
+* Add a default handler with the most common bbcode tags.

data/Rakefile

@@ -0,0 +1,3 @@
+# Must... Resist... Deleting... File with unkown use...
+
+require 'bundler/gem_tasks'

data/bbcode.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bbcode/version"
+
+Gem::Specification.new do |s|
+	s.name        = "th-bbcode"
+	s.version     = Bbcode::VERSION
+	s.authors     = ["Toby Hinloopen"]
+	s.email       = ["toby@kutcomputers.nl"]
+	s.homepage    = ""
+	s.summary     = %q{BBCode parser}
+	s.description = %q{Gem for parsing bbcode-formatted strings to HTML or any other formatting you like (or don't like).}
+
+	s.rubyforge_project = "bbcode"
+
+	s.add_development_dependency "rspec", "~> 2.6"
+	s.add_dependency "activesupport", "~> 3.0.9"
+	s.add_dependency "actionpack", "~> 3.0.9"
+	s.add_dependency "i18n", "~> 0.5.0"
+
+	s.files         = `git ls-files`.split("\n")
+	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+	s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+	s.require_paths = ["lib"]
+end

data/lib/bbcode/base.rb

@@ -0,0 +1,22 @@
+module Bbcode
+	class Base
+		@@handlers = {}.with_indifferent_access
+
+		def initialize( string )
+			@string = string
+		end
+
+		def to( handler )
+			handler = @@handlers[handler]
+			raise "Handler #{handler} isn't registered" if handler.blank?
+			Parser.new(Tokenizer.new).parse @string, handler
+			result = handler.get_document.content.to_s
+			handler.clear
+			result
+		end
+
+		def self.register_handler( name, handler )
+			@@handlers[name] = handler
+		end
+	end
+end

data/lib/bbcode/element.rb

@@ -0,0 +1,37 @@
+require "bbcode/node_list"
+
+module Bbcode
+	class Element
+		def initialize( handler_element )
+			@handler_element = handler_element
+		end
+
+		def tagname
+			@handler_element.tagname
+		end
+
+		def attributes
+			@handler_element.attributes
+		end
+
+		def []( key )
+			@handler_element.attributes[key]
+		end
+
+		def source
+			@handler_element.source
+		end
+
+		def source_wraps_content( content = nil )
+			"#{@handler_element.start_source}#{content || self.content}#{@handler_element.end_source}"
+		end
+
+		def content
+			NodeList.new @handler_element.handler, @handler_element.childs.map{ |child_handler_element| child_handler_element.is_a?(String) ? child_handler_element : child_handler_element.element }
+		end
+
+		def to_s
+			@handler_element.handler.get_element_handler(tagname).call(self)
+		end
+	end
+end

data/lib/bbcode/handler.rb

@@ -0,0 +1,71 @@
+require "bbcode/handler_element"
+
+module Bbcode
+	class Handler
+		attr_accessor :element_handlers
+
+		def initialize( element_handlers = nil )
+			@element_handlers = {}.with_indifferent_access
+			@handler_element_stack = []
+			self.clear
+			register_element_handlers element_handlers unless element_handlers.blank?
+			@interruption_stack = []
+		end
+
+		def register_element_handlers( element_handlers )
+			element_handlers.each do |k, v|
+				register_element_handler k, v
+			end
+		end
+
+		def register_element_handler( name, handler )
+			@element_handlers[name] = handler
+		end
+
+		def start_element( tagname, attributes, source )
+			handler_element = HandlerElement.new self, tagname, attributes, source
+			current_handler_element.childs << handler_element
+			@handler_element_stack << handler_element
+		end
+
+		def interrupt_element( tagname )
+			# TODO: Add better way to handle interrupts
+			@interruption_stack << current_handler_element
+			end_element tagname, ""
+		end
+
+		def continue_element( tagname )
+			# TODO: Add better way to handle interrupts
+			handler_element = @interruption_stack.pop
+			start_element handler_element.tagname, handler_element.attributes, ""
+		end
+
+		def end_element( tagname, source )
+			raise "Unexpected end of #{tagname.inspect}, expected #{current_handler_element.tagname.inspect}" if tagname != current_handler_element.tagname
+			current_handler_element.end_element source
+			@handler_element_stack.pop
+		end
+
+		def text( text )
+			current_handler_element.childs << text
+		end
+
+		def get_document
+			@handler_element_stack.first.element
+		end
+
+		def clear
+			@handler_element_stack.clear
+			@handler_element_stack << HandlerElement.new( self, :"#document", {}, "" )
+		end
+
+		def get_element_handler( name )
+			@element_handlers[name] || ->(element){ element.is_a?(String) ? element : element.source_wraps_content }
+		end
+
+		protected
+		def current_handler_element
+			@handler_element_stack.last
+		end
+	end
+end

data/lib/bbcode/handler_element.rb

@@ -0,0 +1,27 @@
+require "bbcode/element"
+
+module Bbcode
+	# Private data source for an Element updated by the Handler
+	class HandlerElement
+		attr_accessor :childs
+		attr_reader :element, :tagname, :attributes, :handler, :start_source, :end_source
+
+		def initialize( handler, tagname, attributes, start_source )
+			@handler = handler
+			@tagname = tagname
+			@attributes = attributes
+			@start_source = start_source
+			@end_source = nil
+			@childs = []
+			@element = Element.new(self)
+		end
+
+		def end_element( source )
+			@end_source = source
+		end
+
+		def source
+			"#{@start_source}#{@element.content.source}#{@end_source}"
+		end
+	end
+end

data/lib/bbcode/helpers.rb

@@ -0,0 +1,7 @@
+module Bbcode
+	module Helpers
+		def as_bbcode
+			Base.new self.to_s
+		end
+	end
+end

data/lib/bbcode/html_handler.rb

@@ -0,0 +1,24 @@
+require "bbcode/handler"
+
+module Bbcode
+	class HtmlHandler < Handler
+		def initialize( element_handlers = nil )
+			super :"#text" => ->(text){ CGI.escapeHTML(text) }
+			register_element_handlers element_handlers unless element_handlers.nil?
+		end
+
+		def register_element_handler( name, handler )
+			unless handler.is_a?(Proc)
+				args = *handler
+				target_tagname = args.shift
+				attributes = args.first
+				handler = ->(element){
+					content_tag(target_tagname, element.content, !attributes ? {} : Hash[attributes.map{ |k, v|
+						[k, v.gsub(/%{[^}]+}/) { |m| CGI.escapeHTML element[m[3] == ":" ? m[3...-1].to_sym : m[2...-1].to_i] }]
+					}], false)
+				}
+			end
+			super name, handler
+		end
+	end
+end

data/lib/bbcode/node_list.rb

@@ -0,0 +1,23 @@
+module Bbcode
+	# An array with Elements and strings
+	class NodeList < Array
+		def initialize( handler, nodes = [] )
+			super nodes
+			@handler = handler
+		end
+
+		def source
+			self.map{ |element| element.is_a?(String) ? element : element.source }.join
+		end
+
+		def to_s
+			self.map{ |element|
+				@handler.get_element_handler(element.is_a?(String) ? :"#text" : element.tagname).call(element)
+			}.join
+		end
+
+		def with_handler( handler )
+			NodeList.new handler, self
+		end
+	end
+end

data/lib/bbcode/parser.rb

@@ -0,0 +1,50 @@
+module Bbcode
+	# Attempts to pair a stream of tokens created by a tokenizer
+	class Parser
+		attr_accessor :tokenizer
+
+		def initialize( tokenizer = nil )
+			@tags_stack = []
+			self.tokenizer = tokenizer unless tokenizer.blank?
+		end
+
+		def tokenizer=( tokenizer )
+			raise "#{tokenizer.inspect} appears not to be a valid tokenizer for it does not respond to :tokenize" unless tokenizer.respond_to?(:tokenize)
+			@tokenizer = tokenizer
+		end
+
+		def text( text )
+			@handler.send :text, text
+		end
+
+		def start_element( tagname, attributes, source )
+			@tags_stack << tagname
+			@handler.send :start_element, tagname, attributes, source
+		end
+
+		def end_element( tagname, source )
+			return @tags_stack.last.blank? ? self.text(source) : end_element(@tags_stack.last, source) if tagname.blank?
+			return self.text(source) unless @tags_stack.include?(tagname)
+
+			@interruption_stack = []
+			while @tags_stack.last != tagname do
+				@interruption_stack << @tags_stack.last
+				@handler.send :interrupt_element, @tags_stack.pop
+			end
+
+			@handler.send :end_element, @tags_stack.pop, source
+
+			while !@interruption_stack.empty? do
+				@tags_stack << @interruption_stack.last
+				@handler.send :continue_element, @interruption_stack.pop
+			end
+		end
+
+		def parse( document, handler )
+			@handler = handler
+			@tokenizer.tokenize document do |*args|
+				self.send *args if [:start_element, :end_element, :text].include?(args.first)
+			end
+		end
+	end
+end

data/lib/bbcode/tokenizer.rb

@@ -0,0 +1,74 @@
+module Bbcode
+	# Scans a string and converts it to a stream of bbcode tokens.
+	class Tokenizer
+		BBCODE_TAG_PATTERN = /\[(\/?)([a-z0-9_-]*)(\s*=?(?:(?:\s*(?:(?:[a-z0-9_-]+)|(?<=\=))\s*[:=]\s*)?(?:"[^"\\]*(?:\\[\s\S][^"\\]*)*"|'[^'\\]*(?:\\[\s\S][^'\\]*)*'|[^\]\s,]+|(?<=,)(?=\s*,))\s*,?\s*)*)\]/i
+		ATTRIBUTE_PATTERN = /(?:\s*(?:([a-z0-9_-]+)|^)\s*[:=]\s*)?("[^"\\]*(?:\\[\s\S][^"\\]*)*"|'[^'\\]*(?:\\[\s\S][^'\\]*)*'|[^\]\s,]+|(?<=,)(?=\s*,))\s*,?/i
+		UNESCAPE_PATTERN = /\\(.)/
+
+		def parse_attributes_string( attributes_string )
+			attrs = HashWithIndifferentAccess.new
+			return attrs if attributes_string.nil?
+
+			next_anonymous_key = -1
+			attributes_string.scan ATTRIBUTE_PATTERN do |key, value|
+				skip_value = key.blank? && value.blank?
+				key = next_anonymous_key+=1 if key.blank?
+				unless skip_value
+					value = value[1...-1].gsub UNESCAPE_PATTERN, "\\1" if value[0] == value[-1] && ["'", '"'].include?(value[0])
+					attrs[key] = value
+				end
+			end
+
+			return attrs
+		end
+
+		# Parses the document as BBCode-formatted text and calls block with bbcode
+		# events.
+		#
+		# The block is called with the following events:
+		# - :text, text
+		#   A text-event with an additional parameter containing the actual text.
+		# - :start_element, element_name, element_arguments
+		#   An element-event with 2 additional parameters: The element name as a
+		#   symbol and the element attributes as a hash. This events indicate the
+		#   start of the element.
+		# - :end_element, element_name
+		#   An element-event indicating the end of an element. Optionally, the
+		#   element_name is added as a parameter. If no parameter is present, it is
+		#   assumed to be the last started element.
+		#
+		# Note that :start_element and :end_element are not guaranteed to be called
+		# evenly or in the "correct" order. You must match correct start- and end
+		# tags yourself to create the elements.
+		#
+		# Also note that :text events are not guaranteed to match the whole text.
+		# In some cases, the text might be separated to multiple :text events, even
+		# though there are no nodes in between.
+		def tokenize( document, &handler )
+			while !(match = BBCODE_TAG_PATTERN.match(document)).nil?
+				offset = match.begin(0)
+				elem_source = match[0]
+
+				handler.call :text, document[0...offset] unless offset == 0
+
+				elem_is_closing_tag = match[1]=='/'
+				elem_name = (match[2].length > 0 && match[2].to_sym) || nil
+				elem_attr_string = (match[3].length > 0 && match[3]) || nil
+
+				if (elem_is_closing_tag && !elem_attr_string) || (!elem_is_closing_tag && elem_name)
+					if !elem_is_closing_tag
+						handler.call :start_element, elem_name, parse_attributes_string(elem_attr_string), elem_source
+					else
+						handler.call :end_element, elem_name, elem_source
+					end
+				else
+					handler.call :text, elem_source
+				end
+
+				document = document[(offset+elem_source.length)..-1]
+			end
+
+			handler.call :text, document unless document.length == 0
+		end
+	end
+end

data/lib/bbcode/version.rb

@@ -0,0 +1,3 @@
+module Bbcode
+	VERSION = "0.4.0"
+end

data/lib/bbcode.rb

@@ -0,0 +1,11 @@
+require "bbcode/version"
+require "bbcode/tokenizer"
+require "bbcode/parser"
+require "bbcode/handler"
+require "bbcode/html_handler"
+require "bbcode/base"
+require "bbcode/helpers"
+
+module Bbcode
+	String.send :include, Bbcode::Helpers
+end

data/spec/lib/bbcode/base_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper.rb'
+
+describe Bbcode::Base do
+	it "should enable a handler to be registered and used" do
+		Bbcode::Base.register_handler :test, Bbcode::Handler.new
+		Bbcode::Base.new("test").to(:test).should eql("test")
+	end
+end

data/spec/lib/bbcode/handler_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper.rb'
+
+def get_handled_parser_result( string )
+	quote_handler = Bbcode::Handler.new()
+
+	handler = Bbcode::Handler.new({
+		:b => ->(element){ "<strong>#{element.content}</strong>" },
+		:i => ->(element){ "<em>#{element.content}</em>" },
+		:url => ->(element){ %(<a href="#{CGI.escapeHTML(element[0])}">#{element.content}</a>) },
+		:txt => ->(element){ "#{CGI.escapeHTML(element.content.source)}" },
+		:img => ->(element){ %(<img src="#{CGI.escapeHTML(element.content.source)}">) },
+		:quote => ->(element){ %(<blockquote>#{element.content.with_handler(quote_handler)}</blockquote>) },
+		:color => ->(element){ %(<span style="color: #{CGI.escapeHTML(element[0])};">#{element.content}</span>) },
+		:"#text" => ->(text){ CGI.escapeHTML(text) }
+	})
+
+	quote_handler.register_element_handlers handler.element_handlers.merge({
+		:img => ->(element){ %(<a href="#{element.content.source}">image</a>) },
+		:quote => ->(element){ "[...]" }
+	})
+
+	parser = Bbcode::Parser.new Bbcode::Tokenizer.new
+	parser.parse string, handler
+	"#{handler.get_document.content}"
+end
+
+describe Bbcode::Handler do
+	it "should handle text without bbcode" do
+		get_handled_parser_result("Hello, World!").should eql("Hello, World!")
+	end
+
+	it "should handle the text handler" do
+		get_handled_parser_result("&").should eql("&amp;")
+	end
+
+	it "should handle a bbcode tag" do
+		get_handled_parser_result("[b]bold[/]").should eql("<strong>bold</strong>")
+	end
+
+	it "should ignore unregistered elements" do
+		get_handled_parser_result("[foo]text[/foo]").should eql("[foo]text[/foo]")
+	end
+
+	it "should handle bbcode inside an ignored element" do
+		get_handled_parser_result("[foo][b]bold[/b][/foo]").should eql("[foo]<strong>bold</strong>[/foo]")
+	end
+
+	it "should handle nested bbcode tags" do
+		get_handled_parser_result("[b]bold and [i]italic[/][/]").should \
+			eql("<strong>bold and <em>italic</em></strong>")
+	end
+
+	it "should handle attributes in a bbcode tag" do
+		get_handled_parser_result("[url=http://google.com/]google[/url]").should \
+			eql(%(<a href="http://google.com/">google</a>))
+	end
+
+	it "should handle basic tag interrupts" do
+		get_handled_parser_result("[b]bold[i]and italic[/b]only italic[/i]").should \
+			eql("<strong>bold<em>and italic</em></strong><em>only italic</em>")
+	end
+
+	it "should resend attributes in tag interrupts" do
+		get_handled_parser_result("[b]bold[color=red]and red[/b]but not bold[/]").should \
+			eql(%(<strong>bold<span style="color: red;">and red</span></strong><span style="color: red;">but not bold</span>))
+	end
+
+	it "should be able to render the source of an element's contents" do
+		get_handled_parser_result("[txt][b]ignored element[/b][/txt]").should \
+			eql("[b]ignored element[/b]")
+	end
+
+	it "should be able to switch handlers" do
+		get_handled_parser_result("[quote][img]epic.jpg[/img][/quote][img]epic.jpg[/img]").should \
+			eql(%(<blockquote><a href="epic.jpg">image</a></blockquote><img src="epic.jpg">))
+	end
+end

data/spec/lib/bbcode/helpers_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper.rb'
+
+quote_handler = Bbcode::Handler.new()
+
+handler = Bbcode::Handler.new({
+	:b => ->(element){ "<strong>#{element.content}</strong>" },
+	:i => ->(element){ "<em>#{element.content}</em>" },
+	:url => ->(element){ %(<a href="#{CGI.escapeHTML(element[0])}">#{element.content}</a>) },
+	:txt => ->(element){ "#{element.content.source}" },
+	:img => ->(element){ %(<img src="#{element.content.source}">) },
+	:quote => ->(element){ %(<blockquote>#{element.content.with_handler(quote_handler)}</blockquote>) },
+	:color => ->(element){ %(<span style="color: #{CGI.escapeHTML(element[0])};">#{element.content}</span>) },
+	:"#text" => ->(text){ CGI.escapeHTML(text) }
+})
+
+quote_handler.register_element_handlers handler.element_handlers.merge({
+	:img => ->(element){ %(<a href="#{element.content.source}">image</a>) },
+	:quote => ->(element){ "[...]" }
+})
+
+Bbcode::Base.register_handler :html, handler
+Bbcode::Base.register_handler :text, Bbcode::Handler.new()
+
+describe Bbcode::Helpers do
+	it "should enable a string to use a registered helper" do
+		"test".as_bbcode.to(:text).should eql("test")
+	end
+
+	it "should be able to parse for a second time without being affected by the first" do
+		"test 2".as_bbcode.to(:text).should eql("test 2")
+	end
+
+	it "should enable a string to be parsed as bbcode" do
+		"[b]bold[/]".as_bbcode.to(:html).should eql("<strong>bold</strong>")
+	end
+
+	it "should be able to process non-ascii characters" do
+		# load UTF-8 content from a file and parse it
+	end
+end

data/spec/lib/bbcode/html_handler_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper.rb'
+
+def get_handled_html_parser_result( string )
+	quote_handler = Bbcode::HtmlHandler.new()
+
+	handler = Bbcode::HtmlHandler.new({
+		:b => :strong,
+		:i => :em,
+		:url => [ :a, { :href => "%{0}" } ],
+		:txt => ->(element){ "#{CGI.escapeHTML(element.content.source)}" },
+		:img => ->(element){ %(<img src="#{CGI.escapeHTML(element.content.source)}">) },
+		:quote => ->(element){ %(<blockquote>#{element.content.with_handler(quote_handler)}</blockquote>) },
+		:color => [ :span, { :style => "color: %{0};" } ]
+	})
+
+	quote_handler.register_element_handlers handler.element_handlers.merge({
+		:img => ->(element){ %(<a href="#{CGI.escapeHTML(element.content.source)}">image</a>) },
+		:quote => ->(element){ "[...]" }
+	})
+
+	parser = Bbcode::Parser.new Bbcode::Tokenizer.new
+	parser.parse string, handler
+	"#{handler.get_document.content}"
+end
+
+describe Bbcode::HtmlHandler do
+	it "should handle text without bbcode" do
+		get_handled_html_parser_result("Hello, World!").should eql("Hello, World!")
+	end
+
+	it "should escape text" do
+		get_handled_html_parser_result("&").should eql("&amp;")
+	end
+
+	it "should handle a bbcode tag" do
+		get_handled_html_parser_result("[b]bold[/]").should eql("<strong>bold</strong>")
+	end
+
+	it "should handle nested bbcode tags" do
+		get_handled_html_parser_result("[b]bold and [i]italic[/][/]").should \
+			eql("<strong>bold and <em>italic</em></strong>")
+	end
+
+	it "should handle attributes in a bbcode tag" do
+		get_handled_html_parser_result("[url=http://google.com/]google[/url]").should \
+			eql(%(<a href="http://google.com/">google</a>))
+	end
+
+	it "should handle basic tag interrupts" do
+		get_handled_html_parser_result("[b]bold[i]and italic[/b]only italic[/i]").should \
+			eql("<strong>bold<em>and italic</em></strong><em>only italic</em>")
+	end
+
+	it "should resend attributes in tag interrupts" do
+		get_handled_html_parser_result("[b]bold[color=red]and red[/b]but not bold[/]").should \
+			eql(%(<strong>bold<span style="color: red;">and red</span></strong><span style="color: red;">but not bold</span>))
+	end
+
+	it "should be able to render the source of an element's contents" do
+		get_handled_html_parser_result("[txt][b]ignored element[/b][/txt]").should \
+			eql("[b]ignored element[/b]")
+	end
+
+	it "should be able to switch handlers" do
+		get_handled_html_parser_result("[quote][img]epic.jpg[/img][/quote][img]epic.jpg[/img]").should \
+			eql(%(<blockquote><a href="epic.jpg">image</a></blockquote><img src="epic.jpg">))
+	end
+
+	it "should be able to escape content within tags" do
+		get_handled_html_parser_result("[i]&[/i]").should eql("<em>&amp;</em>")
+	end
+
+	it "should be able to escape content within attributes" do
+		get_handled_html_parser_result("[url=http://youtube.com/watch?v=FErzTCzR5N4&feature=]epic tune[/]").should \
+			eql(%(<a href="http://youtube.com/watch?v=FErzTCzR5N4&amp;feature=">epic tune</a>))
+	end
+end

data/spec/lib/bbcode/parser_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper.rb'
+
+class BlockHandler
+	def initialize( block )
+		@block = block
+	end
+
+	def method_missing(*args)
+		@block.call *args
+	end
+end
+
+def get_parser_results(string, strip_source = true)
+	parser = Bbcode::Parser.new Bbcode::Tokenizer.new
+	results = []
+	parser.parse string, BlockHandler.new(->(*args) {
+		args.pop if strip_source && [:end_element, :start_element].include?(args.first) # pop the source
+		results.push args
+	})
+	results
+end
+
+describe Bbcode::Parser do
+	it "should parse text without bbcode" do
+		get_parser_results("Hello, world!")[0].should eql([:text, "Hello, world!"])
+	end
+
+	it "should parse a simple bbcode element" do
+		get_parser_results("[b]text[/b]").should \
+			eql([ [ :start_element, :b, {} ],
+			      [ :text, "text" ],
+			      [ :end_element, :b ] ])
+	end
+
+	it "should parse a simple bbcode element with shorthand closing tag" do
+		get_parser_results("[b]text[/]").should \
+			eql([ [ :start_element, :b, {} ],
+			      [ :text, "text" ],
+			      [ :end_element, :b ] ])
+	end
+
+	it "should provide the actual sourcecode of the elements" do
+		get_parser_results("[b a = 1, b:2, c='1'][/][url=http://www.google.com/][/url]", false).should \
+			eql([ [ :start_element, :b, { :a => "1", :b => "2", :c => "1" }.with_indifferent_access, "[b a = 1, b:2, c='1']"],
+			      [ :end_element, :b, "[/]" ],
+			      [ :start_element, :url, { 0 => "http://www.google.com/" }, "[url=http://www.google.com/]" ],
+			      [ :end_element, :url, "[/url]" ] ])
+	end
+
+	it "should fire an interrupt for incorrect nested elements" do
+		get_parser_results("[b]bold[i]and italic[/b]but not bold[/i]nor italic").should \
+			eql([ [ :start_element, :b, {} ],
+			      [ :text, "bold" ],
+			      [ :start_element, :i, {} ],
+			      [ :text, "and italic" ],
+			      [ :interrupt_element, :i ],
+			      [ :end_element, :b ],
+			      [ :continue_element, :i ],
+			      [ :text, "but not bold" ],
+			      [ :end_element, :i ],
+			      [ :text, "nor italic" ] ])
+	end
+
+	it "should fire multiple interrupts for multiple incorrect nested elements" do
+		get_parser_results("[u]a[b]b[i]c[/u]d[/i]e[/b]").should \
+			eql([ [ :start_element, :u, {} ],
+			      [ :text, "a" ],
+			      [ :start_element, :b, {} ],
+			      [ :text, "b" ],
+			      [ :start_element, :i, {} ],
+			      [ :text, "c" ],
+			      [ :interrupt_element, :i ],
+			      [ :interrupt_element, :b ],
+			      [ :end_element, :u ],
+			      [ :continue_element, :b ],
+			      [ :continue_element, :i ],
+			      [ :text, "d" ],
+			      [ :end_element, :i ],
+			      [ :text, "e" ],
+			      [ :end_element, :b ]])
+	end
+end

data/spec/lib/bbcode/tokenizer_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper.rb'
+
+def get_tokenizer_results(string, strip_source = true)
+	tokenizer = Bbcode::Tokenizer.new
+	results = []
+	tokenizer.tokenize string do |*args|
+		args.pop if strip_source && [:end_element, :start_element].include?(args.first) # pop the source
+		results.push args
+	end
+	results
+end
+
+describe Bbcode::Tokenizer do
+	it "should parse text without bbcode" do
+		get_tokenizer_results("Hello, world!")[0].should eql([:text, "Hello, world!"])
+	end
+
+	it "should parse a simple bbcode tag" do
+		get_tokenizer_results("[b]")[0].should eql([:start_element, :b, {}])
+	end
+
+	it "should provide the actual source of the bbcode tag" do
+		get_tokenizer_results("[b a = 1, b:2, c='1'][/][url=http://www.google.com/][/url]", false).should \
+			eql([ [ :start_element, :b, { :a => "1", :b => "2", :c => "1" }.with_indifferent_access, "[b a = 1, b:2, c='1']"],
+			      [ :end_element, nil, "[/]" ],
+			      [ :start_element, :url, { 0 => "http://www.google.com/" }, "[url=http://www.google.com/]" ],
+			      [ :end_element, :url, "[/url]" ] ])
+	end
+
+	it "should parse 4 simple bbcode tags with text" do
+		get_tokenizer_results("[b]bold[i]and italic[/b]but not bold anymore[/i]nor italic")
+	end
+
+	it "should process text before the first bbcode tag" do
+		get_tokenizer_results("text[b]")[0].should eql([:text, "text"])
+	end
+
+	it "should process text after the last bbcode tag" do
+		get_tokenizer_results("[b]text")[1].should eql([:text, "text"])
+	end
+
+	it "should parse an anonymous closing tag" do
+		get_tokenizer_results("[/]")[0].should eql([:end_element, nil])
+	end
+
+	it "should parse a single, regular unnamed argument" do
+		get_tokenizer_results("[url=http://www.google.com/]")[0].should \
+			eql([:start_element, :url, { 0 => "http://www.google.com/" }])
+	end
+
+	it "should parse a quoted, unnamed argument without the equals-to sign" do
+		get_tokenizer_results("[url'http://www.google.nl/']")[0].should \
+			eql([:start_element, :url, { 0 => "http://www.google.nl/" }])
+	end
+
+	it "should parse multiple unnamed arguments" do
+		get_tokenizer_results("[video=640, 480,,1]")[0].should \
+			eql([:start_element, :video, { 0 => "640", 1 => "480", 3 => "1" }]);
+	end
+
+	it "should parse quoted unnamed arguments with escaped characters" do
+		get_tokenizer_results(%([abbr='It\\'s a test', "...a \\"test\\"!"]))[0].should \
+			eql([:start_element, :abbr, { 0 => "It's a test", 1 => '...a "test"!' }])
+	end
+
+	it "should parse quoted named arguments with escaped characters" do
+		get_tokenizer_results(%([abbr a='It\\'s a test', b: "...a \\"test\\"!"]))[0].should \
+			eql([:start_element, :abbr, { :a => "It's a test", :b => '...a "test"!' }.with_indifferent_access])
+	end
+
+	it "should parse mixed unnamed and named arguments" do
+		get_tokenizer_results(%([a=foo, bar foo=1 bar:2]))[0].should \
+			eql([:start_element, :a, { 0 => "foo", 1 => "bar", :foo => "1", :bar => "2" }.with_indifferent_access])
+	end
+
+	it "should ignore the quotes of an attribute value if the quote-pair is incomplete or incorrect" do
+		get_tokenizer_results(%([a "test]))[0].should eql([:start_element, :a, { 0 => "\"test" }])
+	end
+
+	it "should parse various key=value attribute pairs" do
+		get_tokenizer_results(%([table width = 600 height=300 background-color= \"black\" background-image =url('image.jpg')]))[0].should \
+			eql([:start_element, :table, { :width => "600", :height => "300", :"background-color" => "black", :"background-image" => "url('image.jpg')" }.with_indifferent_access])
+	end
+
+	it "should parse key:value attribute pairs separated with optional comma" do
+		get_tokenizer_results(%([alt ding: a, banana: b]))[0].should \
+			eql([:start_element, :alt, { :ding => "a", :banana => "b" }.with_indifferent_access])
+	end
+
+	it "should ignore the ] in the attribute value" do
+		get_tokenizer_results(%([testing "with a ] in my attribute!"])).should \
+			eql([[:start_element, :testing, { 0 => "with a ] in my attribute!" }]])
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'active_support/all'
+require 'action_view/helpers/capture_helper'
+require 'action_view/helpers/tag_helper'
+
+include  ActionView::Helpers::TagHelper
+
+require 'bbcode'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: th-bbcode
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Toby Hinloopen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70176012816200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70176012816200
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70176012815280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: *70176012815280
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: &70176012814380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: *70176012814380
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70176012813460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70176012813460
+description: Gem for parsing bbcode-formatted strings to HTML or any other formatting
+  you like (or don't like).
+email:
+- toby@kutcomputers.nl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bbcode.gemspec
+- lib/bbcode.rb
+- lib/bbcode/base.rb
+- lib/bbcode/element.rb
+- lib/bbcode/handler.rb
+- lib/bbcode/handler_element.rb
+- lib/bbcode/helpers.rb
+- lib/bbcode/html_handler.rb
+- lib/bbcode/node_list.rb
+- lib/bbcode/parser.rb
+- lib/bbcode/tokenizer.rb
+- lib/bbcode/version.rb
+- spec/lib/bbcode/base_spec.rb
+- spec/lib/bbcode/handler_spec.rb
+- spec/lib/bbcode/helpers_spec.rb
+- spec/lib/bbcode/html_handler_spec.rb
+- spec/lib/bbcode/parser_spec.rb
+- spec/lib/bbcode/tokenizer_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: bbcode
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: BBCode parser
+test_files:
+- spec/lib/bbcode/base_spec.rb
+- spec/lib/bbcode/handler_spec.rb
+- spec/lib/bbcode/helpers_spec.rb
+- spec/lib/bbcode/html_handler_spec.rb
+- spec/lib/bbcode/parser_spec.rb
+- spec/lib/bbcode/tokenizer_spec.rb
+- spec/spec_helper.rb