javascript_features 1.0.0

data/lib/javascript_features/compiler.rb

@@ -0,0 +1,28 @@
+require 'jsmin'
+
+module JavascriptFeatures
+  module Compiler
+    def self.compile(options = {})
+      defaults = {:minify => true, :package => 'main'}
+      options = defaults.merge(options)
+
+      files = files_for_package(options[:package])
+      compiled = files.map{|file| File.read(file) }.join("\n")
+      minified = JSMin.minify(compiled) if options[:minify]
+
+      minified || compiled
+    end
+
+    def self.package_modified_time(package = 'main')
+      files_for_package(package).map{|f| File.new(f).mtime }.max
+    end
+
+  private
+    def self.files_for_package(package)
+      lib_files = Dir.glob(Rails.root + 'public/javascripts/lib/**/*.js')
+      init_files = [File.join(File.dirname(__FILE__), *%w[ .. .. assets init.js ])]
+      feature_files = Dir.glob(Rails.root + "public/javascripts/#{package}/**/*.js")
+      lib_files + init_files + feature_files
+    end
+  end
+end

data/lib/javascript_features/helper.rb

@@ -0,0 +1,33 @@
+module JavascriptFeatures
+  module Helper
+
+    def self.included(controller)
+      controller.helper_method :use_javascript_for, :use_javascript_for?, :javascript_feature_classes, :include_javascript_features if controller.respond_to? :helper_method
+    end
+
+    def use_javascript_for(*features)
+      @javascript_features ||= []
+      @javascript_features += features.map{|f| f.to_s.downcase }
+      response.headers['X-JavascriptFeatures-Init'] = @javascript_features.uniq.join(' ') if request && request.xhr?
+    end
+
+    def use_javascript_for?(feature)
+      @javascript_features.include?(feature.to_s.downcase)
+    end
+
+    def javascript_feature_classes
+      (@javascript_features || []).uniq.map{ |feature| "with-js-#{feature}" }.join(" ")
+    end
+
+    def include_javascript_features(package = 'main')
+      query = Compiler.package_modified_time(package).to_i
+      tag = %Q{<script type="text/javascript" src="/javascripts/packaged/#{package}.js?#{query}"></script>}
+      if tag.respond_to?(:html_safe)
+        tag.html_safe
+      else
+        tag
+      end
+    end
+
+  end
+end

data/lib/javascript_features/test_case/servlet.rb

@@ -0,0 +1,32 @@
+module JavascriptFeatures
+  class TestCase
+    class Servlet < ::WEBrick::HTTPServlet::AbstractServlet
+      def initialize(server, pages)
+        super server
+        @pages = pages
+      end
+
+      def service(req, res)
+        page = @pages[req.path]
+        if page
+          res.status = 200
+          res['Content-Type'] = 'text/html'
+          if page.is_a?(Hash)
+            page[:headers].each{ |k,v| res[k] = v }
+            res.body = page[:body]
+          else
+            res.body = page
+          end
+        elsif req.path =~ %r[^/javascripts/packaged/([^/]+).js$]
+          res.status = 200
+          res['Content-Type'] = 'text/javascript'
+          res.body = JavascriptFeatures::Compiler.compile(:package => $1)
+        else
+          res.status = 404
+          res['Content-Type'] = 'text/plain'
+          res.body = 'Not found'
+        end
+      end
+    end
+  end
+end

data/lib/javascript_features/test_case.rb

@@ -0,0 +1,91 @@
+require 'active_support/test_case'
+require 'harmony'
+
+module JavascriptFeatures
+  class TestCase < ::ActiveSupport::TestCase
+    extend JavascriptFeatures::Helper
+
+    autoload :Servlet, 'javascript_features/test_case/servlet'
+
+    class << self
+      def request
+        nil
+      end
+
+      def uses_feature_package(package)
+        @feature_package = package
+      end
+
+      def feature_package
+        @feature_package ||= 'main'
+      end
+
+      def tests_feature(*names)
+        @feature_names = names
+      end
+
+      def feature_names
+        @feature_names ||= [self.name.downcase.sub(/test$/, '')]
+      end
+
+      def stubs_http_request(url, options)
+        @server_pages = server_pages.merge(url => options)
+      end
+
+      def server_pages
+        @server_pages ||= {}
+      end
+
+      def uses_html(&block)
+        define_method(:setup) do
+          self.class.feature_names.each{ |f| self.class.use_javascript_for f }
+          @html = yield.strip
+
+          server_config = {:BindAddress => '0.0.0.0', :Port => 8076, :AccessLog => [], :Logger => WEBrick::Log::new('/dev/null', 7)}
+          @server = ::WEBrick::HTTPServer.new(server_config)
+          pages = self.class.server_pages.merge(
+                    '/index.html' => @html,
+                    '/jquery.js' => File.read(File.expand_path('../../../assets/jquery.js', __FILE__))
+                  )
+          @server.mount('/', JavascriptFeatures::TestCase::Servlet, pages)
+          Thread.new{ @server.start }
+
+          @page = Harmony::Page.fetch("http://#{server_config[:BindAddress]}:#{server_config[:Port]}/index.html")
+          Harmony::Page::Window::BASE_RUNTIME.wait
+        end
+
+        define_method(:teardown) do
+          @server.shutdown
+        end
+      end
+
+      def uses_html_body
+        uses_html do
+          %%
+            <!DOCTYPE html>
+            <html lang="en">
+              <head>
+                <title>Test page</title>
+              </head>
+              <body class="#{javascript_feature_classes}">
+                #{yield.strip}
+
+                <script src='/jquery.js'></script>
+                #{include_javascript_features(feature_package)}
+              </body>
+            </html>
+          %
+        end
+      end
+    end
+
+    def execute_js(*args)
+      @page.execute_js(*args)
+    end
+
+    def assert_selector_count(expected_count, selector)
+      real_count = execute_js("jQuery(#{selector.to_json}).length")
+      assert_equal expected_count, real_count, "Expected #{expected_count} elements matching selector #{selector}, found #{real_count}"
+    end
+  end
+end

data/lib/javascript_features.rb

@@ -0,0 +1,7 @@
+module JavascriptFeatures
+  autoload :Compiler, 'javascript_features/compiler'
+  autoload :Helper, 'javascript_features/helper'
+  autoload :TestCase, 'javascript_features/test_case'
+end
+
+ActionController::Base.send(:include, JavascriptFeatures::Helper) if defined?(ActionController)

data/lib/rack/javascript_features.rb

@@ -0,0 +1,48 @@
+require 'javascript_features'
+
+module Rack
+  class JavascriptFeatures
+
+    DEFAULT_OPTIONS = {:minify => true}
+
+    def initialize(app, options = {})
+      @app = app
+      @options = DEFAULT_OPTIONS.merge(options)
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      if package = package_for_path(request.path)
+        etag = package_etag(package)
+        if etag == env['HTTP_IF_NONE_MATCH']
+          [304, {}, []]
+        else
+          javascript = package_javascript(package)
+          [200, {"Content-Type" => "text/javascript", "Cache-Control" => "private", "ETag" => etag}, [javascript]]
+        end
+      else
+        @app.call(env)
+      end
+    end
+
+  private
+
+    def package_for_path(path)
+      relevant_url = path =~ %r{javascripts/packaged/([^/]+)\.js}
+      package_name = relevant_url && $1
+      real_package = package_name && ::File.exists?(::File.join(Rails.root, 'public', 'javascripts', package_name))
+      real_package && package_name
+    end
+
+    def package_etag(package_name)
+      mtime = ::JavascriptFeatures::Compiler.package_modified_time(package_name)
+      etag = Digest::MD5.hexdigest("#{package_name}/#{mtime.to_i}")
+    end
+
+    def package_javascript(package_name)
+      ::JavascriptFeatures::Compiler.compile(:package => package_name, :minify => @options[:minify])
+    end
+
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'javascript_features'

data/test/compiler_test.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'jsmin'
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+class CompilerTest < Test::Unit::TestCase
+
+  def setup
+    common_files = [
+      File.join(Rails.root, *%w[ public javascripts lib jquery_plugin.js ]),
+      File.join(File.dirname(__FILE__), *%w[ .. assets init.js ])
+    ]
+
+    @main_files = common_files + [ File.join(Rails.root, *%w[ public javascripts main my_feature.js ]) ]
+    @alternative_files = common_files + [ File.join(Rails.root, *%w[ public javascripts alternative alternative.js ]) ]
+  end
+
+  context 'compiling the main JavaScript package' do
+    should 'concatenate the relevant files in the correct order and minify the result' do
+      assert_equal JSMin.minify(@main_files.map{|f| File.read(f) }.join("\n")), JavascriptFeatures::Compiler.compile
+    end
+
+    should 'optionally disable minification' do
+      assert_equal @main_files.map{|f| File.read(f) }.join("\n"), JavascriptFeatures::Compiler.compile(:minify => false)
+    end
+  end
+
+  context 'compiling the alternative JavaScript package' do
+    should 'take feature files from the /alternative directory instead of /main' do
+      assert_equal JSMin.minify(@alternative_files.map{|f| File.read(f) }.join("\n")), JavascriptFeatures::Compiler.compile(:package => 'alternative')
+    end
+  end
+
+end

data/test/fixtures/public/javascripts/alternative/alternative.js

@@ -0,0 +1,5 @@
+Features.alternative = {
+  init: function() {
+    alert("Hello, world");
+  }
+};

data/test/fixtures/public/javascripts/javascript_test/disabled_feature.js

@@ -0,0 +1,7 @@
+Features.disabled_feature = {
+  init: function() {
+    var div = document.createElement("div");
+    div.className = "disabled_feature";
+    document.body.appendChild(div);
+  }
+}

data/test/fixtures/public/javascripts/javascript_test/enabled_feature.js

@@ -0,0 +1,7 @@
+Features.enabled_feature = {
+  init: function() {
+    var div = document.createElement("div");
+    div.className = "enabled_feature";
+    document.body.appendChild(div);
+  }
+}

data/test/fixtures/public/javascripts/javascript_test/global_feature.js

@@ -0,0 +1,7 @@
+Features.global_feature = {
+  global_init: function() {
+    var div = document.createElement("div");
+    div.className = "global_feature";
+    document.body.appendChild(div);
+  }
+}

data/test/fixtures/public/javascripts/lib/jquery_plugin.js

@@ -0,0 +1 @@
+jQuery.plugin = {};

data/test/fixtures/public/javascripts/main/my_feature.js

@@ -0,0 +1,5 @@
+Features.MyFeature = {
+  init: function($) {
+    alert("Initialise my feature!");
+  }
+};

data/test/fixtures/public/javascripts/xhr_test/global_load.js

@@ -0,0 +1,5 @@
+Features.global_load = {
+  global_init: function(context) {
+    context.find(".xhr-response").append("<span class=\"touched-by-global-init\"></span>");
+  }
+}

data/test/fixtures/public/javascripts/xhr_test/load.js

@@ -0,0 +1,5 @@
+Features.load = {
+  init: function(context) {
+    context.find(".xhr-response").addClass("touched-by-load");
+  }
+}

data/test/fixtures/public/javascripts/xhr_test/xhr.js

@@ -0,0 +1,11 @@
+Features.xhr = {
+  init: function() {
+    var xhr = jQuery.ajax({
+      url: "/xhr",
+      context: $(".xhr-target"),
+      success: function(data) {
+        $(".xhr-target").html(data);
+      }
+    });
+  }
+};

data/test/helper_test.rb

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+class HelperTest < Test::Unit::TestCase
+  include JavascriptFeatures::Helper
+
+  class TestRequest
+    def initialize(options)
+      @xhr = options[:xhr]
+    end
+
+    def xhr?
+      @xhr
+    end
+
+    def xml_http_request?
+      @xhr
+    end
+  end
+
+  class TestResponse
+    attr_accessor :headers
+    def initialize
+      @headers = {'Content-Type' => 'text/html'}
+    end
+  end
+
+  context "when a JavaScript feature is enabled during a normal request" do
+    setup do
+      self.request = TestRequest.new(:xhr => false)
+      self.response = TestResponse.new
+      use_javascript_for "something"
+    end
+
+    should "set the corresponding body class" do
+      assert_equal "with-js-something", javascript_feature_classes
+    end
+
+    should 'not modify the headers' do
+      assert_equal({'Content-Type' => 'text/html'}, response.headers)
+    end
+
+    should 'be able to check that it is enabled' do
+      assert use_javascript_for?('something')
+      assert !use_javascript_for?('something-else')
+    end
+  end
+
+  context 'when a JavaScript feature is enabled during an XHR request' do
+    setup do
+      self.request = TestRequest.new(:xhr => true)
+      self.response = TestResponse.new
+      use_javascript_for "something"
+      use_javascript_for "something_else"
+    end
+
+    should 'modify the headers' do
+      assert_equal({'Content-Type' => 'text/html', 'X-JavascriptFeatures-Init' => 'something something_else'}, response.headers)
+    end
+  end
+
+  context "when the same feature is enabled multiple times" do
+    setup do
+      use_javascript_for "something"
+      use_javascript_for "something-else"
+      use_javascript_for "something"
+    end
+    should "only include each class once" do
+      assert_equal "with-js-something with-js-something-else", javascript_feature_classes
+    end
+  end
+
+  context "when no features have been enabled" do
+    should "not produce any classes" do
+      assert_equal "", javascript_feature_classes
+    end
+  end
+
+  should "allow to pass several features at one call" do
+    use_javascript_for "something", "something-else"
+    assert_equal "with-js-something with-js-something-else", javascript_feature_classes
+  end
+
+  context 'including the packaged JavaScript' do
+    setup{ @script_tag = include_javascript_features }
+    should 'write a script tag containing the correct URL' do
+      assert_match %r{/javascripts/packaged/main\.js}, @script_tag
+    end
+  end
+
+  context 'including an alternative JavaScript package' do
+    setup{ @script_tag = include_javascript_features(:alternative) }
+    should 'write a script tag containing the correct URL' do
+      assert_match %r{/javascripts/packaged/alternative\.js}, @script_tag
+    end
+  end
+
+  context 'including the packaged JavaScript after one of the files has been modified' do
+    setup do
+      @before_modified = include_javascript_features
+      FileUtils.touch File.join(Rails.root, %w[ public javascripts main my_feature.js ])
+      @after_modified = include_javascript_features
+    end
+
+    should 'include different query strings to avoid caching' do
+      assert @before_modified != @after_modified, "Expected #{@before_modified.inspect} and #{@after_modified.inspect} to be different"
+    end
+  end
+end

data/test/javascript_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+require 'harmony'
+require 'webrick'
+
+class JavascriptTest < JavascriptFeatures::TestCase
+  uses_html_body{ '<h1>Test page</h1>' }
+  uses_feature_package :javascript_test
+  tests_feature :enabled_feature
+
+  should 'initialise the enabled feature' do
+    assert_selector_count 1, 'div.enabled_feature'
+  end
+
+  should 'not initialise the disabled feature' do
+    assert_selector_count 0, 'div.disabled_feature'
+  end
+
+  should 'initialise the global feature' do
+    assert_selector_count 1, 'div.global_feature'
+  end
+
+end

data/test/jslint_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+require 'jslint'
+
+class JslintTest < Test::Unit::TestCase
+
+  context 'all built-in JavaScript' do
+    should 'pass JSLint' do
+      paths = File.join(File.dirname(__FILE__), '../assets/**/*.js')
+      exclude = File.join(File.dirname(__FILE__), '../assets/jquery.js')
+      JSLint::Lint.new(:paths => paths, :exclude_paths => exclude).run
+    end
+  end
+
+end

data/test/rack_test.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+require 'rack/test'
+require 'rack/javascript_features'
+
+class RackTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    app = lambda{|env| [200, {"Content-Type" => "text/plain"}, ["all is well"]]}
+    Rack::JavascriptFeatures.new(app)
+  end
+
+  context "when JavaScript isn't being requested" do
+    setup do
+      get '/some/other/path'
+    end
+
+    should 'delegate to the app' do
+      assert_equal 200, last_response.status
+      assert_equal 'all is well', last_response.body
+    end
+  end
+
+  context "when the main JavaScript package is being requested" do
+    setup do
+      get '/javascripts/packaged/main.js'
+    end
+
+    should 'respond with the compiled JavaScript' do
+      assert_equal 200, last_response.status
+      assert_equal JavascriptFeatures::Compiler.compile, last_response.body
+    end
+  end
+
+  context "when the main JavaScript package is being requested with a valid ETag" do
+    setup do
+      get '/javascripts/packaged/main.js'
+      assert_not_nil etag = last_response.headers['ETag'], 'Expected an ETag'
+      get '/javascripts/packaged/main.js', {}, {'HTTP_IF_NONE_MATCH' => etag}
+    end
+
+    should "respond with 'not modified'" do
+      assert_equal 304, last_response.status
+    end
+  end
+
+  context "when the main JavaScript package is being requested with a valid ETag" do
+    setup do
+      get '/javascripts/package/main.js', {}, {'HTTP_IF_NONE_MATCH' => '12345'}
+    end
+
+    should "respond with some JavaScript" do
+      assert_equal 200, last_response.status
+    end
+  end
+
+  context "when an alternative JavaScript package is being requested" do
+    setup do
+      get '/javascripts/packaged/alternative.js'
+    end
+
+    should 'respond with the compiled JavaScript' do
+      assert_equal 200, last_response.status
+      assert_equal JavascriptFeatures::Compiler.compile(:package => 'alternative'), last_response.body
+    end
+  end
+
+  context "when an unknown JavaScript package is being requested" do
+    setup do
+      get '/javascripts/packaged/does_not_exist.js'
+    end
+
+    should 'delegate to the app' do
+      assert_equal 200, last_response.status
+      assert_equal 'all is well', last_response.body
+    end
+  end
+
+end

data/test/test_case_test.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+
+class TestCaseTest < JavascriptFeatures::TestCase
+  uses_html_body{ '<div class="foo"></div>' }
+
+  should 'have some HTML' do
+    assert_not_nil @html
+  end
+
+  should 'include the main JS package' do
+    assert_match %r{<script [^>]*src="/javascripts/packaged/main\.js(\?\d+)?"}, @html
+  end
+
+  should 'take the enabled feature name from the class name' do
+    assert_match %r{<body class="with-js-testcase">}, @html
+  end
+
+  should 'create a Harmony::Page for the HTML' do
+    assert_not_nil @page
+  end
+
+  should 'load the JavaScript in the Harmony::Page' do
+    assert_equal 'object', @page.execute_js('typeof Features')
+  end
+
+  should 'provide a method of executing JS without knowing about the @page variable' do
+    assert_equal 'object', execute_js('typeof Features')
+  end
+
+  should 'provide a custom assertion for counting DOM nodes' do
+    assert_nothing_raised{ assert_selector_count(1, 'div.foo') }
+    assert_raises(Test::Unit::AssertionFailedError){ assert_selector_count(2, 'div.foo') }
+  end
+
+end
+
+class CustomFeatureTest < JavascriptFeatures::TestCase
+  uses_html_body{ '<div class="foo"></div>' }
+  tests_feature 'foo'
+
+  should 'use the custom feature instead of deriving the feature from the class name' do
+    assert_match %r{<body class="with-js-foo">}, @html
+  end
+end
+
+class MultipleFeatureTest < JavascriptFeatures::TestCase
+  uses_html_body{ '<div class="foo"></div>' }
+  tests_feature 'foo', 'bar', 'baz'
+
+  should 'use all of the custom features' do
+    ['foo', 'bar', 'baz'].each do |feature|
+      assert execute_js("jQuery('body').hasClass('with-js-#{feature}')")
+    end
+  end
+
+  should 'not use the feature name derived from the class name' do
+    assert execute_js('!jQuery("body").hasClass("with-js-mulitplefeature")')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'yaml'
+require 'bundler'
+Bundler.require(:default, :development)
+
+class Test::Unit::TestCase
+  attr_accessor :request, :response
+end
+
+module Rails
+  def self.root
+    File.join(File.dirname(__FILE__), 'fixtures') + '/'
+  end
+
+  def self.backtrace_cleaner
+    ActiveSupport::BacktraceCleaner.new
+  end
+end

data/test/xhr_test.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), *%w[test_helper])
+require 'harmony'
+
+class XhrTest < JavascriptFeatures::TestCase
+
+  uses_html_body{%%
+    <h1>Test page</h1>
+    <div class="xhr-target"></div>
+    <div class="unrelated xhr-response">Unrelated</div>
+  %}
+
+  uses_feature_package :xhr_test
+
+  stubs_http_request('/xhr', :body => '<p class="real xhr-response">Hello, world</p>', :headers => {'X-JavascriptFeatures-Init' => 'load'})
+
+  should 'complete the XHR request' do
+    assert_selector_count 1, '.real.xhr-response'
+  end
+
+  should 'initialise the feature required by the XHR content' do
+    assert_match(/touched-by-load/, execute_js('jQuery(".real.xhr-response").attr("class")'))
+  end
+
+  should 'limit the scope of the feature required by the XHR content to the XHR content itself' do
+    assert_no_match(/touched-by-load/, execute_js('jQuery(".unrelated.xhr-response").attr("class")'))
+  end
+
+  should 're-run global initialisation code when the XHR completes, limited to the scope of the XHR content' do
+    assert_selector_count 1, '.real.xhr-response .touched-by-global-init'
+    assert_selector_count 1, '.unrelated.xhr-response .touched-by-global-init'
+  end
+
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification 
+name: javascript_features
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- George Brocklehurst
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-15 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jsmin
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: harmony
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: redgreen
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: jslint_on_rails
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: 
+email: george.brocklehurst@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- test/compiler_test.rb
+- test/fixtures/public/javascripts/alternative/alternative.js
+- test/fixtures/public/javascripts/javascript_test/disabled_feature.js
+- test/fixtures/public/javascripts/javascript_test/enabled_feature.js
+- test/fixtures/public/javascripts/javascript_test/global_feature.js
+- test/fixtures/public/javascripts/lib/jquery_plugin.js
+- test/fixtures/public/javascripts/main/my_feature.js
+- test/fixtures/public/javascripts/xhr_test/global_load.js
+- test/fixtures/public/javascripts/xhr_test/load.js
+- test/fixtures/public/javascripts/xhr_test/xhr.js
+- test/helper_test.rb
+- test/javascript_test.rb
+- test/jslint_test.rb
+- test/rack_test.rb
+- test/test_case_test.rb
+- test/test_helper.rb
+- test/xhr_test.rb
+- lib/javascript_features/compiler.rb
+- lib/javascript_features/helper.rb
+- lib/javascript_features/test_case/servlet.rb
+- lib/javascript_features/test_case.rb
+- lib/javascript_features.rb
+- lib/rack/javascript_features.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://georgebrock.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Structured, unobtrusive JavaScript for Rails applications
+test_files: []
+