utopia 0.9.17

data/ext/utopia/xnode/fast_scanner/extconf.rb

@@ -0,0 +1,6 @@
+
+require 'mkmf'
+
+dir_config('fast_scanner')
+
+create_makefile("fast_scanner")

data/ext/utopia/xnode/fast_scanner/parser.c

@@ -0,0 +1,289 @@
+#include "ruby.h"
+
+#define OPENED_TAG 0
+#define CLOSED_TAG 1
+
+static VALUE rb_XNode;
+static VALUE rb_XNode_ScanError;
+static VALUE rb_XNode_Scanner;
+
+static ID rb_XNode_CDATA_Callback;
+static ID rb_XNode_BeginTag_Callback;
+static ID rb_XNode_FinishTag_Callback;
+static ID rb_XNode_Attribute_Callback;
+static ID rb_XNode_Comment_Callback;
+static ID rb_XNode_Instruction_Callback;
+static ID rb_XNode_Comment_Callback;
+
+#define NewObject(type) (type*)malloc(sizeof(type))
+
+typedef struct {
+	VALUE delegate;
+	VALUE content;
+} XNode_Scanner;
+
+typedef char Character;
+typedef Character * Iterator;
+
+static void XNode_Scanner_Mark(XNode_Scanner * scanner) {
+	rb_gc_mark(scanner->delegate);
+	rb_gc_mark(scanner->content);
+}
+
+static void XNode_Scanner_Free(XNode_Scanner * scanner) {
+	free(scanner);
+}
+
+static VALUE XNode_Scanner_Allocate(VALUE klass) {
+	XNode_Scanner * scanner = NewObject(XNode_Scanner);
+	
+	return Data_Wrap_Struct(klass, XNode_Scanner_Mark, XNode_Scanner_Free, scanner);
+}
+
+static VALUE XNode_Scanner_Initialize(VALUE self, VALUE delegate, VALUE content) {
+	Check_Type(content, T_STRING);
+
+	XNode_Scanner * scanner;
+
+	Data_Get_Struct(self, XNode_Scanner, scanner);
+
+	scanner->delegate = delegate;
+	scanner->content = content;
+
+	return Qnil;
+}
+
+static VALUE rb_str_from_iterators(Iterator start, Iterator end) {
+	return rb_str_new(start, end - start);
+}
+
+static int is_whitespace(Iterator i) {
+	return (*i == ' ' || *i == '\r' || *i == '\n' || *i == '\t');
+}
+
+static int is_tag_character(Iterator i) {
+	return (*i == '<' || *i == '>' || *i == '/');
+}
+
+static int is_tag_name(Iterator i) {
+	return !(is_whitespace(i) || is_tag_character(i));
+}
+
+static Iterator expect_character(XNode_Scanner * scanner, Iterator start, Iterator end, Character c) {
+	if (start >= end || *start != c) {
+		VALUE message = rb_str_new2("Expected Character ");
+		rb_str_cat(message, &c, 1);
+		VALUE exception = rb_exc_new3(rb_XNode_ScanError, message);
+		rb_exc_raise(exception);
+	}
+	
+	return start + 1;
+}
+
+static Iterator skip_whitespace(Iterator start, Iterator end) {
+	while (start < end) {
+		if (!is_whitespace(start))
+			break;
+			
+		++start;
+	}
+	
+	return start;
+}
+
+static Iterator XNode_Scanner_Parse_CDATA(XNode_Scanner * scanner, Iterator start, Iterator end) {
+	Iterator cdata_start = start;
+	
+	while (start < end && *start != '<') {
+		++start;
+	}
+	
+	Iterator cdata_end = start;
+
+	if (cdata_start != cdata_end) {
+		VALUE cdata = rb_str_from_iterators(cdata_start, cdata_end);
+		rb_funcall(scanner->delegate, rb_XNode_CDATA_Callback, 1, cdata);
+	}
+	
+	return start;
+}
+
+static Iterator XNode_Scanner_Parse_Attributes(XNode_Scanner * scanner, Iterator start, Iterator end) {
+	while (start < end && !is_tag_character(start)) {
+		start = skip_whitespace(start, end);
+
+		Iterator attribute_name_start = start;
+	
+		while (start < end && *start != '=') {
+			++start;
+		}
+
+		Iterator attribute_name_end = start;
+
+		start = expect_character(scanner, start, end, '=');
+		start = expect_character(scanner, start, end, '"');
+
+		Iterator attribute_value_start = start;
+
+		while (start < end && *start != '"') {
+			++start;
+		}
+
+		Iterator attribute_value_end = start;
+		start = expect_character(scanner, start, end, '"');
+
+		VALUE attribute_name = rb_str_from_iterators(attribute_name_start, attribute_name_end);
+		VALUE attribute_value = rb_str_from_iterators(attribute_value_start, attribute_value_end);
+		rb_funcall(scanner->delegate, rb_XNode_Attribute_Callback, 2, attribute_name, attribute_value);
+		
+		start = skip_whitespace(start, end);
+	}
+	
+	return start;
+}
+
+static Iterator XNode_Scanner_Parse_Tag_Normal(XNode_Scanner * scanner, Iterator start, Iterator end, int begin_tag_type) {
+	Iterator tag_name_start = start;
+	int finish_tag_type;
+	
+	while (start < end && is_tag_name(start)) {
+		++start;
+	}
+	
+	Iterator tag_name_end = start;
+	
+	VALUE tag_name = rb_str_from_iterators(tag_name_start, tag_name_end);
+	rb_funcall(scanner->delegate, rb_XNode_BeginTag_Callback, 2, tag_name, INT2FIX(begin_tag_type));
+	
+	start = skip_whitespace(start, end);
+	
+	if (!is_tag_character(start))
+		start = XNode_Scanner_Parse_Attributes(scanner, start, end);
+	
+	if (*start == '/') {
+		if (begin_tag_type == CLOSED_TAG) {
+			VALUE exception = rb_exc_new2(rb_XNode_ScanError, "Tag cannot be closed at both ends!");
+			rb_exc_raise(exception);
+		}
+		
+		finish_tag_type = CLOSED_TAG;
+		start += 2;
+	} else if (*start == '>') {
+		finish_tag_type = OPENED_TAG;
+		++start;
+	}
+	
+	rb_funcall(scanner->delegate, rb_XNode_FinishTag_Callback, 2, INT2FIX(begin_tag_type), INT2FIX(finish_tag_type));
+	
+	return start;
+}
+
+static Iterator XNode_Scanner_Parse_Tag_Comment(XNode_Scanner * scanner, Iterator start, Iterator end) {
+	Iterator comment_start = start;
+	
+	while (start < end && *start != '>') {
+		++start;
+	}
+	
+	Iterator comment_end = start;
+	
+	start = expect_character(scanner, start, end, '>');
+	
+	VALUE comment = rb_str_from_iterators(comment_start, comment_end);
+	rb_funcall(scanner->delegate, rb_XNode_Comment_Callback, 1, comment);
+	
+	return start;
+}
+
+static Iterator XNode_Scanner_Parse_Tag_Instruction(XNode_Scanner * scanner, Iterator start, Iterator end) {
+	Iterator instruction_start = start;
+	
+	while ((start+1) < end && *start != '?' && *(start+1) != '>') {
+		++start;
+	}
+	
+	Iterator instruction_end = start;
+	
+	start = expect_character(scanner, start, end, '?');
+	start = expect_character(scanner, start, end, '>');
+	
+	VALUE instruction = rb_str_from_iterators(instruction_start, instruction_end);
+	rb_funcall(scanner->delegate, rb_XNode_Instruction_Callback, 1, instruction);
+	
+	return start;
+}
+
+static Iterator XNode_Scanner_Parse_Tag(XNode_Scanner * scanner, Iterator start, Iterator end) {
+	if (*start == '<') {
+		++start;
+		
+		if (*start == '/') {
+			++start;
+			start = XNode_Scanner_Parse_Tag_Normal(scanner, start, end, CLOSED_TAG);
+		} else if (*start == '!') {
+			++start;
+			start = XNode_Scanner_Parse_Tag_Comment(scanner, start, end);
+		} else if (*start == '?') {
+			++start;
+			start = XNode_Scanner_Parse_Tag_Instruction(scanner, start, end);
+		} else {
+			start = XNode_Scanner_Parse_Tag_Normal(scanner, start, end, OPENED_TAG);
+		}
+	}
+	
+	return start;
+}
+
+static Iterator XNode_Scanner_Parse_Document(XNode_Scanner * scanner) {
+	Iterator current, start, end;
+
+	start = RSTRING(scanner->content)->ptr;
+	end = start + RSTRING(scanner->content)->len;
+
+	while (start < end) {
+		current = start;
+		
+		current = XNode_Scanner_Parse_CDATA(scanner, current, end);
+		current = XNode_Scanner_Parse_Tag(scanner, current, end);
+		
+		if (current == start) {
+			/* We did not parse anything! */
+			VALUE message = rb_str_new2("Parser Stuck at ");
+			
+			int len = 10;
+			if (current + len > end)
+				len = end - current;
+			
+			rb_str_cat(message, current, len);
+			VALUE exception = rb_exc_new3(rb_XNode_ScanError, message);
+			rb_exc_raise(exception);
+		}
+		
+		start = current;
+	}
+}
+
+static VALUE XNode_Scanner_Parse(VALUE self) {
+	XNode_Scanner * scanner;
+
+	Data_Get_Struct(self, XNode_Scanner, scanner);
+		
+	XNode_Scanner_Parse_Document(scanner);
+}
+
+void Init_xnode() {
+	rb_XNode = rb_define_module("XNode");
+	rb_XNode_ScanError = rb_define_class_under(rb_XNode, "ScanError", rb_eStandardError);
+	rb_XNode_Scanner = rb_define_class_under(rb_XNode, "Scanner", rb_cObject);
+	
+	rb_define_alloc_func(rb_XNode_Scanner, XNode_Scanner_Allocate);
+	rb_define_method(rb_XNode_Scanner, "initialize", XNode_Scanner_Initialize, 2);
+	rb_define_method(rb_XNode_Scanner, "parse", XNode_Scanner_Parse, 0);
+	
+	rb_XNode_CDATA_Callback = rb_intern("cdata");
+	rb_XNode_BeginTag_Callback = rb_intern("begin_tag");
+	rb_XNode_FinishTag_Callback = rb_intern("finish_tag");
+	rb_XNode_Attribute_Callback = rb_intern("attribute");
+	rb_XNode_Comment_Callback = rb_intern("comment");
+	rb_XNode_Instruction_Callback = rb_intern("instruction");
+}

data/lib/utopia.rb

@@ -0,0 +1,2 @@
+
+

data/lib/utopia/etanni.rb

@@ -0,0 +1,96 @@
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# [Etanni] Copyright (c) 2008 Michael Fellinger <m.fellinger@gmail.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 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 'digest/md5'
+
+module Utopia
+
+	class Etanni
+		SEPARATOR = Digest::MD5.hexdigest(Time.new.to_s)
+		START = "\n_out_ << <<#{SEPARATOR}.chomp!\n"
+		STOP = "\n#{SEPARATOR}\n"
+		REPLACEMENT = "#{STOP}\\1#{START}"
+
+		def initialize(template, compiled = false)
+			if compiled
+				@compiled = template
+			else
+				@template = template
+				compile!
+			end
+		end
+
+		def compile!
+			temp = @template.dup
+			temp.strip!
+			temp.gsub!(/<\?r\s+(.*?)\s+\?>/m, REPLACEMENT)
+			@compiled = "_out_ = [<<#{SEPARATOR}.chomp!]\n#{temp}#{STOP}_out_"
+		end
+
+		def result(binding, filename = '<Etanni>')
+			eval(@compiled, binding, filename).join
+		end
+		
+		attr :compiled
+	end
+	
+	class TemplateCache
+		CACHE_PREFIX = ".cache."
+		CACHE_ENABLED = true
+		
+		def self.cache_path(path)
+			File.join(File.dirname(path), CACHE_PREFIX + File.basename(path))
+		end
+		
+		def self.mtime(path)
+			File.symlink?(path) ? File.lstat(file_name).mtime : File.mtime(path)
+		end
+		
+		def initialize(path, template_class = Etanni)
+			@path = path
+			@cache_path = TemplateCache.cache_path(@path)
+			
+			if !File.exist?(@cache_path) || (TemplateCache.mtime(@path) > TemplateCache.mtime(@cache_path))
+				@template = template_class.new(File.read(@path))
+				File.open(@cache_path, "w") { |f| f.write(@template.compiled) }
+			else
+				@template = template_class.new(File.read(@cache_path), true)
+			end
+		end
+		
+		def result(binding)
+			@template.result(binding, @cache_path)
+		end
+	end
+end

data/lib/utopia/extensions.rb

@@ -0,0 +1,87 @@
+# Copyright (c) 2010 Samuel Williams. Released under the GNU GPLv3.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'active_support'
+
+class Date
+	alias_method :old_cmp, :<=>
+	
+	def <=> (other)
+		# Comparing a Date with something that has a time component truncates the time
+		# component, thus we need to check if the other object has a more exact comparison
+		# function.
+		if other.respond_to?(:hour)
+			return (other <=> self) * -1
+		else
+			old_cmp(other)
+		end
+	end	
+end
+
+class String
+	HTML_ESCAPE = {"&" => "&amp;", "<" => "&lt;", ">" => "&gt;", "\"" => "&quot;"}
+	HTML_ESCAPE_PATTERN = Regexp.new("[" + Regexp.quote(HTML_ESCAPE.keys.join) + "]")
+
+	def to_html
+		gsub(HTML_ESCAPE_PATTERN){|c| HTML_ESCAPE[c]}
+	end
+
+	def to_title
+		(" " + self).gsub(/[ \-_](.)/){" " + $1.upcase}
+	end
+
+	def to_snake
+		self.gsub("::", "").gsub(/([A-Z]+)/){"_" + $1.downcase}.sub(/^_+/, "")
+	end
+end
+
+class Hash
+	def symbolize_keys
+		inject({}) do |options, (key, value)|
+			options[(key.to_sym rescue key) || key] = value
+			options
+		end
+	end
+end
+
+class Array
+	def find_index(&block)
+		each_with_index do |item, index|
+			if yield(item)
+				return index
+			end
+		end
+		
+		return nil
+	end
+	
+	def split_at(&block)
+		index = find_index(&block)
+		
+		if index
+			return [self[0...index], self[index], self[index+1..-1]]
+		end
+		
+		return [[], nil, []]
+	end
+end
+
+if defined? Rack
+	class Rack::Request
+		def self.new(*args)
+			super(*args)
+		end
+	end
+end