adamh-html_namespacing 0.0.5 → 0.1.0

data/Manifest

@@ -8,7 +8,9 @@ ext/html_namespacing/html_namespacing.c
 ext/html_namespacing/html_namespacing_ext.c
 lib/html_namespacing.rb
 lib/html_namespacing/plugin.rb
+lib/html_namespacing/plugin/dom_scan_jquery.compressed.js
 lib/html_namespacing/plugin/rails.rb
+lib/html_namespacing/plugin/dom_scan_jquery.js
 lib/html_namespacing/plugin/sass.rb
 Manifest
 html_namespacing.gemspec

data/README.rdoc

@@ -150,11 +150,11 @@ which is standard Sass and will equate to ".NAMESPACE" in this context.)
 
 Available options to <tt>HtmlNamespacing::Plugin::Rails.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:
+<tt>:path_to_namespace_callback</tt>: Ruby lambda function which accepts a
+relative path (e.g., "foo/bar") and returns an HTML namespacing string
+(e.g., "foo-bar"). The default is:
 
-  lambda { |template| template.path =~ /^([^\.]+)/ && $1.gsub('/', '-') || nil }
+  lambda { |path| path.gsub('/', '-') }
 
 If the callback returns <tt>nil</tt>, HTML namespacing will not be applied.
 
@@ -167,6 +167,23 @@ an <tt>Exception</tt>, an <tt>ActionView::Template</tt>, and an
 If your <tt>:handle_exception_callback</tt> does not raise an exception,
 the template will be rendered as if HtmlNamespacing were not installed.
 
+<tt>:javascript</tt>: If set, enable
+<tt>html_namespacing_javascript_tag()</tt> (see below). You will need to
+<tt>include HtmlNamespacing::Plugin::Rails::Helpers</tt> in your helpers to
+gain access to this method.
+
+<tt>:javascript_root</tt>: Root of namespaced JavaScript files, if you are
+using <tt>html_namespacing_javascript_tag()</tt> (see below).
+
+<tt>:javascript_optional_suffix</tt>: optional suffix for your JavaScript
+files, if you are using <tt>html_namespacing_javascript_tag()</tt>. For
+instance, if <tt>:javascript_optional_suffix</tt> is <tt>'compressed'</tt> and
+you rendered the partial <tt>app/views/foos/_foo.html.haml</tt>, then the
+(presumably minified) file
+<tt>app/javascripts/views/foos/_foo.compressed.js</tt> will be included if it
+exists (otherwise the standard <tt>app/javascripts/views/foos/_foo.js</tt>,
+otherwise nothing).
+
 Available options to <tt>HtmlNamespacing::Plugin::Sass.install</tt> are:
 
 <tt>:prefix</tt> (default <tt>views</tt>): subdirectory of Sass directory for
@@ -229,66 +246,80 @@ reader.
 
 === jQuery Namespacing
 
-Insert the following before all other JavaScript:
+Use the following Rails helper, possibly in your default layout:
+
+<tt>html_namespacing_javascript_tag(:jquery)</tt>
+
+Afterwards, similar to our namespaced CSS framework above, you can easily
+namespace JavaScript behavior:
+
+<tt>app/javascripts/views/foos/_description.js</tt>:
+
+  $NS().find('p').click(function() { alert("Yup, you clicked!"); });
 
-  $(document).ready(function() {
-    $.NS = {};
+You just write code specific to one Rails partial without actually writing the
+partial's name anywhere, and you will not need to rewrite any selectors if you
+rename or move the partial (as long as you rename or move the corresponding
+JavaScript file).
+
+(All namespaced JavaScript partials will be included inline, all in separate
+<tt>jQuery(document).ready()</tt> blocks. Two local variables will be
+available: <tt>NS</tt>, the namespace string, and <tt>$NS()</tt>, a function
+returning a jQuery object containing all elements at the root of the
+namespace.)
+
+=== Caching and JavaScript Namespacing
+
+Caching throws a wrench into operations.
+<tt>html_namespacing_javascript_tag()</tt> works by watching which templates get
+rendered; when reading from the cache, not all templates will have
+<tt>render()</tt> called on them.
+
+The general solution is to cache the list of rendered templates along with the
+data being cached. A new view method, <tt>html_rendering_rendered_paths</tt>,
+returns an Array to be used for this purpose. As a practical example, here is a
+plugin which makes JavaScript namespacing work with
+{cache_advance}[http://github.com/aub/cache_advance]:
+
+  class HtmlNamespacingCachePlugin
+    def self.key_suffix
+      'HTML_NAMESPACING_DATA'
+    end
   
-    var SPLIT_REGEX = /\s+/;
+    def cache_it_options(view)
+      { :view => view }
+    end
   
-    function populate_NS_from_node(node) {
-      var node_stack = [];
-      node_stack.push(node);
+    def before_render(cache_name, cache_key, options)
+      options[:html_namespacing_rendered_paths_length] = paths(options).length
+    end
   
-      while (node_stack.length) {
-        var cur_node = node_stack.pop();
+    def after_render(cache_name, cache_key, data, options)
+      old_length = options[:html_namespacing_rendered_paths_length]
+      new_length = paths(options).length
   
-        // 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);
-          }
-        }
+      delta = paths(options)[old_length..new_length]
+      unless delta.empty?
+        key = cache_key + self.class.key_suffix
+        Rails.cache.write(key, delta)
+      end
+    end
   
-        // "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);
-        }
-      }
-    }
+    def after_read(cache_name, cache_key, data, options)
+      key = cache_key + self.class.key_suffix
+      if delta = Rails.cache.read(key)
+        paths(options).concat(delta)
+      end
+    end
   
-    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!"); });
-  });
+    protected
+  
+    def paths(options)
+      options[:view].html_namespacing_rendered_paths
+    end
+  end
 
-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.
+Other plugins are welcome; I will consider integrating them into this project.
 
 == Tips and Tricks
 
@@ -312,10 +343,10 @@ Or this Sass:
 
 Or the following JavaScript (following the <tt>$NS</tt> example above):
 
-  var $div = $NS.find('div');
+  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:
+Nothing will be selected, because the <tt>div</tt> element is not a child.
+Instead, you need the following CSS:
 
   div.foos-show { font-weight: bold; }
 
@@ -326,7 +357,7 @@ Or this sass:
 
 Or the following JavaScript:
 
-  var $div = $NS.filter('div');
+  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
@@ -338,9 +369,12 @@ HTML namespacing produces plenty of tiny CSS and/or JavaScript files. Best
 practice is to bundle all namespaced files together: by virtue of being
 namespaced, it is safe to concatenate them. (Advanced CSS users should
 be thoughtful about
-"cascading order and specificity":http://www.w3.org/TR/CSS2/cascade.html#cascading-order;
+{cascading order and specificity}[http://www.w3.org/TR/CSS2/cascade.html#cascading-order]
 and anybody bundling JavaScript files together should wrap each with
-<tt>(function() { ... })();</tt> to prevent variable leakage.)
+<tt>(function() { ... })();</tt> to prevent variable leakage.) CSS files can be
+concatenated using a tool such as
+{asset_library}[http://github.com/adamh/asset_library]; JavaScript files are
+concatenated automatically in <tt>html_namespacing_javascript_tag()</tt>.
 
 These and similar strategies should be considered when building an HTML
 namespacing framework.

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rake'
 require 'echoe'
 
-Echoe.new('html_namespacing', '0.0.5') do |p|
+Echoe.new('html_namespacing', '0.1.0') do |p|
   p.author = 'Adam Hooper'
   p.email = 'adam@adamhooper.com'
   p.summary = 'Automatic HTML namespacing'

data/ext/html_namespacing/html_namespacing_ext.c

@@ -61,10 +61,10 @@ html_namespacing_add_namespace_to_html(
 
     Check_Type(ns, T_STRING);
 
-    html_ptr = RSTRING(html)->ptr;
-    html_len = RSTRING(html)->len;
+    html_ptr = RSTRING_PTR(html);
+    html_len = RSTRING_LEN(html);
 
-    ns_ptr = RSTRING(ns)->ptr;
+    ns_ptr = RSTRING_PTR(ns);
 
     rv = add_namespace_to_html_with_length_and_allocation_strategy(
             html_ptr,

data/html_namespacing.gemspec

@@ -2,16 +2,16 @@
 
 Gem::Specification.new do |s|
   s.name = %q{html_namespacing}
-  s.version = "0.0.5"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Adam Hooper"]
-  s.date = %q{2009-07-10}
+  s.date = %q{2009-07-28}
   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.rb", "lib/html_namespacing/plugin/rails.rb", "lib/html_namespacing/plugin/sass.rb", "Manifest", "html_namespacing.gemspec"]
+  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.rb", "lib/html_namespacing/plugin/dom_scan_jquery.compressed.js", "lib/html_namespacing/plugin/rails.rb", "lib/html_namespacing/plugin/dom_scan_jquery.js", "lib/html_namespacing/plugin/sass.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"]

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

@@ -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/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/rails.rb

@@ -3,15 +3,15 @@ module HtmlNamespacing
     module Rails
       def self.install(options = {})
         @options = options
-        install_rails_2_3
+        install_rails_2_3(options)
       end
 
       # Called by ActionView
-      def self.path_to_namespace(template)
-        if func = @options[:template_to_namespace_callback]
-          func.call(template)
+      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(template.path)
+          HtmlNamespacing::Plugin.default_relative_path_to_namespace(relative_path)
         end
       end
 
@@ -23,31 +23,111 @@ module HtmlNamespacing
         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
+
+      module Helpers
+        def html_namespacing_javascript_tag(framework)
+          files = html_namespacing_files
+          unless files.empty?
+            r = "<script type=\"text/javascript\"><!--//--><![CDATA[//><!--\n"
+            r << HtmlNamespaceJs[framework][:top]
+            r << "\n"
+            files.collect do |relative_path, absolute_path|
+              r << html_namespacing_inline_js(framework, relative_path, absolute_path)
+              r << "\n"
+            end
+            r << "//--><!]]></script>"
+          end
+        end
+
+        private
+
+        HtmlNamespaceJs = {
+          :jquery => {
+            :top => File.open(File.join(File.dirname(__FILE__), 'dom_scan_jquery.compressed.js')) { |f| f.read },
+            :each => 'jQuery(function($){var NS=%s,$NS=function(){return $($.NS[NS])};%s});'
+          }
+        }
+
+        def html_namespacing_files
+          suffix = ::HtmlNamespacing::Plugin::Rails.javascript_optional_suffix
+          root = ::HtmlNamespacing::Plugin::Rails.javascript_root
+
+          r = html_namespacing_rendered_paths
+          
+          r.uniq!
+
+          r.collect! do |relative_path|
+            prefix = File.join(root, relative_path)
+            absolute_path = "#{prefix}.js"
+            absolute_path_with_suffix = "#{prefix}.#{suffix}.js" if suffix
+
+            if suffix && File.exist?(absolute_path_with_suffix)
+              [relative_path, absolute_path_with_suffix]
+            elsif File.exist?(absolute_path)
+              [relative_path, absolute_path]
+            else
+              nil
+            end
+          end
+
+          r.compact!
+
+          r
+        end
+
+        def html_namespacing_inline_js(framework, relative_path, absolute_path)
+          namespace = ::HtmlNamespacing::Plugin::Rails.path_to_namespace(relative_path)
+          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_template_with_html_namespacing(*args)
-            s = render_template_without_html_namespacing(*args)
+          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 format == 'html'
-              begin
-                HtmlNamespacing::add_namespace_to_html(s, html_namespace)
-              rescue ArgumentError => e
-                view = args.first
-                HtmlNamespacing::Plugin::Rails.handle_exception(e, self, view)
-                s # unless handle_exception() raised something
-              end
+              add_namespace_to_html(html, view)
             else
-              s
+              html
             end
           end
-          alias_method_chain :render_template, :html_namespacing
+          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(self)
+            HtmlNamespacing::Plugin::Rails.path_to_namespace(path_without_format_and_extension)
           end
-          memoize :html_namespace
         end
       end
     end

data/lib/html_namespacing/plugin.rb

@@ -4,9 +4,7 @@ module HtmlNamespacing
     autoload(:Sass, File.dirname(__FILE__) + '/plugin/sass')
 
     def self.default_relative_path_to_namespace(path)
-      if path =~ /^([^\.]+)/
-        $1.gsub(/\//, '-')
-      end
+      path.gsub(/\//, '-')
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: adamh-html_namespacing
 version: !ruby/object:Gem::Version 
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors: 
 - Adam Hooper
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-10 00:00:00 -07:00
+date: 2009-07-28 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -32,12 +32,15 @@ files:
 - ext/html_namespacing/html_namespacing_ext.c
 - lib/html_namespacing.rb
 - lib/html_namespacing/plugin.rb
+- lib/html_namespacing/plugin/dom_scan_jquery.compressed.js
 - lib/html_namespacing/plugin/rails.rb
+- lib/html_namespacing/plugin/dom_scan_jquery.js
 - lib/html_namespacing/plugin/sass.rb
 - Manifest
 - html_namespacing.gemspec
 has_rdoc: true
 homepage: http://github.com/adamh/html_namespacing
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --line-numbers
@@ -64,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: html_namespacing
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: Automatic HTML namespacing