html_namespacing 0.1.5

data/ext/html_namespacing/html_namespacing.h

@@ -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

@@ -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_PTR(html);
+    html_len = RSTRING_LEN(html);
+
+    ns_ptr = RSTRING_PTR(ns);
+
+    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: %s", html_ptr);
+    }
+    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/lib/html_namespacing.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/../ext/html_namespacing/html_namespacing_ext'
+
+module HtmlNamespacing
+  autoload(:Plugin, File.dirname(__FILE__) + '/html_namespacing/plugin')
+end

data/lib/html_namespacing/plugin.rb

@@ -0,0 +1,10 @@
+module HtmlNamespacing
+  module Plugin
+    autoload(:Rails, File.dirname(__FILE__) + '/plugin/rails')
+    autoload(:Sass, File.dirname(__FILE__) + '/plugin/sass')
+
+    def self.default_relative_path_to_namespace(path)
+      path.gsub(/\//, '-')
+    end
+  end
+end

data/lib/html_namespacing/plugin/dom_scan_jquery.js

@@ -0,0 +1,44 @@
+jQuery(function($) {
+	function NS_from_node(root_node) {
+		var SPLIT_REGEX = /[ \t\n]+/,
+		    ret = {},
+				node_stack = [root_node],
+				cur_node,
+				class_name_list,
+				class_names,
+				class_name,
+				i,
+				j,
+				children,
+				subnode;
+
+		while (node_stack.length) {
+			cur_node = node_stack.pop();
+
+			// Populate entry in $.NS
+			class_name_list = cur_node.className;
+			if (class_name_list) {
+				class_names = class_name_list.split(SPLIT_REGEX);
+				for (i = 0; i < class_names.length; i++) {
+					class_name = class_names[i];
+					if (!ret[class_name]) {
+						ret[class_name] = [cur_node];
+					} else {
+						ret[class_name].push(cur_node);
+					}
+				}
+			}
+
+			// "recurse" to the children, so they are handled in document order
+			children = cur_node.childNodes;
+			for (var j = children.length - 1; j >= 0; j--) {
+				subnode = children[j];
+				node_stack.push(subnode);
+			}
+		}
+
+		return ret;
+	}
+
+	$.NS = NS_from_node(document.getElementsByTagName('body')[0]);
+});

data/lib/html_namespacing/plugin/dom_scan_jquery.js.compressed

@@ -0,0 +1 @@
+jQuery(function(b){function a(f){var c=/[ \t\n]+/,m={},o=[f],n,l,p,h,k,g,e,d;while(o.length){n=o.pop();l=n.className;if(l){p=l.split(c);for(k=0;k<p.length;k++){h=p[k];if(!m[h]){m[h]=[n]}else{m[h].push(n)}}}e=n.childNodes;for(var g=e.length-1;g>=0;g--){d=e[g];o.push(d)}}return m}b.NS=a(document.getElementsByTagName("body")[0])});

data/lib/html_namespacing/plugin/rails.rb

@@ -0,0 +1,134 @@
+begin
+  require 'glob_fu'
+rescue LoadError
+  require 'rubygems'
+  require 'glob_fu'
+end
+
+module HtmlNamespacing
+  module Plugin
+    module Rails
+      def self.install(options = {})
+        @options = options
+        install_rails_2_3(options)
+      end
+
+      # Called by ActionView
+      def self.path_to_namespace(relative_path)
+        if func = @options[:path_to_namespace_callback]
+          func.call(relative_path)
+        else
+          HtmlNamespacing::Plugin.default_relative_path_to_namespace(relative_path)
+        end
+      end
+
+      def self.handle_exception(e, template, view)
+        if func = @options[:handle_exception_callback]
+          func.call(e, template, view)
+        else
+          raise(e)
+        end
+      end
+
+      def self.javascript_root
+        @options[:javascript_root] || RAILS_ROOT + '/app/javascripts/views'
+      end
+
+      def self.javascript_optional_suffix
+        @options[:javascript_optional_suffix]
+      end
+
+      def self.template_formats
+        @formats ||= Set.new(@options[:template_formats] || ['html'])
+      end
+
+      module Helpers
+        def html_namespacing_javascript_tag(framework, options = {})
+          files = html_namespacing_files(options[:format])
+          root = Pathname.new(::HtmlNamespacing::Plugin::Rails.javascript_root)
+
+          unless files.empty?
+            r = "<script type=\"text/javascript\"><!--//--><![CDATA[//><!--\n"
+            r << HtmlNamespaceJs[framework][:top]
+            r << "\n"
+            files.collect do |path|
+              relative_path = Pathname.new(path).relative_path_from(root)
+              r << html_namespacing_inline_js(framework, relative_path.to_s, path)
+              r << "\n"
+            end
+            r << "//--><!]]></script>"
+          end
+        end
+
+        private
+
+        HtmlNamespaceJs = {
+          :jquery => {
+            :top => File.open(File.join(File.dirname(__FILE__), 'dom_scan_jquery.js.compressed')) { |f| f.read },
+            :each => 'jQuery(function($){var NS=%s,$NS=function(){return $($.NS[NS]||[])};%s});'
+          }
+        }
+
+        def html_namespacing_files(format)
+          (Array === format ? format : [format]).inject([]) do |r, f|
+            r.concat(GlobFu.find(
+              html_namespacing_rendered_paths,
+              :suffix => 'js',
+              :extra_suffix => f && f.to_s,
+              :optional_suffix => ::HtmlNamespacing::Plugin::Rails.javascript_optional_suffix,
+              :root => ::HtmlNamespacing::Plugin::Rails.javascript_root
+            ))
+          end
+        end
+
+        def html_namespacing_inline_js(framework, relative_path, absolute_path)
+          namespace = ::HtmlNamespacing::Plugin::Rails.path_to_namespace(relative_path.sub(/\..*$/, ''))
+          content = File.open(absolute_path) { |f| f.read }
+
+          HtmlNamespaceJs[framework][:each] % [namespace.to_json, content]
+        end
+      end
+
+      private
+
+      def self.install_rails_2_3(options = {})
+        if options[:javascript]
+          ::ActionView::Base.class_eval do
+            attr_writer(:html_namespacing_rendered_paths)
+            def html_namespacing_rendered_paths
+              @html_namespacing_rendered_paths ||= []
+            end
+          end
+        end
+
+        ::ActionView::Template.class_eval do
+          def render_with_html_namespacing(view, local_assigns = {})
+            html = render_without_html_namespacing(view, local_assigns)
+
+            view.html_namespacing_rendered_paths << path_without_format_and_extension if view.respond_to?(:html_namespacing_rendered_paths)
+
+            if HtmlNamespacing::Plugin::Rails.template_formats.include?(format)
+              add_namespace_to_html(html, view)
+            else
+              html
+            end
+          end
+          alias_method_chain :render, :html_namespacing
+
+          private
+
+          def add_namespace_to_html(html, view)
+            HtmlNamespacing::add_namespace_to_html(html, html_namespace)
+          rescue ArgumentError => e
+            HtmlNamespacing::Plugin::Rails.handle_exception(e, self, view)
+            html # unless handle_exception() raised something
+          end
+
+          def html_namespace
+            HtmlNamespacing::Plugin::Rails.path_to_namespace(path_without_format_and_extension)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/html_namespacing/plugin/sass.rb

@@ -0,0 +1,76 @@
+module HtmlNamespacing
+  module Plugin
+    module Sass
+      def self.install(options = {})
+        options[:prefix] ||= 'views'
+        options[:callback] ||= lambda { |p| HtmlNamespacing::Plugin.default_relative_path_to_namespace(p) }
+        Sass_2_2.install(options)
+      end
+
+      module Sass_2_2
+        def self.install(options = {})
+          self.allow_updating_partials
+          self.add_super_rule_to_tree_node(options)
+          self.try_to_enable_memoization
+        end
+
+        private
+
+        def self.allow_updating_partials
+          ::Sass::Plugin.module_eval do
+            private
+
+            # Though a bit over-zealous, who *cares* if we render partial
+            # Sass files?
+            def forbid_update?(*args)
+              false
+            end
+          end
+        end
+
+        def self.add_super_rule_to_tree_node(namespacing_options)
+          ::Sass::Tree::RuleNode.class_eval do
+            def to_s_with_namespacing(tabs, super_rules = nil)
+              super_rules ||= namespacing_rules
+              to_s_without_namespacing(tabs, super_rules)
+            end
+            alias_method_chain(:to_s, :namespacing)
+
+            private
+
+            define_method(:namespacing_prefix) do
+              namespacing_options[:prefix]
+            end
+            define_method(:namespacing_callback) do
+              namespacing_options[:callback]
+            end
+
+            def namespacing_regex
+              /^#{Regexp.quote(options[:css_location])}\/#{Regexp.quote(namespacing_prefix)}\/(.*)\.css$/
+            end
+
+            def namespace
+              @namespace ||= if options[:css_filename] =~ namespacing_regex
+                namespacing_callback.call($1.split('.')[0])
+              end
+              @namespace
+            end
+
+            def namespacing_rules
+              namespace && [ ".#{namespace}" ]
+            end
+          end
+        end
+
+        def self.try_to_enable_memoization
+          ::Sass::Tree::RuleNode.class_eval do
+            extend ActiveSupport::Memoizable
+            memoize :namespacing_rules
+          end
+        rescue NameError
+          # ActiveSupport isn't loaded
+        end
+      end
+    end
+  end
+end

data/spec/c_extension_spec.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe(HtmlNamespacing) do
+  private
+
+  def self.define_test(name, html, ns, expect)
+    it("should work with #{name}") do
+      f(html, ns).should == expect
+    end
+  end
+
+  def self.define_failing_test(name, html)
+    it("should fail on #{name}") do
+      lambda { f(html, 'X') }.should raise_error(ArgumentError)
+    end
+  end
+
+  def f(html, ns)
+    HtmlNamespacing::add_namespace_to_html(html, ns)
+  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('empty tag with " />"', '<div />', 'X', '<div class="X" />')
+  self.define_test('empty tag with " />" and class', '<div class="A" />', 'X', '<div class="A 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('works with "\'" within \'"\' attributes', '<div title="Adam\'s House" class="foo">bar</div>', 'baz', '<div title="Adam\'s House" class="foo baz">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>')
+  self.define_test('detects CDATA end delimiter correctly', '<![CDATA[ ]>< ]]>', 'X', '<![CDATA[ ]>< ]]>')
+  self.define_test('detects comment end delimiter correctly', '<!-- ->< -->', 'X', '<!-- ->< -->')
+
+  [ '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', '<div>foo')
+  self.define_failing_test('closing tag', 'foo</div>')
+  self.define_failing_test('wrong attr syntax', '<div foo=bar>foo</div>')
+end