Module: Utopia::Links

Defined in:

lib/utopia/link.rb

Constant Summary

XNODE_FILTER =

/^(.+)\.xnode$/

INDEX_XNODE_FILTER =

/^(index(\..+)*)\.xnode$/

LINKS_YAML =

"links.yaml"

DEFAULT_OPTIONS =

{
	:directories => true,
	:files => true,
	:virtual => true,
	:indices => false,
	:sort => :order,
	:display => :display,
	:locale => nil
}

Class Method Summary

• .index(root, top, options = {}) ⇒ Object
• .indices(path, &block) ⇒ Object
• .metadata(path) ⇒ Object

Class Method Details

.index(root, top, options = {}) ⇒ Object

# File 'lib/utopia/link.rb', line 142

def self.index(root, top, options = {})
	options = DEFAULT_OPTIONS.merge(options)
	path = File.join(root, top.components)
	metadata = Links.metadata(path)
	
	virtual_metadata = metadata.dup

	links = []

	Dir.entries(path).each do |filename|
		next if filename.match(/^[\._]/)

		fullpath = File.join(path, filename)

		if File.directory?(fullpath) && options[:directories]
			name = filename
			indices_metadata = Links.metadata(fullpath)
			directory_metadata = metadata.delete(name) || {}

			indices = 0
			Links.indices(fullpath) do |index|
				index_name = File.basename(index, ".xnode")
				index_metadata = directory_metadata.merge(indices_metadata[index_name] || {})

				directory_link = Link.new(:directory, top + [filename, index_name], index_metadata)

				# Check for localized directory metadata and update the link
				if directory_link.locale
					localized_metadata = metadata.delete(name + "." + directory_link.locale)

					if localized_metadata
						directory_link.info.update(localized_metadata.symbolize_keys)
					end
				end

				links << directory_link

				indices += 1
			end

			if indices == 0
				links << Link.new(:directory, top + [filename, ""], directory_metadata.merge(:uri => "\#"))
			end
		elsif filename.match(INDEX_XNODE_FILTER) && options[:indices] == false
			name = $1
			metadata.delete(name)

			# We don't include indices in the list of pages.
			next
		elsif filename.match(XNODE_FILTER) && options[:files]
			name = $1

			links << Link.new(:file, top + name, metadata.delete(name))
		end
	end

	if options[:virtual]
		metadata.each do |name, details|
			# Given a virtual named such as "welcome.cn", merge it with metadata 
			# from "welcome" if it exists.
			basename, locale = name.split(".", 2)

			if virtual_metadata[basename]
				details = virtual_metadata[basename].merge(details || {})
				name = basename
				details[:locale] = locale
			end

			links << Link.new(:virtual, name, details)
		end
	end

	if options[:display]
		links = links.delete_if{|link| link[options[:display]] == false}
	end

	if options[:name]
		case options[:name]
		when Regexp
			links.reject!{|link| !link.name.match(options[:name])}
		when String
			links.reject!{|link| link.name.index(options[:name]) != 0}
		end
	end

	if options[:locale]
		reduced = []

		links.group_by(&:name).each do |name, links|
			specific = nil

			links.each do |link|
				if link.locale == options[:locale]
					specific = link
					break
				elsif link.default_locale
					specific ||= link
				end
			end

			reduced << specific if specific
		end
		
		links = reduced
	end
	
	if options[:sort]
		sort_key = options[:sort]
		sort_default = options[:sort_default] || 0
		
		links = links.sort do |a, b|
			result = nil

			lhs = a[sort_key] || sort_default
			rhs = b[sort_key] || sort_default
			
			begin
				result ||= lhs <=> rhs
			rescue
				# LOG.debug("Invalid comparison between #{a.path} and #{b.path} using key #{options[:sort]}!")
			end
			
			if result == 0 || result == nil
				a.title <=> b.title
			else
				result
			end
		end
	end
	
	return links
end

.indices(path, &block) ⇒ Object

# File 'lib/utopia/link.rb', line 122

def self.indices(path, &block)
	entries = Dir.entries(path).delete_if{|filename| !filename.match(INDEX_XNODE_FILTER)}

	if block_given?
		entries.each &block
	else
		return entries
	end
end

.metadata(path) ⇒ Object

# File 'lib/utopia/link.rb', line 113

def self.metadata(path)
	links_path = File.join(path, LINKS_YAML)
	if File.exist?(links_path)
		return YAML::load(File.read(links_path))
	else
		return {}
	end
end