utopia 2.13.4 → 2.14.0

data/lib/utopia/content/links.rb

@@ -27,7 +27,8 @@ require 'concurrent/map'
 module Utopia
 	class Content
 		# The file extension for markup nodes on disk.
-		XNODE_EXTENSION = '.xnode'.freeze
+		XNODE_EXTENSION = '.xnode'
+		INDEX = "index"
 		
 		class Links
 			def self.for(root, path, locale = nil)
@@ -40,47 +41,55 @@ module Utopia
 				self.new(root).index(path, **options)
 			end
 			
-			XNODE_FILTER = /^(.+)#{Regexp.escape XNODE_EXTENSION}$/
-			INDEX_XNODE_FILTER = /^(index(\..+)*)#{Regexp.escape XNODE_EXTENSION}$/
-			
-			def initialize(root)
+			def initialize(root, extension: XNODE_EXTENSION)
 				@root = root
 				
-				@cache = Concurrent::Map.new
+				@extension = extension
+				@file_filter = /\A(?<key>(?<name>[^.]+)(\.(?<locale>.+))?)#{Regexp.escape extension}\Z/
+				@index_filter = /\A(?<key>(?<name>index)(\.(?<locale>.+))?)#{Regexp.escape extension}\Z/
+				
+				@metadata_cache = Concurrent::Map.new
+				@links_cache = Concurrent::Map.new
 			end
 			
+			attr :extension
+			attr :file_filter
+			attr :index_filter
+			
+			# Resolve a link for the specified path, which must be a path to a specific link.
+			# 	for(Path["/index"])
 			def for(path, locale = nil)
-				links = Resolved.new(self, path.dirname)
-				
-				links.lookup(path.last, locale)
+				links(path.dirname).lookup(path.last, locale)
 			end
 			
-			DEFAULT_INDEX_OPTIONS = {
-				:directories => true,
-				:files => true,
-				:virtuals => true,
-				:indices => false,
-				:sort => :order,
-				:display => :display,
-			}
-			
-			def index(path, **options)
-				options = DEFAULT_INDEX_OPTIONS.merge(options)
+			# Give an index of all links that can be reached from the given path.
+			def index(path, name: nil, locale: nil, display: :display, sort: :order, sort_default: 0, directories: true, files: true, virtuals: true, indices: false)
+				ordered = links(path).ordered.dup
+				
+				# Ignore specific kinds of links:
+				ignore = []
+				ignore << :directory unless directories
+				ignore << :file unless files
+				ignore << :virtual unless virtuals
+				ignore << :index unless indices
 				
-				ordered = Resolved.new(self, path, options).ordered
+				if ignore.any?
+					ordered.reject!{|link| ignore.include?(link.kind)}
+				end
 				
-				# This option filters a link based on the display parameter.
-				if display_key = options[:display]
-					ordered.reject!{|link| link.info[display_key] == false}
+				# Filter links by display key:
+				if display
+					ordered.reject!{|link| link.info[display] == false}
 				end
 				
-				# Named:
-				if name = options[:name]
+				# Filter links by name:
+				if name
 					# We use pattern === name, which matches either the whole string, or matches a regexp.
 					ordered.select!{|link| name === link.name}
 				end
 				
-				if locale = options[:locale]
+				# Filter by locale:
+				if locale
 					locales = {}
 					
 					ordered.each do |link|
@@ -94,10 +103,10 @@ module Utopia
 					ordered = locales.values
 				end
 				
-				# Sort:
-				if sort_key = options[:sort]
+				# Order by sort key:
+				if sort
 					# Sort by sort_key, otherwise by title.
-					ordered.sort_by!{|link| [link[sort_key] || options[:sort_default] || 0, link.title]}
+					ordered.sort_by!{|link| [link[sort] || sort_default, link.title]}
 				end
 				
 				return ordered
@@ -105,38 +114,65 @@ module Utopia
 			
 			attr :root
 			
-			# Represents a list of {Link} instances relating to the structure of the content. They are formed from the `links.yaml` file and the actual directory structure on disk.
-			class Resolved
-				DEFAULT_OPTIONS = {
-					:directories => true,
-					:files => true,
-					:virtuals => true,
-					:indices => true,
-				}
+			def metadata(path)
+				@metadata_cache.fetch_or_store(path.to_s) do
+					load_metadata(path)
+				end
+			end
+			
+			def links(path)
+				@links_cache.fetch_or_store(path.to_s) do
+					load_links(path)
+				end
+			end
+			
+			private
+			
+			def symbolize_keys(map)
+				# Second level attributes should be symbolic:
+				map.each do |key, info|
+					map[key] = info.each_with_object({}) { |(k,v),result| result[k.to_sym] = v }
+				end
 				
-				def initialize(links, top = Path.root, options = DEFAULT_OPTIONS)
+				return map
+			end
+			
+			LINKS_YAML = "links.yaml"
+			
+			def load_metadata(path)
+				yaml_path = File.join(path, LINKS_YAML)
+				
+				if File.exist?(yaml_path) && data = YAML::load_file(yaml_path)
+					return symbolize_keys(data)
+				else
+					return {}
+				end
+			end
+			
+			# Represents a list of {Link} instances relating to the structure of the content. They are formed from the `links.yaml` file and the actual directory structure on disk.
+			class Resolver
+				def initialize(links, top = Path.root)
 					raise ArgumentError.new("top path must be absolute") unless top.absolute?
 					
 					@links = links
 					
 					@top = top
-					@options = options
 					
 					# top.components.first == '', but this isn't a problem here.
 					@path = File.join(links.root, top.components)
 					
 					@ordered = []
-					@named = Hash.new{|h,k| h[k] = []}
+					@named = {}
 					
-					if File.directory? @path
+					if File.directory?(@path)
 						@metadata = links.metadata(@path)
 						
 						load_links(@metadata.dup) do |link|
 							@ordered << link
-							@named[link.name] << link
+							(@named[link.name] ||= []) << link
 						end
 					else
-						@metadata = {}
+						@metadata = nil
 					end
 				end
 				
@@ -144,6 +180,10 @@ module Utopia
 				attr :ordered
 				attr :named
 				
+				def indices
+					return @ordered.select{|link| link.index?}
+				end
+				
 				def each(locale)
 					return to_enum(:each, locale) unless block_given?
 					
@@ -155,115 +195,137 @@ module Utopia
 				def lookup(name, locale = nil)
 					# This allows generic links to serve any locale requested.
 					if links = @named[name]
-						links.find{|link| link.locale == locale} || links.find{|link| link.locale == nil}
+						generic_link = nil
+						
+						links.each do |link|
+							if link.locale == locale
+								return link
+							elsif link.locale.nil?
+								generic_link = link
+							end
+						end
+						
+						return generic_link
 					end
 				end
 				
 				private
 				
-				def indices(path, &block)
-					Dir.entries(path).select{|filename| filename.match(INDEX_XNODE_FILTER)}
+				def entries(path)
+					Dir.entries(path).reject{|entry| entry.match(/^[\._]/)}
 				end
 				
-				def load_indices(name, path, metadata)
-					directory_metadata = metadata.delete(name) || {}
-					indices_metadata = @links.metadata(path)
+				# @param name [String] the name of the directory.
+				def load_directory(name, metadata, &block)
+					defaults = metadata.delete(name) || {}
 					
-					indices_count = 0
+					links = @links.links(@top + name).indices
 					
-					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.locale
-							localized_key = "#{directory_link.name}.#{directory_link.locale}"
-							if localized_metadata = metadata.delete(localized_key)
-								directory_link.info.update(localized_metadata)
-							end
+					links.each do |link|
+						# We extract the metadata according to the localized link:
+						if info = metadata.delete("#{name}.#{link.locale}")
+							info = info.merge(link.info)
+						else
+							info = link.info
 						end
 						
-						yield directory_link
-						
-						indices_count += 1
+						yield Link.new(:directory, name, link.locale, link.path, defaults.merge(info))
+					end
+				end
+				
+				def load_index(name, locale, info)
+					info ||=  {}
+					
+					if locale and defaults = @metadata[name]
+						info = defaults.merge(info)
 					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))
+					path = @top + name
+					
+					yield Link.new(:index, name, locale, path, info, path[-2])
+				end
+				
+				def load_default_index(name = INDEX, info = {})
+					path = @top + name
+					
+					if info
+						info = {uri: nil}.merge(info)
+					else
+						info = {uri: nil}
 					end
+					
+					# Specify a nil uri if no index could be found for the directory:
+					yield Link.new(:index, name, nil, @top, info, path[-2])
 				end
 				
-				def entries(path)
-					Dir.entries(path).reject{|filename| filename.match(/^[\._]/)}
+				def load_file(name, locale, info)
+					info ||= {}
+					
+					if locale and defaults = @metadata[name]
+						info = defaults.merge(info)
+					end
+					
+					path = @top + name
+					
+					yield Link.new(:file, name, locale, path, info)
 				end
 				
-				def load_links(metadata, &block)
-					# Load all metadata for a given path:
-					metadata = @metadata.dup
+				def load_virtuals(metadata)
+					virtuals = {}
 					
-					# Check all entries in the given directory:
-					entries(@path).each do |filename|
-						path = File.join(@path, filename)
+					# After processing all directory entries, we are left with virtual links:
+					metadata.each do |key, info|
+						name, locale = key.split('.', 2)
+						localized = (virtuals[name] ||= {})
+						localized[locale] = info
+					end
+					
+					virtuals.each do |name, localized|
+						defaults = localized[nil]
 						
-						# There are two types of filelinks 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))
+						localized.each do |locale, info|
+							info = defaults&.merge(info) || info
+							path = info[:path]
+							
+							yield Link.new(:virtual, name, locale, path, info)
 						end
 					end
+				end
+				
+				def load_links(metadata, &block)
+					index_loaded = false
 					
-					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)
+					# Check all entries in the given directory:
+					entries(@path).each do |entry|
+						path = File.join(@path, entry)
+						
+						# There are serveral types of file based links:
+						
+						# 1. Directories, e.g. bar/ (name=bar)
+						if File.directory?(path)
+							load_directory(entry, metadata, &block)
 							
-							# 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
+						# 2. Index files, e.g. index.xnode, name=parent
+						elsif match = entry.match(@links.index_filter)
+							load_index(match[:name], match[:locale], metadata.delete(match[:key]), &block)
+							index_loaded = true
 							
-							yield virtual_link
+						# 3. Named files, e.g. foo.xnode, name=foo
+						elsif match = entry.match(@links.file_filter)
+							load_file(match[:name], match[:locale], metadata.delete(match[:key]), &block)
 						end
 					end
+					
+					unless index_loaded
+						load_default_index(INDEX, metadata.delete(INDEX), &block)
+					end
+					
+					load_virtuals(metadata, &block)
 				end
 			end
 			
-			def metadata(path)
-				@cache.fetch_or_store(path.to_s) do
-					load(path).freeze
-				end
-			end
-			
-			private
-			
-			def 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
-			
-			LINKS_YAML = "links.yaml"
-			
-			def load(path)
-				yaml_path = File.join(path, LINKS_YAML)
-				
-				if File.exist?(yaml_path) && data = YAML::load_file(yaml_path)
-					return symbolize_keys(data)
-				else
-					return {}
-				end
+			def load_links(path)
+				Resolver.new(self, Path.create(path))
 			end
 		end
 	end

data/lib/utopia/content/node.rb

@@ -33,28 +33,24 @@ module Utopia
 		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 name
 				@uri_path.basename
 			end
-
-			def link
-				return Link.new(:file, uri_path)
-			end
-
+			
 			def lookup_node(path)
 				@controller.lookup_node(parent_path + Path[path])
 			end
-
+			
 			def local_path(path = '.', base = nil)
 				path = Path[path]
 				
@@ -78,7 +74,7 @@ module Utopia
 			def parent_path
 				@uri_path.dirname
 			end
-
+			
 			def links(path = '.', **options, &block)
 				path = uri_path.dirname + Path[path]
 				
@@ -90,11 +86,11 @@ module Utopia
 					links
 				end
 			end
-
+			
 			def related_links
-				@controller.links(@uri_path.dirname, :name => @uri_path.basename, :indices => true)
+				@controller.links(@uri_path.dirname, name: @uri_path.basename, indices: true)
 			end
-
+			
 			def siblings_path
 				if @uri_path.basename == INDEX
 					@uri_path.dirname(2)
@@ -102,7 +98,7 @@ module Utopia
 					@uri_path.dirname
 				end
 			end
-
+			
 			def sibling_links(**options)
 				return @controller.links(siblings_path, **options)
 			end
@@ -129,7 +125,7 @@ module Utopia
 			def process!(request, attributes = {})
 				Document.render(self, request, attributes).to_a
 			end
-		
+			
 			# This is a special context in which a limited set of well defined methods are exposed in the content view.
 			Context = Struct.new(:document, :state) do
 				def partial(*args, &block)
@@ -173,11 +169,11 @@ module Utopia
 				def content
 					document.content
 				end
-
+				
 				def parent
 					document.parent
 				end
-
+				
 				def first
 					document.first
 				end