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

adamh-html_namespacing 0.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 (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