patch-html_namespacing 0.2.0.1

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,9 @@
+require File.dirname(__FILE__) + '/../ext/html_namespacing/html_namespacing_ext'
+
+module HtmlNamespacing
+  autoload(:Plugin, File.dirname(__FILE__) + '/html_namespacing/plugin')
+
+  def self.options
+    @options ||= {}
+  end
+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,206 @@
+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.stylesheet_root
+        @options[:stylesheet_root] || RAILS_ROOT + '/app/stylesheets/views'
+      end
+
+      def self.javascript_optional_suffix
+        @options[:javascript_optional_suffix]
+      end
+
+      def self.stylesheet_optional_suffix
+        @options[:stylesheet_optional_suffix]
+      end
+
+      def self.template_formats
+        @formats ||= Set.new(@options[:template_formats] || ['html'])
+      end
+
+      def self.skip_template?(path)
+        specifier = @options[:skip_templates]
+        if specifier.respond_to?(:call)
+          specifier.call(path)
+        elsif specifier.respond_to?(:include?)
+          specifier.include?(path)
+        else
+          specifier === path
+        end
+      end
+
+      module Helpers
+        #
+        # Return the javascript for the rendered partials, wrapped in
+        # a script tag.
+        #
+        def html_namespacing_javascript_tag(framework, options = {})
+          js = html_namespacing_javascript(framework, options)
+          unless js.blank?
+            "<script type=\"text/javascript\"><!--//--><![CDATA[//><!--\n#{js}//--><!]]></script>"
+          end
+        end
+
+        #
+        # Return the javascript for the rendered partials.
+        #
+        def html_namespacing_javascript(framework, options = {})
+          root = Pathname.new(Rails.javascript_root)
+          optional_suffix = Rails.javascript_optional_suffix
+          files = html_namespacing_files('js',
+                                         :format => options[:format],
+                                         :optional_suffix => optional_suffix,
+                                         :root => root.to_s)
+          unless files.empty?
+            r = [HtmlNamespaceJs[framework][:top]] << "\n"
+            files.each do |path|
+              relative_path = Pathname.new(path).relative_path_from(root)
+              r << html_namespacing_inline_js(framework, relative_path.to_s, path) << "\n"
+            end
+            r.join
+          end
+        end
+
+        #
+        # Return the CSS for the rendered partials, wrapped in a style
+        # tag.
+        #
+        def html_namespacing_style_tag(options = {}, style_tag_attributes = {})
+          css = html_namespacing_styles(options)
+          unless css.blank?
+            attribute_string = style_tag_attributes.map{|k,v| " #{k}=\"#{v}\""}.join
+            "<style type=\"text/css\"#{attribute_string}>#{css}</style>"
+          end
+        end
+
+        #
+        # Return the CSS for the rendered partials.
+        #
+        def html_namespacing_styles(options = {})
+          root = Pathname.new(Rails.stylesheet_root)
+          optional_suffix = Rails.stylesheet_optional_suffix
+          files = html_namespacing_files('sass',
+                                         :format => options[:format],
+                                         :optional_suffix => optional_suffix,
+                                         :root => root.to_s)
+          unless files.empty?
+            r = []
+            files.each do |path|
+              relative_path = Pathname.new(path).relative_path_from(root)
+              r << html_namespacing_inline_css(relative_path.to_s, path)
+            end
+            r.join
+          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(suffix, options={})
+          format = options[:format]
+          (Array === format ? format : [format]).inject([]) do |r, f|
+            r.concat(GlobFu.find(
+              html_namespacing_rendered_paths,
+              :suffix => suffix,
+              :extra_suffix => f && f.to_s,
+              :optional_suffix => options[:optional_suffix],
+              :root => options[: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
+
+        def html_namespacing_inline_css(relative_path, absolute_path)
+          HtmlNamespacing.options[:styles_for].call(relative_path, absolute_path)
+        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)
+
+            return html if HtmlNamespacing::Plugin::Rails.skip_template?(path)
+
+            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,93 @@
+module HtmlNamespacing
+  module Plugin
+    module Sass
+      class << self
+        def install(options = {})
+          options[:prefix] ||= 'views'
+          options[:callback] ||= lambda { |p| HtmlNamespacing::Plugin.default_relative_path_to_namespace(p) }
+          options[:compress] ||= false
+          @options = options
+          Sass_2_2.install(options)
+          HtmlNamespacing.options[:styles_for] = method(:styles_for)
+        end
+
+        attr_reader :options
+
+        def sass_options
+          ::Sass::Plugin.options
+        end
+
+        def styles_for(relative_path, absolute_path)
+          # Assume the file exists. (If it was found by GlobFu, it should.)
+          css_path = File.join(sass_options[:css_location], self.options[:prefix], relative_path.sub(/\.[^\.\/]*\z/, '.css'))
+          File.read(css_path)
+        end
+      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(Sass.sass_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