ubbparser 0.1.6 → 0.1.7

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YWNkMzdhZmM1MTE1ZjAyYzRiZjhiNGU1YjgwZTJiODZiYTU2M2UxOQ==
+    ZjVmZTQ5NWE1Y2FkMzRhNDE5ODRmMjMzYzVkYmRlZjA5MzgyYzYyZQ==
   data.tar.gz: !binary |-
-    YjgwM2Y4MGM4M2Y0NmMwN2VhNmFjN2NjNTVhNzE0OGE4MmFhZWU3Zg==
+    NmY0MzIwNjkxYzQxYjBmNjA5NzcxMDMwMjNiMTQ5MDg2NmE5Yzk3Zg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    MzA5Y2MyMjdlYTVlNTQyMDdkOGExYTIwNzgxOWRhYzNjZmQxNjY0YmI1ZTU3
-    MzUwNzRkNWUyNTM1MzMyZDczZmE3NzA3MTExN2ZkYjFjMmYzMTE5ZTIwYWJj
-    NWJjOWJmYjdjMTJkMTU2ZDRlNGEyOTViODA0ZDhkOTY3MjFiN2M=
+    NDQ1Y2ZmODc1MmNmZmNlNzdlMGIyOTllZDczZDkxN2U1YzQyY2VjNTk3NzU5
+    NDkxNWU3YmY1OGM5MGVlNTA5ZTdjYmZlYmQwOWQzMTNlMDBhMzliNmY3MDIx
+    ZTVlYjMwZGRkOTlhZmRjOTg3NDkyNmI2MGNmMjgwNGZlZmYyNTM=
   data.tar.gz: !binary |-
-    OTRiNzBlMGE0MGQ1ZTJjZTIwMjkxOTA4YTIwODAyODk3MTE4M2NiNjI0OGI0
-    NWFlMjQ5NWNhYzVkM2ZhZTQyYzc4ODY2ZmFiY2QwNDUwMTdlN2FjOTk5OTE5
-    NDI4ZTY1MmM2MWM0YTIyYjI2MTk4MTg2NjZiZjkxNjI1NDk4ZTg=
+    ZGY2N2ExOGYzNmEwMzUxOTYxYzljYjc2ZmYwZTEwODJjOWFlNmU3MzI1MzUw
+    YWFiZDY1MmQ0ZTlmMzQ5YjVkMWI0ZTYxYjA1MzBhZDkzNDBhMjYxM2NjZTAw
+    YjdjOTFkZDg1NTM1NzdkNjdkYTVmYTJmMTIyNTJkNDMxNGYxN2E=

data/lib/ubbparser.rb

@@ -27,19 +27,25 @@ require 'cgi'
 #noinspection RubyUnusedLocalVariable RubyTooManyMethods
 module UBBParser
 
+	extend self
+
+	def inline_elements
+		%w(b big i small tt abbr acronym cite code dfn em kbd strong samp var a bdo br img map object q script span sub sup button input label select textarea)
+	end
+
 	# Mapping can be used to allow simplified use of files
 	# [img]123123[/img] would have the same effect as [img]files/download/123123[/img]
 	#noinspection RubyClassVariableUsageInspection
-	def self.set_file_url_convert_method(callback_method)
+	def set_file_url_convert_method(callback_method)
 		@@file_url_convert_method = callback_method
 	end
 
 	#noinspection RubyClassVariableUsageInspection
 	@@file_url_convert_method = nil
 
-	# Converts a strings containing key-value-list into a hash. This function is mostly used by the parser itself.
+	# Converts a strings containing key-value-list into a hash. This function is mostly used by the parser it
 	# Attributes are given to the render methods as a hash.
-	def self.attrib_str_to_hash(attrib_str)
+	def attrib_str_to_hash(attrib_str)
 		result = {:class_attrib_str => attrib_str.gsub(/^=/, '')}
 
 		attrib_str.insert(0, 'default') if (attrib_str[0] == '=')
@@ -54,7 +60,7 @@ module UBBParser
 	# [:denied_keys]    An array of keys that are denied
 	# ===Example:
 	#   UBBParser.hash_to_attrib_str({}, {:allowed_keys => [:class, :src, :width]})
-	def self.hash_to_attrib_str(hash, options = {})
+	def hash_to_attrib_str(hash, options = {})
 		hash.delete_if { |k, _| !options[:allowed_keys].include?(k) } if options[:allowed_keys].is_a?(Array)
 		hash.delete_if { |k, _| options[:denied_keys].include?(k) } if options[:denied_keys].is_a?(Array)
 		return hash.map { |k, v| v = v.to_s.gsub(/\\|'/) { |c| "\\#{c}" }; "#{k}='#{v}'" }.join(' ')
@@ -69,7 +75,7 @@ module UBBParser
 	#   {:class_code: "prettify linenums"} => <pre class='prettify linenums'>...</pre>
 	#
 	# When developing your own tags, you can also define your own parse_options.
-	def self.parse(text, parse_options = {})
+	def parse(text, parse_options = {})
 		result = ''
 		scnr = StringScanner.new(text)
 		parse_options.each { |k, v| v.to_s.gsub(/-/, '_').gsub(/[^\w]+/, '') if (k.to_s.start_with?('class_')); v }
@@ -94,10 +100,10 @@ module UBBParser
 				scnr.skip(/\[/)
 				code = scnr.scan(/[\w-]*/)
 				method_name = ('render_' + code.to_s.gsub(/-/, '_')).to_sym
-				if ((scnr.eos?) || (code == "") || (!self.respond_to?(method_name)))
+				if ((scnr.eos?) || (code == "") || (!respond_to?(method_name)))
 					result << '[' + code
 				else
-					attributes = self.attrib_str_to_hash(scnr.scan(/[^\]]*/))
+					attributes = attrib_str_to_hash(scnr.scan(/[^\]]*/))
 					scnr.skip(/]/)
 					inner_text = scnr.scan_until(/\[\/#{code}\]/)
 					if inner_text.nil? #no closing tag found
@@ -106,9 +112,10 @@ module UBBParser
 					else
 						inner_text.chomp!("[/#{code}]")
 					end
-					method_result = self.send(method_name, inner_text, attributes, parse_options).to_s
+					method_result = send(method_name, inner_text, attributes, parse_options).to_s
 					result << method_result
-					scnr.skip(/\n?/)
+					last_html_tag = method_result.match('</\w+>$').to_s
+					scnr.skip(/\n?/) unless (inline_elements.include?(last_html_tag)) # Skip next newline if last tag was not inline element
 				end
 			end
 		end
@@ -117,95 +124,95 @@ module UBBParser
 
 	# Returns true if the given value matches the given regular expression.
 	# :category: Validation methods
-	def self.matches_regexp?(value, regexp)
+	def matches_regexp?(value, regexp)
 		return !value.to_s.match(regexp).nil?
 	end
 
 	# Returns true if the given value is a valid email address
 	# :category: Validation methods
-	def self.is_email?(value)
+	def is_email?(value)
 		return false unless value.is_a?(String)
-		return self.matches_regexp?(value, /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i)
+		return matches_regexp?(value, /^[-a-z0-9~!$%^&*_=+}{\'?]+(\.[-a-z0-9~!$%^&*_=+}{\'?]+)*@([a-z0-9_][-a-z0-9_]*(\.[-a-z0-9_]+)*\.(aero|arpa|biz|com|coop|edu|gov|info|int|mil|museum|name|net|org|pro|travel|mobi|[a-z][a-z])|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(:[0-9]{1,5})?$/i)
 	end
 
 	# Returns true if the given value is a valid url
 	# :category: Validation methods
-	def self.is_url?(value)
-		return self.matches_regexp?(value, /^(http|https)\:\/\/([a-zA-Z0-9\.\-]+(\:[a-zA-Z0-9\.&amp;%\$\-]+)*@)*((25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[1-9][0-9]{1}|[0-9])|localhost|([a-zA-Z0-9\-]+\.)*[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9\.\,\?\'\\\+&amp;%\$#\=~_\-]+))*$/)
+	def is_url?(value)
+		return matches_regexp?(value, /^(http|https)\:\/\/([a-zA-Z0-9\.\-]+(\:[a-zA-Z0-9\.&amp;%\$\-]+)*@)*((25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[1-9][0-9]|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1][0-9]{2}|[1-9][0-9]{1}|[0-9])|localhost|([a-zA-Z0-9\-]+\.)*[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9\.\,\?\'\\\+&amp;%\$#\=~_\-]+))*$/)
 	end
 
 	# Converts the [anchor=myname]...[/anchor] tag into <a name='myname'>...</a>. Use the :class_anchor parse option to define html classes.
 	# :category: Render methods
-	def self.render_anchor(inner_text, attributes = {}, parse_options = {})
+	def render_anchor(inner_text, attributes = {}, parse_options = {})
 		name = attributes[:default] || ''
 		inner_text.gsub!(/\\|'/) { |c| "\\#{c}" }
 		css_class = parse_options[:class_anchor] || 'ubb-anchor'
-		"<a name='#{name}' class='#{css_class}'>#{self.parse(inner_text, parse_options)}</a>"
+		"<a name='#{name}' class='#{css_class}'>#{parse(inner_text, parse_options)}</a>"
 	end
 
 	# Converts the url in the inner_text into a webplayer, playing the audio file.
 	# :category: Render methods
-	def self.render_audio(inner_text, attributes = {}, parse_options = {})
+	def render_audio(inner_text, attributes = {}, parse_options = {})
 		# Not yet implemented
 	end
 
 	# Renders the inner_text bold (using <strong>).
 	# :category: Render methods
-	def self.render_b(inner_text, attributes = {}, parse_options = {})
-		"<strong>#{self.parse(inner_text, parse_options)}</strong>"
+	def render_b(inner_text, attributes = {}, parse_options = {})
+		"<strong>#{parse(inner_text, parse_options)}</strong>"
 	end
 
 	# Converts [br] into a <br />.
 	# :category: Render methods
-	def self.render_br(inner_text, attributes = {}, parse_options = {})
-		"<br />#{self.parse(inner_text, parse_options)}"
+	def render_br(inner_text, attributes = {}, parse_options = {})
+		"<br />#{parse(inner_text, parse_options)}"
 	end
 
 	# Converts all lines in the inner_text as a bullet list. Each line represents one list item. Empty lines are ignored. Use the :class_bullet parse option to define html classes.
 	# :category: Render methods
-	def self.render_bullets(inner_text, attributes = {}, parse_options = {})
+	def render_bullets(inner_text, attributes = {}, parse_options = {})
 		items = inner_text.split(/\n/)
 		items.delete_if { |item| item.strip == '' }
-		items.map! { |item| '<li>' + self.parse(item, parse_options) + '</li>' }
+		items.map! { |item| '<li>' + parse(item, parse_options) + '</li>' }
 		css_class = parse_options[:class_list] || 'ubb-list'
 		return (items.empty?) ? '' : "<ul class='#{css_class}'>" + items.join('') + '</ul>'
 	end
 
 	# Centers the inner_text.
 	# :category: Render methods
-	def self.render_center(inner_text, attributes = {}, parse_options = {})
-		"<div style='text-align: center'>#{self.parse(inner_text, parse_options)}</div>"
+	def render_center(inner_text, attributes = {}, parse_options = {})
+		"<div style='text-align: center'>#{parse(inner_text, parse_options)}</div>"
 	end
 
 	# Assures the inner_text is rendered below floating elements.
 	# :category: Render methods
-	def self.render_class(inner_text, attributes = {}, parse_options = {})
+	def render_class(inner_text, attributes = {}, parse_options = {})
 		classes = attributes[:class_attrib_str].to_s.gsub(/'/, "\\'")
-		"<div class='#{classes}'>#{self.parse(inner_text, parse_options)}</div>"
+		"<div class='#{classes}'>#{parse(inner_text, parse_options)}</div>"
 	end
 
 	# Assures the inner_text is rendered below floating elements.
 	# :category: Render methods
-	def self.render_clear(inner_text, attributes = {}, parse_options = {})
+	def render_clear(inner_text, attributes = {}, parse_options = {})
 		"<div style='clear: both'></div>"
 	end
 
 	# Changes the font color of the inner_text
 	# :category: Render methods
-	def self.render_color(inner_text, attributes = {}, parse_options = {})
+	def render_color(inner_text, attributes = {}, parse_options = {})
 		color = attributes[:default].gsub(/'/, "\\'")
-		"<div style='color:#{color}'>#{self.parse(inner_text, parse_options)}</div>"
+		"<div style='color:#{color}'>#{parse(inner_text, parse_options)}</div>"
 	end
 
 	#	Ignores all the inner_text
 	# :category: Render methods
-	def self.render_comment(inner_text, attributes = {}, parse_options = {})
+	def render_comment(inner_text, attributes = {}, parse_options = {})
 		''
 	end
 
 	# Places the inner_text in a fixed font type. Also adds the classes prettify and linenums for styling purposes. Use the :class_code parse option to define html classes.
 	# :category: Render methods
-	def self.render_code(inner_text, attributes = {}, parse_options = {})
+	def render_code(inner_text, attributes = {}, parse_options = {})
 		css_class = parse_options[:class_code] || 'ubb-code'
 		"<pre class='#{css_class}'>#{inner_text}</pre>"
 	end
@@ -213,7 +220,7 @@ module UBBParser
 	# Renders csv-data into a html table. You can use the following attributes:
 	# [:has_header]  The first row should be rendered as header cells (using th).
 	# :category: Render methods
-	def self.render_csv(inner_text, attributes = {}, parse_options = {})
+	def render_csv(inner_text, attributes = {}, parse_options = {})
 		head_cells = body_cells = ''
 		cell_tag = (attributes[:has_header]) ? 'th' : 'td'
 		lines = inner_text.gsub(/(^\n|\n*$)/, '').split(/\n/)
@@ -248,11 +255,11 @@ module UBBParser
 	#    [email=info@osingasoftware.nl]Osinga Software[/email]
 	# By default the email address is protected against spoofing, using JavaScript. Use the email parse option to define html classes.
 	# :category: Render methods
-	def self.render_email(inner_text, attributes = {}, parse_options = {})
+	def render_email(inner_text, attributes = {}, parse_options = {})
 		css_class = (parse_options[:class_email] || 'ubb-email').to_s.strip
-		inner_text = self.parse(inner_text, parse_options) if !attributes[:default].nil?
+		inner_text = parse(inner_text, parse_options) if !attributes[:default].nil?
   	email = (attributes[:default] || inner_text)
-  	if (!self.is_email?(email))
+  	if (!is_email?(email))
     	result = "<span class='#{css_class} ubbparser-error'>UBB error: invalid email address #{email}</span>"
     elsif ((parse_options.has_key?(:protect_email) && !parse_options[:protect_email]) || (attributes[:protected] == "false"))
     	result = "<a href='mailto:#{email}' class='#{css_class}'>#{inner_text}</a>"
@@ -276,87 +283,87 @@ module UBBParser
 
 	# Renders the inner_text in a H1 heading.
 	# :category: Render methods
-	def self.render_h1(inner_text, attributes = {}, parse_options = {})
-		"<h1>#{self.parse(inner_text, parse_options)}</h1>"
+	def render_h1(inner_text, attributes = {}, parse_options = {})
+		"<h1>#{parse(inner_text, parse_options)}</h1>"
 	end
 
 	# Renders the inner_text in a H2 heading.
 	# :category: Render methods
-	def self.render_h2(inner_text, attributes = {}, parse_options = {})
-		"<h2>#{self.parse(inner_text, parse_options)}</h2>"
+	def render_h2(inner_text, attributes = {}, parse_options = {})
+		"<h2>#{parse(inner_text, parse_options)}</h2>"
 	end
 
 	# Renders the inner_text in a H3 heading.
 	# :category: Render methods
-	def self.render_h3(inner_text, attributes = {}, parse_options = {})
-		"<h3>#{self.parse(inner_text, parse_options)}</h3>"
+	def render_h3(inner_text, attributes = {}, parse_options = {})
+		"<h3>#{parse(inner_text, parse_options)}</h3>"
 	end
 
 	# Renders the inner_text in a H4 heading.
 	# :category: Render methods
-	def self.render_h4(inner_text, attributes = {}, parse_options = {})
-		"<h4>#{self.parse(inner_text, parse_options)}</h4>"
+	def render_h4(inner_text, attributes = {}, parse_options = {})
+		"<h4>#{parse(inner_text, parse_options)}</h4>"
 	end
 
 	# Renders the inner_text in a H5 heading.
 	# :category: Render methods
-	def self.render_h5(inner_text, attributes = {}, parse_options = {})
-		"<h5>#{self.parse(inner_text, parse_options)}</h5>"
+	def render_h5(inner_text, attributes = {}, parse_options = {})
+		"<h5>#{parse(inner_text, parse_options)}</h5>"
 	end
 
 	# Renders the inner_text in a H6 heading.
 	# :category: Render methods
-	def self.render_h6(inner_text, attributes = {}, parse_options = {})
-		"<h6>#{self.parse(inner_text, parse_options)}</h6>"
+	def render_h6(inner_text, attributes = {}, parse_options = {})
+		"<h6>#{parse(inner_text, parse_options)}</h6>"
 	end
 
 	# Renders a horizontal ruler.
 	# :category: Render methods
-	def self.render_hr(inner_text, attributes = {}, parse_options = {})
-		"<hr />#{self.parse(inner_text, parse_options)}"
+	def render_hr(inner_text, attributes = {}, parse_options = {})
+		"<hr />#{parse(inner_text, parse_options)}"
 	end
 
 	# Renders the inner_text in italic.
 	# :category: Render methods
-	def self.render_i(inner_text, attributes = {}, parse_options = {})
-		"<em>#{self.parse(inner_text, parse_options)}</em>"
+	def render_i(inner_text, attributes = {}, parse_options = {})
+		"<em>#{parse(inner_text, parse_options)}</em>"
 	end
 
 	# Renders an iframe. Use the inner_text as source. Use the :class_iframe parse option to define html classes.
 	# :category: Render methods
-	def self.render_iframe(inner_text, attributes = {}, parse_options = {})
+	def render_iframe(inner_text, attributes = {}, parse_options = {})
 		src = inner_text
 		src = 'http://' + src if (src.match(/^www\./))
 		src.gsub!(/\\|'/) { |c| "\\#{c}" }
 		attributes[:src] = inner_text
 		attributes[:class] = attributes[:class] || parse_options[:class_iframe] || 'ubb-iframe'
-		attrib_str = self.hash_to_attrib_str(attributes, :allowed_keys => [:src, :class, :frameborder, :marginwidth, :marginheight, :width, :height])
+		attrib_str = hash_to_attrib_str(attributes, :allowed_keys => [:src, :class, :frameborder, :marginwidth, :marginheight, :width, :height])
 		return "<iframe #{attrib_str}></iframe>"
 	end
 
 	# Doesn't render the ubb code in the inner_text. It does strip all html-tags from the inner_text
 	# :category: Render methods
-	def self.render_ignore(inner_text, attributes = {}, parse_options = {})
+	def render_ignore(inner_text, attributes = {}, parse_options = {})
 		inner_text
 	end
 
 	# Renders an image. Use the :class_img parse option to define html classes.
 	# :category: Render methods
 	#noinspection RubyClassVariableUsageInspection
-	def self.render_img(inner_text, attributes = {}, parse_options = {})
+	def render_img(inner_text, attributes = {}, parse_options = {})
 		url = inner_text
 		url = @@file_url_convert_method.call(url) unless @@file_url_convert_method.nil?
 		attributes[:src] = url.gsub(/\\|'/) { |c| "\\#{c}" }
 		attributes[:alt] ||= ''
 
 		attributes[:class] = attributes[:class] || parse_options[:class] || 'ubb-img'
-		attrib_str = self.hash_to_attrib_str(attributes, :allowed_keys => [:src, :alt, :styles, :class])
+		attrib_str = hash_to_attrib_str(attributes, :allowed_keys => [:src, :alt, :styles, :class])
 		return "<img #{attrib_str} />"
 	end
 
 	# Renders an image, floated on the left side of the text frame. Use the :class_img_left parse option to define html classes.
 	# :category: Render methods
-	def self.render_img_left(inner_text, attributes = {}, parse_options = {})
+	def render_img_left(inner_text, attributes = {}, parse_options = {})
 		attributes[:styles] = 'float: left; margin: 0px 10px 10px 0px'
 		attributes[:class] = parse_options[:class_img_left] || 'ubb-img-left'
 		render_img(inner_text, attributes, parse_options)
@@ -364,7 +371,7 @@ module UBBParser
 
 	# Renders an image, floated on the right side of the text frame. Use the :class_img_right parse option to define html classes.
 	# :category: Render methods
-	def self.render_img_right(inner_text, attributes = {}, parse_options = {})
+	def render_img_right(inner_text, attributes = {}, parse_options = {})
 		attributes[:styles] = 'float: left; margin: 0px 0px 10px 10px'
 		attributes[:class] = parse_options[:class_img_right] || 'ubb-img-right'
 		render_img(inner_text, attributes, parse_options)
@@ -372,75 +379,75 @@ module UBBParser
 
 	# Renders the inner_text with a justified text alignment.
 	# :category: Render methods
-	def self.render_justify(inner_text, attributes = {}, parse_options = {})
-		"<div style='text-align: justify'>#{self.parse(inner_text, parse_options)}</div>"
+	def render_justify(inner_text, attributes = {}, parse_options = {})
+		"<div style='text-align: justify'>#{parse(inner_text, parse_options)}</div>"
 	end
 
 	# Renders the inner_text with a left text alignment.
 	# :category: Render methods
-	def self.render_left(inner_text, attributes = {}, parse_options = {})
-		"<div style='text-align: left'>#{self.parse(inner_text, parse_options)}</div>"
+	def render_left(inner_text, attributes = {}, parse_options = {})
+		"<div style='text-align: left'>#{parse(inner_text, parse_options)}</div>"
 	end
 
 	# Renders the inner_text as an ordered list. Each line represents a list item. Use the :class_list parse option to define html classes.
 	# :category: Render methods
-	def self.render_list(inner_text, attributes = {}, parse_options = {})
+	def render_list(inner_text, attributes = {}, parse_options = {})
 		items = inner_text.split(/\n/)
 		items.delete_if { |item| item.strip == '' }
-		items.map! { |item| '<li>' + self.parse(item, parse_options) + '</li>' }
+		items.map! { |item| '<li>' + parse(item, parse_options) + '</li>' }
 		return (items.empty?) ? '' : "<ol class='#{parse_options[:class_list].to_s.strip}'>" + items.join('') + '</ol>'
 	end
 
 	# Renders the inner_text as a paragraph. Use the :class_p parse option to define html classes.
 	# :category: Render methods
-	def self.render_p(inner_text, attributes = {}, parse_options = {})
+	def render_p(inner_text, attributes = {}, parse_options = {})
 		css_class = parse_options[:class_p] || 'ubb-p'
-		"<p class='#{css_class}'>#{self.parse(inner_text, parse_options)}</p>"
+		"<p class='#{css_class}'>#{parse(inner_text, parse_options)}</p>"
 	end
 
 	# Renders the inner_text with a right text alignment.
 	# :category: Render methods
-	def self.render_right(inner_text, attributes = {}, parse_options = {})
-		"<div style='text-align: right'>#{self.parse(inner_text, parse_options)}</div>"
+	def render_right(inner_text, attributes = {}, parse_options = {})
+		"<div style='text-align: right'>#{parse(inner_text, parse_options)}</div>"
 	end
 
 	# Renders the inner_text in a <div> block with inline CSS styles, i.e.:
 	#    [style color: red; border: 1px solid green]...[/style]
 	# :category: Render methods
-	def self.render_style(inner_text, attributes = {}, parse_options = {})
+	def render_style(inner_text, attributes = {}, parse_options = {})
 		styles = attributes[:class_attrib_str].to_s.gsub(/'/, "\\'")
-		"<div style='#{styles}'>#{self.parse(inner_text, parse_options)}</div>"
+		"<div style='#{styles}'>#{parse(inner_text, parse_options)}</div>"
 	end
 
 	# Converts the [table] to a <table>. Always use this in combination with [tr] and [td] or [th]. Use the :class_table parse option to define html classes.
 	# :category: Render methods
-	def self.render_table(inner_text, attributes = {}, parse_options = {})
+	def render_table(inner_text, attributes = {}, parse_options = {})
 		css_class = parse_options[:class_table] || 'ubb-table'
-		"<table class='#{css_class}'>#{self.parse(inner_text.gsub(/(^\n+)|(\n+$)/, ''), parse_options)}</table>"
+		"<table class='#{css_class}'>#{parse(inner_text.gsub(/(^\n+)|(\n+$)/, ''), parse_options)}</table>"
 	end
 
 	# Converts the [td] to a <td>. Always use this in combination with [table] and [tr].
 	# :category: Render methods
-	def self.render_td(inner_text, attributes = {}, parse_options = {})
-		"<td>#{self.parse(inner_text, parse_options)}</td>"
+	def render_td(inner_text, attributes = {}, parse_options = {})
+		"<td>#{parse(inner_text, parse_options)}</td>"
 	end
 
 	# Converts the [th] to a <th>. Always use this in combination with [table] and [tr].
 	# :category: Render methods
-	def self.render_th(inner_text, attributes = {}, parse_options = {})
-		"<th>#{self.parse(inner_text, parse_options)}</th>"
+	def render_th(inner_text, attributes = {}, parse_options = {})
+		"<th>#{parse(inner_text, parse_options)}</th>"
 	end
 
 	# Converts the [tr] to a <tr>. Always use this in combination with [table] and [td] or [th].
 	# :category: Render methods
-	def self.render_tr(inner_text, attributes = {}, parse_options = {})
-		"<tr>#{self.parse(inner_text.gsub(/(^\n+)|(\n+$)/, ''), parse_options)}</tr>"
+	def render_tr(inner_text, attributes = {}, parse_options = {})
+		"<tr>#{parse(inner_text.gsub(/(^\n+)|(\n+$)/, ''), parse_options)}</tr>"
 	end
 
 	# Renders the inner_text underline. Use this with caution, since underline text is associated with hyperlinks.
 	# :category: Render methods
-	def self.render_u(inner_text, attributes = {}, parse_options = {})
-		"<u>#{self.parse(inner_text, parse_options)}</u>"
+	def render_u(inner_text, attributes = {}, parse_options = {})
+		"<u>#{parse(inner_text, parse_options)}</u>"
 	end
 
 	# Renders a web addres. There are two options to define:
@@ -449,8 +456,8 @@ module UBBParser
 	# Use the :class_url parse option to define html classes.
 	# :category: Render methods
 	#noinspection RubyClassVariableUsageInspection
-	def self.render_url(inner_text, attributes = {}, parse_options = {})
-		inner_text = self.parse(inner_text, parse_options) if !attributes[:default].nil?
+	def render_url(inner_text, attributes = {}, parse_options = {})
+		inner_text = parse(inner_text, parse_options) if !attributes[:default].nil?
 		url = (attributes[:default] || inner_text)
 		url = 'http://' + url if (url.start_with?('www.'))
 		target = (url.start_with?('http://')) ? " target='_blank'" : ''
@@ -462,7 +469,7 @@ module UBBParser
 
 	# Renders a YouTube video using the video id or url in the inner_text.
 	# :category: Render methods
-	def self.render_vimeo(inner_text, attributes = {}, parse_options = {})
+	def render_vimeo(inner_text, attributes = {}, parse_options = {})
 		attributes[:width] ||= 500
 		attributes[:height] ||= 281
 		attributes[:class] = parse_options[:class_vimeo] || 'ubb-vimeo'
@@ -473,7 +480,7 @@ module UBBParser
 
 	# Renders a YouTube video using the video id or url in the inner_text.
 	# :category: Render methods
-	def self.render_youtube(inner_text, attributes = {}, parse_options = {})
+	def render_youtube(inner_text, attributes = {}, parse_options = {})
 		attributes[:width] ||= 560
 		attributes[:height] ||= 315
 		attributes[:class] = parse_options[:class_youtube] || 'ubb-youtube'
@@ -485,15 +492,15 @@ module UBBParser
 	# Renders a Youtube, Vimeo or Zideo video using the video id or url in the inner_text.
 	# It automatically determines which video renderer should be used based on the given url.
 	# :category: Render methods
-	def self.render_video(inner_text, attributes = {}, parse_options = {})
+	def render_video(inner_text, attributes = {}, parse_options = {})
 		attributes[:class] = "#{attributes[:class]} #{parse_options[:class_zideo]}"
 		url = inner_text
 		if !url.match(/zideo\.nl/).nil?
-			return self.render_zideo(inner_text, attributes, parse_options)
+			return render_zideo(inner_text, attributes, parse_options)
 		elsif (!url.match(/[0-9]{5,}/).nil?) || (!url.match(/vimeo/).nil?)
-			return self.render_vimeo(inner_text, attributes, parse_options)
+			return render_vimeo(inner_text, attributes, parse_options)
 		elsif (!url.match(/youtu/).nil?) || (!url.match(/^[^\?&]+\{11}$/).nil?)
-			return self.render_youtube(inner_text, attributes, parse_options)
+			return render_youtube(inner_text, attributes, parse_options)
 		else
 			return 'Unknown video'
 		end
@@ -501,7 +508,7 @@ module UBBParser
 
 	# Renders a zideo.nl video using the video id or url in the inner_text.
 	# :category: Render methods
-	def self.render_zideo(inner_text, attributes = {}, parse_options = {})
+	def render_zideo(inner_text, attributes = {}, parse_options = {})
 		attributes[:width] ||= 480
 		attributes[:height] ||= :auto
 		attributes[:class] = parse_options[:class_zideo] || 'ubb-zideo'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ubbparser
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Taco Jan Osinga
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-14 00:00:00.000000000 Z
+date: 2014-02-19 00:00:00.000000000 Z
 dependencies: []
 description: A simple and flexibel ubb parser.
 email: info@osingasoftware.nl