rails-js 0.1.0 → 0.1.1

data/Rakefile

@@ -1,25 +0,0 @@
-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/VERSION

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

data/app/assets/javascripts/rails.js

@@ -1,327 +0,0 @@
-(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);

data/lib/rails/js.rb

@@ -1,8 +0,0 @@
-module Rails
-  module JS
-    if defined?(::Rails)
-      require_relative 'js/view_helpers'
-      require_relative 'js/engine'
-    end
-  end
-end

data/lib/rails/js/engine.rb

@@ -1,10 +0,0 @@
-module Rails
-  module JS
-    class Engine < ::Rails::Engine
-      initializer "rails-js.view_helpers" do |app|
-        # include view helpers
-        ActionView::Base.send :include, ViewHelpers
-      end
-    end
-  end
-end

data/lib/rails/js/version.rb

@@ -1,5 +0,0 @@
-module Rails
-  module JS
-    VERSION = "0.1.0"
-  end
-end

data/lib/rails/js/view_helpers.rb

@@ -1,23 +0,0 @@
-module Rails
-  module JS
-    module ViewHelpers
-      def rails_js
-
-        namespace = controller_path.split('/').reject do |el|
-          el == controller_name
-        end.join
-
-        raw [
-          '<script type="text/javascript">',
-            'window.Rails = window.Rails || {};',
-            'Rails.config = {',
-            "  controller: '#{controller_name}',",
-            "  namespace: '#{namespace}',",
-            "  action: '#{action_name}'",
-            '};',
-          '</script>'
-        ].join("\n")
-      end
-    end
-  end
-end

data/rails-js.gemspec

@@ -1,24 +0,0 @@
-$:.push File.expand_path("../lib", __FILE__)
-
-# Maintain your gem's version:
-require "rails/js/version"
-
-Gem::Specification.new do |s|
-  s.name          = 'rails-js'
-  s.version       = Rails::JS::VERSION
-  s.date          = Time.now.strftime("%Y-%m-%d")
-  s.summary       = "A new approach to structure your javascript in non single-page Rails apps"
-  s.description   = "Divide your javascript like you divide your ruby code. Put it in controllers and actions and write clean, scalable code."
-  s.authors       = ["Finn-Lenanrt Heemeyer"]
-  s.email         = 'finn@heemeyer.net'
-  s.files         = `git ls-files`.split("\n")
-  s.require_paths = ['lib']
-  s.homepage      = 'http://rubygems.org/gems/rails-js'
-  s.license       = 'MIT'
-
-  s.add_dependency "rails", "~> 4"
-  s.add_development_dependency "sqlite3", "~> 1.3"
-  s.add_development_dependency "teaspoon", "~> 0.8"
-  s.add_development_dependency "poltergeist", "~> 1.5"
-  s.add_development_dependency "coveralls", "~> 0.7"
-end

data/test/dummy/README.rdoc

@@ -1,28 +0,0 @@
-== README
-
-This README would normally document whatever steps are necessary to get the
-application up and running.
-
-Things you may want to cover:
-
-* Ruby version
-
-* System dependencies
-
-* Configuration
-
-* Database creation
-
-* Database initialization
-
-* How to run the test suite
-
-* Services (job queues, cache servers, search engines, etc.)
-
-* Deployment instructions
-
-* ...
-
-
-Please feel free to use a different markup language if you do not plan to run
-<tt>rake doc:app</tt>.