xrb 0.1 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec15e8b31b37bcb608d2e1fb7e5748081e76872a8aa5c31b4ec6fc4d4e74122c
+  data.tar.gz: d57336048d69699d54a16016dd1bcaf3764372828baa41a3b7da59273cf50f18
+SHA512:
+  metadata.gz: 7f8f906db2c28206e7892ce08775015d090785f29a6c095959a3de25e56d6a40ace9e7941613fc9158ce9bab588d1bfa6add5d0b72ab1f251174d7ef9de2cfce
+  data.tar.gz: fe3707d210322d99d85f1b75be28e9990a3a22addf1a56a675ba95fcb262fd1669185edeb5dd7bb3caec1995535f74fc9cb8efa6921e9476314080e89e244395

data/bake/xrb/entities.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2017-2024, by Samuel Williams.
+
+# Fetch the HTML5 entities from w3.org and update the local cache.
+# @parameter force [Boolean] Whether to force regenerate the local cache.
+def fetch_entities(force: false)
+	require 'json'
+	require 'async'
+	require 'async/http/internet'
+	
+	internet = Async::HTTP::Internet.new
+	entites_json_path = self.entites_json_path
+	
+	if force || !File.exist?(entites_json_path)
+		url = "https://www.w3.org/TR/html5/entities.json"
+		
+		Sync do
+			File.write(entites_json_path, internet.get(url).read)
+		end
+	end
+	
+	return JSON.parse(File.read(entites_json_path)).delete_if{|string, _| !string.end_with? ';'}
+end
+
+# Consume the HTML5 entites and generate parsers to escape them.
+# @parameter wet [Boolean] Whether to write updated files.
+def update_entities(wet: false)
+	require 'xrb/template'
+	
+	paths = {
+		# 'ext/xrb/entities.rl' => 'ext/xrb/entities.xrb',
+		'lib/xrb/entities.rb' => 'lib/xrb/entities.xrb',
+	}
+	
+	entities = self.fetch_entities
+	
+	paths.each do |output_path, template_path|
+		template_path = File.expand_path(template_path, context.root)
+		output_path = File.expand_path(output_path, context.root)
+		
+		template = XRB::Template.load_file(template_path)
+		
+		output = template.to_string(entities)
+		
+		if wet
+			File.write(output_path, output)
+		else
+			puts "*** #{output_path} ***"
+			puts output
+		end
+	end
+end
+
+private
+
+def entites_json_path
+	File.expand_path("entities.json", context.root)
+end

data/bake/xrb/parsers.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2017-2024, by Samuel Williams.
+
+# Generate the pure Ruby parsers.
+def generate_fallback
+	Dir.chdir(fallback_directory) do
+		Dir.glob("*.rl").each do |parser_path|
+			system("ragel", "-I", parsers_directory, "-R", parser_path, "-F1")
+		end
+		
+		# sh("ruby-beautify", "--tabs", "--overwrite", *Dir.glob("*.rb"))
+	end
+end
+
+# Generate the native C parsers.
+def generate_native
+	Dir.chdir(native_directory) do
+		Dir.glob("*.rl").each do |parser_path|
+			system("ragel", "-I", parsers_directory, "-C", parser_path, "-G2")
+		end
+	end
+end
+
+# Compile the C extension.
+def compile
+	system("rake", "compile", chdir: extensions_directory)
+end
+
+# Generate the parsers and compile them as required.
+def generate
+	self.generate_native
+	self.generate_fallback
+	self.compile
+end
+
+# Generate a visualisation of the parsers.
+def visualize_parsers
+	Dir.chdir(fallback_directory) do
+		Dir.glob("*.rl").each do |parser_path|
+			dot_path = parser_path + ".dot"
+			system("ragel", "-I", parsers_directory, "-Vp", parser_path, "-o", dot_path)
+			
+			pdf_path = parser_path + ".pdf"
+			system("dot", "-Tpdf", "-o", pdf_path, dot_path)
+			
+			system("open", pdf_path) rescue nil
+		end
+	end
+end
+
+private
+
+def parsers_directory
+	File.expand_path("parsers", context.root)
+end
+
+def fallback_directory
+	File.expand_path("lib/xrb/fallback", context.root)
+end
+
+def extensions_directory
+	File.expand_path("ext", context.root)
+end
+
+def native_directory
+	File.expand_path("ext/xrb", context.root)
+end

data/ext/extconf.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2016-2024, by Samuel Williams.
+
+return if RUBY_DESCRIPTION =~ /jruby/
+
+require 'mkmf'
+
+$CFLAGS << " -O3 -Wall -Wno-unknown-pragmas -std=c99"
+
+have_func("rb_sym2str")
+have_func("rb_str_cat_cstr")
+have_func("rb_str_reserve")
+
+$srcs = Dir.glob("xrb/*.c")
+$VPATH << "$(srcdir)/xrb"
+
+create_header
+
+create_makefile('XRB_Extension')

data/ext/xrb/escape.c

@@ -0,0 +1,152 @@
+
+#include "escape.h"
+#include <assert.h>
+
+inline static int XRB_Markup_is_markup(VALUE value) {
+	if (RB_IMMEDIATE_P(value))
+		return 0;
+	
+	// This is a short-cut:
+	if (rb_class_of(value) == rb_XRB_MarkupString) {
+		return 1;
+	}
+	
+	return rb_funcall(value, id_is_a, 1, rb_XRB_Markup) == Qtrue;
+}
+
+VALUE XRB_MarkupString_raw(VALUE self, VALUE string) {
+	string = rb_str_dup(string);
+	
+	rb_obj_reveal(string, rb_XRB_MarkupString);
+	
+	return string;
+}
+
+// => [["<", 60, "3c"], [">", 62, "3e"], ["\"", 34, "22"], ["&", 38, "26"]] 
+// static const uint32_t MASK = 0x3e3e3e3e;
+// 
+// static const uint32_t MASK_LT = 0x3c3c3c3c;
+// static const uint32_t MASK_GT = 0x3e3e3e3e;
+// static const uint32_t MASK_QUOT = 0x22222222;
+// static const uint32_t MASK_AMP = 0x26262626;
+
+static inline const char * XRB_Markup_index_symbol(const char * begin, const char * end) {
+	const char * p = begin;
+
+	while (p < end) {
+		// if ((end - p) >= 4) {
+		// 	// Do the next 4 characters contain anything we are interested in?
+		// 	if ((*(const uint32_t *)p) & MASK_LT) {
+		// 		p += 4;
+		// 		
+		// 		continue;
+		// 	}
+		// }
+		
+		switch (*p) {
+			case '<':
+			case '>':
+			case '"':
+			case '&':
+				return p;
+		}
+
+		p += 1;
+	}
+
+	return end;
+}
+
+static inline void XRB_Markup_append_entity(const char * p, VALUE buffer) {
+	// What symbol are we looking at?
+	switch (*p) {
+		case '<':
+			rb_str_cat_cstr(buffer, "&lt;");
+			break;
+		case '>':
+			rb_str_cat_cstr(buffer, "&gt;");
+			break;
+		case '"':
+			rb_str_cat_cstr(buffer, "&quot;");
+			break;
+		case '&':
+			rb_str_cat_cstr(buffer, "&amp;");
+			break;
+	}
+}
+
+static inline VALUE XRB_Markup_append_buffer(VALUE buffer, const char * s, const char * p, const char * end) {
+	while (1) {
+		// Append the non-symbol part:
+		rb_str_buf_cat(buffer, s, p - s);
+
+		// We escape early if there were no changes to be made:
+		if (p == end) return buffer;
+
+		XRB_Markup_append_entity(p, buffer);
+
+		s = p + 1;
+		p = XRB_Markup_index_symbol(s, end);
+	}
+}
+
+// Escape and append a string to the output buffer.
+VALUE XRB_Markup_append_string(VALUE buffer, VALUE string) {
+	const char * begin = RSTRING_PTR(string);
+	const char * end = begin + RSTRING_LEN(string);
+	
+	const char * s = begin;
+
+	// There are two outcomes, either p is at end, or p points to a symbol:
+	const char * p = XRB_Markup_index_symbol(s, end);
+	
+	return XRB_Markup_append_buffer(buffer, s, p, end);
+}
+
+VALUE XRB_Markup_append(VALUE self, VALUE buffer, VALUE value) {
+	if (value == Qnil) return Qnil;
+	
+	if (XRB_Markup_is_markup(value)) {
+		rb_str_append(buffer, value);
+	} else {
+		if (rb_type(value) != T_STRING) {
+			value = rb_funcall(value, id_to_s, 0);
+		}
+		
+		XRB_Markup_append_string(buffer, value);
+	}
+	
+	return buffer;
+}
+
+// Convert markup special characters to entities. May return the original string if no changes were made.
+VALUE XRB_Markup_escape_string(VALUE self, VALUE string) {
+	const char * begin = RSTRING_PTR(string);
+	const char * end = begin + RSTRING_LEN(string);
+	
+	const char * s = begin;
+
+	// There are two outcomes, either p is at end, or p points to a symbol:
+	const char * p = XRB_Markup_index_symbol(s, end);
+
+	// We escape early if there were no changes to be made:
+	if (p == end) return string;
+	
+	return XRB_Markup_append_buffer(XRB_buffer_for(string), s, p, end);
+}
+
+void Init_xrb_escape() {
+	rb_XRB_MarkupString = rb_define_class_under(rb_XRB, "MarkupString", rb_cString);
+	rb_gc_register_mark_object(rb_XRB_MarkupString);
+	
+	rb_include_module(rb_XRB_MarkupString, rb_XRB_Markup);
+	
+	rb_undef_method(rb_class_of(rb_XRB_Markup), "escape_string");
+	rb_define_singleton_method(rb_XRB_Markup, "escape_string", XRB_Markup_escape_string, 1);
+	
+	rb_undef_method(rb_class_of(rb_XRB_Markup), "append");
+	rb_define_singleton_method(rb_XRB_Markup, "append", XRB_Markup_append, 2);
+	
+	rb_undef_method(rb_class_of(rb_XRB_Markup), "raw");
+	rb_define_singleton_method(rb_XRB_Markup, "raw", XRB_MarkupString_raw, 1);
+}

data/ext/xrb/escape.h

@@ -0,0 +1,15 @@
+
+#pragma once
+
+#include "xrb.h"
+
+void Init_xrb_escape();
+
+// Given a string, replace it's class with XRB::MarkupString so that it would be output as is.
+VALUE XRB_MarkupString_raw(VALUE self, VALUE string);
+
+// Append any value to the output buffer efficiently, escaping entities as needed.
+VALUE XRB_Markup_append(VALUE self, VALUE buffer, VALUE value);
+
+// Escape any entities in the given string. If no entities were found, might return the original string.
+VALUE XRB_Markup_escape_string(VALUE self, VALUE string);