rails-js-routes 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1cebb23dcc0242dba9c4c8de6a37f79737ef6199
+  data.tar.gz: f5437c7549d77798db7f435ada04920c62a58b7c
+SHA512:
+  metadata.gz: 0fccbf3b17c3c6c9f9517d618bbc2bba4a9dd96e34c9bdc220b359e4c0baa4d859f36081972f611e9a6c42c5298055e2c6568cfa08c4283948ad7e73c49a9ec3
+  data.tar.gz: 39a428a03ef6a41eaaf1a3e717e6e27bf3e772684b6dd3fd9664e7957a1fe07c9f0fbd696397ef287d25720ee0a13aed6c73466fc0f6ca7b54ceaeedfa94974c

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+test/dummy/tmp/
+test/dummy/log/
+coverage
+.DS_STORE
+test/dummy/db

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in penis.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/Gemfile.lock

@@ -0,0 +1,127 @@
+PATH
+  remote: .
+  specs:
+    rails-js-routes (0.2.0)
+      rails (~> 4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionmailer (4.1.8)
+      actionpack (= 4.1.8)
+      actionview (= 4.1.8)
+      mail (~> 2.5, >= 2.5.4)
+    actionpack (4.1.8)
+      actionview (= 4.1.8)
+      activesupport (= 4.1.8)
+      rack (~> 1.5.2)
+      rack-test (~> 0.6.2)
+    actionview (4.1.8)
+      activesupport (= 4.1.8)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+    activemodel (4.1.8)
+      activesupport (= 4.1.8)
+      builder (~> 3.1)
+    activerecord (4.1.8)
+      activemodel (= 4.1.8)
+      activesupport (= 4.1.8)
+      arel (~> 5.0.0)
+    activesupport (4.1.8)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    arel (5.0.1.20140414130214)
+    builder (3.2.2)
+    capybara (2.4.4)
+      mime-types (>= 1.16)
+      nokogiri (>= 1.3.3)
+      rack (>= 1.0.0)
+      rack-test (>= 0.5.4)
+      xpath (~> 2.0)
+    cliver (0.3.2)
+    coveralls (0.7.2)
+      multi_json (~> 1.3)
+      rest-client (= 1.6.7)
+      simplecov (>= 0.7)
+      term-ansicolor (= 1.2.2)
+      thor (= 0.18.1)
+    docile (1.1.5)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.11)
+    json (1.8.1)
+    mail (2.6.3)
+      mime-types (>= 1.16, < 3)
+    mime-types (2.4.3)
+    mini_portile (0.6.1)
+    minitest (5.4.3)
+    multi_json (1.10.1)
+    nokogiri (1.6.4.1)
+      mini_portile (~> 0.6.0)
+    poltergeist (1.5.1)
+      capybara (~> 2.1)
+      cliver (~> 0.3.1)
+      multi_json (~> 1.0)
+      websocket-driver (>= 0.2.0)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (4.1.8)
+      actionmailer (= 4.1.8)
+      actionpack (= 4.1.8)
+      actionview (= 4.1.8)
+      activemodel (= 4.1.8)
+      activerecord (= 4.1.8)
+      activesupport (= 4.1.8)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.1.8)
+      sprockets-rails (~> 2.0)
+    railties (4.1.8)
+      actionpack (= 4.1.8)
+      activesupport (= 4.1.8)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.3.2)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    simplecov (0.9.1)
+      docile (~> 1.1.0)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    sprockets (2.12.3)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sprockets-rails (2.2.0)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (>= 2.8, < 4.0)
+    sqlite3 (1.3.10)
+    teaspoon (0.8.0)
+      railties (>= 3.2.5, < 5)
+    term-ansicolor (1.2.2)
+      tins (~> 0.8)
+    thor (0.18.1)
+    thread_safe (0.3.4)
+    tilt (1.4.1)
+    tins (0.13.2)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    websocket-driver (0.4.0)
+    xpath (2.0.0)
+      nokogiri (~> 1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  coveralls (~> 0.7)
+  poltergeist (~> 1.5)
+  rails-js-routes!
+  sqlite3 (~> 1.3)
+  teaspoon (~> 0.8)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Finn-Lennart Heemeyer
+
+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.md

@@ -0,0 +1,161 @@
+rails-js-routes
+========
+[![Build Status](https://travis-ci.org/tonekk/rails-js-routes.svg)](https://travis-ci.org/tonekk/rails-js-routes)
+[![Dependency Status](https://gemnasium.com/tonekk/rails-js-routes.svg)](https://gemnasium.com/tonekk/rails-js-routes)
+[![Gem Version](http://img.shields.io/gem/v/rails-js-routes.svg)](https://rubygems.org/gems/rails-js-routes)
+[![License](http://img.shields.io/:license-mit-blue.svg)](http://tonekk.mit-license.org)
+
+
+[Check out the blog post!](http://finn.heemeyer.net/2014/10/18/rails-js/)
+
+NOTICE: We decided to rename this gem from ``rails-js`` to ``rails-js-routes`` as it was nearly impossible to find.
+The name may be somewhat long, but for us it describes the functionality appropriate.
+
+
+I worked on several Rails projects and there were many cases when it felt overkill to use a framework like ``Angular`` or ``Ember``, because javascript was only needed in some parts of the application.
+But by not using these frameworks I had to think of a way to *structure* the code by myself.
+I came up with the conclusion to organize the javascript code like the ruby code is organized, that means: __Split up in controllers, which are split up in actions.__
+
+## How it works
+* In ``rails-js-routes`` we are able to define ``controllers``, as well as ``helpers``.
+* Controllers have ``actions`` which are executed when the matching rails action is executed.
+* Helpers should be clear. Pretty much like the rails helpers. There are helper per controller and global helpers.
+* The gem also provides a ``view helper`` to use in your layouts, which passes the routing information to ``rails-js-routes``.
+
+#### You start by creating an app.
+
+```js
+//= require routes
+
+/*
+ * app/assets/javascripts/application.js
+ */
+
+Rails.app({
+ // Define global helpers here
+ helper: function() {
+ }
+},
+// Put in initial data
+{
+  foo: 'bar'
+},
+// A function that is executed before every action
+function() {
+ console.log('beforeAll() executed');
+});
+
+```
+#### Create controllers accordingly.
+
+```js
+
+/*
+ * app/assets/javascripts/controllers/users.js
+ */
+
+Rails.controller('users', {
+  // actions here
+  new: function(h) {
+    // execute helper
+    h.awesomeHelper();
+  },
+
+  index: function(h) {
+    // Do the same as in new()
+    this.index(h);
+  }
+},
+{
+  // helpers here
+  awesomeHelper: function() {
+  }
+});
+
+```
+
+
+#### Use code from other controllers.
+```js
+
+/*
+ * app/assets/javascripts/controllers/admin/users.js
+ */
+
+Rails.controller('admin/users', {
+  new: function(h) {
+    // Execute action of foreign controller
+    R.action('users#new');
+  },
+
+  index: function(h) {
+    // Execute foreign helper with arguments
+    R.helper('users', 'awesomeHelper', 1, 2, 3);
+
+    // Execute global helper with arguments
+    R.global('helper', 1, 2, 3);
+  }
+},{});
+
+```
+
+
+#### Global variables without the mess.
+```js
+/*
+ * Use R singleton everywhere
+ */
+
+// Setting
+R('answer', 42);
+// Multiple levels
+R('a.global.variable', 'foo');
+
+// Getting
+console.log(R('a.global.variable'));
+```
+
+
+#### Define hooks for namespaces.
+```js
+/*
+ * app/assets/javascripts/namespaces/admin.js
+ */
+
+Rails.namespace('admin', function() {
+  // Will be executed on all admin routes (e.g. admin/users#new)
+  console.log('Hello Mr. Admin');
+});
+```
+
+#### For more info...
+...just read in ``app/assets/javascripts/routes.js``. I tried my best and documented nearly every line of code :)
+
+Installing
+==========
+
+Install it as any other gem by putting this to your ``Gemfile``:
+```ruby
+gem 'rails-js-routes'
+```
+In your layouts, put this line into the ``head``:
+```erb
+<%= js_routes %>
+```
+Also make sure to include ``routes`` in your ``application.js``. If you are using [Turbolinks](https://github.com/rails/turbolinks), make sure to include ``routes`` after ``turbolinks``.
+
+Testing
+=======
+
+Javascript tests are in ``test/dummy/spec/javascripts/rails-js-routes_spec.js``.
+They are executed using ``rake teaspoon`` (by using the [teaspoon runner](https://github.com/modeset/teaspoon)).
+I'm still trying to get [travis to execute the teaspoon tests properly...](https://travis-ci.org/tonekk/rails-js-routes/builds/37740824)
+
+Contributing
+============
+
+[Fork](https://github.com/tonekk/rails-js-routes/fork) -> Commit -> Pull Request
+
+This project uses the [Airbnb Styleguide](https://github.com/airbnb/javascript) as our coding guideline.
+We think this is a good piece of work and worth spreading.
+In case of any doubts refer to the style used around.

data/Rakefile

@@ -0,0 +1,25 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+# teaspoon must be executed inside the dummy rails app
+task :teaspoon do
+  Dir.chdir('test/dummy/')
+  sh 'bundle exec rake teaspoon'
+end
+
+# add teaspoon to default tasks
+task default: :test

data/app/assets/javascripts/routes.js

@@ -0,0 +1,327 @@
+(function(window, document) {
+
+  /*
+   * All the global stuff (helpers, data, hooks) is stored
+   * locally in this closure so we cannot do anything wrong
+   */
+  var controllers = {},
+      globalHelpers = {},
+      namespaceHooks = {},
+      data = {},
+      beforeAll = null;
+
+  /*
+   * Singleton that stores functions to create your apps' structure
+   */
+  Rails = window.Rails || {};
+
+  /*
+   * For testing. We want to start each test with emtpiness.
+   */
+  Rails.clear = function() {
+    controllers = {};
+    globalHelpers = {};
+    namespaceHooks = {};
+    data = {};
+    beforeAll = null;
+  };
+
+  /*
+   * Creates a Rails application (the javascript part!)
+   *
+   * Pass global helper and initial data as params
+   */
+  Rails.app = function(helpers, initialData, beforeHook) {
+
+    /*
+     * Store everything in our local variables
+     */
+    globalHelpers = helpers;
+    data = initialData;
+    beforeAll = beforeHook;
+
+    /*
+     * Set event listener to execute controllers' javascript
+     *
+     * There might be cases where we do not want to execute
+     * DOM-related js (e.g. javascript unit-tests).
+     * Set Rails.config.test to disable action execution.
+     */
+    listener = function(event) {
+
+      if (Rails.config && Rails.config.test) {
+        return;
+      }
+
+      Rails.execute();
+    };
+
+    document.addEventListener("DOMContentLoaded", listener);
+
+    /*
+     * Add support to Turbolinks page changes
+     */
+    if (typeof Turbolinks !== 'undefined') {
+      document.addEventListener('page:load', listener);
+    }
+  };
+
+  /*
+   * Adds a controller.
+   * Controllers are used to apply javascript in rails routes.
+   * Example:
+   *
+   * Rails.controller('users', {
+   *
+   *   new: function() {
+   *    // Executed on users/new
+   *   }
+   * });
+   */
+  Rails.controller = function(name, actions, helpers) {
+
+    /*
+     * Should not be able to define controller (and helpers) twice
+     */
+    if (controllers[name]) {
+      throw ['Controller \'', name,
+             '\' is already defined! Please use a namespace'].join('');
+    }
+
+    /*
+     * Store controller & helpers in our local closure
+     */
+    controllers[name] = actions;
+    controllers[name].helpers = helpers;
+  },
+
+  /*
+   * Execute the actual controller action.
+   * e.g. will execute controller.users.index()
+   * when on #users/index
+   */
+  Rails.execute = function() {
+
+    /*
+     * Make sure rails.js has been properly added to the layout
+     */
+    if (!(this.config && this.config.controller && this.config.action)) {
+
+      throw ['No action or controller given.',
+             'It seems like you forgot to add rails.js to your layouts\' header.'].join(' ');
+    }
+
+    var controllerName = this.config.controller,
+        namespaceHook,
+        controller;
+
+    /*
+     * Execute beforeAll() hook if defined
+     */
+    if (beforeAll && typeof(beforeAll) == 'function') {
+      beforeAll();
+    }
+
+    /*
+     * Take care of namespace (e.g. admin/users)
+     */
+    if (this.config.namespace) {
+      controllerName = this.config.namespace + '/' + controllerName;
+
+      /*
+       * Execute namespace hook if we defined one
+       */
+      namespaceHook = namespaceHooks[this.config.namespace];
+      if (namespaceHook && typeof(namespaceHook) == 'function') {
+        namespaceHook();
+      }
+    }
+
+    /*
+     * Find controller and execute method
+     */
+    var controller = controllers[controllerName];
+    if (controller && controller[this.config.action] &&
+       typeof(controller[this.config.action]) == 'function') {
+
+      controller[this.config.action](controller.helpers);
+    }
+  };
+
+  /*
+   * Defines a namespace hook which will be executed when
+   * we are in the namespace of that hook.
+   *
+   * For example:
+   * When we define a namespace for 'admin'
+   * the function will be executed on all controllers in that namespace.
+   * (e.g. Admin::UsersController, Admin::SettingsController, etc...)
+   */
+  Rails.namespace = function(name, block) {
+
+    /*
+     * Should not be able to define controller (and helpers) twice
+     */
+    if (namespaceHooks[name]) {
+      throw ['Namespace \'', name, '\' is already defined!'].join('');
+    }
+
+    namespaceHooks[name] = block;
+  };
+
+
+  /*
+   * Global Singleton to store variables and functions
+   * that you need all over your javascript codebase.
+   *
+   * Also contains global helpers, so to prevent conflicts
+   * we save global variables by using this singleton as a function.
+   *
+   * R('foo'); // Gets window.R.data.foo
+   * R('foo', 'bar'); // Sets window.R.data.foo
+   */
+  R = function(key, val) {
+
+    /*
+     * It's possible to go multiple layers with one call, e.g.
+     * R('foo.bar.baz');
+     *
+     * Or you can set things at paths which are not there:
+     * // foo and bar will be created as empty objects
+     * R('foo.bar.baz', 'foo');
+     *
+     */
+    var steps = key.split('.'),
+        step = data,
+        i;
+
+    if (arguments.length == 2) {
+      for (i = 0; i < steps.length-1; i++) {
+        if (!step[steps[i]]) {
+          step[steps[i]] = {};
+        }
+
+        step = step[steps[i]];
+      }
+
+      step[steps[steps.length -1]] = val;
+
+    } else {
+      for (i = 0; i < steps.length; i++) {
+        step = step[steps[i]];
+        if (!step) {
+          break;
+        }
+
+      }
+      return step;
+    }
+  };
+
+  /*
+   * Execute a helper of a foreign controller
+   *
+   * e.g.
+   * Rails.helper('admin/users', 'method', [arg1, arg2, arg3]);
+   * or
+   * Rails.helper('entities', 'method', arg1, arg2, arg3);
+   */
+  R.helper = function(controllerName, helperName) {
+
+    var controller,
+        helper,
+        context,
+        args = Array.prototype.slice.call(arguments, 2);
+
+    /*
+     * Treat 3rd argument as arguments for helper if it is an Array
+     */
+    if (args.length == 1 && args[0] instanceof Array) {
+      args = args[0];
+    }
+
+    /*
+     * Choose global helper if controllerName is not given
+     */
+    if (controllerName) {
+      controller = controllers[controllerName];
+      helper = controller.helpers[helperName];
+    } else {
+      helper = globalHelpers[helperName];
+    }
+
+    /*
+     * Make sure our helper exists
+     */
+    if (!(helper && typeof(helper) == 'function')) {
+      if (controllerName) {
+        throw ['Helper \'', helperName, '\' not defined for controller \'',
+               controllerName, '\''].join('');
+      } else {
+        throw ['Global helper \'', helperName, '\' not defined'].join('');
+      }
+    }
+
+    /*
+     * Choose context, either some controllers' helpers or
+     * the globalHelpers object
+     */
+    context = controller ? controller.helpers : globalHelpers;
+
+    /*
+     * Execute helper in context with arguments
+     */
+    return helper.apply(context, args);
+  };
+
+  /*
+   * Execute a global helper
+   *
+   * Global helpers are defined when the Rails.app is created
+   */
+  R.global = function(helperName) {
+    return this.helper(undefined, helperName, Array.prototype.slice.call(arguments, 1));
+  };
+
+  /*
+   * Executes a controller action
+   * (to execute the same javascript in a different controller)
+   */
+  R.action = function(action) {
+
+    /*
+     * Arguments are either controller and action or the
+     * familliar rails syntax:
+     *
+     * R.action('users', 'index');
+     * R.action('users#index');
+     */
+    var controller,
+        controllerName = arguments[0],
+        actionName = arguments[1];
+
+    if (action.indexOf('#') !== -1) {
+      controllerName = action.split('#')[0];
+      actionName = action.split('#')[1];
+    }
+
+    /*
+     * Make sure controller and action exist
+     */
+    controller = controllers[controllerName];
+
+    if (!controller) {
+        throw ['Attempting to call action \'', controllerName, '#', actionName,
+               '\', but Controller \'', controllerName, '\' is not defined!'].join('');
+    } else if (!controller[actionName] || !(typeof(controller[actionName]) == 'function')) {
+        throw ['Attempting to call action \'', controllerName, '#', actionName,
+               '\', but Action \'', actionName, '\' is not defined!'].join('');
+    }
+
+    /*
+     * Execute controller action with helpers as argument
+     */
+    controller[actionName](controller.helper);
+  };
+
+})(window, window.document);