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

patch-html_namespacing 0.2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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 */