rinku 1.2.2 → 1.3.0

data/ext/rinku/rinku.c

@@ -34,13 +34,20 @@
 
 static VALUE rb_mRinku;
 
+typedef enum {
+	HTML_TAG_NONE = 0,
+	HTML_TAG_OPEN,
+	HTML_TAG_CLOSE,
+} html_tag;
+
 typedef enum {
 	AUTOLINK_URLS = (1 << 0),
 	AUTOLINK_EMAILS = (1 << 1),
+	AUTOLINK_IN_CODE = (1 << 2),
 	AUTOLINK_ALL = AUTOLINK_URLS|AUTOLINK_EMAILS
 } autolink_mode;
 
-typedef size_t (*autolink_parse_cb)(size_t *rewind, struct buf *, char *, size_t, size_t);
+typedef size_t (*autolink_parse_cb)(size_t *rewind, struct buf *, uint8_t *, size_t, size_t);
 
 typedef enum {
 	AUTOLINK_ACTION_NONE = 0,
@@ -52,9 +59,9 @@ typedef enum {
 
 static autolink_parse_cb g_callbacks[] = {
 	NULL,
-	ups_autolink__www,	/* 1 */
-	ups_autolink__email,/* 2 */
-	ups_autolink__url,	/* 3 */
+	sd_autolink__www,	/* 1 */
+	sd_autolink__email,/* 2 */
+	sd_autolink__url,	/* 3 */
 };
 
 static const char *g_hrefs[] = {
@@ -65,93 +72,94 @@ static const char *g_hrefs[] = {
 };
 
 static void
-autolink_escape_cb(struct buf *ob, const struct buf *text, void *unused)
+autolink__html_escape(struct buf *ob, const struct buf *link, void *payload)
 {
-	size_t  i = 0, org;
-
-	while (i < text->size) {
-		org = i;
-
-		while (i < text->size &&
-			text->data[i] != '<' &&
-			text->data[i] != '>' &&
-			text->data[i] != '&' &&
-			text->data[i] != '"')
-			i++;
-
-		if (i > org)
-			bufput(ob, text->data + org, i - org);
-
-		if (i >= text->size)
-			break;
-
-		switch (text->data[i]) {
-			case '<': BUFPUTSL(ob, "&lt;"); break;
-			case '>': BUFPUTSL(ob, "&gt;"); break;
-			case '&': BUFPUTSL(ob, "&amp;"); break;
-			case '"': BUFPUTSL(ob, "&quot;"); break;
-			default: bufputc(ob, text->data[i]); break;
-		}
-
-		i++;
-	}
+	houdini_escape_html0(ob, link->data, link->size, 0);
 }
 
-static inline int
-is_closing_a(const char *tag, size_t size)
+/* From sundown/html/html.c */
+static int
+html_is_tag(const uint8_t *tag_data, size_t tag_size, const char *tagname)
 {
 	size_t i;
+	int closed = 0;
 
-	if (tag[0] != '<' || size < STRLEN("</a>") || tag[1] != '/')
-		return 0;
+	if (tag_size < 3 || tag_data[0] != '<')
+		return HTML_TAG_NONE;
 
-	i = 2;
+	i = 1;
 
-	while (i < size && isspace(tag[i]))
+	if (tag_data[i] == '/') {
+		closed = 1;
 		i++;
+	}
 
-	if (i == size || tag[i] != 'a')
-		return 0;
+	for (; i < tag_size; ++i, ++tagname) {
+		if (*tagname == 0)
+			break;
 
-	i++;
+		if (tag_data[i] != *tagname)
+			return HTML_TAG_NONE;
+	}
 
-	while (i < size && isspace(tag[i]))
-		i++;
+	if (i == tag_size)
+		return HTML_TAG_NONE;
 
-	if (i == size || tag[i] != '>')
-		return 0;
+	if (isspace(tag_data[i]) || tag_data[i] == '>')
+		return closed ? HTML_TAG_CLOSE : HTML_TAG_OPEN;
 
-	return i;
+	return HTML_TAG_NONE;
 }
 
 static size_t
-autolink__skip_tag(struct buf *ob, char *text, size_t size)
+autolink__skip_tag(
+	struct buf *ob,
+	const uint8_t *text,
+	size_t size,
+	const char **skip_tags,
+	size_t skip_tags_count)
 {
-	size_t i = 0;
+	size_t tag, i = 0;
 
 	while (i < size && text[i] != '>')
 		i++;
 
-	if (size > 3 && text[1] == 'a' && isspace(text[2])) {
-		while (i < size) {
-			size_t tag_len = is_closing_a(text + i, size - i);
-			if (tag_len) {
-				i += tag_len;
+	for (tag = 0; tag < skip_tags_count; ++tag) {
+		if (html_is_tag(text, size, skip_tags[tag]) == HTML_TAG_OPEN)
+			break;
+	}
+
+	if (tag < skip_tags_count) {
+		for (;;) {
+			while (i < size && text[i] != '<')
+				i++;
+
+			if (i == size)
 				break;
-			}
+
+			if (html_is_tag(text + i, size - i, skip_tags[tag]) == HTML_TAG_CLOSE)
+				break;
+
 			i++;
 		}
+
+		while (i < size && text[i] != '>')
+			i++;
 	}
 
-	return i + 1;
+//	bufput(ob, text, i + 1);
+	return i;
 }
 
 int
 rinku_autolink(
 	struct buf *ob,
-	struct buf *text,
+	const uint8_t *text,
+	size_t size,
 	unsigned int flags,
 	const char *link_attr,
+	const char **skip_tags,
+	size_t skip_tags_count,
 	void (*link_text_cb)(struct buf *ob, const struct buf *link, void *payload),
 	void *payload)
 {
@@ -161,7 +169,7 @@ rinku_autolink(
 	void (*link_url_cb)(struct buf *, const struct buf *, void *);
 	int link_count = 0;
 
-	if (!text || text->size == 0)
+	if (!text || size == 0)
 		return;
 
 	memset(active_chars, 0x0, sizeof(active_chars));
@@ -178,44 +186,48 @@ rinku_autolink(
 	}
 
 	if (link_text_cb == NULL)
-		link_text_cb = &autolink_escape_cb;
+		link_text_cb = &autolink__html_escape;
 
 	if (link_attr != NULL) {
 		while (isspace(*link_attr))
 			link_attr++;
 	}
 
-	bufgrow(ob, text->size);
+	bufgrow(ob, size);
 
 	i = end = 0;
 
-	while (i < text->size) {
+	while (i < size) {
 		size_t rewind, link_end;
 		char action;
 
-		while (end < text->size && (action = active_chars[text->data[end] & 0xFF]) == 0)
+		while (end < size && (action = active_chars[text[end]]) == 0)
 			end++;
 
-		if (end == text->size) {
+		if (end == size) {
 			if (link_count > 0)
-				bufput(ob, text->data + i, end - i);
+				bufput(ob, text + i, end - i);
 			break;
 		}
 
 		if (action == AUTOLINK_ACTION_SKIP_TAG) {
-			end += autolink__skip_tag(ob, text->data + end, text->size - end);
+			end += autolink__skip_tag(ob,
+				text + end, size - end,
+				skip_tags, skip_tags_count);
+
 			continue;
 		}
 
 		link->size = 0;
-		link_end = g_callbacks[(int)action](&rewind, link, text->data + end, end, text->size - end);
+		link_end = g_callbacks[(int)action](
+			&rewind, link, (uint8_t *)text + end, end, size - end);
 
 		/* print the link */
 		if (link_end > 0) {
-			bufput(ob, text->data + i, end - i - rewind);
+			bufput(ob, text + i, end - i - rewind);
 
 			bufputs(ob, g_hrefs[(int)action]);
-			autolink_escape_cb(ob, link, NULL);
+			houdini_escape_href(ob, link->data, link->size);
 
 			if (link_attr) {
 				BUFPUTSL(ob, "\" ");
@@ -258,8 +270,8 @@ autolink_callback(struct buf *link_text, const struct buf *link, void *block)
  * Document-method: auto_link
  *
  * call-seq:
- *  auto_link(text, mode=:all, link_attr=nil)
- *  auto_link(text, mode=:all, link_attr=nil) { |link_text| ... }
+ *  auto_link(text, mode=:all, link_attr=nil, skip_tags=nil)
+ *  auto_link(text, mode=:all, link_attr=nil, skip_tags=nil) { |link_text| ... }
  *
  * Parses a block of text looking for "safe" urls or email addresses,
  * and turns them into HTML links with the given attributes.
@@ -277,8 +289,9 @@ autolink_callback(struct buf *link_text, const struct buf *link, void *block)
  * HTML, Rinku is smart enough to skip the links that are already enclosed in <a>
  * tags.
  *
- * +mode+ is a symbol, either :all, :urls or :email_addresses, which specifies which
- * kind of links will be auto-linked.
+ * +mode+ is a symbol, either :all, :in_code, :urls or :email_addresses, 
+ * which specifies which kind of links will be auto-linked. The :in_code symbol
+ * will autolink e
  *
  * +link_attr+ is a string containing the link attributes for each link that
  * will be generated. These attributes are not sanitized and will be include as-is
@@ -289,6 +302,9 @@ autolink_callback(struct buf *link_text, const struct buf *link, void *block)
  *
  * This string can be autogenerated from a hash using the Rails `tag_options` helper.
  *
+ * +skip_tags+ is a list of strings with the names of HTML tags that will be skipped
+ * when autolinking. If nil, this defaults to ["a", "pre", "code", "kbd", "script"].
+ *
  * +block+ The method takes an optional block argument. If a block is passed, it will
  * be yielded for each found link in the text, and its return value will be used instead
  * of the name of the link. E.g.
@@ -301,13 +317,17 @@ autolink_callback(struct buf *link_text, const struct buf *link, void *block)
 static VALUE
 rb_rinku_autolink(int argc, VALUE *argv, VALUE self)
 {
-	VALUE result, rb_text, rb_mode, rb_html, rb_block;
-	struct buf input_buf = {0, 0, 0, 0, 0}, *output_buf;
+	static const char *SKIP_TAGS[] = {"a", "pre", "code", "kbd", "script"};
+
+	VALUE result, rb_text, rb_mode, rb_html, rb_skip, rb_block;
+	struct buf *output_buf;
 	int link_mode, count;
 	const char *link_attr = NULL;
+	const char **skip_tags = NULL;
+	size_t skip_tags_count;
 	ID mode_sym;
 
-	rb_scan_args(argc, argv, "12&", &rb_text, &rb_mode, &rb_html, &rb_block);
+	rb_scan_args(argc, argv, "13&", &rb_text, &rb_mode, &rb_html, &rb_skip, &rb_block);
 
 	Check_Type(rb_text, T_STRING);
 
@@ -323,8 +343,27 @@ rb_rinku_autolink(int argc, VALUE *argv, VALUE self)
 		link_attr = RSTRING_PTR(rb_html);
 	}
 
-	input_buf.data = RSTRING_PTR(rb_text);
-	input_buf.size = RSTRING_LEN(rb_text);
+	if (!NIL_P(rb_skip)) {
+		long i;
+
+		Check_Type(rb_skip, T_ARRAY);
+
+		skip_tags_count = RARRAY_LEN(rb_skip);
+		skip_tags = malloc(sizeof(void *) * skip_tags_count);
+		if (!skip_tags)
+			rb_raise(rb_eNoMemError, "Out of memory");
+
+		for (i = 0; i < skip_tags_count; ++i) {
+			VALUE tag = rb_ary_entry(rb_skip, i);
+			Check_Type(tag, T_STRING);
+
+			skip_tags[i] = StringValueCStr(tag);
+		}
+	} else {
+		skip_tags = SKIP_TAGS;
+		skip_tags_count = sizeof(SKIP_TAGS) / sizeof(SKIP_TAGS[0]);
+	}
+
 	output_buf = bufnew(32);
 
 	if (mode_sym == rb_intern("all"))
@@ -339,9 +378,12 @@ rb_rinku_autolink(int argc, VALUE *argv, VALUE self)
 
 	count = rinku_autolink(
 		output_buf,
-		&input_buf,
+		RSTRING_PTR(rb_text),
+		RSTRING_LEN(rb_text),
 		link_mode,
 		link_attr,
+		skip_tags,
+		skip_tags_count,
 		RTEST(rb_block) ? &autolink_callback : NULL,
 		(void*)rb_block);
 
@@ -352,6 +394,9 @@ rb_rinku_autolink(int argc, VALUE *argv, VALUE self)
 		rb_enc_copy(result, rb_text);
 	}
 
+	if (skip_tags != SKIP_TAGS)
+		free(skip_tags);
+
 	bufrelease(output_buf);
 	return result;
 }

data/lib/rails_rinku.rb

@@ -1,7 +1,7 @@
 require 'rinku'
 
 module RailsRinku
-  def auto_link(text, *args, &block)
+  def rinku_auto_link(text, *args, &block)
     return '' if text.blank?
 
     options = args.size == 2 ? {} : args.extract_options!
@@ -10,7 +10,6 @@ module RailsRinku
       options[:html] = args[1] || {}
     end
     options.reverse_merge!(:link => :all, :html => {})
-    text = sanitize(text) unless options[:sanitize] == false
 
     Rinku.auto_link(text, options[:link], tag_options(options[:html]), &block)
   end
@@ -18,4 +17,5 @@ end
 
 module ActionView::Helpers::TextHelper
  include RailsRinku
+ alias_method :auto_link, :rinku_auto_link
 end

data/rinku.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'rinku'
-  s.version = '1.2.2'
+  s.version = '1.3.0'
   s.summary = "Mostly autolinking"
   s.description = <<-EOF
     A fast and very smart autolinking library that
@@ -20,6 +20,9 @@ Gem::Specification.new do |s|
     ext/rinku/buffer.c
     ext/rinku/buffer.h
     ext/rinku/extconf.rb
+    ext/rinku/houdini.h
+    ext/rinku/houdini_href_e.c
+    ext/rinku/houdini_html_e.c
     lib/rinku.rb
     lib/rails_rinku.rb
     rinku.gemspec

data/test/autolink_test.rb

@@ -4,13 +4,46 @@ $LOAD_PATH.unshift "#{rootdir}/lib"
 
 require 'test/unit'
 require 'cgi'
+require 'uri'
 require 'rinku'
 
 class RedcarpetAutolinkTest < Test::Unit::TestCase
+
+  SAFE_CHARS = "{}[]~'"
+
   def assert_linked(expected, url)
     assert_equal expected, Rinku.auto_link(url)
   end
 
+  def test_does_not_segfault
+    assert_linked "< this is just a test", "< this is just a test"
+  end
+
+  def test_skips_tags
+    html = <<-html
+This is just a test. http://www.pokemon.com
+<div>
+  More test
+  http://www.amd.com
+</div>
+<pre>
+  CODE www.less.es
+</pre>
+    html
+
+    result = <<-result
+This is just a test. <a href="http://www.pokemon.com">http://www.pokemon.com</a>
+<div>
+  More test
+  http://www.amd.com
+</div>
+<pre>
+  CODE <a href="http://www.less.es">www.less.es</a>
+</pre>
+    result
+    assert_equal result, Rinku.auto_link(html, :all, nil, ["div", "a"])
+  end
+
   def test_auto_link_with_brackets
     link1_raw = 'http://en.wikipedia.org/wiki/Sprite_(computer_graphics)'
     link1_result = generate_result(link1_raw)
@@ -128,12 +161,12 @@ class RedcarpetAutolinkTest < Test::Unit::TestCase
               http://www.mail-archive.com/rails@lists.rubyonrails.org/
               http://www.amazon.com/Testing-Equal-Sign-In-Path/ref=pd_bbs_sr_1?ie=UTF8&s=books&qid=1198861734&sr=8-1
               http://en.wikipedia.org/wiki/Sprite_(computer_graphics)
-              http://en.wikipedia.org/wiki/Texas_hold'em
+              http://en.wikipedia.org/wiki/Texas_hold%27em
               https://www.google.com/doku.php?id=gps:resource:scs:start
             )
 
     urls.each do |url|
-      assert_linked %(<a href="#{CGI.escapeHTML url}">#{CGI.escapeHTML url}</a>), url
+      assert_linked %(<a href="#{CGI.escapeHTML URI.escape(url, SAFE_CHARS)}">#{CGI.escapeHTML url}</a>), url
     end
   end
 
@@ -212,7 +245,7 @@ class RedcarpetAutolinkTest < Test::Unit::TestCase
 
   def generate_result(link_text, href = nil)
     href ||= link_text
-    %{<a href="#{CGI::escapeHTML href}">#{CGI::escapeHTML link_text}</a>}
+    %{<a href="#{CGI::escapeHTML URI.escape(href, SAFE_CHARS)}">#{CGI::escapeHTML link_text}</a>}
   end
   
 end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 1
-  - 2
-  - 2
-  version: 1.2.2
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - "Vicent Mart\xC3\xAD"
@@ -15,8 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-19 00:00:00 +02:00
-default_executable: 
+date: 2011-11-08 00:00:00 Z
 dependencies: []
 
 description: "    A fast and very smart autolinking library that\n    acts as a drop-in replacement for Rails `auto_link`\n"
@@ -37,11 +36,13 @@ files:
 - ext/rinku/buffer.c
 - ext/rinku/buffer.h
 - ext/rinku/extconf.rb
+- ext/rinku/houdini.h
+- ext/rinku/houdini_href_e.c
+- ext/rinku/houdini_html_e.c
 - lib/rinku.rb
 - lib/rails_rinku.rb
 - rinku.gemspec
 - test/autolink_test.rb
-has_rdoc: true
 homepage: http://github.com/tanoku/rinku
 licenses: []
 
@@ -71,7 +72,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Mostly autolinking