utopia 0.12.6 → 1.0.0

data/lib/utopia/content/link.rb

@@ -0,0 +1,124 @@
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'yaml'
+require 'trenni/builder'
+
+require_relative '../content'
+require_relative '../path'
+
+module Utopia
+	class Content
+		class Link
+			def initialize(kind, path, info = nil)
+				path = Path.create(path)
+
+				@info = info || {}
+				@kind = kind
+
+				case @kind
+				when :file
+					@name, @variant = path.last.split('.', 2)
+					@path = path
+				when :directory
+					# raise ArgumentError unless path.last.start_with? 'index'
+					
+					@name = path.dirname.last
+					@variant = path.last.split('.', 2)[1]
+					@path = path
+				when :virtual
+					@name, @variant = path.to_s.split('.', 2)
+					@path = @info[:path] ? Path.create(@info[:path]) : nil
+				else
+					raise ArgumentError.new("Unknown link kind #{@kind} with path #{path}")
+				end
+				
+				@title = Trenni::Strings.to_title(@name)
+			end
+
+			def href
+				@href ||= @info.fetch(:uri) do
+					(@path.dirname + @path.basename.parts[0]).to_s if @path
+				end
+			end
+
+			def [] key
+				@info[key]
+			end
+
+			attr :kind
+			attr :name
+			attr :path
+			attr :info
+			attr :variant
+
+			def href?
+				!!href
+			end
+
+			def relative_href(base = nil)
+				if base and href.start_with? '/'
+					Path.shortest_path(href, base)
+				else
+					href
+				end
+			end
+
+			def title
+				@info.fetch(:title, @title)
+			end
+
+			def to_href(options = {})
+				Trenni::Builder.fragment(options[:builder]) do |builder|
+					if href?
+						relative_href(options[:base])
+						
+						builder.inline('a', class: options.fetch(:class, 'link'), href: relative_href(options[:base])) do
+							builder.text(options[:content] || title)
+						end
+					else
+						builder.inline('span', class: options.fetch(:class, 'link')) do
+							builder.text(options[:content] || title)
+						end
+					end
+				end
+			end
+			
+			def eql? other
+				if other && self.class == other.class
+					return kind.eql?(other.kind) && 
+					       name.eql?(other.name) && 
+					       path.eql?(other.path) && 
+					       info.eql?(other.info)
+				else
+					return false
+				end
+			end
+
+			def == other
+				return other && kind == other.kind && name == other.name && path == other.path
+			end
+			
+			def default_locale?
+				@locale == nil
+			end
+		end
+	end
+end

data/lib/utopia/content/links.rb

@@ -0,0 +1,228 @@
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative 'link'
+
+module Utopia
+	class Content
+		XNODE_EXTENSION = '.xnode'.freeze
+		
+		# Links are essentially a static list of information relating to the structure of the content. They are formed from the `links.yaml` file and the actual files on disk. 
+		class Links
+			def self.for(root, path, variant = nil)
+				links = self.new(root, path.dirname)
+				
+				links.lookup(path.last, variant)
+			end
+			
+			DEFAULT_INDEX_OPTIONS = {
+				:directories => true,
+				:files => true,
+				:virtuals => true,
+				:indices => false,
+				:sort => :order,
+				:display => :display,
+			}
+			
+			def self.index(root, path, options = {})
+				options = DEFAULT_INDEX_OPTIONS.merge(options)
+				
+				ordered = self.new(root, path, options).ordered
+				
+				# This option filters a link based on the display parameter.
+				if display_key = options[:display]
+					ordered.reject!{|link| link.info[display_key] == false}
+				end
+				
+				# Named:
+				if name = options[:name]
+					ordered.select!{|link| link.name[options[:name]]}
+				end
+				
+				if variant = options[:variant]
+					variants = {}
+					
+					ordered.each do |link|
+						if link.variant == variant
+							variants[link.name] = link
+						elsif link.variant == nil
+							variants[link.name] ||= link
+						end
+					end
+					
+					ordered = variants.values
+				end
+				
+				# Sort:
+				if sort_key = options[:sort]
+					# Sort by sort_key, otherwise by title.
+					ordered.sort_by!{|link| [link[sort_key] || options[:sort_default] || 0, link.title]}
+				end
+				
+				return ordered
+			end
+			
+			XNODE_FILTER = /^(.+)#{Regexp.escape XNODE_EXTENSION}$/
+			INDEX_XNODE_FILTER = /^(index(\..+)*)#{Regexp.escape XNODE_EXTENSION}$/
+			LINKS_YAML = "links.yaml"
+			
+			DEFAULT_OPTIONS = {
+				:directories => true,
+				:files => true,
+				:virtuals => true,
+				:indices => true,
+			}
+			
+			def initialize(root, top = Path.new, options = DEFAULT_OPTIONS)
+				@top = top
+				@options = options
+				
+				@path = File.join(root, top.components)
+				@metadata = self.class.metadata(@path)
+				
+				@ordered = []
+				@named = Hash.new{|h,k| h[k] = []}
+				
+				if File.directory? @path
+					load_links(@metadata.dup) do |link|
+						@ordered << link
+						@named[link.name] << link
+					end
+				end
+			end
+			
+			attr :top
+			attr :ordered
+			attr :named
+			
+			def each(variant)
+				return to_enum(:each, variant) unless block_given?
+				
+				ordered.each do |links|
+					yield links.find{|link| link.variant == variant}
+				end
+			end
+			
+			def lookup(name, variant = nil)
+				# This allows generic links to serve any variant requested.
+				if links = @named[name]
+					links.find{|link| link.variant == variant} || links.find{|link| link.variant == nil}
+				end
+			end
+			
+			private
+			
+			def self.symbolize_keys(hash)
+				# Second level attributes should be symbolic:
+				hash.each do |key, info|
+					hash[key] = info.each_with_object({}) { |(k,v),result| result[k.to_sym] = v }
+				end
+				
+				return hash
+			end
+			
+			def self.metadata(path)
+				links_path = File.join(path, LINKS_YAML)
+				
+				hash = if File.exist?(links_path)
+					YAML::load(File.read(links_path)) || {}
+				else
+					{}
+				end
+				
+				return symbolize_keys(hash)
+			end
+			
+			def indices(path, &block)
+				Dir.entries(path).reject{|filename| !filename.match(INDEX_XNODE_FILTER)}
+			end
+			
+			def load_indices(name, path, metadata)
+				directory_metadata = metadata.delete(name) || {}
+				indices_metadata = Links.metadata(path)
+				
+				indices_count = 0
+				
+				indices(path).each do |filename|
+					index_name = File.basename(filename, XNODE_EXTENSION)
+					# Values in indices_metadata will override values in directory_metadata:
+					index_metadata = directory_metadata.merge(indices_metadata[index_name] || {})
+					
+					directory_link = Link.new(:directory, @top + [name, index_name], index_metadata)
+					
+					# Merge metadata from foo.en into foo/index.en
+					if directory_link.variant
+						if variant_metadata = metadata.delete(directory_link.name + '.' + directory_link.variant)
+							directory_link.info.update(variant_metadata)
+						end
+					end
+					
+					yield directory_link
+					
+					indices_count += 1
+				end
+				
+				if indices_count == 0
+					# Specify a nil uri if no index could be found for the directory:
+					yield Link.new(:directory, top + [name, ""], {:uri => nil}.merge(directory_metadata))
+				end
+			end
+			
+			def entries(path)
+				Dir.entries(path).reject{|filename| filename.match(/^[\._]/)}
+			end
+			
+			def load_links(metadata, &block)
+				# Load all metadata for a given path:
+				metadata = @metadata.dup
+				
+				# Check all entries in the given directory:
+				entries(@path).each do |filename|
+					path = File.join(@path, filename)
+					
+					# There are two types of filesystem based links:
+					# 1/ Named files, e.g. foo.xnode, name=foo
+					# 2/ Directories, e.g. bar/index.xnode, name=bar
+					if File.directory?(path) and @options[:directories]
+						load_indices(filename, path, metadata, &block)
+					elsif filename.match(INDEX_XNODE_FILTER) and @options[:indices] == false
+						metadata.delete($1) # We don't include indices in the list of pages.
+					elsif filename.match(XNODE_FILTER) and @options[:files]
+						yield Link.new(:file, @top + $1, metadata.delete($1))
+					end
+				end
+				
+				if @options[:virtuals]
+					# After processing all directory entries, we are left with virtual entries in the metadata:
+					metadata.each do |name, info|
+						virtual_link = Link.new(:virtual, name, info)
+						
+						# Given a virtual named such as "welcome.cn", merge it with metadata from "welcome" if it exists:
+						if virtual_metadata = @metadata[virtual_link.name]
+							virtual_link.info.update(virtual_metadata)
+						end
+						
+						yield virtual_link
+					end
+				end
+			end
+		end
+	end
+end

data/lib/utopia/content/node.rb

@@ -0,0 +1,387 @@
+# Copyright, 2012, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require 'set'
+
+require_relative 'processor'
+require_relative 'links'
+
+module Utopia
+	class Content
+		class UnbalancedTagError < StandardError
+			def initialize(tag)
+				@tag = tag
+				
+				super("Unbalanced tag #{tag.name}")
+			end
+			
+			attr :tag
+		end
+		
+		# A single request through content middleware.
+		class Transaction
+			# The state of a single tag being rendered.
+			class State
+				def initialize(tag, node)
+					@node = node
+
+					@buffer = StringIO.new
+					@overrides = {}
+
+					@tags = []
+					@attributes = tag.to_hash
+
+					@content = nil
+					@deferred = []
+				end
+
+				attr :attributes
+				attr :overrides
+				attr :content
+				attr :node
+				attr :tags
+
+				attr :deferred
+
+				def defer(value = nil, &block)
+					@deferred << block
+				
+					Tag.closed("deferred", :id => @deferred.size - 1).to_html
+				end
+
+				def [](key)
+					@attributes[key.to_s]
+				end
+
+				def call(transaction)
+					@content = @buffer.string
+					@buffer = StringIO.new
+					
+					if node.respond_to? :call
+						node.call(transaction, self)
+					else
+						transaction.parse_xml(@content)
+					end
+
+					return @buffer.string
+				end
+
+				def lookup(tag)
+					if override = @overrides[tag.name]
+						if override.respond_to? :call
+							return override.call(tag)
+						elsif String === override
+							return Tag.new(override, tag.attributes)
+						else
+							return override
+						end
+					else
+						return tag
+					end
+				end
+
+				def cdata(text)
+					@buffer.write(text)
+				end
+
+				def markup(text)
+					cdata(text)
+				end
+
+				def tag_complete(tag)
+					tag.write_full_html(@buffer)
+				end
+
+				def tag_begin(tag)
+					@tags << tag
+					tag.write_open_html(@buffer)
+				end
+
+				def tag_end(tag)
+					raise UnbalancedTagError(tag) unless @tags.pop.name == tag.name
+
+					tag.write_close_html(@buffer)
+				end
+			end
+
+			def initialize(request, response)
+				@begin_tags = []
+				@end_tags = []
+
+				@request = request
+				@response = response
+			end
+
+			attr :request
+			attr :response
+			
+			# A helper method for accessing controller variables from view:
+			def controller
+				@request.controller
+			end
+
+			def parse_xml(xml_data)
+				Processor.parse_xml(xml_data, self)
+			end
+
+			# Begin tags represents a list from outer to inner most tag.
+			# At any point in parsing xml, begin_tags is a list of the inner most tag,
+			# then the next outer tag, etc. This list is used for doing dependent lookups.
+			attr :begin_tags
+
+			# End tags represents a list of execution order. This is the order that end tags
+			# have appeared when evaluating nodes.
+			attr :end_tags
+
+			def attributes
+				return current.attributes
+			end
+
+			def current
+				@begin_tags[-1]
+			end
+
+			def content
+				@end_tags[-1].content
+			end
+
+			def parent
+				end_tags[-2]
+			end
+
+			def first
+				@begin_tags[0]
+			end
+
+			def tag(name, attributes = {}, &block)
+				tag = Tag.new(name, attributes)
+
+				node = tag_begin(tag)
+
+				yield node if block_given?
+
+				tag_end(tag)
+			end
+
+			def tag_complete(tag, node = nil)
+				if tag.name == "content"
+					current.markup(content)
+				else
+					node ||= lookup(tag)
+
+					if node
+						tag_begin(tag, node)
+						tag_end(tag)
+					else
+						current.tag_complete(tag)
+					end
+				end
+			end
+
+			def tag_begin(tag, node = nil)
+				node ||= lookup(tag)
+
+				if node
+					state = State.new(tag, node)
+					@begin_tags << state
+
+					if node.respond_to? :tag_begin
+						node.tag_begin(self, state)
+					end
+
+					return node
+				end
+
+				current.tag_begin(tag)
+
+				return nil
+			end
+
+			def cdata(text)
+				current.cdata(text)
+			end
+
+			def partial(*args, &block)
+				if block_given?
+					current.defer(&block)
+				else
+					current.defer do
+						tag(*args)
+					end
+				end
+			end
+
+			alias deferred_tag partial
+
+			def tag_end(tag = nil)
+				top = current
+
+				if top.tags.empty?
+					if top.node.respond_to? :tag_end
+						top.node.tag_end(self, top)
+					end
+
+					@end_tags << top
+					buffer = top.call(self)
+
+					@begin_tags.pop
+					@end_tags.pop
+
+					if current
+						current.markup(buffer)
+					end
+
+					return buffer
+				else
+					current.tag_end(tag)
+				end
+
+				return nil
+			end
+
+			def render_node(node, attributes = {})
+				state = State.new(attributes, node)
+				@begin_tags << state
+
+				return tag_end
+			end
+
+			# Takes an instance of Tag
+			def lookup(tag)
+				result = tag
+				node = nil
+
+				@begin_tags.reverse_each do |state|
+					result = state.lookup(result)
+					
+					node ||= state.node if state.node.respond_to? :lookup
+
+					return result if Node === result
+				end
+
+				@end_tags.reverse_each do |state|
+					return state.node.lookup(result) if state.node.respond_to? :lookup
+				end
+
+				return nil
+			end
+
+			def method_missing(name, *args)
+				@begin_tags.reverse_each do |state|
+					if state.node.respond_to? name
+						return state.node.send(name, *args)
+					end
+				end
+
+				super
+			end
+		end
+
+		class Node
+			def initialize(controller, uri_path, request_path, file_path)
+				@controller = controller
+
+				@uri_path = uri_path
+				@request_path = request_path
+				@file_path = file_path
+			end
+
+			attr :request_path
+			attr :uri_path
+			attr :file_path
+
+			def link
+				return Link.new(:file, uri_path)
+			end
+
+			def lookup_node(path)
+				@controller.lookup_node(path)
+			end
+
+			def local_path(path = ".", base = nil)
+				path = Path.create(path)
+				root = Pathname.new(@controller.root)
+				
+				if path.absolute?
+					return root.join(*path.components)
+				else
+					base ||= uri_path.dirname
+					return root.join(*(base + path).components)
+				end
+			end
+
+			def lookup(tag)
+				from_path = parent_path
+				
+				# If the current node is called 'foo', we can't lookup 'foo' in the current directory or we will have infinite recursion.
+				if tag.name == @uri_path.basename
+					from_path = from_path.dirname
+				end
+				
+				return @controller.lookup_tag(tag.name, from_path)
+			end
+
+			def parent_path
+				uri_path.dirname
+			end
+
+			def links(path = ".", options = {}, &block)
+				path = uri_path.dirname + Path.create(path)
+				links = Links.index(@controller.root, path, options)
+				
+				if block_given?
+					links.each &block
+				else
+					links
+				end
+			end
+
+			def related_links
+				name = @uri_path.last.split('.', 2).first
+				links = Links.index(@controller.root, uri_path.dirname, :name => name, :indices => true)
+			end
+
+			def siblings_path
+				name = @uri_path.last.split('.', 2).first
+				
+				if name == "index"
+					@uri_path.dirname(2)
+				else
+					@uri_path.dirname
+				end
+			end
+
+			def sibling_links(options = {})
+				return Links.index(@controller.root, siblings_path, options)
+			end
+
+			def call(transaction, state)
+				xml_data = @controller.fetch_xml(@file_path).evaluate(transaction)
+				
+				transaction.parse_xml(xml_data)
+			end
+
+			def process!(request, response, attributes = {})
+				transaction = Transaction.new(request, response)
+				response.write(transaction.render_node(self, attributes))
+			end
+		end
+	end
+end