j-walker 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/plugins/blue-ridge"]
+	path = vendor/plugins/blue-ridge
+	url = http://github.com/relevance/blue-ridge.git

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Henry Hsu
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,91 @@
+# j_walker
+
+A way to run JavaScript based on Rails controller actions. This gives you the freedom to DRY up your JavaScript, or modularize code around REST resources, whatever you can think of!
+
+For example, with `jWalker` you can route a JS function to `WelcomeController#index`. When a user visits that page, jWalker will automatically cross to the correct route via `controller_name`/`action_name` and execute your JS.
+
+With a few quick lines of code, you can get Rails and jWalker working in unison. Read on!
+
+*****
+*****
+
+## Installation
+
+First:
+
+    gem install j-walker
+
+### Rails
+
+    config.gem 'j-walker', :lib => 'j_walker
+
+In the body of your layout (preferably the end):
+
+    <%= render 'shared/j_walker' %>
+
+This is the glue that bonds Rails and jWalker together.
+
+*****
+
+### Javascript
+
+Requires `jQuery`.
+
+#### Sprockets
+
+This project was structured with [Sprockets](http://getsprockets.org) in mind. I'm assuming you have [`sprocket-rails`](http://github.com/sstephenson/sprockets-rails/tree/master) set up.
+
+Just like any sprocketized dependency:
+
+    //= require <j_walker>
+
+in `application.js` (or any other source file preprocessed by Sprockets)
+
+#### Non-sprockets
+
+I can't offer any suggestions other than cloning `src/j_walker.js` into wherever your javascript files are stored and
+adding a `<%= javascript_include_tag 'j_walker' %>` into your `application` layout.
+
+*****
+*****
+
+## Usage
+
+To set up routes (i.e., in `application.js` or any file that's loaded in every single Rails page):
+
+    jWalker.route("welcome", "index", function() {
+      say_hello();
+    })
+
+    jWalker.route("door", "show", function() {
+      say_goodbye();
+    })
+
+Routes should be invoked using:
+
+    jWalker.cross("welcome", "index");
+
+This is exactly what the `j_walker` partial does, except it plugs in the `controller_name` and `action_name`
+
+*****
+*****
+
+## Testing
+
+This thing was developed test-first using [blue-ridge](http://github.com/relevance/blue-ridge). If you want to verify that everything works as expected, make sure the `blue-ridge` submodule is updated and open `spec/javascripts/fixtures/j_walker.html` in Firefox.
+
+*****
+*****
+
+## Future
+
+* Params-based routing (instead of just controller and action)
+* Route aliasing
+* Full-stack testing
+
+*****
+*****
+
+## Copyright
+
+Copyright (c) 2010 Henry Hsu. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "j-walker"
+    gem.summary = %Q{Modularize your *.js, the Rails way. Jaywalk your Rails routes.}
+    gem.description = %Q{A way to run JavaScript based on Rails controller actions. This gives you the freedom to DRY up your JavaScript, or modularize code around REST resources, whatever you can think of!}
+    gem.email = "henry@qlane.com"
+    gem.homepage = "http://github.com/hsume2/j-walker"
+    gem.authors = ["Henry Hsu"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "yard", ">= 0"
+    # gem.add_development_dependency "cucumber", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end
+
+Dir[File.join('tasks', '*.rake')].each { |f| load f }

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/app/views/shared/_j_walker.html.erb

@@ -0,0 +1,5 @@
+<script type="text/javascript" charset="utf-8">
+jQuery(document).ready(function($) {
+  jWalker.cross("<%= controller_name %>", "<%= action_name %>", jQuery);
+});
+</script>

data/j-walker.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{j-walker}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Henry Hsu"]
+  s.date = %q{2010-05-21}
+  s.description = %q{A way to run JavaScript based on Rails controller actions. This gives you the freedom to DRY up your JavaScript, or modularize code around REST resources, whatever you can think of!}
+  s.email = %q{henry@qlane.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     ".gitmodules",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "app/views/shared/_j_walker.html.erb",
+     "j-walker.gemspec",
+     "lib/j_walker.rb",
+     "rails/init.rb",
+     "spec/j_walker_spec.rb",
+     "spec/javascripts/fixtures/j_walker.html",
+     "spec/javascripts/j_walker_spec.js",
+     "spec/javascripts/spec_helper.js",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "src/j_walker.js"
+  ]
+  s.homepage = %q{http://github.com/hsume2/j-walker}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Modularize your *.js, the Rails way. Jaywalk your Rails routes.}
+  s.test_files = [
+    "spec/j_walker_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<yard>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<yard>, [">= 0"])
+  end
+end
+

data/lib/j_walker.rb

@@ -0,0 +1,11 @@
+require 'sprockets'
+
+Sprockets::Environment.class_eval do
+  def initialize_with_j_walker(root, load_path = [])
+    load_path.unshift File.join(File.dirname(__FILE__), %w[.. src])
+    initialize_without_j_walker(root, load_path)
+  end
+  
+  alias_method :initialize_without_j_walker, :initialize unless method_defined?(:initialize_without_j_walker)
+  alias_method :initialize, :initialize_with_j_walker
+end

data/spec/j_walker_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "JWalker" do
+  before do
+    @sec = Sprockets::Secretary.new
+    @j_walker_path = File.expand_path(File.join(File.dirname(__FILE__), %w[.. src]))
+    @env = @sec.environment
+  end
+
+  it "should be added to sprockets load path" do
+    j_walker_pathname = Sprockets::Pathname.new(@env, @j_walker_path)
+
+    @env.load_path.should include(j_walker_pathname)
+  end
+end

data/spec/javascripts/fixtures/j_walker.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+
+<head>
+  <title>jWalker In-Browser Test Runner | JavaScript Testing Results</title>
+  <link rel="stylesheet" href="../../../vendor/plugins/blue-ridge/generators/blue_ridge/templates/screw.css" type="text/css" charset="utf-8" />
+  <script type="text/javascript" src="../../../vendor/plugins/blue-ridge/lib/blue-ridge.js"></script>
+</head>
+
+<body>
+  <!-- Put any HTML fixture elements here. -->
+</body>
+</html>

data/spec/javascripts/j_walker_spec.js

@@ -0,0 +1,124 @@
+require('spec_helper.js');
+require('../../src/j_walker.js');
+
+Screw.Unit(function() {
+  describe("jWalker", function(){
+    before(function(){
+      jWalker.clear();
+    });
+
+    it("exists", function(){ expect(jWalker).to_not(equal, null); });
+
+    describe("#routes", function(){
+      it("should respond", function(){ expect(jWalker).to(respond_to, "routes"); });
+      it("should be object", function(){
+        expect(jWalker.routes()).to(equal, {});
+      });
+    });
+
+    describe("#clear", function(){
+      it("should clear", function(){
+        jWalker.route("taxons", "index");
+        expect(jWalker.routes()).to_not(equal, {});
+
+        jWalker.clear();
+
+        expect(jWalker.routes()).to(equal, {});
+      });
+      it("should respond", function(){ expect(jWalker).to(respond_to, "clear"); });
+    });
+
+    describe("#route", function(){
+      it("should route controller and action to function", function(){
+        var my_func = function() {}
+        jWalker.route("taxons", "index", my_func);
+
+        var routes = jWalker.routes();
+
+        expect(routes).to(equal, {
+          "taxons": {
+            "index": my_func
+          }
+        });
+      });
+
+      it("should route multiple actions for controller", function(){
+        var my_func = function() {}
+        jWalker.route("taxons", "index", my_func);
+        jWalker.route("taxons", "show", my_func);
+
+        var routes = jWalker.routes();
+
+        expect(routes).to(equal, {
+          "taxons": {
+            "index": my_func,
+            "show": my_func
+          }
+        });
+      });
+
+      it("should route default action for controller", function(){
+        var my_func = function() {}
+        jWalker.route("taxons", null, my_func);
+
+        var routes = jWalker.routes();
+
+        expect(routes).to(equal, {
+          "taxons": {
+            "/jWalker.defaultAction/": my_func
+          }
+        });
+      });
+      it("should respond", function(){ expect(jWalker).to(respond_to, "route"); });
+    });
+
+    describe("#cross", function(){
+      it("should invoke controller and action", function(){
+        var received_action;
+        jWalker.route("taxons", "index", function() {
+          received_action = this;
+        });
+
+        jWalker.cross("taxons", "index", jQuery);
+
+        expect(received_action).to(equal, jQuery);
+      });
+
+      it("should invoke default action for controller", function(){
+        var received_action_count = 0;
+        jWalker.route("taxons", null, function() {
+          received_action_count += 1;
+        });
+
+        jWalker.cross("taxons", "index", jQuery);
+        jWalker.cross("taxons", "show", jQuery);
+        jWalker.cross("taxons", null, jQuery);
+        jWalker.cross("other", null, jQuery);
+
+        expect(received_action_count).to(equal, 3);
+      });
+
+      it("should quietly invoke bad params", function(){ // TODO: decide on this
+        jWalker.cross(null, "index", jQuery);
+        jWalker.cross("index", null, jQuery);
+      });
+      it("should respond", function(){ expect(jWalker).to(respond_to, "cross"); });
+    });
+
+    describe("#isRouted", function(){
+      it("should check if not routed", function(){
+        expect(jWalker.isRouted("taxons", "show")).to(equal, false);
+      });
+
+      it("should check if routed", function(){
+        expect(jWalker.isRouted("taxons", "show")).to(equal, false);
+
+        var my_func = function() {}
+        jWalker.route("taxons", "index", my_func);
+
+        expect(jWalker.isRouted("taxons", "index")).to(equal, true);
+      });
+      it("should respond", function(){ expect(jWalker).to(respond_to, "isRouted"); });
+    });
+  });
+});

data/spec/javascripts/spec_helper.js

@@ -0,0 +1,21 @@
+Screw.Matchers["respond_to"] = (function($) {
+  var is_defined = false;
+  var is_func = false;
+  var func;
+
+  return {
+    match: function(method, object) {
+      eval("func = object." + method + ";");
+      is_defined = func != undefined;
+      is_func = typeof(func) == "function";
+      return is_defined && is_func;
+    },
+    failure_message: function(expected, actual, not) {
+      if (!is_defined) {
+        return 'expected ' + $.print(actual) + (not ? ' not' : '') + ' to respond to: ' + expected;
+      } else if (!is_func) {
+        return 'expected ' + $.print(expected) + (not ? ' not' : '') + ' to be a function, got: ' + typeof(func);
+      }
+    }
+  }
+})(jQuery);

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'j_walker'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/src/j_walker.js

@@ -0,0 +1,51 @@
+var jWalker = (function($) {
+  var _routes = {};
+  var _default_action = "/jWalker.defaultAction/"; // An impossible name for a Rails action to have... right?
+
+  return {
+    route: function(controller_name, action_name, function_or_function_name) {
+      var action_name_object = {};
+
+      if (action_name == null)
+        action_name = _default_action;
+
+      action_name_object[action_name] = function_or_function_name;
+
+      var controller_name_object = _routes[controller_name];
+
+      if (controller_name_object == null) {
+        _routes[controller_name] = action_name_object;
+      } else {
+        jQuery.extend(_routes[controller_name], action_name_object);
+      }
+    },
+    cross: function(controller_name, action_name, direct_injection) {
+      var controller = _routes[controller_name];
+      if (controller != null) {
+        var action = controller[action_name];
+
+        if (action == null)
+          action = controller[_default_action];
+
+        if (action != null) {
+          action.call(direct_injection);
+        }
+      }
+    },
+    routes: function() {
+      return _routes;
+    },
+    clear: function() {
+      _routes = {};
+    },
+    isRouted: function(controller_name, action_name) {
+      var controller = _routes[controller_name];
+      if (controller == null)
+        return false;
+      var action = controller[action_name];
+      if (action == null)
+        return false;
+      return true;
+    }
+  }
+})(jQuery);

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: j-walker
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Henry Hsu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
+        version: 1.2.9
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: A way to run JavaScript based on Rails controller actions. This gives you the freedom to DRY up your JavaScript, or modularize code around REST resources, whatever you can think of!
+email: henry@qlane.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- .gitmodules
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- app/views/shared/_j_walker.html.erb
+- j-walker.gemspec
+- lib/j_walker.rb
+- rails/init.rb
+- spec/j_walker_spec.rb
+- spec/javascripts/fixtures/j_walker.html
+- spec/javascripts/j_walker_spec.js
+- spec/javascripts/spec_helper.js
+- spec/spec.opts
+- spec/spec_helper.rb
+- src/j_walker.js
+has_rdoc: true
+homepage: http://github.com/hsume2/j-walker
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Modularize your *.js, the Rails way. Jaywalk your Rails routes.
+test_files: 
+- spec/j_walker_spec.rb
+- spec/spec_helper.rb