reins 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c94c1362681a7d1fc9abb25e1cdbcc9d77a5136
-  data.tar.gz: 5f59f0adb23f90acb5f8d448f9044088d8ce995e
+  metadata.gz: a1af0eeaf611a0c430bb05eef27b354f126a50b9
+  data.tar.gz: 648ccd2171cbf03f3a44db40647c3f3b35440000
 SHA512:
-  metadata.gz: 9178864998b34cb92cd9a624f894291661b44267f37d3eb53c7555026846f1680e5e5409862fd5dafd3f4349a680ad239ebf0c0523253c7a5947375948b9112f
-  data.tar.gz: 555e9f4427efa2de4ec4d63cbeb9e4d395fe4e1021206e1c0ecc3e5ab5ee5ba36d99cdbcdfa09661a6d9d63a64e62ae61d1926c07715c9618a759dfae52f8ed1
+  metadata.gz: 52fa48f4129ee24a7ea6d40eb72f56bdab5462f65c463f1bf833a7f7e31d0ea5b71da053e4dddf42a59c094627a29e9d2c0abcddd86ca945979d06466db2e1ac
+  data.tar.gz: '0681b9869d9b7b0931a22bff3a10e3332e5dd078c43d2238a9f6acae7e144bffd424ddda785a4af797dda366ee4b73d1aef50ea9a7e183f44be5c40d5f72c4e7'

data/README.md

@@ -8,39 +8,39 @@
 [![Gem Version](https://badge.fury.io/rb/reins.svg)](http://badge.fury.io/rb/reins)
 ![](http://ruby-gem-downloads-badge.herokuapp.com/reins)
 
+### TL;DR
+Reins provides an easy way to have separate jQuery ```$(document).ready``` and turbolinks ```page:load``` handlers for each of your controllers and actions. This will avoid weird initialization issues with conflicting selectors, and will help you know where JS initialization code for each page lives.
+
 ### Why reins?
-Rails' convention over configuration approach to development is well known, however when it comes to javascript it is sorely missing.
-Every time you create a scaffold, resource, or controller you get a new javascript file with that controller's name, but that's it.
-Since all the code is minified and aggregated into application.js by the assets pipeline, it's very easy to end up with a big mess.
+Rails' convention over configuration approach to development is well known, however when it comes to javascript it is sorely lacking - every time you create a scaffold, resource, or controller, you get a new javascript file named after that controller, but that's it.
+Then all your JS code is minified and aggregated into application.js by the assets pipeline with multiple ```$.ready``` callbacks that run on every page.
 
-This means that you need to manually find a way to keep the global scope clean, avoid name collisions and define a common structure for your javascript code.
+This means that you need to manually find a way to keep the global scope clean, avoid name collisions and define a common structure for your javascript code. If you're not very careful with your code's structure it's very easy to end up with a big unmaintainable mess as your application grows.
 
 
-Reins is a ruby gem that automates the creation of javascript controllers that match the structure of your rails controllers.
-It creates a predefined structure for your javascript code where code for different controllers is kept in separate namespaces.
-It also enables you to keep javascript code out of your views by defining functions that get called automatically on jQuery.ready and Turbolinks page:load for each rails controller action that runs.
+Reins is a ruby gem that automates the creation of jQuery ```$.ready``` and turbolinks ```page:load``` callbacks matching the structure of your rails controllers. It also creates a predefined structure for your javascript that helps you keep code for different controllers in separate namespaces.
 
-This even works in the case of javascript code that needs data from the server (which almost always ends up inside a script tag somewhere with erb thrown in the mix to include server-side data...).
-You just have to define a special hash on the controller and this hash will be JSONified and passed to the reins javascript controller as a dictionary object.
+Reins even works with javascript code that needs data from the server (which almost always ends up inside a script tag somewhere with erb thrown in the mix to include server-side data...).
+You just have to define a special hash on the controller and this hash will be JSONified and passed to the reins javascript controller as a dictionary object. We'll take a look at this further down.
 
 ### How can I start using it?
 
 Add reins to your Gemfile:
 
-```
+```ruby
 gem 'reins'
 ```
 
 Add reins.js to application.js:
 
-```
+```javascript
 //= require reins
 ```
 
 Add the reins script tag to your application layout, or any layout/view where you want reins to automatically call your javascript controllers.
 I prefer just adding it to ```layouts/application.html.erb``` (and any other layouts I might have) right before closing the ```<body>``` tag:
 
-```
+```html
 ...
 <body>
   ...
@@ -59,7 +59,7 @@ If the above steps went ok, now is the perfect time for an example:
 
 Suppose we generate a HelloController and add the following code inside:
 
-```
+```ruby
 class HelloController < ApplicationController
 
   def index
@@ -73,15 +73,15 @@ end
 
 Let's quickly create a controller and view by running:
 ```
-rails g controller hello
-touch app/views/hello/index.html.erb
+$ rails g controller hello
+$ touch app/views/hello/index.html.erb
 ```
 Don't worry about the empty view for now, as it is irrelevant for reins to work :)
 When you run the rails generator, reins will create a javascript file at
 /app/assets/javascripts/controllers/cookies.js with some boilerplate code. After
 changing a few lines it might look like this:
 
-```
+```javascript
 /**
  * Anonymous self-running closure to avoid polluting the global namespace with
  * definitions that should be kept private.
@@ -158,9 +158,8 @@ Most of the functionality is explained in the comments inside the javascript sni
 
 #### What if I'm rendering a js.erb view?
 
-Reins will not be called automatically for these, as the whole idea of js.erb views is to give you full control.
-However, to avoid repeating code, you can call your reins controller from js.erb views.
-You just need to do this:
+Reins will not be called automatically for these, as the whole idea of js.erb views is to give you fine tuned control.
+However, to avoid repeating code, you can call your reins controller from js.erb views if you want. You just need to do this:
 ```
 <%= call_reins_controller %>
 ```
@@ -168,14 +167,15 @@ This will call the matching controller and pass the @reins_params hash if it was
 
 #### Why do my controllers only get called on page:load when using turbolinks? I want page:change!
 
+When using turbolinks, ```page:change``` can mean that we are rendering a page from the turbolinks cache with no server intervention at all. You shoud realize that calling the reins controller from this event will use the last params that were sent by the server, so it's probably not what you want.
+To reiterate, this could mean that if you are going back to a page that was cached by turbolinks, the controller could be called with params from another controller/action, which is probably not what you want.
+
 Just add this to your application.js:
-```
+```javascript
 $(document).off('page:load').on('page:change', r.call_js_controller);
 ```
 THIS WILL REMOVE any page:load event handlers that you may have attached to $(document), so be warned!
 
-Also of note is that calling the reins controller in this way will use the last params that were sent by the server.
-This means that if you are going back to a page that was cached by turbolinks, the controller could be called with params from another controller/action, which is probably not what you want.
 
 
 

data/lib/reins/version.rb

@@ -1,3 +1,3 @@
 module Reins
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: reins
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Tony Goncalves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-13 00:00:00.000000000 Z
+date: 2017-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.1'
 - !ruby/object:Gem::Dependency
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Reins! Rein in your javascript