rbbcode 0.1.11 → 1.0.0

data/Rakefile

@@ -1,35 +0,0 @@
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-
-Jeweler::Tasks.new do |gem|
-	gem.name = 'rbbcode'
-	gem.homepage = "http://github.com/jarrett/rbbcode"
-	gem.license = "MIT"
-	gem.summary = 'Ruby BB Code parser'
-	gem.description = 'RbbCode is a customizable Ruby library for parsing BB Code. RbbCode validates and cleans input. It supports customizable schemas so you can set rules about what tags are allowed where. The default rules are designed to ensure valid HTML output.'
-	gem.email = "jarrett@jarrettcolby.com, aq1018@gmail.com"
-	gem.authors = ['Jarrett Colby', "aq1018@gmail.com"]
-end
-Jeweler::RubygemsDotOrgTasks.new
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-  spec.rspec_opts = "--color --format progress"
-end
-
-task :default => :spec
-
-require 'yard'
-YARD::Rake::YardocTask.new

data/VERSION

@@ -1 +0,0 @@
-0.1.11

data/lib/rbbcode/html_maker.rb

@@ -1,90 +0,0 @@
-require 'cgi'
-require 'sanitize-url'
-
-module RbbCode
-	DEFAULT_TAG_MAPPINGS = {
-		'p' => 'p',
-		'br' => 'br',
-		'b' => 'strong',
-		'i' => 'em',
-		'u' => 'u',
-		'code' => 'code',
-		'quote' => 'blockquote',
-		'list' => 'ul',
-		'*' => 'li'
-	}
-	
-	class HtmlMaker
-		include SanitizeUrl
-		
-		def make_html(node)
-			output = ''
-			case node
-			when RbbCode::RootNode
-				node.children.each do |child|
-					output << make_html(child)
-				end
-			when RbbCode::TagNode
-				custom_tag_method = "html_from_#{node.tag_name}_tag"
-				if respond_to?(custom_tag_method)
-					output << send(custom_tag_method, node)
-				else
-					inner_html = ''
-					node.children.each do |child|
-						inner_html << make_html(child)
-					end
-					to_append = content_tag(map_tag_name(node.tag_name), inner_html)
-					if node.preformatted?
-						to_append = content_tag('pre', to_append)
-					end
-					output << to_append
-					#puts output
-				end
-			when RbbCode::TextNode
-				output << node.text
-			else
-				raise "Don't know how to make HTML from #{node.class}"
-			end
-			output
-		end
-		
-		protected
-		
-		def content_tag(tag_name, contents, attributes = {})
-			output = "<#{tag_name}"
-			attributes.each do |attr, value|
-				output << " #{attr}=\"#{value}\""
-			end
-			if contents.nil? or contents.empty? and not tag_name == 'code'
-				output << '/>'
-			else
-				output << ">#{contents}</#{tag_name}>"
-			end
-		end
-		
-		def html_from_img_tag(node)
-			src = sanitize_url(node.inner_bb_code)
-			content_tag('img', nil, {'src' => src, 'alt' => ''})
-		end
-
-		def html_from_url_tag(node)
-			if node.value.nil?
-				url = node.inner_bb_code
-			else
-				url = node.value
-			end
-			url = sanitize_url(url)
-			inner_html = node.children.inject('') do |output, child|
-				output + make_html(child)
-			end
-			content_tag('a', inner_html, {'href' => url})
-		end
-		
-		def map_tag_name(tag_name)
-			unless DEFAULT_TAG_MAPPINGS.has_key?(tag_name)
-				raise "No tag mapping for '#{tag_name}'"
-			end
-			DEFAULT_TAG_MAPPINGS[tag_name]
-		end
-	end
-end

data/lib/rbbcode/parser.rb

@@ -1,32 +0,0 @@
-module RbbCode
-	class Parser
-		def initialize(config = {})
-			config.each_key do |key|
-				raise(ArgumentError, "Unknown option #{key}") unless known_options.include?(key)
-			end
-			@config = config
-		end
-		
-		def parse(str)
-			str = escape_html_tags(str)
-			
-			schema = @config[:schema] || RbbCode::Schema.new
-			
-			tree_maker = @config[:tree_maker] || RbbCode::TreeMaker.new(schema)
-			tree = tree_maker.make_tree(str)
-			
-			html_maker = @config[:html_maker] || RbbCode::HtmlMaker.new
-			html_maker.make_html(tree)
-		end
-		
-		protected
-		
-		def escape_html_tags(str)
-			str.gsub('<', '&lt;').gsub('>', '&gt;')
-		end
-		
-		def known_options
-			[:schema, :tree_maker, :html_maker]
-		end
-	end
-end

data/lib/rbbcode/schema.rb

@@ -1,309 +0,0 @@
-module RbbCode
-	DEFAULT_ALLOWED_TAGS = [
-		'p',
-		'br',
-		'b',
-		'i',
-		'u',
-		'url',
-		'img',
-		'code',
-		'quote',
-		'list',
-		'*'
-	]
-	
-	DEFAULT_BLOCK_LEVEL_ELEMENTS = [
-		'quote',
-		'list',
-		'*'
-	]
-	
-	class SchemaNode
-		def initialize(schema)
-			@schema = schema
-		end
-		
-		protected
-		
-		def normalize_ancestors(ancestors)
-			if ancestors.length == 1 and ancestors[0].is_a?(Array)
-				ancestors = ancestors[0]
-			end
-			ancestors
-		end
-	end
-	
-	class SchemaTag < SchemaNode
-		def closes_twins
-			@schema.close_twins(@name)
-			self
-		end
-		
-		def does_not_close_twins
-			@schema.dont_close_twins(@name)
-			self
-		end
-		
-		def initialize(schema, name)
-			@schema = schema
-			@name = name
-		end
-		
-		def is_not_preformatted
-			@schema.unmark_as_preformatted(@name)
-			self
-		end
-		
-		def is_preformatted
-			@schema.mark_as_preformatted(@name)
-			self
-		end
-		
-		def may_be_nested
-			@schema.allow_descent(@name, @name)
-			self
-		end
-		
-		def may_contain_text
-			@schema.allow_text(@name)
-			self
-		end
-		
-		def may_not_be_empty
-			@schema.forbid_emptiness(@name)
-		end
-		
-		def may_not_be_nested
-			@schema.forbid_descent(@name, @name)
-			self
-		end
-		
-		def may_descend_from(tag_name)
-			@schema.allow_descent(tag_name, @name)
-			self
-		end
-		
-		def may_only_be_parent_of(*tag_names)
-			@schema.forbid_children_except(@name, tag_names)
-			self
-		end
-		
-		def may_not_contain_text
-			@schema.forbid_text(@name)
-			self
-		end
-		
-		def may_not_descend_from(tag_name)
-			@schema.forbid_descent(tag_name, @name)
-			self
-		end
-		
-		def must_be_child_of(*tag_names)
-			@schema.require_parents(tag_names, @name)
-			self
-		end
-		
-		def must_be_empty
-			@schema.forbid_children_except(@name, [])
-			may_not_contain_text
-			self
-		end
-		
-		def need_not_be_child_of(tag_name)
-			@schema.unrequire_parent(tag_name, @name)
-			self
-		end
-		
-		# Returns true if tag_name is valid in the context defined by its list of ancestors.
-		# ancestors should be ordered from most recent ancestor to most distant.
-		def valid_in_context?(*ancestors)
-			@schema.tag_valid_in_context?(@name, normalize_ancestors(ancestors))
-		end
-	end
-	
-	class SchemaText < SchemaNode
-		def valid_in_context?(*ancestors)
-			@schema.text_valid_in_context?(normalize_ancestors(ancestors))
-		end
-	end
-
-	class Schema
-		def allow_descent(ancestor, descendant) #:nodoc:
-			if @forbidden_descent.has_key?(descendant.to_s) and @forbidden_descent[descendant.to_s].include?(ancestor.to_s)
-				@forbidden_descent[descendant.to_s].delete(ancestor.to_s)
-			end
-		end
-		
-		def allow_emptiness(tag_name)
-			@never_empty.delete(tag_name.to_s)
-		end
-		
-		def allow_tag(*tag_names)
-			tag_names.each do |tag_name|
-				unless @allowed_tags.include?(tag_name.to_s)
-					@allowed_tags << tag_name.to_s
-				end
-			end
-		end
-		
-		def allow_text(tag_name)
-			@no_text.delete(tag_name.to_s)
-		end
-		
-		def block_level?(tag_name)
-			DEFAULT_BLOCK_LEVEL_ELEMENTS.include?(tag_name.to_s)
-		end
-		
-		alias_method :allow_tags, :allow_tag
-		
-		def clear
-			@allowed_tags = []
-			@never_empty = []
-			@forbidden_descent = {}
-			@required_parents = {}
-			@no_text = []
-			@twin_closers = []
-			@preformatted = []
-		end
-		
-		def close_twins(tag_name)
-			@twin_closers << tag_name.to_s unless @twin_closers.include?(tag_name.to_s)
-		end
-		
-		def close_twins?(tag_name)
-			@twin_closers.include?(tag_name.to_s)
-		end
-		
-		def does_not_close_twins(tag_name)
-			@twin_closers.delete(tag_name.to_s)
-		end
-		
-		def forbid_children_except(parent, children)
-			@child_requirements[parent.to_s] = children.collect { |c| c.to_s }
-		end
-		
-		def forbid_descent(ancestor, descendant) #:nodoc:
-			@forbidden_descent[descendant.to_s] ||= []
-			unless @forbidden_descent[descendant.to_s].include?(ancestor.to_s)
-				@forbidden_descent[descendant.to_s] << ancestor.to_s
-			end
-		end
-		
-		def forbid_emptiness(tag_name)
-			@never_empty << tag_name.to_s unless @never_empty.include?(tag_name.to_s)
-		end
-		
-		def forbid_tag(name)
-			@allowed_tags.delete(name.to_s)
-		end
-		
-		def forbid_text(tag_name)
-			@no_text << tag_name.to_s unless @no_text.include?(tag_name.to_s)
-		end
-		
-		def initialize
-			@allowed_tags = DEFAULT_ALLOWED_TAGS.dup
-			@forbidden_descent = {}
-			@required_parents = {}
-			@child_requirements = {}
-			@never_empty = []
-			@no_text = []
-			@twin_closers = []
-			@preformatted = []
-			use_defaults
-		end
-		
-		def line_break_tag_name
-			'br'
-		end
-		
-		def mark_as_preformatted(tag_name)
-			@preformatted << tag_name.to_s unless @preformatted.include?(tag_name.to_s)
-		end
-		
-		def paragraph_tag_name
-			'p'
-		end
-		
-		def preformatted?(tag_name)
-			@preformatted.include?(tag_name.to_s)
-		end
-		
-		def require_parents(parents, child) #:nodoc:
-			@required_parents[child.to_s] = parents.collect { |p| p.to_s }
-			parents.each do |parent|
-				if @forbidden_descent.has_key?(child.to_s)
-					@forbidden_descent[child.to_s].delete(parent)
-				end
-			end
-		end
-		
-		def tag(name)
-			SchemaTag.new(self, name)
-		end
-		
-		def tag_may_be_empty?(tag_name)
-			!@never_empty.include?(tag_name.to_s)
-		end
-		
-		def tag_valid_in_context?(tag_name, ancestors)
-			return false unless @allowed_tags.include?(tag_name.to_s)
-			if @required_parents.has_key?(tag_name.to_s) and !@required_parents[tag_name.to_s].include?(ancestors[0].to_s)
-				return false
-			end
-			if @child_requirements.has_key?(ancestors[0].to_s) and !@child_requirements[ancestors[0].to_s].include?(tag_name.to_s)
-				return false
-			end
-			if @forbidden_descent.has_key?(tag_name.to_s)
-				@forbidden_descent[tag_name.to_s].each do |forbidden_ancestor|
-					return false if ancestors.include?(forbidden_ancestor)
-				end
-			end
-			return true
-		end
-		
-		def text
-			SchemaText.new(self)
-		end
-		
-		def text_valid_in_context?(*ancestors)
-		  ancestors.flatten!
-			if @no_text.include?(ancestors[0].to_s)
-				return false
-			end
-			return true
-		end
-
-		def unmark_as_preformatted(tag_name)
-			@preformatted.delete(tag_name.to_s)
-		end
-
-		def unrequire_parent(parent, child)
-			@required_parents.delete(child.to_s)
-		end
-		
-		def use_defaults
-			tag('br').must_be_empty
-			tag('p').may_not_be_nested
-			tag('b').may_not_be_nested
-			tag('b').may_not_be_empty
-			tag('i').may_not_be_nested
-			tag('i').may_not_be_empty
-			tag('u').may_not_be_nested
-			tag('u').may_not_be_empty
-			tag('url').may_not_be_nested
-			tag('img').may_not_be_nested
-			tag('code').may_not_be_nested
-			tag('code').is_preformatted
-			#tag('code').may_not_be_empty
-			tag('quote').may_not_be_empty
-			tag('p').may_not_be_nested
-			tag('*').must_be_child_of('list')
-			tag('*').closes_twins
-			tag('list').may_not_descend_from('p')
-			tag('list').may_only_be_parent_of('*')
-			tag('list').may_not_contain_text
-		end
-	end
-end