commonmarker 0.0.1 → 0.1.0

data/ext/commonmarker/cmark/src/houdini_html_u.c

@@ -12,32 +12,45 @@ houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size)
 {
 	size_t i = 0;
 
-	if (size > 3 && src[0] == '#') {
-		int codepoint = 0;
+	if (size >= 3 && src[0] == '#') {
+		int codepoint  = 0;
+		int num_digits = 0;
 
 		if (_isdigit(src[1])) {
 			for (i = 1; i < size && _isdigit(src[i]); ++i) {
-				int cp = (codepoint * 10) + (src[i] - '0');
+				codepoint = (codepoint * 10) + (src[i] - '0');
 
-				if (cp < codepoint)
-					return 0;
-
-				codepoint = cp;
+				if (codepoint >= 0x110000) {
+					// Keep counting digits but
+					// avoid integer overflow.
+					codepoint = 0x110000;
+				}
 			}
+
+			num_digits = i - 1;
 		}
 
 		else if (src[1] == 'x' || src[1] == 'X') {
 			for (i = 2; i < size && _isxdigit(src[i]); ++i) {
-				int cp = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
+				codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
 
-				if (cp < codepoint)
-					return 0;
-
-				codepoint = cp;
+				if (codepoint >= 0x110000) {
+					// Keep counting digits but
+					// avoid integer overflow.
+					codepoint = 0x110000;
+				}
 			}
+
+			num_digits = i - 2;
 		}
 
-		if (i < size && src[i] == ';' && codepoint) {
+		if (num_digits >= 1 && num_digits <= 8 &&
+		    i < size && src[i] == ';') {
+			if (codepoint == 0 ||
+			    (codepoint >= 0xD800 && codepoint < 0xE000) ||
+			    codepoint >= 0x110000) {
+				codepoint = 0xFFFD;
+			}
 			utf8proc_encode_char(codepoint, ob);
 			return i + 1;
 		}

data/ext/commonmarker/cmark/src/iterator.c

@@ -138,8 +138,8 @@ void cmark_consolidate_text_nodes(cmark_node *root)
 				cmark_node_free(tmp);
 				tmp = next;
 			}
-			cmark_strbuf_putc(&buf, 0);
-			cmark_node_set_literal(cur, (char *)buf.ptr);
+			cmark_chunk_free(&cur->as.literal);
+			cur->as.literal = cmark_chunk_buf_detach(&buf);
 		}
 	}
 

data/ext/commonmarker/commonmarker.c

@@ -5,9 +5,14 @@
 VALUE rb_mCommonMark;
 
 static VALUE
-rb_markdown_to_html(VALUE text)
+rb_markdown_to_html(VALUE self, VALUE rb_text)
 {
-	return rb_str_new2((char *)cmark_markdown_to_html((char *)RSTRING_PTR(text), RSTRING_LEN(text), 0));
+	Check_Type(rb_text, T_STRING);
+
+	char *str = (char *)RSTRING_PTR(rb_text);
+	int len = RSTRING_LEN(rb_text);
+
+	return rb_str_new2(cmark_markdown_to_html(str, len, 0));
 }
 
 static VALUE
@@ -41,7 +46,11 @@ rb_node_get_string_content(VALUE self, VALUE n)
 	cmark_node *node;
 	Data_Get_Struct(n, cmark_node, node);
 
-	return rb_str_new2(cmark_node_get_literal(node));
+	char *text = (char *) cmark_node_get_literal(node);
+	if (text == NULL)
+		return Qnil;
+
+	return rb_str_new2(text);
 }
 
 static VALUE
@@ -145,6 +154,250 @@ rb_render_html(VALUE self, VALUE n, VALUE rb_options)
 	return rb_str_new2(cmark_render_html(node, options));
 }
 
+static VALUE
+rb_node_insert_after(VALUE self, VALUE n1, VALUE n2)
+{
+	cmark_node *node1;
+	Data_Get_Struct(n1, cmark_node, node1);
+
+	cmark_node *node2;
+	Data_Get_Struct(n2, cmark_node, node2);
+
+	return INT2NUM(cmark_node_insert_after(node1, node2));
+}
+
+
+static VALUE
+rb_node_prepend_child(VALUE self, VALUE n1, VALUE n2)
+{
+	cmark_node *node1;
+	Data_Get_Struct(n1, cmark_node, node1);
+
+	cmark_node *node2;
+	Data_Get_Struct(n2, cmark_node, node2);
+
+	return INT2NUM(cmark_node_prepend_child(node1, node2));
+}
+
+
+static VALUE
+rb_node_append_child(VALUE self, VALUE n1, VALUE n2)
+{
+	cmark_node *node1;
+	Data_Get_Struct(n1, cmark_node, node1);
+
+	cmark_node *node2;
+	Data_Get_Struct(n2, cmark_node, node2);
+
+	return INT2NUM(cmark_node_append_child(node1, node2));
+}
+
+
+static VALUE
+rb_node_last_child(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	if (node == NULL)
+		return Qnil;
+
+	cmark_node *child = cmark_node_last_child(node);
+
+	return Data_Wrap_Struct(self, NULL, NULL, child);
+}
+
+
+static VALUE
+rb_node_parent(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	if (node == NULL)
+		return Qnil;
+
+	cmark_node *parent = cmark_node_parent(node);
+
+	return Data_Wrap_Struct(self, NULL, NULL, parent);
+}
+
+
+static VALUE
+rb_node_previous(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	if (node == NULL)
+		return Qnil;
+
+	cmark_node *previous = cmark_node_previous(node);
+
+	return Data_Wrap_Struct(self, NULL, NULL, previous);
+}
+
+
+static VALUE
+rb_node_get_url(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	char *text = (char *) cmark_node_get_url(node);
+	if (text == NULL)
+		return Qnil;
+
+	return rb_str_new2(text);
+}
+
+static VALUE
+rb_node_set_url(VALUE self, VALUE n, VALUE s)
+{
+	Check_Type(s, T_STRING);
+
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	char *text = (char *)RSTRING_PTR(s);
+
+	return INT2NUM(cmark_node_set_url(node, text));
+}
+
+
+static VALUE
+rb_node_get_title(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	char *text = (char *) cmark_node_get_title(node);
+	if (text == NULL)
+		return Qnil;
+
+	return rb_str_new2(text);
+}
+
+static VALUE
+rb_node_set_title(VALUE self, VALUE n, VALUE s)
+{
+	Check_Type(s, T_STRING);
+
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	char *text = (char *)RSTRING_PTR(s);
+
+	return INT2NUM(cmark_node_set_title(node, text));
+}
+
+
+static VALUE
+rb_node_get_header_level(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	return INT2NUM(cmark_node_get_header_level(node));
+}
+
+static VALUE
+rb_node_set_header_level(VALUE self, VALUE n, VALUE l)
+{
+	Check_Type(l, T_FIXNUM);
+
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	int level = FIX2INT(l);
+
+	return INT2NUM(cmark_node_set_header_level(node, level));
+}
+
+
+static VALUE
+rb_node_get_list_type(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	return INT2NUM(cmark_node_get_list_type(node));
+}
+
+static VALUE
+rb_node_set_list_type(VALUE self, VALUE n, VALUE t)
+{
+	Check_Type(t, T_FIXNUM);
+
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	int type = FIX2INT(t);
+
+	return INT2NUM(cmark_node_set_list_type(node, type));
+}
+
+
+static VALUE
+rb_node_get_list_start(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	return INT2NUM(cmark_node_get_list_start(node));
+}
+
+static VALUE
+rb_node_set_list_start(VALUE self, VALUE n, VALUE s)
+{
+	Check_Type(s, T_FIXNUM);
+
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	int start = FIX2INT(s);
+
+	return INT2NUM(cmark_node_set_list_start(node, start));
+}
+
+
+static VALUE
+rb_node_get_list_tight(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	int flag = cmark_node_get_list_tight(node);
+
+	return flag ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_node_set_list_tight(VALUE self, VALUE n, VALUE t)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	int tight = RTEST(t);
+
+	return INT2NUM(cmark_node_set_list_tight(node, tight));
+}
+
+
+static VALUE
+rb_node_get_fence_info(VALUE self, VALUE n)
+{
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+
+	return rb_str_new2(cmark_node_get_fence_info(node));
+}
+
+static VALUE
+rb_node_set_fence_info(VALUE self, VALUE n, VALUE s)
+{
+	Check_Type(s, T_STRING);
+
+	cmark_node *node;
+	Data_Get_Struct(n, cmark_node, node);
+	char *text = (char *)RSTRING_PTR(s);
+
+	return INT2NUM(cmark_node_set_fence_info(node, text));
+}
+
 __attribute__((visibility("default")))
 void Init_commonmarker()
 {
@@ -162,4 +415,24 @@ void Init_commonmarker()
 	rb_define_singleton_method(rb_mCommonMark, "node_next", rb_node_next, 1);
 	rb_define_singleton_method(rb_mCommonMark, "node_insert_before", rb_node_insert_before, 2);
 	rb_define_singleton_method(rb_mCommonMark, "render_html", rb_render_html, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_insert_after", rb_node_insert_after, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_prepend_child", rb_node_prepend_child, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_append_child", rb_node_append_child, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_last_child", rb_node_last_child, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_parent", rb_node_parent, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_previous", rb_node_previous, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_get_url", rb_node_get_url, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_set_url", rb_node_set_url, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_get_title", rb_node_get_title, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_set_title", rb_node_set_title, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_get_header_level", rb_node_get_header_level, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_set_header_level", rb_node_set_header_level, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_get_list_type", rb_node_get_list_type, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_set_list_type", rb_node_set_list_type, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_get_list_start", rb_node_get_list_start, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_set_list_start", rb_node_set_list_start, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_get_list_tight", rb_node_get_list_tight, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_set_list_tight", rb_node_set_list_tight, 2);
+	rb_define_singleton_method(rb_mCommonMark, "node_get_fence_info", rb_node_get_fence_info, 1);
+	rb_define_singleton_method(rb_mCommonMark, "node_set_fence_info", rb_node_set_fence_info, 2);
 }

data/ext/commonmarker/extconf.rb

@@ -10,9 +10,11 @@ FileUtils.mkdir_p(CMARK_BUILD_DIR)
 Dir.chdir(CMARK_BUILD_DIR) do
   system 'cmake ..'
   system 'make'
+  # rake-compiler seems to complain about this line, not sure why it's messing with it
+  FileUtils.rm_rf(File.join(CMARK_BUILD_DIR, 'Testing', 'Temporary'))
 end
 
+$LDFLAGS << " -Wl,-rpath,#{CMARK_BUILD_DIR}/src -L#{CMARK_BUILD_DIR}/src -lcmark"
 $CFLAGS << " -I#{CMARK_DIR}/src -I#{CMARK_BUILD_DIR}/src"
-$LOCAL_LIBS << "#{CMARK_BUILD_DIR}/src/libcmark.a"
 
 create_makefile('commonmarker/commonmarker')

data/lib/commonmarker.rb

@@ -1,53 +1,22 @@
 #!/usr/bin/env ruby
 require 'commonmarker/commonmarker'
 require 'commonmarker/config'
-require 'stringio'
-require 'cgi'
-require 'set'
-require 'uri'
-
-NODE_TYPES = [:none, :document, :blockquote, :list, :list_item,
-              :code_block, :html, :paragraph,
-              :header, :hrule, :text, :softbreak,
-              :linebreak, :code, :inline_html,
-              :emph, :strong, :link, :image]
-LIST_TYPES = [:no_list, :bullet_list, :ordered_list]
-
-# module CMark
-
-  # attach_function :cmark_node_new, [:node_type], :node
-  # attach_function :cmark_node_free, [:node], :void
-  # attach_function :cmark_node_unlink, [:node], :void
-  # attach_function :cmark_node_insert_before, [:node, :node], :int
-  # attach_function :cmark_node_insert_after, [:node, :node], :int
-  # attach_function :cmark_node_prepend_child, [:node, :node], :int
-  # attach_function :cmark_node_append_child, [:node, :node], :int
-  # attach_function :cmark_markdown_to_html, [:string, :int], :string
-  # attach_function :cmark_render_html, [:node], :string
-  # attach_function :cmark_parse_document, [:string, :int], :node
-  # attach_function :cmark_node_first_child, [:node], :node
-  # attach_function :cmark_node_last_child, [:node], :node
-  # attach_function :cmark_node_parent, [:node], :node
-  # attach_function :cmark_node_next, [:node], :node
-  # attach_function :cmark_node_previous, [:node], :node
-  # attach_function :cmark_node_get_type, [:node], :node_type
-  # attach_function :cmark_node_get_literal, [:node], :string
-  # attach_function :cmark_node_set_literal, [:node, :string], :int
-  # attach_function :cmark_node_get_url, [:node], :string
-  # attach_function :cmark_node_set_url, [:node, :string], :int
-  # attach_function :cmark_node_get_title, [:node], :string
-  # attach_function :cmark_node_set_title, [:node, :string], :int
-  # attach_function :cmark_node_get_header_level, [:node], :int
-  # attach_function :cmark_node_set_header_level, [:node, :int], :int
-  # attach_function :cmark_node_get_list_type, [:node], :list_type
-  # attach_function :cmark_node_set_list_type, [:node, :list_type], :int
-  # attach_function :cmark_node_get_list_start, [:node], :int
-  # attach_function :cmark_node_set_list_start, [:node, :int], :int
-  # attach_function :cmark_node_get_list_tight, [:node], :bool
-  # attach_function :cmark_node_set_list_tight, [:node, :bool], :int
-  # attach_function :cmark_node_get_fence_info, [:node], :string
-  # attach_function :cmark_node_set_fence_info, [:node, :string], :int
-# end
+require 'commonmarker/renderer'
+require 'commonmarker/renderer/html_renderer'
+
+begin
+  require 'awesome_print'
+rescue LoadError; end
+
+NODE_TYPES = %i(none document blockquote list list_item
+                code_block html paragraph
+                header hrule text softbreak
+                linebreak code inline_html
+                emph strong link image)
+
+LIST_TYPES = %i(no_list bullet_list ordered_list)
+
+NONE_TYPE = 'NONE'
 
 module CommonMarker
   class NodeError < StandardError
@@ -63,18 +32,17 @@ module CommonMarker
     # Params:
     # +type+:: +node_type+ of the node to be created (nil if +pointer+ is used).
     # +pointer+:: pointer to C node (nil if +type+ is used).
-    def initialize(type=nil, pointer=nil)
+    def initialize(type = nil, pointer = nil)
       if pointer
         @pointer = pointer
       else
         unless NODE_TYPES.include?(type)
-          raise NodeError, "node type does not exist #{type}"
+          fail NodeError, "node type does not exist #{type}"
         end
         @pointer = CMark.node_new(type)
       end
-      if @pointer.nil?
-        raise NodeError, "could not create node of type #{type}"
-      end
+
+      fail NodeError, "could not create node of type #{type}" if @pointer.nil?
     end
 
     # Parses a string into a :document Node.  The
@@ -106,10 +74,22 @@ module CommonMarker
       Node.new(nil, CMark.node_last_child(@pointer))
     end
 
+    def parent
+      Node.new(nil, CMark.node_parent(@pointer))
+    end
+
+    def previous
+      Node.new(nil, CMark.node_previous(@pointer))
+    end
+
+    def next
+      Node.new(nil, CMark.node_next(@pointer))
+    end
+
     # Iterator over the children (if any) of this Node.
     def each_child
       childptr = CMark.node_first_child(@pointer)
-      until CMark.node_get_type_string(childptr) == "NONE" do
+      until CMark.node_get_type_string(childptr) == NONE_TYPE
         nextptr = CMark.node_next(childptr)
         yield Node.new(nil, childptr)
         childptr = nextptr
@@ -128,31 +108,23 @@ module CommonMarker
     # +sibling+::  Sibling node to insert.
     def insert_before(sibling)
       res = CMark.node_insert_before(@pointer, sibling.pointer)
-      if res == 0 then raise NodeError, "could not insert before" end
+      fail NodeError, 'could not insert before' if res == 0
     end
 
     # Insert a node after this Node.
     # Params:
     # +sibling+::  Sibling Node to insert.
     def insert_after(sibling)
-      CMark.node_insert_before(@pointer, sibling.pointer)
-      if res == 0 then raise NodeError, "could not insert after" end
+      res = CMark.node_insert_before(@pointer, sibling.pointer)
+      fail NodeError, 'could not insert after' if res == 0
     end
 
     # Prepend a child to this Node.
     # Params:
     # +child+::  Child Node to prepend.
     def prepend_child(child)
-      CMark.node_prepend_child(@pointer, child.pointer)
-      if res == 0 then raise NodeError, "could not prepend child" end
-    end
-
-    # Append a child to this Node.
-    # Params:
-    # +child+::  Child Node to append.
-    def prepend_child(child)
-      CMark.node_append_child(@pointer, child.pointer)
-      if res == 0 then raise NodeError, "could not append child" end
+      res = CMark.node_prepend_child(@pointer, child.pointer)
+      fail NodeError, 'could not prepend child' if res == 0
     end
 
     # Returns string content of this Node.
@@ -165,14 +137,12 @@ module CommonMarker
     # +s+:: +String+ containing new content.
     def string_content=(s)
       res = CMark.node_set_string_content(@pointer, s)
-      if res == 0 then raise NodeError, "could not set string content" end
+      fail NodeError, 'could not set string content' if res == 0
     end
 
     # Returns header level of this Node (must be a :header).
     def header_level
-      if self.type != :header
-        raise NodeError, "can't get header_level for non-header"
-      end
+      fail NodeError, 'can\'t get header_level for non-header' unless type == :header
       CMark.node_get_header_level(@pointer)
     end
 
@@ -180,22 +150,18 @@ module CommonMarker
     # Params:
     # +level+:: New header level (+Integer+).
     def header_level=(level)
-      if self.type != :header
-        raise NodeError, "can't set header_level for non-header"
-      end
-      if !level.kind_of?(Integer) || level < 0 || level > 6
-        raise NodeError, "level must be between 1-6"
+      fail NodeError, 'can\'t set header_level for non-header' unless type == :header
+      if !level.is_a?(Integer) || level < 0 || level > 6
+        fail NodeError, 'level must be between 1-6'
       end
       res = CMark.node_set_header_level(@pointer, level)
-      if res == 0 then raise NodeError, "could not set header level" end
+      fail NodeError, 'could not set header level' if res == 0
     end
 
     # Returns list type of this Node (must be a :list).
     def list_type
-      if self.type != :list
-        raise NodeError, "can't get list_type for non-list"
-      end
-      CMark.node_get_list_type(@pointer)
+      fail NodeError, 'can\'t get list_type for non-list' unless type == :list
+      LIST_TYPES[CMark.node_get_list_type(@pointer)]
     end
 
     # Sets list type of this Node (must be a :list).
@@ -203,18 +169,16 @@ module CommonMarker
     # +list_type+:: New list type (+:list_type+), either
     # :ordered_list or :bullet_list.
     def list_type=(list_type)
-      if self.type != :list
-        raise NodeError, "can't set list_type for non-list"
-      end
+      fail NodeError, 'can\'t set list_type for non-list' unless type == :list
       res = CMark.node_set_list_type(@pointer, list_type)
-      if res == 0 then raise NodeError, "could not set list_type" end
+      fail NodeError, 'could not set list_type' if res == 0
     end
 
     # Returns start number of this Node (must be a :list of
     # list_type :ordered_list).
     def list_start
-      if self.type != :list || self.list_type != :ordered_list
-        raise NodeError, "can't get list_start for non-ordered list"
+      if type != :list || list_type != :ordered_list
+        fail NodeError, 'can\'t get list_start for non-ordered list'
       end
       CMark.node_get_list_start(@pointer)
     end
@@ -224,21 +188,17 @@ module CommonMarker
     # Params:
     # +start+:: New start number (+Integer+).
     def list_start=(start)
-      if self.type != :list || self.list_type != :ordered_list
-        raise NodeError, "can't set list_start for non-ordered list"
-      end
-      if !start.kind_of?(Integer)
-        raise NodeError, "start must be Integer"
+      if type != :list || list_type != :ordered_list
+        fail NodeError, 'can\'t set list_start for non-ordered list'
       end
+      fail NodeError, 'start must be Integer' unless start.is_a?(Integer)
       res = CMark.node_set_list_start(@pointer, start)
-      if res == 0 then raise NodeError, "could not set list_start" end
+      fail NodeError, 'could not set list_start' if res == 0
     end
 
     # Returns tight status of this Node (must be a :list).
     def list_tight
-      if self.type != :list
-        raise NodeError, "can't get list_tight for non-list"
-      end
+      fail NodeError, 'can\'t get list_tight for non-list' unless type == :list
       CMark.node_get_list_tight(@pointer)
     end
 
@@ -246,18 +206,14 @@ module CommonMarker
     # Params:
     # +tight+:: New tight status (boolean).
     def list_tight=(tight)
-      if self.type != :list
-        raise NodeError, "can't set list_tight for non-list"
-      end
+      fail NodeError, 'can\'t set list_tight for non-list' unless type == :list
       res = CMark.node_set_list_tight(@pointer, tight)
-      if res == 0 then raise NodeError, "could not set list_tight" end
+      fail NodeError, 'could not set list_tight' if res == 0
     end
 
     # Returns URL of this Node (must be a :link or :image).
     def url
-      if not (self.type == :link || self.type == :image)
-        raise NodeError, "can't get URL for non-link or image"
-      end
+      fail NodeError, 'can\'t get URL for non-link or image' if !(type == :link || type == :image)
       CMark.node_get_url(@pointer)
     end
 
@@ -265,23 +221,17 @@ module CommonMarker
     # Params:
     # +URL+:: New URL (+String+).
     def url=(url)
-      if not (self.type == :link || self.type == :image)
-        raise NodeError, "can't set URL for non-link or image"
-      end
-      if !url.kind_of?(String)
-        raise NodeError, "url must be a String"
-      end
+      fail NodeError, 'can\'t set URL for non-link or image' if !(type == :link || type == :image)
+      fail NodeError, 'url must be a String' unless url.is_a?(String)
       # Make our own copy so ruby won't garbage-collect it:
       c_url = FFI::MemoryPointer.from_string(url)
       res = CMark.node_set_url(@pointer, c_url)
-      if res == 0 then raise NodeError, "could not set header level" end
+      fail NodeError, 'could not set header level' if res == 0
     end
 
     # Returns title of this Node (must be a :link or :image).
     def title
-      if not (self.type == :link || self.type == :image)
-        raise NodeError, "can't get title for non-link or image"
-      end
+      fail NodeError, 'can\'t get title for non-link or image' if !(type == :link || type == :image)
       CMark.node_get_title(@pointer)
     end
 
@@ -289,23 +239,17 @@ module CommonMarker
     # Params:
     # +title+:: New title (+String+).
     def title=(title)
-      if not (self.type == :link || self.type == :image)
-        raise NodeError, "can't set title for non-link or image"
-      end
-      if !title.kind_of?(String)
-        raise NodeError, "title must be a String"
-      end
+      fail NodeError, 'can\'t set title for non-link or image' if !(type == :link || type == :image)
+      fail NodeError, 'title must be a String' unless title.is_a?(String)
       # Make our own copy so ruby won't garbage-collect it:
       c_title = FFI::MemoryPointer.from_string(title)
       res = CMark.node_set_title(@pointer, c_title)
-      if res == 0 then raise NodeError, "could not set header level" end
+      fail NodeError, 'could not set header level' if res == 0
     end
 
     # Returns fence info of this Node (must be a :code_block).
     def fence_info
-      if not (self.type == :code_block)
-        raise NodeError, "can't get fence_info for non code_block"
-      end
+      fail NodeError, 'can\'t get fence_info for non code_block' unless type == :code_block
       CMark.node_get_fence_info(@pointer)
     end
 
@@ -313,23 +257,19 @@ module CommonMarker
     # Params:
     # +info+:: New info (+String+).
     def fence_info=(info)
-      if self.type != :code_block
-        raise NodeError, "can't set fence_info for non code_block"
-      end
-      if !info.kind_of?(String)
-        raise NodeError, "info must be a String"
-      end
+      fail NodeError, 'can\'t set fence_info for non code_block' unless type == :code_block
+      fail NodeError, 'info must be a String' unless info.is_a?(String)
       # Make our own copy so ruby won't garbage-collect it:
       c_info = FFI::MemoryPointer.from_string(info)
       res = CMark.node_set_fence_info(@pointer, c_info)
-      if res == 0 then raise NodeError, "could not set info" end
+      fail NodeError, 'could not set info' if res == 0
     end
 
     # An iterator that "walks the tree," descending into children
     # recursively.
     def walk(&blk)
       yield self
-      self.each_child do |child|
+      each_child do |child|
         child.walk(&blk)
       end
     end
@@ -343,7 +283,6 @@ module CommonMarker
       CMark.node_get_type_string(@pointer)
     end
 
-
     # Convert to HTML using libcmark's fast (but uncustomizable) renderer.
     def to_html(option = :default)
       Config.option_exists?(option)
@@ -356,233 +295,4 @@ module CommonMarker
       # CMark.node_free(@pointer)
     end
   end
-
-  class Renderer
-    attr_accessor :in_tight, :warnings, :in_plain
-    def initialize
-      @stream = StringIO.new
-      @need_blocksep = false
-      @warnings = Set.new []
-      @in_tight = false
-      @in_plain = false
-    end
-
-    def out(*args)
-      args.each do |arg|
-        if arg == :children
-          @node.each_child do |child|
-            self.out(child)
-          end
-        elsif arg.kind_of?(Array)
-          arg.each do |x|
-            self.render(x)
-          end
-        elsif arg.kind_of?(Node)
-          self.render(arg)
-        else
-          @stream.write(arg)
-        end
-      end
-    end
-
-    def render(node)
-      @node = node
-      if node.type == :document
-        self.document(node)
-        return @stream.string
-      elsif self.in_plain && node.type != :text && node.type != :softbreak
-        node.each_child do |child|
-          render(child)
-        end
-      else
-        begin
-          self.send(node.type, node)
-        rescue NoMethodError => e
-          @warnings.add("WARNING:  " + node.type.to_s + " not implemented.")
-          raise e
-        end
-      end
-    end
-
-    def document(node)
-      self.out(:children)
-    end
-
-    def code_block(node)
-      self.code_block(node)
-    end
-
-    def reference_def(node)
-    end
-
-    def blocksep
-      self.out("\n")
-    end
-
-    def containersep
-      if !self.in_tight
-        self.out("\n")
-      end
-    end
-
-    def block(&blk)
-      if @need_blocksep
-        self.blocksep
-      end
-      blk.call
-      @need_blocksep = true
-    end
-
-    def container(starter, ender, &blk)
-      self.out(starter)
-      self.containersep
-      @need_blocksep = false
-      blk.call
-      self.containersep
-      self.out(ender)
-    end
-
-    def plain(&blk)
-      old_in_plain = @in_plain
-      @in_plain = true
-      blk.call
-      @in_plain = old_in_plain
-    end
-  end
-
-  class HtmlRenderer < Renderer
-    def render(node)
-      result = super(node)
-      if node.type == :document
-        result += "\n"
-      end
-    end
-
-    def header(node)
-      block do
-        self.out("<h", node.header_level, ">", :children,
-               "</h", node.header_level, ">")
-      end
-    end
-
-    def paragraph(node)
-      block do
-        if self.in_tight
-          self.out(:children)
-        else
-          self.out("<p>", :children, "</p>")
-        end
-      end
-    end
-
-    def list(node)
-      old_in_tight = self.in_tight
-      self.in_tight = node.list_tight
-      block do
-        if node.list_type == :bullet_list
-          container("<ul>", "</ul>") do
-            self.out(:children)
-          end
-        else
-          start = node.list_start == 1 ? '' :
-                  (' start="' + node.list_start.to_s + '"')
-          container(start, "</ol>") do
-            self.out(:children)
-          end
-        end
-      end
-      self.in_tight = old_in_tight
-    end
-
-    def list_item(node)
-      block do
-        container("<li>", "</li>") do
-          self.out(:children)
-        end
-      end
-    end
-
-    def blockquote(node)
-      block do
-        container("<blockquote>", "</blockquote>") do
-          self.out(:children)
-        end
-      end
-    end
-
-    def hrule(node)
-      block do
-        self.out("<hr />")
-      end
-    end
-
-    def code_block(node)
-      block do
-        self.out("<pre><code")
-        if node.fence_info && node.fence_info.length > 0
-          self.out(" class=\"language-", node.fence_info.split(/\s+/)[0], "\">")
-        else
-          self.out(">")
-        end
-        self.out(CGI.escapeHTML(node.string_content))
-        self.out("</code></pre>")
-      end
-    end
-
-    def html(node)
-      block do
-        self.out(node.string_content)
-      end
-    end
-
-    def inline_html(node)
-      self.out(node.string_content)
-    end
-
-    def emph(node)
-      self.out("<em>", :children, "</em>")
-    end
-
-    def strong(node)
-      self.out("<strong>", :children, "</strong>")
-    end
-
-    def link(node)
-      self.out('<a href="', node.url.nil? ? '' : URI.escape(node.url), '"')
-      if node.title && node.title.length > 0
-        self.out(' title="', CGI.escapeHTML(node.title), '"')
-      end
-      self.out('>', :children, '</a>')
-    end
-
-    def image(node)
-      self.out('<img src="', URI.escape(node.url), '"')
-      if node.title && node.title.length > 0
-        self.out(' title="', CGI.escapeHTML(node.title), '"')
-      end
-      plain do
-        self.out(' alt="', :children, '" />')
-      end
-    end
-
-    def text(node)
-      self.out(CGI.escapeHTML(node.string_content))
-    end
-
-    def code(node)
-      self.out("<code>")
-      self.out(CGI.escapeHTML(node.string_content))
-      self.out("</code>")
-    end
-
-    def linebreak(node)
-      self.out("<br/>")
-      self.softbreak(node)
-    end
-
-    def softbreak(node)
-      self.out("\n")
-    end
-  end
-
 end