Use Controller.all() in place of Controller constructor.

Author: kpheasey

README.md

@@ -24,61 +24,35 @@ After the generator finishes, you will be prompted to add helper call to your ap
 
 ## Usage
 
-### Global Functions
-
-Any functions that need to be accessible in the global scope should be defined in ```global.js.coffee``` using the ```App``` namespace.  Below is an example of one of our favorite functions that we use to submit a form using AJAX as a JSON request.
-
-```
-# app/assets/javascripts/global.js.coffee
-window.App ||= {}
-
-App.remoteSubmission = ($form, onCompleteCallBack) ->
-  $.ajax
-    url: $form.attr('action')
-    type: $form.attr('method')
-    data: $form.serialize()
-    dataType: 'json'
-    complete: (result) ->
-      onCompleteCallBack(result)
-
-  return
-```
-
-Now you can access this function from anywhere in the application by just calling ```App.remoteSubmission($('#myForm'), alert('Hello'))```
-
+### Page (Action) Specific JavaScript
 
-### Page Specific JavaScript
-
-This is where things get even easier, your JavaScript class is named after your Controller and there is a method for each Controller action.  Whenever you generate a Controller, the CoffeeScript file that is generated will define the new JavaScript class and the basic REST actions.  This means on ```Users#show``` we can submit that 'follow' request in the background like so:
+Your JavaScript class is named after your Controller and there is a method for each Controller action.  Whenever you generate a Controller, the CoffeeScript file that is generated will define the new JavaScript class and the basic REST actions.  The example below would print 'users#show' in the console for the ```Users#show``` action.
 
 ```
 # app/assets/javascripts/users.js.coffee
 
 window.App ||= {}
 class App.Users extends App.Base
 
-   show: ->
-      App.remoteSubmission($('#follow-user-form'), alert('You are now following them!'))
+   show: =>
+      console.log 'users#show'
 ```
 
 
+
 ### Controller Specific JavaScript
 
-Executing some JavaScript to run on all controller actions is just a matter of adding it to the class constructor.  In the below example we will change the background color of the page for all actions in ```UsersController```.
+Executing some JavaScript to run on all controller actions is just a matter of adding it to the ```all``` function.  This is run before the action specific method.  The example below would print 'users' for each ```Users``` controller action.  
 
 ```
 # app/assets/javascripts/users.js.coffee
 window.App ||= {}
-class App.Example extends App.Base
+class App.Users extends App.Base
 
-  constructor: ->
-    super
-    $('body').css('background-color', 'yellow')
-    return this
+  all: =>
+    console.log 'users'
 ```
 
-Note the call to ```super``` and the ```return this```, it is very important to keep these.  If you wanted your Controller specific JavaScript to run before Application wide JavaScript, then you would call ```super``` just before ```return this```.  Returning ```this``` allows the Application layout JavaScript to call the action specific functions.
-
 
 ### Application Wide JavaScript
 
@@ -105,6 +79,29 @@ class App.Base
 In this example we extracted the rollover action into a new function.  Doing so will make the class cleaner and easier to maintain as the application grows.  Once again note the ```return this``` in the constructor.
 
 
+
+### Global Functions
+
+Any functions that need to be accessible in the global scope should be defined in ```global.js.coffee``` using the ```App``` namespace.  Below is an example of one of our favorite functions that we use to submit a form using AJAX as a JSON request.
+
+```
+# app/assets/javascripts/global.js.coffee
+window.App ||= {}
+
+App.remoteSubmission = ($form) ->
+  $.ajax
+    url: $form.attr('action')
+    type: $form.attr('method')
+    data: $form.serialize()
+    dataType: 'json'
+
+  return
+```
+
+Now you can access this function from anywhere in the application by just calling ```App.remoteSubmission($('#myForm'))```
+
+
+
 ### Utilities
 
 A ```Utility``` is a class that will be used to create similar functionality in many areas of the application.  A good example of this is a Modal, which could appear multiple times on the same page.  So, let's encapsulate this functionality in a highly reusable class.
@@ -168,6 +165,7 @@ class App.Users extends App.Base
 ```
 
 
+
 ### Elements
 
 An ```Element``` is a class that describes the functionality of a one off element in the application.  A Main Menu is a good example of this since there is usually only a single Main Menu.
@@ -202,6 +200,7 @@ class App.Base
 ```
 
 
+
 #### Element Inheritance
 
 Inheritance is another key tool for reusability.  Let's say our ```Element.MainMenu``` opens and closes in the same way as the ```Utility.Modal```.  Well then MainMenu should just extend Modal, this can be accomplished from the generator:
@@ -223,6 +222,7 @@ class Element.MainMenu extends Utility.Modal
 Inheritance from the generator can only come from a Utility class.  Any class you wish to extend should be created as a Utility.  The installer adds the line ```//= require_tree ./utilities``` before loading tree to handle this.  If you have a utility that extends a utility, then make sure the extended utility is loaded first by explicitly requiring it before ```//= require_tree ./utilities```.
 
 
+
 ### Custom Controllers
 
 When a new controller is generated, the JavaScript asset file will be generated with RailsScript.  However, if you need to manually generate a RailsScript controller you can use:
@@ -237,28 +237,28 @@ Since the above example includes a namespace, it would generate:
 window.App ||= {}
 class App.SomeNewController extends App.Base
 
-  constructor: ->
-    super
-    return this
+  all: =>
+    return
 
 
-  index: ->
+  index: =>
     return
 
 
-  show: ->
+  show: =>
     return
 
 
-  new: ->
+  new: =>
     return
 
 
-  edit: ->
+  edit: =>
     return
 ```
 
-None of the pre-defined functions are necessary, you can remove the ones you don't want.
+None of the pre-defined functions are necessary, you can remove the ones you don't need.
+
 
 
 ### Generic Classes
@@ -280,6 +280,8 @@ class App.MyClassName
 
 ```
 
+
+
 ### Passing Rails Variables
 
 To pass data from Rails to JavaScript, just call ```to_javascript``` along with a hash of your data.  This is then converted to a JSON object with ```to_javascript.to_json``` and can be accessed with ```Utility.RailsVars```.  The ```to_javascript``` helper may be called from multiple points in the application, all data is merged together. 
@@ -315,6 +317,7 @@ class App.Users extends App.Base
 ```
 
 
+
 ### Events
 
 Since Turbolinks doesn't refresh the page and only replaces the body, event listeners defined on ```window``` and ```document``` carry between page loads.  To avoid these event listeners stacking, RailsScript will destroy all event listeners on ```window``` and ```document``` that have a blank namespace, i.e. ```$(window).on 'scroll', myHandler```.  If you need an event handler to persist between page changes, then define a namespace, i.e. ```$(window).on 'scroll.namespace', myHandler```.

lib/generators/rails_script/controller/templates/javascript.js.coffee

@@ -1,9 +1,8 @@
 window.App ||= {}
 class App.<%= controller.gsub('::', '') %> extends App.Base
 
-  constructor: ->
-    super
-    return this
+  all: =>
+    return
 
 
   index: =>

lib/rails_script/loader_helper.rb

@@ -8,8 +8,11 @@ def include_rails_script
 
 (function() {
   window.$this = new (App.#{ controller_path.split(/\/|_/).map(&:capitalize).join('') } || App.Base)();
+  if (typeof $this.all === 'function') {
+    $this.all.call();
+  }
   if (typeof $this.#{ action_name } === 'function') {
-    return $this.#{ action_name }.call();
+    $this.#{ action_name }.call();
   }
 })();
 RUBY

lib/rails_script/version.rb

@@ -1,3 +1,3 @@
 module RailsScript
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end