xrb 0.1 → 0.3.0

data/ext/xrb/template.h

@@ -0,0 +1,6 @@
+
+#pragma once
+
+#include "xrb.h"
+
+VALUE XRB_Native_parse_template(VALUE self, VALUE buffer, VALUE delegate);

data/ext/xrb/template.rl

@@ -0,0 +1,77 @@
+
+#include "template.h"
+
+%%{
+	machine XRB_template_parser;
+	
+	action instruction_begin {
+		instruction.begin = p;
+	}
+	
+	action instruction_end {
+		instruction.end = p;
+	}
+	
+	action emit_instruction {
+		rb_funcall(delegate, id_instruction, 1, XRB_Token_string(instruction, encoding));
+	}
+	
+	action emit_instruction_line {
+		rb_funcall(delegate, id_instruction, 2, XRB_Token_string(instruction, encoding), newline);
+	}
+	
+	action instruction_error {
+		XRB_raise_error("failed to parse instruction", buffer, p-s);
+	}
+	
+	action expression_begin {
+		expression.begin = p;
+	}
+	
+	action expression_end {
+		expression.end = p;
+	}
+	
+	action emit_expression {
+		rb_funcall(delegate, id_expression, 1, XRB_Token_string(expression, encoding));
+	}
+	
+	action expression_error {
+		XRB_raise_error("failed to parse expression", buffer, p-s);
+	}
+	
+	action emit_text {
+		rb_funcall(delegate, id_text, 1, XRB_string(ts, te, encoding));
+	}
+	
+	include template "xrb/template.rl";
+	
+	write data;
+}%%
+
+VALUE XRB_Native_parse_template(VALUE self, VALUE buffer, VALUE delegate) {
+	VALUE string = rb_funcall(buffer, id_read, 0);
+	
+	rb_encoding *encoding = rb_enc_get(string);
+	
+	VALUE newline = rb_obj_freeze(rb_enc_str_new("\n", 1, encoding));
+	
+	const char *s, *p, *pe, *eof, *ts, *te;
+	unsigned long cs, act, top = 0, stack[32] = {0};
+	
+	XRB_Token expression = {0}, instruction = {0};
+	
+	s = p = RSTRING_PTR(string);
+	eof = pe = p + RSTRING_LEN(string);
+	
+	%%{
+		write init;
+		write exec;
+	}%%
+	
+	if (p != eof) {
+		XRB_raise_error("could not parse all input", buffer, p-s);
+	}
+	
+	return Qnil;
+}

data/ext/xrb/xrb.c

@@ -0,0 +1,72 @@
+
+#include "xrb.h"
+
+#include "markup.h"
+#include "template.h"
+#include "query.h"
+#include "tag.h"
+#include "escape.h"
+
+VALUE rb_XRB = Qnil, rb_XRB_Native = Qnil, rb_XRB_Tag = Qnil, rb_XRB_Markup = Qnil, rb_XRB_MarkupString = Qnil, rb_XRB_ParseError = Qnil;
+ID id_cdata, id_open_tag_begin, id_open_tag_end, id_attribute, id_close_tag, id_text, id_doctype, id_comment, id_instruction, id_read, id_expression, id_key_get, id_string, id_integer, id_append, id_assign, id_pair, id_new, id_name, id_attributes, id_closed, id_to_s, id_is_a;
+
+void XRB_raise_error(const char * message, VALUE buffer, size_t offset) {
+	VALUE exception = rb_funcall(rb_XRB_ParseError, id_new, 3, rb_str_new_cstr(message), buffer, ULONG2NUM(offset));
+	
+	rb_exc_raise(exception);
+}
+
+void Init_XRB_Extension() {
+	id_open_tag_begin = rb_intern("open_tag_begin");
+	id_open_tag_end = rb_intern("open_tag_end");
+	id_close_tag = rb_intern("close_tag");
+
+	id_cdata = rb_intern("cdata");
+	id_attribute = rb_intern("attribute");
+	id_comment = rb_intern("comment");
+	id_text = rb_intern("text");
+	id_doctype = rb_intern("doctype");
+	id_instruction = rb_intern("instruction");
+	id_expression = rb_intern("expression");
+	
+	id_read = rb_intern("read");
+	id_new = rb_intern("new");
+	
+	id_name = rb_intern("name");
+	id_attributes = rb_intern("attributes");
+	id_closed = rb_intern("closed");
+	
+	id_key_get = rb_intern("[]");
+	
+	id_string = rb_intern("string");
+	id_integer = rb_intern("integer");
+	id_append = rb_intern("append");
+	id_assign = rb_intern("assign");
+	id_pair = rb_intern("pair");
+	
+	id_to_s = rb_intern("to_s");
+	id_is_a = rb_intern("is_a?");
+	
+	rb_XRB = rb_define_module("XRB");
+	rb_gc_register_mark_object(rb_XRB);
+	
+	rb_XRB_Markup = rb_define_module_under(rb_XRB, "Markup");
+	rb_gc_register_mark_object(rb_XRB_Markup);
+	
+	rb_XRB_Native = rb_define_module_under(rb_XRB, "Native");
+	rb_gc_register_mark_object(rb_XRB_Native);
+	
+	Init_xrb_escape();
+	
+	rb_XRB_ParseError = rb_const_get_at(rb_XRB, rb_intern("ParseError"));
+	rb_gc_register_mark_object(rb_XRB_ParseError);
+	
+	rb_define_module_function(rb_XRB_Native, "parse_markup", XRB_Native_parse_markup, 3);
+	rb_define_module_function(rb_XRB_Native, "parse_template", XRB_Native_parse_template, 2);
+	rb_define_module_function(rb_XRB_Native, "parse_query", XRB_Native_parse_query, 2);
+	
+	rb_XRB_Tag = rb_const_get_at(rb_XRB, rb_intern("Tag"));
+	rb_gc_register_mark_object(rb_XRB_Tag);
+	
+	Init_xrb_tag();
+}

data/ext/xrb/xrb.h

@@ -0,0 +1,132 @@
+
+#pragma once
+
+#include "ruby.h"
+#include <ruby/encoding.h>
+
+// Used to efficiently convert symbols to strings (e.g. tag attribute keys).
+#ifndef HAVE_RB_SYM2STR
+#define rb_sym2str(sym) rb_id2str(SYM2ID(sym))
+#endif
+
+// Consistent and meaningful append cstring to ruby string/buffer.
+#ifndef HAVE_RB_STR_CAT_CSTR
+#define rb_str_cat_cstr rb_str_cat2
+#endif
+
+// Prefer non-generic macro names where possible.
+#ifndef RB_IMMEDIATE_P
+#define RB_IMMEDIATE_P IMMEDIATE_P
+#endif
+
+// A helper to reserve a specific capacity of data for a buffer.
+#ifndef HAVE_RB_STR_RESERVE
+inline VALUE rb_str_reserve(VALUE string, long extra) {
+	long actual = RSTRING_LEN(string);
+	rb_str_resize(string, actual + extra);
+	rb_str_set_len(string, actual);
+	return string;
+}
+#endif
+
+// Modules and classes exposed by XRB.
+extern VALUE
+	rb_XRB,
+	rb_XRB_Markup,
+	rb_XRB_Tag,
+	rb_XRB_MarkupString,
+	rb_XRB_Native,
+	rb_XRB_ParseError;
+
+// Symbols used for delegate callbacks and general function calls.
+extern ID
+	id_cdata,
+	id_open_tag_begin,
+	id_open_tag_end,
+	id_attribute,
+	id_close_tag,
+	id_text,
+	id_doctype,
+	id_comment,
+	id_instruction,
+	id_read,
+	id_expression,
+	id_key_get,
+	id_new,
+	id_name,
+	id_integer,
+	id_string,
+	id_append,
+	id_assign,
+	id_pair,
+	id_attributes,
+	id_closed,
+	id_to_s,
+	id_is_a;
+
+// A convenient C string token class.
+typedef struct {
+	const char * begin;
+	const char * end;
+} XRB_Token;
+
+// Convert a token to a Ruby string.
+static inline VALUE XRB_Token_string(XRB_Token token, rb_encoding * encoding) {
+	return rb_enc_str_new(token.begin, token.end - token.begin, encoding);
+}
+
+// Convert a C string to a Ruby string.
+static inline VALUE XRB_string(const char * begin, const char * end, rb_encoding * encoding) {
+	return rb_enc_str_new(begin, end - begin, encoding);
+}
+
+// Create an empty buffer for the given input string.
+static inline VALUE XRB_buffer_for(VALUE string) {
+	VALUE buffer = rb_enc_str_new(0, 0, rb_enc_get(string));
+	
+	rb_str_reserve(buffer, RSTRING_LEN(string) + 128);
+	
+	return buffer;
+}
+
+// Raise a parse error for the given input buffer at a specific offset.
+NORETURN(void XRB_raise_error(const char * message, VALUE buffer, size_t offset));
+
+// Append a string to a buffer. The buffer may or may not be initialized.
+static inline void XRB_append(VALUE * buffer, rb_encoding * encoding, VALUE string) {
+	if (*buffer == Qnil) {
+		*buffer = rb_enc_str_new(0, 0, encoding);
+	}
+	
+	rb_str_concat(*buffer, string);
+}
+
+// Append a token to a buffer. The buffer may or may not be initialized.
+static inline void XRB_append_token(VALUE * buffer, rb_encoding * encoding, XRB_Token token) {
+	if (*buffer == Qnil) {
+		// Allocate a buffer exactly the right size:
+		*buffer = rb_enc_str_new(token.begin, token.end - token.begin, encoding);
+	} else {
+		// Append the characters to the existing buffer:
+		rb_str_buf_cat(*buffer, token.begin, token.end - token.begin);
+	}
+}
+
+// Append a (unicode) codepoint to a buffer. The buffer may or may not be initialized.
+static inline void XRB_append_codepoint(VALUE * buffer, rb_encoding * encoding, unsigned long codepoint) {
+	if (*buffer == Qnil) {
+		*buffer = rb_enc_str_new(0, 0, encoding);
+	}
+	
+	rb_str_concat(*buffer, ULONG2NUM(codepoint));
+}
+
+// Convert the class of a string if there were no entities detected.
+static inline VALUE XRB_markup_safe(VALUE string, unsigned has_entities) {
+	if (!has_entities) {
+		// Apparently should not use this to change klass, but it's exactly what we need here to make things lightning fast.
+		rb_obj_reveal(string, rb_XRB_MarkupString);
+	}
+	
+	return string;
+}

data/lib/xrb/buffer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2016-2024, by Samuel Williams.
+
+module XRB
+	class Buffer
+		def initialize(string, path: '<string>')
+			@string = string
+			@path = path
+		end
+		
+		attr :path
+		
+		def encoding
+			@string.encoding
+		end
+		
+		def read
+			@string
+		end
+		
+		def self.load_file(path)
+			FileBuffer.new(path).freeze
+		end
+		
+		def self.load(string)
+			Buffer.new(string).freeze
+		end
+		
+		def to_buffer
+			self
+		end
+	end
+	
+	class FileBuffer
+		def initialize(path)
+			@path = path
+		end
+		
+		def freeze
+			return self if frozen?
+			
+			read
+			
+			super
+		end
+		
+		attr :path
+		
+		def encoding
+			read.encoding
+		end
+		
+		def read
+			@cache ||= File.read(@path).freeze
+		end
+		
+		def to_buffer
+			Buffer.new(self.read, @path)
+		end
+	end
+	
+	class IOBuffer
+		def initialize(io, path: io.inspect)
+			@io = io
+			@path = path
+		end
+		
+		def freeze
+			return self if frozen?
+			
+			read
+			
+			super
+		end
+		
+		attr :path
+		
+		def encoding
+			read.encoding
+		end
+		
+		def read
+			@cache ||= @io.read.freeze
+		end
+		
+		def to_buffer
+			Buffer.new(self.read, path: @path)
+		end
+	end
+	
+	def self.Buffer(value)
+		case value
+		when String
+			Buffer.new(value)
+		when Buffer, FileBuffer, IOBuffer
+			value
+		else
+			value.to_buffer
+		end
+	end
+end

data/lib/xrb/builder.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2012-2024, by Samuel Williams.
+
+require_relative 'markup'
+require_relative 'tag'
+
+module XRB
+	# Build markup quickly and efficiently.
+	class Builder
+		include Markup
+		
+		INDENT = "\t"
+		
+		class Fragment
+			def initialize(block)
+				@block = block
+				@builder = nil
+			end
+			
+			def call(builder)
+				@block.call(builder)
+			end
+			
+			def to_s
+				unless @builder
+					@builder = Builder.new
+					
+					self.call(@builder)
+				end
+				
+				return @builder.to_s
+			end
+			
+			def == other
+				# This is a bit of a hack... but is required for existing specs to pass:
+				self.to_s == other.to_s
+			end
+			
+			def >> block
+				if block
+					Template.buffer(block.binding) << self
+					
+					return nil
+				else
+					return self
+				end
+			end
+		end
+		
+		# A helper to generate fragments of markup.
+		def self.fragment(output = nil, &block)
+			if output.is_a?(Binding)
+				output = Template.buffer(output)
+			end
+			
+			if output.nil?
+				return Fragment.new(block)
+			end
+			
+			block.call(output)
+			
+			# We explicitly return nil here as we don't want to append the output twice.
+			return nil
+		end
+		
+		def self.tag(name, content, **attributes)
+			self.fragment do |builder|
+				builder.inline(name, attributes) do
+					builder.text(content)
+				end
+			end
+		end
+		
+		def initialize(output = nil, indent: true, encoding: Encoding::UTF_8)
+			# This field gets togged in #inline so we keep track of it separately from @indentation.
+			@indent = indent
+			
+			# We don't need to use MarkupString here as Builder itself is considered markup and should be inserted directly into the output stream.
+			@output = output || MarkupString.new.force_encoding(encoding)
+			
+			@level = [0]
+			@children = [0]
+		end
+		
+		attr :output
+		
+		def encoding
+			@output.encoding
+		end
+		
+		# Required for output to buffer.
+		def to_str
+			@output
+		end
+		
+		alias to_s to_str
+		
+		def == other
+			@output == String(other)
+		end
+		
+		def indentation
+			if @indent
+				INDENT * (@level.size - 1)
+			else
+				''
+			end
+		end
+		
+		def doctype(attributes = 'html')
+			@output << "<!doctype #{attributes}>\n"
+		end
+		
+		# Begin a block tag.
+		def tag(name, attributes = {}, &block)
+			full_tag(name, attributes, @indent, @indent, &block)
+		end
+		
+		# Begin an inline tag.
+		def inline_tag(name, attributes = {}, &block)
+			original_indent = @indent
+			
+			full_tag(name, attributes, @indent, false) do
+				@indent = false
+				yield if block_given?
+			end
+		ensure
+			@indent = original_indent
+		end
+		
+		alias inline inline_tag
+		
+		def inline!
+			original_indent = @indent
+			@indent = false
+			
+			yield
+		ensure
+			@indent = original_indent
+		end
+		
+		def text(content)
+			return unless content
+			
+			if @indent
+				@output << "\n" if @level.last > 0
+				@output << indentation
+			end
+			
+			Markup.append(@output, content)
+			
+			if @indent
+				@output << "\n"
+			end
+		end
+		
+		def raw(content)
+			@output << content
+		end
+		
+		def <<(content)
+			return unless content
+			
+			if content.is_a?(Fragment)
+				inline! do
+					content.call(self)
+				end
+			else
+				Markup.append(@output, content)
+			end
+		end
+		
+		# Append pre-existing markup:
+		def append(value)
+			return unless value
+			
+			# The parent has one more child:
+			@level[-1] += 1
+			
+			if @indent
+				value.each_line.with_index do |line, i|
+					@output << indentation << line
+				end
+			else
+				@output << value
+			end
+		end
+		
+		protected
+		
+		# A normal block level/container tag.
+		def full_tag(name, attributes, indent_outer, indent_inner, &block)
+			if block_given?
+				if indent_outer
+					@output << "\n" if @level.last > 0
+					@output << indentation
+				end
+				
+				tag = XRB::Tag.opened(name.to_s, attributes)
+				tag.write_opening_tag(@output)
+				@output << "\n" if indent_inner
+				
+				# The parent has one more child:
+				@level[-1] += 1
+				
+				@level << 0
+				
+				yield
+				
+				children = @level.pop
+				
+				if indent_inner
+					@output << "\n" if children > 0
+					@output << indentation
+				end
+				
+				tag.write_closing_tag(@output)
+			else
+				# The parent has one more child:
+				@level[-1] += 1
+				
+				@output << indentation
+				XRB::Tag.append_tag(@output, name.to_s, attributes, nil)
+			end
+		end
+	end
+end