RubyGems - adamh-html_namespacing - Versions diffs - 0.0.1 - Mend

adamh-html_namespacing 0.0.1

Files changed (13) hide show

data/Manifest +12 -0
data/README.rdoc +274 -0
data/Rakefile +12 -0
data/ext/html_namespacing/extconf.rb +6 -0
data/ext/html_namespacing/html_namespacing.c +531 -0
data/ext/html_namespacing/html_namespacing.h +35 -0
data/ext/html_namespacing/html_namespacing_ext.c +97 -0
data/html_namespacing.gemspec +36 -0
data/lib/html_namespacing.rb +6 -0
data/lib/html_namespacing/plugin/rails.rb +42 -0
data/test/c_extension_test.rb +52 -0
data/test/test_helper.rb +3 -0
metadata +80 -0

data/Manifest ADDED Viewed

@@ -0,0 +1,12 @@
+README.rdoc
+Rakefile
+test/c_extension_test.rb
+test/test_helper.rb
+ext/html_namespacing/extconf.rb
+ext/html_namespacing/html_namespacing.h
+ext/html_namespacing/html_namespacing.c
+ext/html_namespacing/html_namespacing_ext.c
+lib/html_namespacing.rb
+lib/html_namespacing/plugin/rails.rb
+Manifest
+html_namespacing.gemspec

data/README.rdoc ADDED Viewed

@@ -0,0 +1,274 @@
+= HTML Namespacing
+HTML Namespacing automatically adds HTML class attributes to partial HTML
+code.
+== 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
+HTML namespacing expects valid, properly-nested HTML (not XML). It has no
+effect on doctype tags, XML declaration, comments, and the HTML tags which 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>.
+Only the root tags of the partial HTML 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>
+Remember, <tt>html</tt> (and other HTML tags which do not allow the
+<tt>class</tt> attribute) will be ignored. This 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>
+Though the actual namespacing functions are written in pure C with no
+dependencies, only Ruby bindings are available at this time.
+== Integrating in your Project
+More likely, you want to integrate HTML namespacing 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 => 'details', :locals => { :foo => @foo }) %>
+  <%= link_to 'Edit', foo_edit_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-_details 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>
+Rails will integrate with all HTML templates, regardless of their
+implementation; feel free to use Haml.
+=== Options
+Available options to <tt>install</tt> are:
+<tt>:template_to_namespace_callback</tt>: Ruby lambda function which accepts an
+<tt>ActionView::Template</tt> and returns an HTML namespacing string. The
+default is:
+  lambda { |template| template.path =~ /^([^\.]+)/ && $1.gsub('/', '-') || nil }
+If the callback returns <tt>nil</tt>, HTML namespacing will not be applied.
+== 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
+Insert the following before all other JavaScript:
+  $(document).ready(function() {
+    $.NS = {};
+    var SPLIT_REGEX = /\s+/;
+    function populate_NS_from_node(node) {
+      var node_stack = [];
+      node_stack.push(node);
+      while (node_stack.length) {
+        var cur_node = node_stack.pop();
+        // Populate entry in $.NS
+        var class_name_list = node.className;
+        var class_names = class_name_list.split(SPLIT_REGEX);
+        for (var i = 0; i < class_names.length; i++) {
+          var class_name = class_names[i];
+          if (!$.NS[class_name]) {
+            $.NS[class_name] = [cur_node];
+          } else {
+            $.NS[class_name].push(cur_node);
+          }
+        }
+        // "recurse" to the children, so they are handled in document order
+        var children = cur_node.childNodes;
+        for (var j = children.length - 1; j >= 0; j--) {
+          var subnode = children[j];
+          node_stack.push(subnode);
+        }
+      }
+    }
+    populate_NS_from_node(document.getElementsByTagName('body')[0]);
+  });
+(The CPU cost of this code is small but nonzero, as it precomputes many
+selectors. On a 75kb page with a 2.5Ghz computer, it might take 75ms with
+Firebug profiling turned on. This may or may not be faster than writing each
+selector by hand.)
+Afterwards, if you set up a JavaScript framework similar to the CSS framework
+above, you can easily namespace JavaScript behavior:
+<tt>javascripts/onload/foos/_description.js</tt>:
+  $(document).ready(function() {
+    var $NS = $.NS['foos-_description']; // auto-generated line at top of file
+    $NS.find('p').click(function() { alert("Yup, you clicked!"); });
+  });
+In the above file, if every line but the third is automatically generated based
+on the file's location (an exercise, for now, left to the reader), the third
+line can be written in full confidence that only paragraphs within the
+<tt>_description</tt> partial will have this jQuery code bound. The end result?
+You can 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.
+== 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 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. You
+would need the following CSS:
+  div.foos-show { 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. (Rule of thumb: use sub-partials very liberally.)
+These and similar strategies should be considered when building your automated
+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/Rakefile ADDED Viewed

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+Echoe.new('html_namespacing', '0.0.1') do |p|
+  p.author = 'Adam Hooper'
+  p.email = 'adam@adamhooper.com'
+  p.summary = 'Automatic HTML namespacing'
+  p.description = 'Inserts "class=" attributes within snippets of HTML so CSS and JavaScript can use automatic scopes'
+  p.url = 'http://github.com/adamh/html_namespacing'
+  p.rdoc_files = ['README.rdoc'] # echoe seems to gather everything twice
+end

data/ext/html_namespacing/extconf.rb ADDED Viewed

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

data/ext/html_namespacing/html_namespacing.c ADDED Viewed

@@ -0,0 +1,531 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include "html_namespacing.h"
+static const char* const IGNORE_TAGS[] = {
+    "html",
+    "head",
+    "base",
+    "meta",
+    "title",
+    "link",
+    "script",
+    "noscript",
+    "style",
+    NULL
+};
+/*
+ * Returns the first power of 2 which is >= the given length.
+ */
+static int
+round_to_power_of_two(int i)
+{
+    int j = 1;
+    while (j < i) {
+        j <<= 1;
+    }
+    return j;
+}
+/*
+ * Returns the number of bytes in the first utf-8 character of *utf8.
+ */
+static size_t
+utf8_char_bytes(const char *utf8)
+{
+    size_t i;
+    const unsigned char *u;
+    if (utf8[0] < 0x80) {
+        return 1;
+    }
+    u = (const unsigned char *) utf8;
+    for (i = 1; i < 6; i++) {
+        if ((u[i] & 0xc0) != 0x80) {
+            return i;
+        }
+    }
+    return -1;
+}
+/*
+ * 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 a single utf8 character to 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).
+ *   - src_p: Source string. Will be advanced.
+ *
+ * Returns:
+ *   - 0 on success. dest may be changed; dest_p will be incremented; src_p
+ *     will be incremented.
+ *   - ENOMEM if reallocation failed. dest, dest_p, and src_p will remain
+ *     unchanged.
+ */
+static int
+append_next_utf8_char(
+        char **dest,
+        size_t *dest_len,
+        char **dest_p,
+        const char **src_p,
+        HtmlNamespacingAllocationStrategy allocation_strategy)
+{
+    size_t c_num_utf8_bytes;
+    size_t dest_p_offset;
+    size_t new_dest_len;
+    char *new_dest;
+    int rv;
+    c_num_utf8_bytes = utf8_char_bytes(*src_p);
+    dest_p_offset = *dest_p - *dest;
+    new_dest = *dest;
+    new_dest_len = dest_p_offset + c_num_utf8_bytes;
+    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, *src_p, c_num_utf8_bytes);
+    *dest_p += c_num_utf8_bytes;
+    *src_p += c_num_utf8_bytes;
+    return 0;
+}
+static int
+append_string(
+        char **dest,
+        size_t *dest_len,
+        char **dest_p,
+        const char *s,
+        HtmlNamespacingAllocationStrategy allocation_strategy)
+{
+    int rv = 0;
+    while (*s && rv == 0) {
+        rv = append_next_utf8_char(
+                dest, dest_len, dest_p, &s, allocation_strategy);
+    }
+    return rv;
+};
+static int
+append_end_of_string(
+        char **dest,
+        size_t *dest_len,
+        char **dest_p,
+        HtmlNamespacingAllocationStrategy allocation_strategy)
+{
+    int rv;
+    const char *end = "\0";
+    rv = append_next_utf8_char(
+            dest, dest_len, dest_p, &end, allocation_strategy);
+    if (rv == 0) {
+        /* We don't add the length of '\0' */
+        *dest_len -= 1;
+        *dest_p -= 1;
+    }
+    return rv;
+}
+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;
+    const char *test_ignore;
+    for (i = 0; test_ignore = IGNORE_TAGS[i]; i++) {
+        if (0 == strncmp(test_ignore, tag_name, tag_len)
+                && strlen(test_ignore) == 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.
+ *   - int html_len: Length of HTML string.
+ *   - 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_NEXT_CHAR() \
+        if (append_next_utf8_char(&r, &r_len, &r_p, &html, allocation_strategy) != 0) goto error/*;*/
+#define APPEND_STRING(s) \
+        if (append_string(&r, &r_len, &r_p, s, allocation_strategy) != 0) goto error/*;*/
+#define APPEND_END_OF_STRING() \
+        if (append_end_of_string(&r, &r_len, &r_p, allocation_strategy) != 0) goto error/*;*/
+    unsigned int state;
+    char *r; /* Start of retval */
+    char *r_p; /* Pointer in retval */
+    size_t r_len; /* Length of retval */
+    const char *html_start;
+    const char *open_tag_name;
+    size_t open_tag_name_len;
+    char c;
+    size_t num_chars_remaining;
+    int num_tags_open;
+    int open_tag_attribute_is_class_attribute;
+    int open_tag_had_class_attribute;
+    const char *open_tag_attribute_value;
+    r_len = round_to_power_of_two(html_len);
+    r = allocation_strategy.malloc(sizeof(char) * r_len);
+    if (!r) {
+        return ENOMEM;
+    }
+    html_start = 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) {
+        num_chars_remaining = html_len - (html - html_start);
+        if (num_chars_remaining <= 0) break;
+        c = *html;
+        switch (state) {
+            case PARSE_NORMAL:
+                if (c == '<') {
+                    APPEND_NEXT_CHAR();
+                    if (num_chars_remaining >= 9
+                            && 0 == strncmp("![CDATA[", html, 8)) {
+                        state = PARSE_CDATA;
+                    } else if (num_chars_remaining >= 2 && html[0] == '/') {
+                        state = PARSE_CLOSE_TAG;
+                    } else if (num_chars_remaining >= 4
+                            && 0 == strncmp("!--", html, 3)) {
+                        state = PARSE_COMMENT;
+                    } else if (num_chars_remaining >= 9
+                            && 0 == strncmp("!DOCTYPE", html, 8)) {
+                        state = PARSE_DOCTYPE;
+                    } else if (num_chars_remaining >= 5
+                            && 0 == strncmp("?xml", html, 4)) {
+                        state = PARSE_XML_DECL;
+                    } else {
+                        open_tag_name = html;
+                        state = PARSE_OPEN_TAG_NAME;
+                    }
+                } else {
+                    APPEND_NEXT_CHAR();
+                }
+                break;
+            case PARSE_OPEN_TAG_NAME:
+                if (char_is_whitespace(c) || c == '>' || c == '/') {
+                    open_tag_name_len = html - open_tag_name;
+                    state = PARSE_OPEN_TAG;
+                }
+                if (c != '>' && c != '/') {
+                    APPEND_NEXT_CHAR();
+                }
+                break;
+            case PARSE_OPEN_TAG:
+                if (c == '/' || c == '>') {
+                    if (num_tags_open == 0 && !open_tag_had_class_attribute
+                            && !should_ignore_tag(open_tag_name, open_tag_name_len)) {
+                        APPEND_STRING(" class=\"");
+                        APPEND_STRING(ns);
+                        APPEND_STRING("\"");
+                    }
+                    open_tag_had_class_attribute = 0;
+                    open_tag_attribute_value = NULL;
+                    if (c == '/') {
+                        APPEND_STRING(" ");
+                        state = PARSE_EMPTY_TAG;
+                    } else {
+                        num_tags_open++;
+                        state = PARSE_NORMAL;
+                    }
+                } else if (!char_is_whitespace(c)) {
+                    if (num_chars_remaining >= 5
+                            && 0 == strncmp(html, "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;
+                }
+                APPEND_NEXT_CHAR();
+                break;
+            case PARSE_OPEN_TAG_ATTRIBUTE_NAME:
+                if (char_is_whitespace(c) || c == '=') {
+                    state = PARSE_OPEN_TAG_ATTRIBUTE_EQUALS;
+                }
+                APPEND_NEXT_CHAR();
+                break;
+            case PARSE_OPEN_TAG_ATTRIBUTE_EQUALS:
+                if (c == '\'' || c == '"') {
+                    open_tag_attribute_value = html;
+                    state = PARSE_OPEN_TAG_ATTRIBUTE_VALUE;
+                }
+                APPEND_NEXT_CHAR();
+                break;
+            case PARSE_OPEN_TAG_ATTRIBUTE_VALUE:
+                /* open_tag_attribute_value is either ' or " */
+                if (c == *open_tag_attribute_value) {
+                    if (open_tag_attribute_is_class_attribute
+                            && num_tags_open == 0) {
+                        APPEND_STRING(" ");
+                        APPEND_STRING(ns);
+                    }
+                    open_tag_attribute_is_class_attribute = 0;
+                    state = PARSE_OPEN_TAG;
+                }
+                APPEND_NEXT_CHAR();
+                break;
+            case PARSE_CLOSE_TAG:
+                if (c == '>') {
+                    num_tags_open--;
+                    open_tag_attribute_value = NULL;
+                    state = PARSE_NORMAL;
+                }
+                APPEND_NEXT_CHAR();
+                break;
+            case PARSE_EMPTY_TAG:
+            case PARSE_XML_DECL:
+            case PARSE_DOCTYPE:
+                if (c == '>') {
+                    state = PARSE_NORMAL;
+                }
+                APPEND_NEXT_CHAR();
+                break;
+            case PARSE_COMMENT:
+                APPEND_NEXT_CHAR();
+                if (c == '-' && num_chars_remaining >= 3
+                        && 0 == strncmp("->", html, 2)) {
+                    APPEND_NEXT_CHAR();
+                    APPEND_NEXT_CHAR();
+                    state = PARSE_NORMAL;
+                }
+                break;
+            case PARSE_CDATA:
+                APPEND_NEXT_CHAR();
+                if (c == ']' && num_chars_remaining >= 3
+                        && 0 == strncmp("]>", html, 2)) {
+                    APPEND_NEXT_CHAR();
+                    APPEND_NEXT_CHAR();
+                    state = PARSE_NORMAL;
+                }
+                break;
+            default:
+                assert(0);
+        }
+    }
+    APPEND_END_OF_STRING();
+    if (state != PARSE_NORMAL
+            || (r_p - r) < html_len
+            || num_chars_remaining != 0
+            || 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 */

data/ext/html_namespacing/html_namespacing.h ADDED Viewed

@@ -0,0 +1,35 @@
+#ifndef HTML_NAMESPACING_H
+#define HTML_NAMESPACING_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+typedef struct _HtmlNamespacingAllocationStrategy {
+    void *(*malloc)(size_t size);
+    void (*free)(void *ptr);
+    void *(*realloc)(void *ptr, size_t size);
+} HtmlNamespacingAllocationStrategy;
+int
+add_namespace_to_html_with_length(
+        const char *html,
+        size_t html_len,
+        const char *ns,
+        char **ret,
+        size_t *ret_len);
+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);
+#ifdef __cplusplus
+}
+#endif
+#endif /* HTML_NAMESPACING_H */

data/ext/html_namespacing/html_namespacing_ext.c ADDED Viewed

@@ -0,0 +1,97 @@
+#include <errno.h>
+#include "ruby.h"
+#include "html_namespacing.h"
+#include <stdio.h>
+VALUE rb_mHtmlNamespacing = Qnil;
+static const HtmlNamespacingAllocationStrategy ALLOCATION_STRATEGY = {
+    (void *(*)(size_t)) ruby_xmalloc,
+    ruby_xfree,
+    (void *(*)(void *, size_t)) ruby_xrealloc
+};
+/*
+ * call-seq:
+ *   HtmlNamespacing.add_namespace_to_html(html, ns) => String
+ *
+ * Returns new HTML string based on +html+ with the  HTML class +ns+ to root
+ * elements.
+ *
+ * If +html+ is nil, returns +nil+.
+ *
+ * If +ns+ is nil, returns +html+.
+ */
+VALUE
+html_namespacing_add_namespace_to_html(
+        VALUE obj,
+        VALUE html,
+        VALUE ns)
+{
+    /*
+     * It's almost tempting to manually allocate the RString object to save
+     * ourselves the stupid extra copy. (add_namespace_to_html_with_length()
+     * implicitly copies the string, and here we are copying it again because
+     * Ruby can't convert from a char* to an RString? How lame....)
+     *
+     * But for now, let's just do the extra copy (implicit in rb_str_new2) and
+     * be done with it.
+     */
+    const char *html_ptr;
+    size_t html_len;
+    const char *ns_ptr;
+    char *ret_ptr;
+    size_t ret_len;
+    int rv;
+    VALUE ret;
+    if (TYPE(html) == T_NIL) {
+      return Qnil;
+    }
+    Check_Type(html, T_STRING);
+    if (TYPE(ns) == T_NIL) {
+      return html;
+    }
+    Check_Type(ns, T_STRING);
+    html_ptr = RSTRING(html)->ptr;
+    html_len = RSTRING(html)->len;
+    ns_ptr = RSTRING(ns)->ptr;
+    rv = add_namespace_to_html_with_length_and_allocation_strategy(
+            html_ptr,
+            html_len,
+            ns_ptr,
+            &ret_ptr,
+            &ret_len,
+            ALLOCATION_STRATEGY);
+    if (rv == EINVAL) {
+        rb_raise(rb_eArgError, "Badly-formed HTML");
+    }
+    if (rv != 0) {
+        rb_raise(rb_eRuntimeError, "Unknown error in add_namespace_to_html");
+    }
+    ret = rb_str_new(ret_ptr, ret_len);
+    ruby_xfree(ret_ptr);
+    return ret;
+}
+/*
+ * Holds functions related to HTML namespacing.
+ */
+void
+Init_html_namespacing_ext()
+{
+    rb_mHtmlNamespacing = rb_define_module("HtmlNamespacing");
+    rb_define_module_function(rb_mHtmlNamespacing, "add_namespace_to_html", html_namespacing_add_namespace_to_html, 2);
+}

data/html_namespacing.gemspec ADDED Viewed

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name = %q{html_namespacing}
+  s.version = "0.0.1"
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Adam Hooper"]
+  s.date = %q{2009-03-17}
+  s.description = %q{Inserts "class=" attributes within snippets of HTML so CSS and JavaScript can use automatic scopes}
+  s.email = %q{adam@adamhooper.com}
+  s.extensions = ["ext/html_namespacing/extconf.rb"]
+  s.extra_rdoc_files = ["README.rdoc"]
+  s.files = ["README.rdoc", "Rakefile", "test/c_extension_test.rb", "test/test_helper.rb", "ext/html_namespacing/extconf.rb", "ext/html_namespacing/html_namespacing.h", "ext/html_namespacing/html_namespacing.c", "ext/html_namespacing/html_namespacing_ext.c", "lib/html_namespacing.rb", "lib/html_namespacing/plugin/rails.rb", "Manifest", "html_namespacing.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/adamh/html_namespacing}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Html_namespacing", "--main", "README.rdoc"]
+  s.require_paths = ["lib", "ext"]
+  s.rubyforge_project = %q{html_namespacing}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Automatic HTML namespacing}
+  s.test_files = ["test/c_extension_test.rb", "test/test_helper.rb"]
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<echoe>, [">= 0"])
+    else
+      s.add_dependency(%q<echoe>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<echoe>, [">= 0"])
+  end
+end

data/lib/html_namespacing.rb ADDED Viewed

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/../ext/html_namespacing/html_namespacing_ext'
+require 'html_namespacing/plugin/rails'
+module HtmlNamespacing
+end

data/lib/html_namespacing/plugin/rails.rb ADDED Viewed

@@ -0,0 +1,42 @@
+module HtmlNamespacing
+  module Plugin
+    module Rails
+      def self.install(options = {})
+        @options = options
+        install_rails_2_3
+      end
+      # Called by ActionView
+      def self.path_to_namespace(template)
+        if func = @options[:template_to_namespace_callback]
+          func.call(template)
+        elsif template.path =~ /^([^\.]+)/
+          $1.gsub('/', '-')
+        end
+      end
+      private
+      def self.install_rails_2_3(options = {})
+        ::ActionView::Template.class_eval do
+          def render_template_with_html_namespacing(*args)
+            s = render_template_without_html_namespacing(*args)
+            if format == 'html'
+              HtmlNamespacing::add_namespace_to_html(s, html_namespace)
+            else
+              s
+            end
+          end
+          alias_method_chain :render_template, :html_namespacing
+          def html_namespace
+            HtmlNamespacing::Plugin::Rails.path_to_namespace(self)
+          end
+          memoize :html_namespace
+        end
+      end
+    end
+  end
+end

data/test/c_extension_test.rb ADDED Viewed

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/test_helper'
+class CExtensionTest < Test::Unit::TestCase
+  private
+  def self.define_test(name, html, ns, expect)
+    define_method("test_#{name}".to_sym) do
+      assert_equal(expect, f(html, ns))
+    end
+  end
+  def self.define_failing_test(name, html)
+    define_method("test_#{name}".to_sym) do
+      assert_raises(ArgumentError) do
+        f(html, 'X')
+      end
+    end
+  end
+  self.define_test('nil HTML', nil, 'X', nil)
+  self.define_test('nil namespace', '<div>hello</div>', nil, '<div>hello</div>')
+  self.define_test('nil everything', nil, nil, nil)
+  self.define_test('plain text', 'hello', 'X', 'hello')
+  self.define_test('regular tag', '<div>hello</div>', 'X', '<div class="X">hello</div>')
+  self.define_test('empty tag', '<div/>', 'X', '<div class="X" />')
+  self.define_test('nested tag', '<div><div>hello</div></div>', 'X', '<div class="X"><div>hello</div></div>')
+  self.define_test('two tags', '<div>hello</div><div>goodbye</div>', 'X', '<div class="X">hello</div><div class="X">goodbye</div>')
+  self.define_test('existing class= tag with double-quotes', '<div class="foo">bar</div>', 'baz', '<div class="foo baz">bar</div>')
+  self.define_test('existing class= tag with single-quotes', "<div class='foo'>bar</div>", 'baz', "<div class='foo baz'>bar</div>")
+  self.define_test('other attributes are ignored', '<div id="id" class="foo" style="display:none;">bar</div>', 'baz', '<div id="id" class="foo baz" style="display:none;">bar</div>')
+  self.define_test('works with utf-8', '<div class="𝞪">𝟂</div>', '𝞺', '<div class="𝞪 𝞺">𝟂</div>')
+  self.define_test('empty tag with existing class=', '<span class="foo"/>', 'bar', '<span class="foo bar" />')
+  self.define_test('works with newlines in tag', "<div\n\nclass\n\n=\n\n'foo'\n\n>bar</div>", 'baz', "<div\n\nclass\n\n=\n\n'foo baz'\n\n>bar</div>")
+  self.define_test('ignores XML prolog', '<?xml version="1.0"?><div>foo</div>', 'X', '<?xml version="1.0"?><div class="X">foo</div>')
+  self.define_test('ignores DOCTYPE', '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><div>foo</div>', 'X', '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><div class="X">foo</div>')
+  self.define_test('ignores CDATA', '<![CDATA[ignore <div class="foo">]] </div>]]><div>foo</div>', 'X', '<![CDATA[ignore <div class="foo">]] </div>]]><div class="X">foo</div>')
+  self.define_test('ignores comments', '<!-- blah <div class="foo">foo</div> - <span/>--><div>foo</div>', 'X', '<!-- blah <div class="foo">foo</div> - <span/>--><div class="X">foo</div>')
+  [ 'html', 'head', 'base', 'meta', 'title', 'link', 'script', 'noscript', 'style' ].each do |tag|
+    self.define_test("ignores <#{tag}> tags", "<#{tag}>foo</#{tag}>", "X", "<#{tag}>foo</#{tag}>")
+  end
+  self.define_failing_test('unclosed tag fails', '<div>foo')
+  self.define_failing_test('closing tag fails', 'foo</div>')
+  self.define_failing_test('wrong attr syntax fails', '<div foo=bar>foo</div>')
+  def f(html, ns)
+    HtmlNamespacing::add_namespace_to_html(html, ns)
+  end
+end

data/test/test_helper.rb ADDED Viewed

@@ -0,0 +1,3 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/html_namespacing'

metadata ADDED Viewed

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: adamh-html_namespacing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Hooper
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2009-03-17 00:00:00 -07:00
+default_executable:
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: echoe
+  type: :development
+  version_requirement:
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: "0"
+    version:
+description: Inserts "class=" attributes within snippets of HTML so CSS and JavaScript can use automatic scopes
+email: adam@adamhooper.com
+executables: []
+extensions:
+- ext/html_namespacing/extconf.rb
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- Rakefile
+- test/c_extension_test.rb
+- test/test_helper.rb
+- ext/html_namespacing/extconf.rb
+- ext/html_namespacing/html_namespacing.h
+- ext/html_namespacing/html_namespacing.c
+- ext/html_namespacing/html_namespacing_ext.c
+- lib/html_namespacing.rb
+- lib/html_namespacing/plugin/rails.rb
+- Manifest
+- html_namespacing.gemspec
+has_rdoc: true
+homepage: http://github.com/adamh/html_namespacing
+post_install_message:
+rdoc_options:
+- --line-numbers
+- --inline-source
+- --title
+- Html_namespacing
+- --main
+- README.rdoc
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "0"
+  version:
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: "1.2"
+  version:
+requirements: []
+rubyforge_project: html_namespacing
+rubygems_version: 1.2.0
+signing_key:
+specification_version: 2
+summary: Automatic HTML namespacing
+test_files:
+- test/c_extension_test.rb
+- test/test_helper.rb