utopia 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e53e0a1f210f0c4e8e14ff4f7e1cf21bbc705f18
-  data.tar.gz: 3756ebee30e3b76f4712d7f129aecdf943d60931
+  metadata.gz: c561c449df8eaaff74066cd697d74d59144eed35
+  data.tar.gz: 31e712f26e682f8f6f002b3f7f425ef8b68199f1
 SHA512:
-  metadata.gz: f751489f085bf36b52d6a0b842e127f56d1061d0050f1452ae9798d2deadd2fdef426c254a1ec15a7f06715ef01e56a5c78c2e5abea095f7cbd89c925d136776
-  data.tar.gz: 679a51d33577028c5fdc27a66498617e9b5e4f764a483a387f9b005df33c6ded2439cebb8ba6f30be0a6c9d670694407289d22681553b916816328517dfa47e3
+  metadata.gz: 021df2ac5a3caddcb2c6a1e3951660670bc8e6244f6457791a15a3b93f377495270604575d4ee75b06850a26ef6f2ee56019bc7af6a5fdc44d8c48e2cc10c911
+  data.tar.gz: 1f30b81c891cebf3a35a5c9536569b18553f7306d32f119967b385c66dd230ae020ac37c30672c6c2763fd93c452d7984c5ef6baf3c85acf0f2faaab2e5ff1d0

data/Gemfile

@@ -3,6 +3,11 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in utopia.gemspec
 gemspec
 
+group :development do
+	gem 'pry'
+	gem 'pry-coolline'
+end
+
 group :test do
 	gem 'rack-test'
 	gem 'simplecov'

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/controller.rb

@@ -53,6 +53,8 @@ module Utopia
 			if options[:cache_controllers]
 				@controllers = Concurrent::Map.new
 			end
+			
+			self.freeze
 		end
 		
 		attr :app
@@ -69,12 +71,11 @@ module Utopia
 					load_controller_file(path)
 				end
 			else
-				return load_controller_file(path)
+				load_controller_file(path)
 			end
 		end
 		
-		def load_controller_file(path)
-			uri_path = path
+		def load_controller_file(uri_path)
 			base_path = File.join(@root, uri_path.components)
 			
 			controller_path = File.join(base_path, CONTROLLER_RB)
@@ -84,10 +85,10 @@ module Utopia
 				klass = Class.new(Base)
 				
 				# base_path is expected to be a string representing a filesystem path:
-				klass.const_set(:BASE_PATH, base_path)
+				klass.const_set(:BASE_PATH, base_path.freeze)
 				
 				# uri_path is expected to be an instance of Path:
-				klass.const_set(:URI_PATH, uri_path)
+				klass.const_set(:URI_PATH, uri_path.dup.freeze)
 				
 				klass.const_set(:CONTROLLER, self)
 				

data/lib/utopia/controller/base.rb

@@ -49,14 +49,6 @@ module Utopia
 					path.dirname == uri_path
 				end
 				
-				def patterns
-					@patterns ||= []
-				end
-				
-				def match(pattern, &block)
-					patterns << [pattern, block]
-				end
-				
 				def actions
 					@actions ||= Action.new
 				end
@@ -70,9 +62,12 @@ module Utopia
 				end
 				
 				def lookup(path)
-					relative_path = (path - uri_path).to_a
-					
-					possible_actions = actions.select(relative_path)
+					if @actions
+						relative_path = (path - uri_path).to_a
+						return @actions.select(relative_path)
+					else
+						[]
+					end
 				end
 			end
 			

data/lib/utopia/controller/rewrite.rb

@@ -110,12 +110,18 @@ module Utopia
 				def rewrite
 					@rewriter ||= Rewriter.new
 				end
+				
+				def rewrite_request(controller, request, path)
+					if @rewriter
+						@rewriter.invoke!(controller, request, path)
+					end
+				end
 			end
 			
 			# Rewrite the path before processing the request if possible.
 			def passthrough(request, path)
 				catch_response do
-					self.class.rewrite.invoke!(self, request, path)
+					self.class.rewrite_request(self, request, path)
 				end || super
 			end
 		end

data/lib/utopia/http.rb

@@ -22,6 +22,8 @@ require 'rack'
 
 module Utopia
 	module HTTP
+		# A list of commonly used HTTP status codes.
+		# For help choosing the right status code, see http://racksburg.com/choosing-an-http-status-code/
 		STATUS_CODES = {
 			:success => 200,
 			:created => 201,
@@ -44,7 +46,8 @@ module Utopia
 			:unavailable => 503
 		}
 		
-		# For a more detailed description see https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
+		# A list of human readable descriptions for a given status code.
+		# For a more detailed description, see https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
 		STATUS_DESCRIPTIONS = {
 			200 => 'OK'.freeze,
 			201 => 'Created'.freeze,
@@ -80,6 +83,7 @@ module Utopia
 		CONTENT_TYPE = 'Content-Type'.freeze
 		LOCATION = 'Location'.freeze
 		
+		# A small HTTP status wrapper that verifies the status code within a given range.
 		class Status
 			def initialize(code, valid_range = 100...600)
 				if code.is_a? Symbol

data/lib/utopia/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Utopia
-	VERSION = "1.2.1"
+	VERSION = "1.2.2"
 end

data/spec/utopia/controller/middleware_spec.rb

@@ -30,6 +30,12 @@ module Utopia::Controller::MiddlewareSpec
 		
 		let(:app) {Rack::Builder.parse_file(File.expand_path('../middleware_spec.ru', __FILE__)).first}
 		
+		it "should successfully call empty controller" do
+			get "/empty/index"
+			
+			expect(last_response.status).to be == 404
+		end
+		
 		it "should successfully call the controller method" do
 			get "/controller/hello-world"
 			

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: utopia
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-09 00:00:00.000000000 Z
+date: 2015-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trenni
@@ -169,6 +169,8 @@ files:
 - README.md
 - Rakefile
 - bin/utopia
+- ext/utopia/xnode/fast_scanner/extconf.rb
+- ext/utopia/xnode/fast_scanner/parser.c
 - lib/utopia.rb
 - lib/utopia/content.rb
 - lib/utopia/content/link.rb
@@ -258,6 +260,7 @@ files:
 - spec/utopia/controller/middleware_spec/controller/controller.rb
 - spec/utopia/controller/middleware_spec/controller/index.xnode
 - spec/utopia/controller/middleware_spec/controller/nested/controller.rb
+- spec/utopia/controller/middleware_spec/empty/controller.rb
 - spec/utopia/controller/rewrite_spec.rb
 - spec/utopia/controller/sequence_spec.rb
 - spec/utopia/exception_handler_spec.rb
@@ -346,6 +349,7 @@ test_files:
 - spec/utopia/controller/middleware_spec/controller/controller.rb
 - spec/utopia/controller/middleware_spec/controller/index.xnode
 - spec/utopia/controller/middleware_spec/controller/nested/controller.rb
+- spec/utopia/controller/middleware_spec/empty/controller.rb
 - spec/utopia/controller/rewrite_spec.rb
 - spec/utopia/controller/sequence_spec.rb
 - spec/utopia/exception_handler_spec.rb