minispade-rails 0.0.1

data/README.md

@@ -0,0 +1,94 @@
+# minispade-rails  [![Build Status](https://secure.travis-ci.org/keithpitt/minispade-rails.png)](http://travis-ci.org/keithpitt/minispade-rails) [![Dependency Status](https://gemnasium.com/keithpitt/minispade-rails.png)](https://gemnasium.com/keithpitt/minispade-rails)
+
+For large JavaScript applications, you need to include and parse alot of JavaScript just to start showing something on the page. minispade-rails allows you to defer the parsing of parts of your application until you need it.
+
+minispade-rails allows you to compile your javascript files into strings that can be required at runtime using [minispade.js](https://github.com/wycats/minispade)
+
+To understand the problem that minispade-rails solves, read [AMD is Not the Answer](http://tomdale.net/2012/01/amd-is-not-the-answer/) by [@tomdale](http://github.com/tomdale) and [Lazy evaluation of CommonJS modules](http://calendar.perfplanet.com/2011/lazy-evaluation-of-commonjs-modules/) by [Tobie Langel](http://tobielangel.com/)
+
+## Getting started
+
+Add the gem to your application Gemfile:
+
+```ruby
+gem "minispade-rails"
+```
+
+Then replace `require_tree` with `require_spade` and things should _"just work"_, for example:
+
+```javascript
+//= require_tree ./your_application
+// Becomes...
+//= require_spade ./your_application
+```
+
+## What does require_spade do?
+
+Usually, `require_tree` will recursively go through your folder structure, compile the asset, and drop it into the current file. So you get something that looks like this:
+
+```javascript
+// path/to/file_1.js
+(function() {
+   alert('File #1');
+}).call(this)
+// path/to/file_2.js
+(function() {
+   alert('File #2');
+}).call(this)
+// path/to/file_3.js
+(function() {
+   alert('File #3');
+}).call(this)
+```
+
+What `require_spade` will do, is it will compile the asset, and drop the contents into a `minispade.register` call, like so:
+
+```javascript
+minispade.register("path/to/file_1.js", "alert('File #1')");
+minispade.register("path/to/file_2.js", "alert('File #2')");
+minispade.register("path/to/file_3.js", "alert('File #3')");
+```
+
+Then during your application code, as you need access to "file_1", you simply call `minispade.require` like so:
+
+```javascript
+minispade.require("path/to/file_1.js")
+```
+
+And it will execute the file. If you've already called `minispade.require` before on the same file, it will do nothing. Note that calling `minispade.require` is a synchronous function call.
+
+## Configuration
+
+The only configuration option that minispade-rails supports at the moment is the ability to switch on/off using a string to defer the parsing of the JavaScript.
+
+Setting `MinispadeRails::Config.deferred` in an initializer to `true` will cause the following output:
+
+```javascript
+minispade.register("path/to/file_1.js", "alert('File #1')");
+```
+
+Setting it to `false` will give you something like this:
+
+```javascript
+minispade.register("path/to/file_1.js", function() { alert('File #1') });
+```
+
+Sometimes, evaling code is actually slower than just parsing it. If you have a very small app, but want to future-proof the code, then setting `deferred` to false early on, will give you faster loading times.
+
+See http://blog.sproutcore.com/faster-loading-through-eval/ for more details.
+
+## Contributors / Credits
+
+Thanks to the following:
+
+- [@robmonie](http://twitter.com/robmonie) and [@hassox](http://twitter.com/hassox) for suggesting that this gem could be possible.
+- [@wycats](http://github.com/wycats) for writing minispade.js
+- [@tomdale](http://github.com/tomdale) for writing his excellent article on AMD
+
+## Note on Patches/Pull Requests
+
+1. Fork the project.
+2. Make your feature addition or bug fix.
+3. Add tests for it. This is important so I don't break it in a future version unintentionally.
+4. Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+5. Send me a pull request. Bonus points for topic branches.

data/lib/minispade-rails.rb

@@ -0,0 +1,12 @@
+require 'sprockets'
+require 'sprockets/engines'
+
+require "minispade-rails/config"
+require 'minispade-rails/directive_processor'
+require 'minispade-rails/compiler'
+require 'minispade-rails/railtie'
+require "minispade-rails/version"
+
+module MinispadeRails
+  Sprockets.register_engine '.spade', MinispadeRails::Compiler
+end

data/lib/minispade-rails/compiler.rb

@@ -0,0 +1,28 @@
+require 'tilt/template'
+
+module MinispadeRails
+
+  # = Sprockets engine for Minispade templates
+  class Compiler < Tilt::Template
+
+    def self.default_mime_type
+      'application/javascript'
+    end
+
+    def initialize_engine
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      if MinispadeRails::Config.deferred
+        "minispade.register(\"#{scope.logical_path}\", #{data.inspect});\n"
+      else
+        "minispade.register(\"#{scope.logical_path}\", function() { #{data} });\n"
+      end
+    end
+
+  end
+
+end

data/lib/minispade-rails/config.rb

@@ -0,0 +1,15 @@
+module MinispadeRails
+
+  module Config
+
+    def self.deferred=(val)
+      @deferred = val
+    end
+
+    def self.deferred
+      @deferred
+    end
+
+  end
+
+end

data/lib/minispade-rails/directive_processor.rb

@@ -0,0 +1,56 @@
+module MinispadeRails
+  class DirectiveProcessor < Sprockets::DirectiveProcessor
+
+    def process_source
+      super
+
+      if @spades
+        output = @spades.map do |spade|
+          # Create a custom context for the spade require
+          attributes = context.environment.attributes_for(spade)
+          spade_context = context.environment.context_class.new(context.environment, attributes.logical_path, spade)
+
+          # Add the minispade custom processor as the last item
+          processors = [ *attributes.processors, MinispadeRails::Compiler ]
+
+          # Remove the directive processors for the individual file
+          processors.delete(Sprockets::DirectiveProcessor)
+
+          # Evaluate the spade
+          spade_context.evaluate(spade, :processors => processors)
+        end
+
+        # Prepend the requires
+        @result = output.join("") + @result
+      end
+
+      @result
+    end
+
+    def process_require_spade_directive(path = ".")
+      if relative?(path)
+        root = pathname.dirname.join(path).expand_path
+
+        unless (stats = stat(root)) && stats.directory?
+          raise ArgumentError, "require_spade argument must be a directory"
+        end
+
+        context.depend_on(root)
+
+        @spades ||= []
+        each_entry(root) do |pathname|
+          if context.asset_requirable?(pathname)
+            context.depend_on pathname
+            @spades << pathname
+          end
+        end
+      else
+        # The path must be relative and start with a `./`.
+        raise ArgumentError, "require_spade argument must be a relative path"
+      end
+
+      nil
+    end
+
+  end
+end

data/lib/minispade-rails/railtie.rb

@@ -0,0 +1,9 @@
+module MinispadeRails
+  class Railtie < Rails::Engine
+
+    initializer :setup_minispade do |app|
+      app.assets.register_preprocessor 'application/javascript', MinispadeRails::DirectiveProcessor
+    end
+
+  end
+end

data/lib/minispade-rails/version.rb

@@ -0,0 +1,3 @@
+module MinispadeRails
+  VERSION = "0.0.1"
+end

data/vendor/assets/javascripts/minispade.js

@@ -0,0 +1,51 @@
+/*jshint evil:true*/
+
+if (typeof document !== "undefined") {
+  (function() {
+    minispade = {
+      root: null,
+      modules: {},
+      loaded: {},
+
+      globalEval: function(data) {
+        if ( data ) {
+          // We use execScript on Internet Explorer
+          // We use an anonymous function so that context is window
+          // rather than jQuery in Firefox
+          ( window.execScript || function( data ) {
+            window[ "eval" ].call( window, data );
+          } )( data );
+        }
+      },
+
+      require: function(name) {
+        var loaded = minispade.loaded[name];
+        var mod = minispade.modules[name];
+
+        if (!loaded) {
+          if (mod) {
+            minispade.loaded[name] = true;
+
+            if (typeof mod === "string") {
+              this.globalEval(mod);
+            } else {
+              mod();
+            }
+          } else {
+            if (minispade.root && name.substr(0,minispade.root.length) !== minispade.root) {
+              return minispade.require(minispade.root+name);
+            } else {
+              throw "The module '" + name + "' could not be found";
+            }
+          }
+        }
+
+        return loaded;
+      },
+
+      register: function(name, callback) {
+        minispade.modules[name] = callback;
+      }
+    };
+  })();
+}

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: minispade-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Keith Pitt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70146629093640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: *70146629093640
+description: 
+email:
+- me@keithpitt.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/minispade-rails/compiler.rb
+- lib/minispade-rails/config.rb
+- lib/minispade-rails/directive_processor.rb
+- lib/minispade-rails/railtie.rb
+- lib/minispade-rails/version.rb
+- lib/minispade-rails.rb
+- vendor/assets/javascripts/minispade.js
+homepage: https://github.com/keithpitt/minispade-rails
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 739185026345522521
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 739185026345522521
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Compile your javascript into minispade modules using the asset pipeline
+test_files: []