utopia 0.12.6 → 1.0.0

data/lib/utopia/content/processor.rb

@@ -0,0 +1,128 @@
+# 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 'trenni/parser'
+require 'trenni/strings'
+
+require_relative 'tag'
+
+module Utopia
+	class Content
+		class Processor
+			def self.parse_xml(xml_data, delegate)
+				processor = self.new(delegate)
+				
+				processor.parse(xml_data)
+			end
+
+			class UnbalancedTagError < StandardError
+				def initialize(scanner, start_position, current_tag, closing_tag)
+					@scanner = scanner
+					@start_position = start_position
+					@current_tag = current_tag
+					@closing_tag = closing_tag
+					
+					@starting_line = Trenni::Parser.line_at_offset(@scanner.string, @start_position)
+					@ending_line = Trenni::Parser.line_at_offset(@scanner.string, @scanner.pos)
+				end
+
+				attr :scanner
+				attr :start_position
+				attr :current_tag
+				attr :closing_tag
+
+				def to_s
+					"Unbalanced Tag Error. " \
+					"Line #{@starting_line[:line_number]}: #{@current_tag} has been closed by #{@closing_tag} on line #{@ending_line[:line_number]}!"
+				end
+			end
+
+			def initialize(delegate)
+				@delegate = delegate
+				@stack = []
+
+				@parser = Trenni::Parser.new(self)
+			end
+
+			def parse(input)
+				@parser.parse(input)
+				
+				unless @stack.empty?
+					current_tag, current_position = @stack.pop
+					
+					raise UnbalancedTagError.new(@scanner, current_position, current_tag.name, 'EOF')
+				end
+			end
+
+			def begin_parse(scanner)
+				@scanner = scanner
+			end
+
+			def text(text)
+				@delegate.cdata(text)
+			end
+
+			def cdata(text)
+				@delegate.cdata(Trenni::Strings::to_html(text))
+			end
+
+			def comment(text)
+				@delegate.cdata("<!#{text}>")
+			end
+
+			def begin_tag(tag_name, begin_tag_type)
+				if begin_tag_type == :opened
+					@stack << [Tag.new(tag_name, {}), @scanner.pos]
+				else
+					current_tag, current_position = @stack.pop
+			
+					if tag_name != current_tag.name
+						raise UnbalancedTagError.new(@scanner, current_position, current_tag.name, tag_name)
+					end
+			
+					@delegate.tag_end(current_tag)
+				end
+			end
+
+			def finish_tag(begin_tag_type, end_tag_type)
+				if begin_tag_type == :opened # <...
+					if end_tag_type == :closed # <.../>
+						cur, pos = @stack.pop
+						cur.closed = true
+
+						@delegate.tag_complete(cur)
+					elsif end_tag_type == :opened # <...>
+						cur, pos = @stack.last
+
+						@delegate.tag_begin(cur)
+					end
+				end
+			end
+
+			def attribute(name, value)
+				@stack.last[0].attributes[name] = value
+			end
+
+			def instruction(content)
+				cdata("<?#{content}?>")
+			end
+		end
+	end
+end

data/lib/utopia/content/tag.rb

@@ -0,0 +1,102 @@
+# 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.
+
+module Utopia
+	class Content
+		# This represents an individual SGML tag, e.g. <a>, </a> or <a />, with attributes. Attribute values must be escaped.
+		class Tag
+			def == other
+				if Tag === other
+					[@name, @attributes, @closed] == [other.name, other.attributes, other.closed]
+				end
+			end
+			
+			def self.closed(name, attributes = {})
+				tag = Tag.new(name, attributes)
+				tag.closed = true
+				
+				return tag
+			end
+			
+			def initialize(name, attributes = {})
+				@name = name
+				@attributes = attributes
+				@closed = false
+			end
+
+			attr :name
+			attr :attributes
+			attr :closed, true
+
+			def [](key)
+				@attributes[key]
+			end
+
+			def to_html(content = nil, buffer = StringIO.new)
+				write_full_html(buffer, content)
+				
+				return buffer.string
+			end
+			
+			def to_hash
+				@attributes
+			end
+			
+			def to_s(content = nil)
+				buffer = StringIO.new
+				write_full_html(buffer, content)
+				return buffer.string
+			end
+			
+			def write_open_html(buffer, terminate = false)
+				buffer ||= StringIO.new 
+				buffer.write "<#{name}"
+
+				@attributes.each do |key, value|
+					if value
+						buffer.write " #{key}=\"#{value}\""
+					else
+						buffer.write " #{key}"
+					end
+				end
+				
+				if terminate
+					buffer.write "/>"
+				else
+					buffer.write ">"
+				end
+			end
+			
+			def write_close_html(buffer)
+				buffer.write "</#{name}>"
+			end
+			
+			def write_full_html(buffer, content = nil)
+				if @closed && content == nil
+					write_open_html(buffer, true)
+				else
+					write_open_html(buffer)
+					buffer.write(content)
+					write_close_html(buffer)
+				end
+			end
+		end
+	end
+end

data/lib/utopia/controller.rb

@@ -0,0 +1,137 @@
+# 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 'path'
+
+require_relative 'controller/variables'
+require_relative 'controller/action'
+require_relative 'controller/base'
+
+class Rack::Request
+	def controller(&block)
+		if block_given?
+			env["utopia.controller"].instance_eval(&block)
+		else
+			env["utopia.controller"]
+		end
+	end
+end
+
+module Utopia
+	class Controller
+		CONTROLLER_RB = "controller.rb".freeze
+
+		def initialize(app, options = {})
+			@app = app
+			@root = options[:root] || Utopia::default_root
+
+			@controllers = {}
+			
+			@cache_controllers = options[:cache_controllers] || false
+		end
+		
+		attr :app
+		
+		def lookup_controller(path)
+			if @cache_controllers
+				return @controllers.fetch(path.to_s) do |key|
+					@controllers[key] = load_controller_file(path)
+				end
+			else
+				return load_controller_file(path)
+			end
+		end
+		
+		def load_controller_file(path)
+			uri_path = path
+			base_path = File.join(@root, uri_path.components)
+			
+			controller_path = File.join(base_path, CONTROLLER_RB)
+			# puts "load_controller_file(#{path.inspect}) => #{controller_path}"
+			
+			if File.exist?(controller_path)
+				klass = Class.new(Base)
+				
+				# base_path is expected to be a string representing a filesystem path:
+				klass.const_set(:BASE_PATH, base_path)
+				
+				# uri_path is expected to be an instance of Path:
+				klass.const_set(:URI_PATH, uri_path)
+				
+				klass.const_set(:CONTROLLER, self)
+				
+				$LOAD_PATH.unshift(base_path)
+				
+				klass.class_eval(File.read(controller_path), controller_path)
+				
+				$LOAD_PATH.delete(base_path)
+				
+				return klass.new
+			else
+				return nil
+			end
+		end
+		
+		def invoke_controllers(variables, request, done = Set.new)
+			path = Path.create(request.path_info)
+			controller_path = Path.new
+			
+			path.descend do |controller_path|
+				# puts "Invoke controller: #{controller_path}"
+				if controller = lookup_controller(controller_path)
+					# We only want to invoke controllers which have not already been invoked:
+					unless done.include? controller
+						# If we get throw :rewrite, location, the URL has been rewritten and we need to request again:
+						location = catch(:rewrite) do
+							# Invoke the controller and if it returns a result, send it back out:
+							if result = controller.process!(request, path)
+								return result
+							end
+						end
+						
+						if location
+							# Rewrite relative paths based on the controller's URI:
+							request.env['PATH_INFO'] = Path[location].expand(controller.class.uri_path).to_s
+							
+							return invoke_controllers(variables, request, done)
+						end
+						
+						done << controller
+					end
+				end
+			end
+			
+			# No controller gave a useful result:
+			return nil
+		end
+		
+		def call(env)
+			variables = (env["utopia.controller"] ||= Variables.new)
+			
+			request = Rack::Request.new(env)
+			
+			if result = invoke_controllers(variables, request)
+				return result
+			end
+			
+			return @app.call(env)
+		end
+	end
+end

data/lib/utopia/controller/action.rb

@@ -0,0 +1,112 @@
+# Copyright, 2014, 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.
+
+module Utopia
+	class Controller
+		class Action < Hash
+			attr_accessor :callback
+			attr_accessor :options
+			
+			def callback?
+				@callback != nil
+			end
+			
+			def indirect?
+				@options[:indirect]
+			end
+			
+			def eql? other
+				super and self.callback.eql? other.callback and self.options.eql? other.options
+			end
+			
+			def hash
+				[super, callback, options].hash
+			end
+			
+			def == other
+				super and (self.callback == other.callback) and (self.options == other.options)
+			end
+			
+			protected
+			
+			def append(path, index, actions = [])
+				# ** is greedy, it always matches if possible:
+				if match_all = self[:**]
+					# Match all remaining input:
+					actions << match_all if match_all.callback?
+				end
+				
+				if index < path.size
+					name = path[index].to_sym
+					
+					if match_name = self[name]
+						# Match the exact name:
+						match_name.append(path, index+1, actions)
+					end
+					
+					if match_one = self[:*]
+						# Match one input:
+						match_one.append(path, index+1, actions)
+					end
+				else
+					# Got to end, matched completely:
+					actions << self if self.callback?
+				end
+			end
+			
+			public
+			
+			# relative_path = 2014/mr-potato
+			# actions => {:** => A}
+			def select(relative_path)
+				actions = []
+				
+				append(relative_path.reverse, 0, actions)
+				
+				return actions
+			end
+			
+			def define(path, options = {}, &callback)
+				current = self
+				
+				path.reverse.each do |name|
+					current = (current[name.to_sym] ||= Action.new)
+				end
+				
+				current.options = options
+				current.callback = callback
+				
+				return current
+			end
+			
+			def invoke!(controller, *arguments)
+				controller.instance_exec(*arguments, &@callback)
+			end
+			
+			def inspect
+				if callback?
+					"<action " + super + ":#{callback.source_location}(#{options})>"
+				else
+					"<action " + super + ">"
+				end
+			end
+		end
+	end
+end