rind 0.1.0

data/lib/rind/parser.rb

@@ -0,0 +1,141 @@
+module Rind
+	TEXT      = 0
+	CDATA     = 1
+	COMMENT   = 2
+	DOCTYPE   = 3
+	PRO_INST  = 4
+	END_TAG   = 5
+	START_TAG = 6
+
+	def self.parse(file_name, type, base_namespace, namespaces_allowed)
+		create_tree(tokenize(file_name, type), type, base_namespace, namespaces_allowed)
+	end
+
+	def self.tokenize(file_name, type)
+		content = File.read(file_name)
+
+		# tag types
+		name = /[a-zA-Z_]/
+		cdata = /<!\[CDATA\[(.*?)\]\]>/m
+		comment = /<!--(.*?)-->/m
+		doctype = /<!DOCTYPE(.*?)>/m
+		processing_instruction = /<\?(.*?)>/m
+		end_tag = /<\s*\/\s*((?:#{name}+:)?#{name}+)\s*>/m
+		start_tag = /<\s*((?:#{name}+:)?#{name}+)\s*(.*?)?\/?>/m
+
+		# extract tokens from the file content
+		tokens = Array.new
+		text_start = 0
+		content.scan(/#{cdata}|#{comment}|#{doctype}|#{processing_instruction}|#{end_tag}|#{start_tag}/o) do |token|
+			# remove nil entries from the unmatched tag checks
+			token.compact!
+			# get match object
+			match = $~
+
+			# create a proceeding text token if one exists
+			text_end = match.begin(0)
+			if text_start < text_end
+				text = content[text_start...text_end]
+				tokens.push([TEXT, text]) if text !~ /^\s*$/
+			end
+			text_start = match.end(0)
+
+			# create a token for the appropriate tag
+			if match.begin(1) # cdata
+				tokens.push([CDATA, token].flatten)
+			elsif match.begin(2) # comment
+				tokens.push([COMMENT, token].flatten)
+			elsif match.begin(3) # doctype tag
+				tokens.push([DOCTYPE, token].flatten)
+			elsif match.begin(4) # processing instruction
+				tokens.push([PRO_INST, token].flatten)
+			elsif match.begin(5) # end tag
+				tokens.push([END_TAG, token].flatten)
+			elsif match.begin(6) # start tag
+				tokens.push([START_TAG, token].flatten)
+			end
+		end
+
+		tokens
+	end
+	private_class_method :tokenize
+
+	# tokens will arrive in reverse order
+	def self.create_tree(tokens, type, base_namespace, namespaces_allowed, complete_tag = nil)
+		dom = Rind::Nodes.new
+
+		# create the nodes and push them onto the dom tree
+		while 0 < tokens.length
+			token = tokens.pop
+
+			case token[0]
+			when TEXT
+				dom.push(Rind::Text.new(token[1]))
+			when CDATA
+				dom.push(Rind::CDATA.new(token[1]))
+			when COMMENT
+				dom.push(Rind::Comment.new(token[1]))
+			when DOCTYPE
+				dom.push(Rind::DocType.new(token[1]))
+			when PRO_INST
+				dom.push(Rind::ProcessingInstruction.new(token[1]))
+			when END_TAG
+				# recursively retreive all the children and the matching start tag
+				children = create_tree(tokens, type, base_namespace, namespaces_allowed, token[1])
+				start_tag = children.shift
+
+				start_tag.children.replace(children)
+
+				dom.push(start_tag)
+			when START_TAG
+				namespace_name, local_name = extract_name_and_namespace(token[1], base_namespace)
+
+				# create the element
+				if not namespaces_allowed.nil? and (namespace_name == base_namespace or namespaces_allowed.include? namespace_name)
+					passed_namespace = namespace_name == base_namespace ? nil : namespace_name
+					begin
+						node = create_node(get_library_name(namespace_name), local_name.capitalize, token[2], nil, passed_namespace)
+					rescue
+						node = create_node("Rind::#{type.capitalize}", local_name.capitalize, token[2], nil, passed_namespace)
+					end
+				else
+					node = create_node("Rind::#{type.capitalize}", local_name.capitalize, token[2], nil, namespace_name)
+				end
+				dom.push(node)
+
+				# break if this tag completes the grouping from an end tag
+				break if complete_tag.eql?(token[1])
+			end
+		end
+
+		# output in the correct order
+		dom.reverse
+	end
+	private_class_method :create_tree
+
+	def self.extract_name_and_namespace(tag_name, base_namespace)
+		tag_name =~ /^(?:([\w:]+):)?(\w+)$/
+		namespace_name, local_name = $1, $2
+		namespace_name = base_namespace if namespace_name.nil?
+
+		[namespace_name, local_name]
+	end
+	private_class_method :extract_name_and_namespace
+
+	def self.get_library_name(namespace_name)
+		namespace_name.split(/:/).collect{|ns| ns.capitalize}.join('::')
+	end
+	private_class_method :get_library_name
+
+	def self.create_node(class_namespace, class_name, attributes, children, namespace_name)
+		command = "#{class_namespace}::#{class_name.capitalize}.new("
+		options = [":attributes => attributes"]
+		options.push(":namespace_name => '#{namespace_name}'")
+		options.push(":children => children") if not children.nil?
+		command.concat(options.join(','))
+		command.concat(')')
+
+		class_eval(command)
+	end
+	private_class_method :create_node
+end

data/lib/rind/traverse.rb

@@ -0,0 +1,86 @@
+module Traverse
+	attr_accessor :parent
+
+	# Creates a Rind::Nodes list of all ancestors. If an Xpath
+	# is provided it will only return the nodes that match.
+	def ancestors(path = nil)
+		if not self.parent.nil?
+			ancestors = Rind::Nodes.new([self.parent])
+
+			parent_ancestors = self.parent.ancestors
+			ancestors.push(*parent_ancestors) if not parent_ancestors.nil?
+
+			path.nil? ? ancestors : ancestors.filter(path)
+		end
+	end
+
+	# Creates a Rind::Nodes list of all descendants. If an Xpath
+	# is provided it will only return the nodes that match.
+	def descendants(path = nil)
+		if self.respond_to? :children and not self.children.empty?
+			descendants = Rind::Nodes.new(self.children)
+
+			self.children.each do |child|
+				child_descendants = child.descendants
+				descendants.push(*child_descendants) if not child_descendants.nil?
+			end
+
+			path.nil? ? descendants : descendants.filter(path)
+		end
+	end
+
+	# Returns the first descendant node. If an Xpath is provided
+	# it will return the first one that matches.
+	def down(path = nil)
+		descendants = self.descendants(path)
+		descendants.first if not descendants.nil?
+	end
+
+	# Returns the first sibling that follows the current node in
+	# the list of siblings. If an Xpath is provided it will return
+	# the first one that matches.
+	def next(path = nil)
+		siblings = self.next_siblings(path)
+		siblings.first if not siblings.nil?
+	end
+
+	# Creates a Rind::Nodes list of all siblings that follow the
+	# current node in the list of siblings. If an Xpath is provided
+	# it will only return the nodes that match.
+	def next_siblings(path = nil)
+		children = self.parent.children
+		siblings = Rind::Nodes.new(children[children.index(self)+1..children.length-1])
+		path.nil? ? siblings : siblings.filter(path)
+	end
+
+	# Returns the first sibling that proceeds the current node in
+	# the list of siblings. If an Xpath is provided it will return
+	# the first one that matches.
+	def prev(path = nil)
+		siblings = self.prev_siblings(path)
+		siblings.last if not siblings.nil?
+	end
+
+	# Creates a Rind::Nodes list of all siblings that proceed the
+	# current node in the list of siblings. If an Xpath is provided
+	# it will only return the nodes that match.
+	def prev_siblings(path = nil)
+		children = self.parent.children
+		siblings = Rind::Nodes.new(children[0...children.index(self)])
+		path.nil? ? siblings : siblings.filter(path)
+	end
+
+	# Creates a Rind::Nodes list of all siblings. If an Xpath is
+	# provided it will only return the nodes that match.
+	def siblings(path = nil)
+		siblings = Rind::Nodes.new(self.parent.children.find_all{|child| not child.equal? self})
+		path.nil? ? siblings : siblings.filter(path)
+	end
+
+	# Returns the first ancestor node. If an Xpath is provided
+	# it will return the first one that matches.
+	def up(path = nil)
+		ancestors = self.ancestors(path)
+		ancestors.first if not ancestors.nil?
+	end
+end

data/lib/rind/xml.rb

@@ -0,0 +1,28 @@
+module Rind
+	# Rind::Xml will dynamically create any XML element.
+	module Xml
+		def self.const_missing(full_class_name, options={}) # :nodoc:
+			klass = Class.new(Element) do
+			  # <b>Parent:</b> Element
+				# === Example
+				#  Rind::Xml::Foo.new(
+				#    :attributes => {:id => "bar"},
+				#    :children   => "Hello World!"
+				#  )
+				def initialize(options={})
+					super(options)
+				end
+
+				def expanded_name # :nodoc:
+					if @namespace_name.nil? or @namespace_name == '' or @namespace_name =~ /^(?:rind:)?xml/
+						@local_name
+					else
+						[@namespace_name, @local_name].join(':')
+					end
+				end
+			end
+			const_set full_class_name, klass
+			klass
+		end
+	end
+end

data/lib/rind/xpath.rb

@@ -0,0 +1,144 @@
+# Current Xpath support is fairly basic but covers almost all axes and node tests.
+# Predicates are limited to attribute and position checks. I intend to expand support
+# but that should cover most of the needed functionality.
+module Xpath
+	# Xpath search of a node that returns a list of matching nodes.
+	def s(path)
+		node = self.clone;
+
+		# absolute paths to the top
+		if '/' == path[0,1]
+			while not node.parent.nil?
+				node = node.parent
+			end
+			if 1 < path.length and '/' == path[1,1]
+				path[0] = ''
+			else
+				path[0] = 'self::'
+			end
+		end
+
+		# node check
+		nodes = [node]
+		path.split('/').each do |step|
+			case step
+			when ''
+				step = 'descendant-or-self::node()'
+			when '.'
+				step = 'self::node()'
+			when '..'
+				step = 'parent::node()'
+			end
+
+			step.gsub!(/^@/, 'attribute::')
+
+			step =~ /^(?:(.*?)::)?(.+?)(\[.*?)?$/
+			axis, node_test, predicates = $1, $2, $3
+			axis = 'child' if axis.nil?
+
+			# find matching nodes
+			nodes = nodes.collect{|node| node.find_matching_nodes(axis, node_test)}.flatten.compact
+
+			# check predicates
+			if not predicates.nil?
+				# true() and false()
+				predicates.gsub!(/(true|false)\(\)/, '\1')
+				# ==
+				predicates.gsub!(/=/, '==')
+
+				predicates.scan(/\[(.*?)\]/) do |predicate|
+					predicate = predicate[0]
+					# last()
+					predicate.gsub!(/last\(\)/, nodes.length.to_s)
+
+					nodes = nodes.find_all{|node| node.validate_predicate(predicate.clone, nodes.index(node)+1)}
+					break if nodes.empty?
+				end
+			end
+
+			return nil if nodes.empty?
+		end
+
+		Rind::Nodes.new(nodes)
+	end
+
+	# Xpath search returning only the first matching node in the list.
+	def sf(path)
+		nodes = self.s(path)
+		nodes.nil? ? nil : nodes.first
+	end
+
+	def find_matching_nodes(axis, node_test) # :nodoc:
+		case axis
+		when 'ancestor'
+			self.ancestors.find_all{|node| node.is_matching_node?(node_test)}
+		when 'ancestor-or-self'
+			self.find_matching_nodes('self', node_test) + self.find_matching_nodes('ancestor', node_test)
+		when 'attribute'
+			'*' == node_test ? self[] : self[node_test] || []
+		when 'child'
+			if self.respond_to? :children
+				self.children.find_all{|node| node.is_matching_node?(node_test)}
+			else
+				[]
+			end
+		when 'descendant'
+			self.descendants.find_all{|node| node.is_matching_node?(node_test)}
+		when 'descendant-or-self'
+			self.find_matching_nodes('self', node_test) + self.find_matching_nodes('descendant', node_test)
+		when 'following-sibling'
+			self.next_siblings.find_all{|node| node.is_matching_node?(node_test)}
+		when 'parent'
+			self.parent.is_matching_node?(node_test) ? [self.parent] : []
+		when 'preceding-sibling'
+			self.prev_siblings.find_all{|node| node.is_matching_node?(node_test)}
+		when 'self'
+			self.is_matching_node?(node_test) ? [self] : []
+		else
+			raise "Invalid axis: #{axis}"
+		end
+	end
+	protected :find_matching_nodes
+
+	def is_matching_node?(node_test) # :nodoc:
+		case node_test
+		when '*'
+			self.is_a?(Rind::Text) ? false : true
+		when 'comment()'
+			self.is_a?(Rind::Comment) ? true : false
+		when 'node()'
+			true
+		when 'processing-instruction()'
+			self.is_a?(Rind::ProcessingInstruction) ? true : false
+		when 'text()'
+			self.is_a?(Rind::Text) ? true : false
+		else
+			if self.is_a?(Rind::Element)
+				if self.namespace_name == 'rind:html' and self.local_name == node_test
+					true
+				elsif self.expanded_name == node_test
+					true
+				end
+		  else
+				false
+			end
+		end
+	end
+	protected :is_matching_node?
+
+	def validate_predicate(predicate, position) # :nodoc:
+		# attribute replacement
+		predicate.gsub!(/@([0-9a-zA-Z]+)/){self.respond_to?(:[]) ? "self[:#{$1}]" : 'nil'}
+		# position()
+		predicate.gsub!(/position\(\)/, position.to_s)
+
+		valid = eval predicate
+		# a number indicates a position request
+		if valid.is_a? Fixnum
+			valid == position
+		else
+			valid
+		end
+	end
+	protected :validate_predicate
+end

data/test/all_test.rb

@@ -0,0 +1,14 @@
+require 'test/unit'
+require 'children_test'
+require 'cdata_test'
+require 'comment_test'
+require 'document_test'
+require 'equality_test'
+require 'element_test'
+require 'html_test'
+require 'xml_test'
+require 'nodes_test'
+require 'parser_test'
+require 'xpath_test'
+require 'traverse_test'
+require 'manipulate_test'

data/test/cdata_test.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+require 'rind'
+
+class CdataTest < Test::Unit::TestCase
+	def test_to_s
+		cdata = Rind::Cdata.new('foo')
+		assert_equal(cdata.to_s, '<![CDATA[foo]]>')
+	end
+end

data/test/children_test.rb

@@ -0,0 +1,50 @@
+require 'test/unit'
+require 'rind'
+
+class ChildrenTest < Test::Unit::TestCase
+	def setup
+		@parent = Rind::Html::Html.new()
+		@one = Rind::Html::P.new(:attributes => {:id => '1'})
+		@two = Rind::Html::P.new(:attributes => {:id => '2'})
+		@three = Rind::Html::P.new(:attributes => {:id => '3'})
+		@children = Rind::Children.new(@parent, @one, @two, @three)
+	end
+
+	def test_delete
+		# normal
+		child = @children.delete(@one)
+		assert_same(child, @one)
+		assert_nil(child.parent)
+		assert_equal(@children.length, 2)
+
+		# item not found
+		child = @children.delete('a')
+		assert_nil(child)
+
+		# item not found with block
+		child = @children.delete('a') {'not found'}
+		assert_equal(child, 'not found')
+	end
+
+	# testing the clearing of the parent using internal wrapper
+	def test_pop
+		child = @children.pop
+		assert_same(child, @three)
+		assert_nil(child.parent)
+		assert_equal(@children.length, 2)
+	end
+
+	# testing the addition of the parent using internal wrapper
+	def test_push
+		children = Rind::Children.new(@parent)
+		children.push(@one, @two, @three)
+		assert_equal(children, @children)
+		children.each do |child|
+			assert_same(child.parent, @parent)
+		end
+	end
+
+	def test_to_s
+		assert_equal(@children.to_s, '<p id="1"></p><p id="2"></p><p id="3"></p>')
+	end
+end