RubyGems - patch-html_namespacing - Versions diffs - 0.2.0.1 - Mend

patch-html_namespacing 0.2.0.1

Files changed (14) hide show

data/README.rdoc +406 -0
data/ext/html_namespacing/extconf.rb +6 -0
data/ext/html_namespacing/html_namespacing.c +481 -0
data/ext/html_namespacing/html_namespacing.h +35 -0
data/ext/html_namespacing/html_namespacing_ext.c +97 -0
data/lib/html_namespacing.rb +9 -0
data/lib/html_namespacing/plugin.rb +10 -0
data/lib/html_namespacing/plugin/dom_scan_jquery.js +44 -0
data/lib/html_namespacing/plugin/dom_scan_jquery.js.compressed +1 -0
data/lib/html_namespacing/plugin/rails.rb +206 -0
data/lib/html_namespacing/plugin/sass.rb +93 -0
data/spec/c_extension_spec.rb +58 -0
data/spec/spec_helper.rb +4 -0
metadata +87 -0

data/README.rdoc ADDED

@@ -0,0 +1,406 @@
+= HTML Namespacing
+HTML Namespacing automatically adds HTML class attributes to partial HTML
+code.
+The intent is for HTML, CSS, and JavaScript files to be "namespaced" according
+to their location in the filesystem. That way, CSS and JavaScript can be scoped
+to individual HTML files--even automatically.
+== Installing
+  gem install adamh-html_namespacing --source http://gems.github.com
+== Using
+HTML Namespacing can be used on its own for a snippet of code:
+  require 'rubygems'
+  require 'html_namespacing'
+  html = '<p>Here is some <em>HTML</em>!</p>'
+  # Returns '<p class="foo">Here is some <em>HTML</em>!</p>'
+  namespaced = HtmlNamespacing::add_namespace_to_html(html, 'foo')
+== Details
+Only root tags will be namespaced. For instance, all <tt>p</tt> tags in this
+example will have a class added, but no other tags:
+  <p>This is a root tag. <b>This tag is nested.</b></p>
+  <p>This is another root tag.</p>
+Because XML, DOCTYPE, comments, and <tt>html</tt> tags do not allow the
+<tt>class</tt> attribute, the following HTML will pass through unchanged:
+  <?xml version="1.0"?>
+  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+  <!-- Here is a comment -->
+  <html>
+    <head>
+      <title>Hello</title>
+    </head>
+    <body>
+      <p>Blah blah blah</p>
+    </body>
+  </html>
+(The following elements do not support the <tt>class</tt> attribute:
+<tt>html</tt>, <tt>head</tt>, <tt>base</tt>, <tt>meta</tt>, <tt>title</tt>,
+<tt>link</tt>, <tt>script</tt>, <tt>noscript</tt>, <tt>style</tt>.)
+Though the actual namespacing functions are written in pure C with no
+dependencies, only Ruby bindings are available at this time.
+== Integrating in a Rails project
+HTML namespacing is meant to integrate into a framework. Here is a Rails
+example:
+In <tt>config/environment.rb</tt>:
+  config.gem 'html_namespacing'
+In <tt>config/initializers/html_namespacing.rb</tt>:
+  HtmlNamespacing::Plugin::Rails.install
+Now, all templates will have HTML namespacing applied. For instance, with a
+<tt>views/foos/show.html.erb</tt> like this:
+  <p>
+    <b>Name:</b>
+    <%=h @foo.name %>
+  </p>
+  <%= render(:partial => @foo) %>
+  <%= link_to 'Edit', edit_foo_path(@foo) %> |
+  <%= link_to 'Back', foos_path %>
+The following HTML might be generated (depending on the <tt>_details</tt>
+partial and the data in the actual <tt>Foo</tt> object):
+  <p class="foos-show">
+    <b>Name:</b>
+    Foo
+  </p>
+  <p class="foos-_foo foos-show">
+    <b>Description:</b>
+    Bar
+  </p>
+  <a href="/foos/1/edit" class="hellos-show">Edit</a> |
+  <a href="/foos" class="hellos-show">Back</a>
+== Integrating with Haml and Sass in Rails
+With Haml:http://haml-lang.com/ and Sass:http://sass-lang.com/ namespacing can
+be automated even further.
+In your Rails project, implement the following:
+In <tt>config/environment.rb</tt>:
+  config.gem 'haml', :version => '2.2.0'
+  config.gem 'adamh-html_namespacing', :library => 'html_namespacing'
+In <tt>config/initializers/html_namespacing.rb</tt>:
+  HtmlNamespacing::Plugin::Rails.install
+  HtmlNamespacing::Plugin::Sass.install
+Then add <tt>stylesheet_link_tag(:all, :recursive => true)</tt> to your layout.
+Now, all templates will have HTML namespacing applied, and Sass files in
+<tt>SASS_DIR/views</tt> (where <tt>SASS_DIR</tt> is Sass's
+<tt>:template_location</tt>, default <tt>public/stylesheets/sass</tt>) will
+also be HTML-namespaced. For example:
+With a partial, <tt>app/views/foos/show.html.haml</tt> like this:
+  %p
+    %strong Name:
+    %span.name&= @foo.name
+  = render(:partial => @foo)
+  = link_to('Edit', edit_foo_path(@foo)
+  |
+  = link_to('Back', foos_path
+And a Sass file in <tt>public/stylesheets/sass/views/foos/show.sass</tt>:
+  strong
+    :font-size 1.3em
+  span.name
+    :font-style italic
+  a&
+    :font-weight bold
+The Sass rules will only apply to their corresponding partial.
+(Note: to target root-level elements in a Sass partial, use the "&" rule,
+which is standard Sass and will equate to ".NAMESPACE" in this context.)
+=== Options
+Available options to <tt>HtmlNamespacing::Plugin::Rails.install</tt> are:
+<tt>:path_to_namespace_callback</tt>: Ruby lambda function which accepts a
+relative path (e.g., "foo/bar") and returns an HTML namespacing string
+(e.g., "foo-bar"). The default is:
+  lambda { |path| path.gsub('/', '-') }
+If the callback returns <tt>nil</tt>, HTML namespacing will not be applied.
+<tt>:handle_exception_callback</tt>: Ruby lambda function which accepts
+an <tt>Exception</tt>, an <tt>ActionView::Template</tt>, and an
+<tt>ActionView::Base</tt>. The default behavior is:
+  lambda { |exception, template, view| raise(exception) }
+If your <tt>:handle_exception_callback</tt> does not raise an exception,
+the template will be rendered as if HtmlNamespacing were not installed.
+<tt>:javascript</tt>: If set, enable
+<tt>html_namespacing_javascript_tag()</tt> (see below). You will need to
+<tt>include HtmlNamespacing::Plugin::Rails::Helpers</tt> in your helpers to
+gain access to this method.
+<tt>:javascript_root</tt>: Root of namespaced JavaScript files, if you are
+using <tt>html_namespacing_javascript_tag()</tt> (see below).
+<tt>:template_formats</tt>: If set (to an Array), apply HTML namespacing
+under the given (String) formats. Default is <tt>['html']</tt>.
+<tt>:javascript_optional_suffix</tt>: optional suffix for your JavaScript
+files, if you are using <tt>html_namespacing_javascript_tag()</tt>. For
+instance, if <tt>:javascript_optional_suffix</tt> is <tt>'compressed'</tt> and
+you rendered the partial <tt>app/views/foos/_foo.html.haml</tt>, then the
+(presumably minified) file
+<tt>app/javascripts/views/foos/_foo.js.compressed</tt> will be included if it
+exists (otherwise the standard <tt>app/javascripts/views/foos/_foo.js</tt>,
+otherwise nothing).
+Available options to <tt>HtmlNamespacing::Plugin::Sass.install</tt> are:
+<tt>:prefix</tt> (default <tt>views</tt>): subdirectory of Sass directory for
+which we want to namespace our Sass.
+<tt>:callback</tt>: See <tt>:template_to_namespace_callback</tt> above; this
+callback is similar, though it accepts a string path rather than an
+<tt>ActionView::Template</tt>.
+== Why?
+HTML namespacing gives huge benefits when writing CSS and JavaScript:
+especially if the CSS and JavaScript components are automatically namespaced
+in a similar manner.
+Imagine we have the following namespaced HTML:
+  <div class="foos-show">
+    <p>In the show partial</p>
+    <div class="foos-_details">
+      <p>In the details partial</p>
+      <div class="foos-_description">
+        <p>In the description</p>
+      </div>
+    </div>
+  </div>
+=== CSS Namespacing
+We can set three CSS rules:
+  .foos-show p { font-size: 1.1em; }
+  .foos-_details p { font-weight: bold; }
+  .foos-_description p { font-style: italic; }
+In such an example, the top paragraph would be large, the second would be large
+and bold, and the third would be large, bold, and italic.
+The benefit comes when automating these namespaces. For instance, if the CSS
+rules were placed in <tt>stylesheets/views/foos/show.css</tt>,
+<tt>stylesheets/views/foos/_details.css</tt>, and
+<tt>stylesheets/views/foos/_description.css</tt>, respectively, and a
+preprocessor inserted the namespace before (or within) every rule in the file,
+all CSS namespacing would be done for free, so you would be able to write:
+<tt>stylesheets/views/foos/show.css</tt>:
+  p { font-size: 1.1em; }
+<tt>stylesheets/views/foos/_details.css</tt>:
+  p { font-weight: bold; }
+<tt>stylesheets/views/foos/_description.css</tt>:
+  p { font-style: italic; }
+Thus, the namespaces would never need to be explicitly mentioned. The
+framework used to generate such CSS is left (for now) as an exercise to the
+reader.
+=== jQuery Namespacing
+Use the following Rails helper, possibly in your default layout:
+  html_namespacing_javascript_tag(:jquery)
+Afterwards, similar to our namespaced CSS framework above, you can easily
+namespace JavaScript behavior:
+<tt>app/javascripts/views/foos/_description.js</tt>:
+  $NS().find('p').click(function() { alert("Yup, you clicked!"); });
+You just write code specific to one Rails partial without actually writing the
+partial's name anywhere, and you will not need to rewrite any selectors if you
+rename or move the partial (as long as you rename or move the corresponding
+JavaScript file).
+(All namespaced JavaScript partials will be included inline, all in separate
+<tt>jQuery(document).ready()</tt> blocks. Two local variables will be
+available: <tt>NS</tt>, the namespace string, and <tt>$NS()</tt>, a function
+returning a jQuery object containing all elements at the root of the
+namespace.)
+In a more complex setup, you may prefer to add another extension, like so:
+  html_namespacing_javascript_tag(:jquery, :format => :mobile)
+This will find <tt>app/javascripts/views/foos/_description.mobile.js</tt> and
+will ignore <tt>app/javascripts/views/foos/_description.js</tt>. Neglecting the
+second parameter, <tt>html_namespacing_javascript_tag()</tt> would include
+<tt>_description.js</tt> and <em>exclude</em> <tt>_description.mobile.js</tt>:
+only single-extension JavaScript will be included. To include both, use:
+  html_namespacing_javascript_tag(:jquery, :format => [nil, :mobile])
+=== Caching and JavaScript Namespacing
+Caching throws a wrench into operations.
+<tt>html_namespacing_javascript_tag()</tt> works by watching which templates get
+rendered; when reading from the cache, not all templates will have
+<tt>render()</tt> called on them.
+The general solution is to cache the list of rendered templates along with the
+data being cached. A new view method, <tt>html_rendering_rendered_paths</tt>,
+returns an Array to be used for this purpose. As a practical example, here is a
+plugin which makes JavaScript namespacing work with
+{cache_advance}[http://github.com/aub/cache_advance]:
+  class HtmlNamespacingCachePlugin
+    def self.key_suffix
+      'HTML_NAMESPACING_DATA'
+    end
+    def cache_it_options(view)
+      { :view => view }
+    end
+    def before_render(cache_name, cache_key, options)
+      options[:html_namespacing_rendered_paths_length] = paths(options).length
+    end
+    def after_render(cache_name, cache_key, data, options)
+      old_length = options[:html_namespacing_rendered_paths_length]
+      new_length = paths(options).length
+      delta = paths(options)[old_length..new_length]
+      unless delta.empty?
+        key = cache_key + self.class.key_suffix
+        Rails.cache.write(key, delta)
+      end
+    end
+    def after_read(cache_name, cache_key, data, options)
+      key = cache_key + self.class.key_suffix
+      if delta = Rails.cache.read(key)
+        paths(options).concat(delta)
+      end
+    end
+    protected
+    def paths(options)
+      options[:view].html_namespacing_rendered_paths
+    end
+  end
+Other plugins are welcome; I will consider integrating them into this project.
+== Tips and Tricks
+You may find that HTML namespacing works best when each HTML partial is wrapped
+in its own <tt>div</tt> tag. Both CSS's child selectors and jQuery's
+<tt>find()</tt> function will ordinarily ignore the element with the namespace
+class, only selecting sub-elements. For instance, with this HTML:
+  <div class="foos-show">
+    <p>Hello</p>
+  </div>
+If you wrote the following CSS:
+  .foos-show div { font-weight: bold; }
+Or this Sass:
+  div
+    :font-weight bold
+Or the following JavaScript (following the <tt>$NS</tt> example above):
+  var $div = $NS().find('div');
+Nothing will be selected, because the <tt>div</tt> element is not a child.
+Instead, you need the following CSS:
+  div.foos-show { font-weight: bold; }
+Or this sass:
+  div&
+    :font-weight bold
+Or the following JavaScript:
+  var $div = $NS().filter('div');
+Also, watch out for nesting: selectors with the <tt>foos-show</tt> namespace
+will match anything inside any partials rendered by
+<tt>foos/show.html.erb</tt>. As a rule of thumb to circumvent this problem: the
+wider the namespaces's scope, the less CSS and JavaScript you should write
+which depends on it. (Use sub-partials very liberally.)
+HTML namespacing produces plenty of tiny CSS and/or JavaScript files. Best
+practice is to bundle all namespaced files together: by virtue of being
+namespaced, it is safe to concatenate them. (Advanced CSS users should
+be thoughtful about
+{cascading order and specificity}[http://www.w3.org/TR/CSS2/cascade.html#cascading-order]
+and anybody bundling JavaScript files together should wrap each with
+<tt>(function() { ... })();</tt> to prevent variable leakage.) CSS files can be
+concatenated using a tool such as
+{asset_library}[http://github.com/adamh/asset_library]; JavaScript files are
+concatenated automatically in <tt>html_namespacing_javascript_tag()</tt>.
+These and similar strategies should be considered when building an HTML
+namespacing framework.
+== License
+I believe in software freedom, not any abomination thereof. This project is
+released under the Public Domain, meaning I relinquish my copyright (to any
+extend the law allows) and grant you all rights to use, modify, sell, or
+otherwise take advantage of my software.
+However, I do kindly request that, as a favor, you refrain from using my
+software as part of an evil plan involving velociraptors and mind-controlling
+robots (even though I would not be legally entitled to sue you for doing so).

data/ext/html_namespacing/extconf.rb ADDED

@@ -0,0 +1,6 @@
+require 'mkmf'
+name = 'html_namespacing_ext'
+dir_config(name)
+create_makefile(name)

data/ext/html_namespacing/html_namespacing.c ADDED

@@ -0,0 +1,481 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "html_namespacing.h"
+#define WHITE_SPACE " \t\r\n"
+static const struct IgnoreTag {
+    const char *str;
+    size_t len;
+} IGNORE_TAGS[] = {
+    { "html", 4 },
+    { "head", 4 },
+    { "base", 4 },
+    { "meta", 4 },
+    { "title", 5 },
+    { "link", 4 },
+    { "script", 6 },
+    { "noscript", 8 },
+    { "style", 5 }
+};
+static const int NUM_IGNORE_TAGS = 9;
+static int
+determine_alloc_size_of_at_least(int i)
+{
+    return i + 1024;
+}
+/*
+ * Ensures *r is long enough to hold len chars (using realloc).
+ *
+ * Arguments:
+ *   - char **r: Pointer to the string (which need not be \0-terminated). Will
+ *     be replaced by the new string.
+ *   - size_t *r_len: Pointer to the length of the string. Will be replaced by
+ *     the new length, which will be >= len.
+ *   - size_t len: Minimum length of the new string.
+ *
+ * Returns:
+ *   - 0 on success, whether or not *r changed length.
+ *   - ENOMEM if reallocation failed. *r and *r_len will point to their old
+ *     values, which will remain unchanged.
+ */
+static int
+ensure_string_length(
+        char **r,
+        size_t *r_len,
+        size_t len,
+        HtmlNamespacingAllocationStrategy allocation_strategy)
+{
+    char *new_r;
+    size_t new_r_len;
+    new_r_len = *r_len;
+    if (new_r_len >= len) {
+        /* No need to realloc */
+        return 0;
+    }
+    while (new_r_len < len) {
+        new_r_len <<= 1;
+    }
+    new_r = allocation_strategy.realloc(*r, sizeof(char) * new_r_len);
+    if (!new_r) {
+        return ENOMEM;
+    }
+    *r = new_r;
+    *r_len = new_r_len;
+    return 0;
+}
+/*
+ * Tries to copy s into dest, possibly reallocating.
+ *
+ * Arguments:
+ *   - dest: Beginning of destination string. May be reallocated during copy.
+ *   - dest_len: Amount of memory allocated to dest. May be increased during
+ *     copy.
+ *   - dest_p: Pointer to end of destination string (potentially 1 past the
+ *     allocated length of dest).
+ *   - s: Source string.
+ *
+ * Returns:
+ *   - 0 on success. dest may be changed; dest_p will be incremented.
+ *   - ENOMEM if reallocation failed. dest and dest_p will remain unchanged.
+ */
+static int
+append_string(
+        char **dest,
+        size_t *dest_len,
+        char **dest_p,
+        const char *s,
+        size_t len,
+        HtmlNamespacingAllocationStrategy allocation_strategy)
+{
+    int rv;
+    size_t dest_p_offset;
+    size_t new_dest_len;
+    char *new_dest;
+    new_dest = *dest;
+    dest_p_offset = *dest_p - *dest;
+    new_dest_len = dest_p_offset + len;
+    rv = ensure_string_length(
+            &new_dest, dest_len, new_dest_len, allocation_strategy);
+    if (rv == ENOMEM) {
+        return ENOMEM;
+    }
+    if (new_dest != *dest) {
+        *dest = new_dest;
+        *dest_p = new_dest + dest_p_offset;
+    }
+    strncpy(*dest_p, s, len);
+    *dest_p += len;
+    return 0;
+};
+enum {
+    PARSE_NORMAL,
+    PARSE_OPEN_TAG,
+    PARSE_OPEN_TAG_NAME,
+    PARSE_OPEN_TAG_ATTRIBUTE_NAME,
+    PARSE_OPEN_TAG_ATTRIBUTE_VALUE,
+    PARSE_OPEN_TAG_ATTRIBUTE_EQUALS,
+    PARSE_CLOSE_TAG,
+    PARSE_EMPTY_TAG, /* detected while we're inside PARSE_OPEN_TAG */
+    PARSE_COMMENT,
+    PARSE_XML_DECL,
+    PARSE_DOCTYPE,
+    PARSE_CDATA
+};
+static int
+char_is_whitespace(char c)
+{
+    return c == 0x20 || c == 0x09 || c == 0x0d || c == 0x0a;
+}
+static int
+should_ignore_tag(const char *tag_name, size_t tag_len)
+{
+    int i = 0;
+    for (i = 0; i < NUM_IGNORE_TAGS; i++) {
+        if (tag_len == IGNORE_TAGS[i].len
+                && 0 == strncmp(IGNORE_TAGS[i].str, tag_name, tag_len)) {
+            return 1;
+        }
+    }
+    return 0;
+}
+/*
+ * Adjusts the given HTML so that top-level elements get an added "class" of
+ * namespace.
+ *
+ * For instance, given
+ * "<div><span>Hello</span></div><p class="below">Goodbye</p>" and a
+ * namespace of "foo", returns
+ * "<div class="foo"><span>Hello</span></div><p class="below foo">Goodbye</p>".
+ *
+ * Arguments:
+ *   - const char *html: Original HTML string. Must be valid HTML encoded as
+ *     utf-8, \0-terminated.
+ *   - int html_len: Length of HTML string, without the \0.
+ *   - const char *namespace: Namespace to add. Must be of the form
+ *     "[a-zA-Z][-_a-zA-Z0-9]*".
+ *   - char **ret: Pointer to return value, which will be newly-allocated. Will
+ *     be overwritten only on success.
+ *   - int *ret_len: Pointer to return value's length. Will be overwritten only
+ *     on success.
+ *
+ * Returns:
+ *   - 0 on success. *ret will be overwritten to point to the newly-allocated
+ *     string.
+ *   - ENOMEM if *ret could not be allocated.
+ *   - EINVAL if html is not valid XML.
+ */
+int
+add_namespace_to_html_with_length_and_allocation_strategy(
+        const char *html,
+        size_t html_len,
+        const char *ns,
+        char **ret,
+        size_t *ret_len,
+        HtmlNamespacingAllocationStrategy allocation_strategy)
+{
+#define APPEND_STRING(s, n) \
+        do { \
+            if (append_string(&r, &r_len, &r_p, s, n, allocation_strategy) != 0) goto error; \
+        } while (0)/*;*/
+#define APPEND_END_OF_STRING() \
+        do { \
+            if (append_string(&r, &r_len, &r_p, "", 1, allocation_strategy) != 0) goto error; \
+            r_len -= 1; \
+            r_p -= 1; \
+        } while (0)/*;*/
+#define COPY_TO_HERE() \
+        do { \
+            if (append_string(&r, &r_len, &r_p, html_first_uncopied_p, html_p - html_first_uncopied_p, allocation_strategy) != 0) goto error; \
+            html_first_uncopied_p = html_p; \
+        } while (0)/*;*/
+#define ADVANCE(n) \
+        do { \
+            if (html_p + n <= html + html_len) { \
+                html_p += n; \
+            } else { \
+                html_p = html + html_len; \
+            } \
+        } while (0)/*;*/
+#define ADVANCE_UNTIL_ONE_OF_THESE_CHARS(chars) \
+        do { \
+          const size_t num_chars = strcspn(html_p, chars); \
+          ADVANCE(num_chars); \
+          if (*html_p == '\0') \
+            goto end; \
+        } while (0) /*;*/
+    unsigned int state;
+    char *r; /* Start of retval */
+    char *r_p; /* Pointer in retval */
+    size_t r_len; /* Length of retval */
+    const char *html_first_uncopied_p;
+    const char *html_p;
+    const char *open_tag_name = NULL;
+    size_t open_tag_name_len = 0;
+    int num_tags_open;
+    int open_tag_attribute_is_class_attribute;
+    int open_tag_had_class_attribute;
+    const char *open_tag_attribute_value;
+    size_t ns_len = strlen(ns);
+    r_len = determine_alloc_size_of_at_least(html_len);
+    r = allocation_strategy.malloc(sizeof(char) * r_len);
+    if (!r) {
+        return ENOMEM;
+    }
+    html_first_uncopied_p = html_p = html;
+    state = PARSE_NORMAL;
+    r_p = r;
+    num_tags_open = 0;
+    open_tag_attribute_is_class_attribute = 0;
+    open_tag_had_class_attribute = 0;
+    open_tag_attribute_value = NULL;
+    while (1) {
+        if (html_p[0] == 0) break;
+        switch (state) {
+            case PARSE_NORMAL:
+                if (*html_p == '<') {
+                    ADVANCE(1);
+                    if (0 == strncmp("![CDATA[", html_p, 8)) {
+                        state = PARSE_CDATA;
+                    } else if (html_p[0] == '/') {
+                        state = PARSE_CLOSE_TAG;
+                    } else if (0 == strncmp("!--", html_p, 3)) {
+                        state = PARSE_COMMENT;
+                    } else if (0 == strncmp("!DOCTYPE", html_p, 8)) {
+                        state = PARSE_DOCTYPE;
+                    } else if (0 == strncmp("?xml", html_p, 4)) {
+                        state = PARSE_XML_DECL;
+                    } else {
+                        open_tag_name = html_p;
+                        state = PARSE_OPEN_TAG_NAME;
+                    }
+                } else {
+                    ADVANCE_UNTIL_ONE_OF_THESE_CHARS("<");
+                }
+                break;
+            case PARSE_OPEN_TAG_NAME:
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS(WHITE_SPACE ">/");
+                open_tag_name_len = html_p - open_tag_name;
+                state = PARSE_OPEN_TAG;
+                break;
+            case PARSE_OPEN_TAG:
+                if (*html_p == '/' || *html_p == '>') {
+                    if (num_tags_open == 0 && !open_tag_had_class_attribute
+                            && !should_ignore_tag(open_tag_name, open_tag_name_len)) {
+                        COPY_TO_HERE();
+                        if (*html_p == '/' && char_is_whitespace(*(html_p - 1))) {
+                            /* We're in an empty tag with a trailing space */
+                            APPEND_STRING("class=\"", 7);
+                            APPEND_STRING(ns, ns_len);
+                            APPEND_STRING("\" ", 2);
+                        } else {
+                            APPEND_STRING(" class=\"", 8);
+                            APPEND_STRING(ns, ns_len);
+                            APPEND_STRING("\"", 1);
+                        }
+                    }
+                    open_tag_had_class_attribute = 0;
+                    open_tag_attribute_value = NULL;
+                    if (*html_p == '/') {
+                        state = PARSE_EMPTY_TAG;
+                    } else {
+                        num_tags_open++;
+                        state = PARSE_NORMAL;
+                    }
+                    ADVANCE(1);
+                } else if (!char_is_whitespace(*html_p)) {
+                    if (0 == strncmp(html_p, "class", 5)) {
+                        open_tag_attribute_is_class_attribute = 1;
+                        open_tag_had_class_attribute = 1;
+                    } else {
+                        open_tag_attribute_is_class_attribute = 0;
+                    }
+                    state = PARSE_OPEN_TAG_ATTRIBUTE_NAME;
+                } else {
+                    ADVANCE(1);
+                }
+                break;
+            case PARSE_OPEN_TAG_ATTRIBUTE_NAME:
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS("=");
+                ADVANCE(1);
+                state = PARSE_OPEN_TAG_ATTRIBUTE_EQUALS;
+                break;
+            case PARSE_OPEN_TAG_ATTRIBUTE_EQUALS:
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS("'\"");
+                open_tag_attribute_value = html_p;
+                state = PARSE_OPEN_TAG_ATTRIBUTE_VALUE;
+                ADVANCE(1);
+                break;
+            case PARSE_OPEN_TAG_ATTRIBUTE_VALUE:
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS("'\"");
+                /* open_tag_attribute_value is either ' or " */
+                while (*html_p != *open_tag_attribute_value) {
+                    ADVANCE(1);
+                    ADVANCE_UNTIL_ONE_OF_THESE_CHARS("'\"");
+                }
+                if (open_tag_attribute_is_class_attribute
+                        && num_tags_open == 0) {
+                    COPY_TO_HERE();
+                    APPEND_STRING(" ", 1);
+                    APPEND_STRING(ns, ns_len);
+                }
+                open_tag_attribute_is_class_attribute = 0;
+                state = PARSE_OPEN_TAG;
+                ADVANCE(1);
+                break;
+            case PARSE_CLOSE_TAG:
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS(">");
+                num_tags_open--;
+                open_tag_attribute_value = NULL;
+                state = PARSE_NORMAL;
+                ADVANCE(1);
+                break;
+            case PARSE_EMPTY_TAG:
+            case PARSE_XML_DECL:
+            case PARSE_DOCTYPE:
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS(">");
+                ADVANCE(1);
+                state = PARSE_NORMAL;
+                break;
+            case PARSE_COMMENT:
+                ADVANCE(1); /* at least one */
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS("-");
+                if (0 == strncmp("-->", html_p, 3)) {
+                    ADVANCE(3);
+                    state = PARSE_NORMAL;
+                }
+                /* else loop... */
+                break;
+            case PARSE_CDATA:
+                ADVANCE(1); /* at least one */
+                ADVANCE_UNTIL_ONE_OF_THESE_CHARS("]");
+                if (0 == strncmp("]]>", html_p, 3)) {
+                    ADVANCE(3);
+                    state = PARSE_NORMAL;
+                }
+                /* else loop... */
+                break;
+            default:
+                assert(0);
+        }
+    }
+ end:
+    COPY_TO_HERE();
+    APPEND_END_OF_STRING();
+    if (state != PARSE_NORMAL
+            || (r_p - r) < html_len
+            || html_p != html + html_len
+            || num_tags_open != 0
+            || open_tag_attribute_is_class_attribute
+            || open_tag_attribute_value)
+    {
+        allocation_strategy.free (r);
+        *ret = NULL;
+        *ret_len = -1;
+        return EINVAL;
+    }
+    *ret = r;
+    *ret_len = r_p - r;
+    return 0;
+error:
+    allocation_strategy.free(r);
+    *ret = NULL;
+    *ret_len = -1;
+    return ENOMEM;
+}
+int
+add_namespace_to_html_with_length(
+        const char *html,
+        size_t html_len,
+        const char *ns,
+        char **ret,
+        size_t *ret_len)
+{
+    HtmlNamespacingAllocationStrategy allocation_strategy;
+    allocation_strategy.malloc = malloc;
+    allocation_strategy.free = free;
+    allocation_strategy.realloc = realloc;
+    return add_namespace_to_html_with_length_and_allocation_strategy(
+            html, html_len, ns, ret, ret_len, allocation_strategy);
+}
+#if INCLUDE_MAIN
+#include <stdio.h>
+int
+main(int argc, char **argv)
+{
+    const char *html;
+    size_t html_len;
+    const char *ns;
+    char *ret;
+    size_t ret_len;
+    int rv;
+    HtmlNamespacingAllocationStrategy allocation_strategy;
+    if (argc != 3) {
+        printf("usage: %s HTML_STRING NAMESPACE", argv[0]);
+        return 1;
+    }
+    html = argv[1];
+    html_len = strlen(html);
+    ns = argv[2];
+    printf("html: %s\n", html);
+    printf("html_len: %d\n", html_len);
+    printf("ns: %s\n", ns);
+    allocation_strategy.malloc = malloc;
+    allocation_strategy.free = free;
+    allocation_strategy.realloc = realloc;
+    rv = add_namespace_to_html_with_length_and_allocation_strategy(html, html_len, ns, &ret, &ret_len, allocation_strategy);
+    if (ret) {
+        printf("ret: %s\n", ret);
+        printf("ret_len: %d\n", ret_len);
+    } else {
+        printf("Failed!\n");
+    }
+    return rv;
+}
+#endif /* INCLUDE_MAIN */