rails_jskit 5.0.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cfada1cab937ef9b8502560244c406545178417
-  data.tar.gz: 9a1decf703ee7a5d321542c7acf32ad72a674efd
+  metadata.gz: ad1c775799b28a7db824596cc46bd3a408e4dfe4
+  data.tar.gz: 5705864e3a14dfc72b20cd65bceee5efb1c09107
 SHA512:
-  metadata.gz: 1cf188610748aa597bd9a46c3655204bab5e37aaf6fb98b5230e9de373184d40c13b6467b51e8f6b76b56931989f7c65fdc7be07fd52083a99de451803c2b760
-  data.tar.gz: 1e69b27142a52ab2eca03eeffda2c6d91e555153a2ee3fe86a6e06e1a090eaccf216eb1c010fc20f408f724df4fae322e154534fe8a82deb9b9c81c8bb34171b
+  metadata.gz: 57bc99de58e79d624bfbc3b3b98ed98d29bb60189df8aeed45bcf7df6e5be5c0f1b7688fe4c343dd5e6a329b8e5cd0d9d9731c7d46240550a2321a9978bbb1a3
+  data.tar.gz: 8f7c5caba135044cf229c8b43e7e8b916e258ce782e6a5307ee9109c4142f8e291a22ca80c61a88207aa7d0dcd1efa6908af4d8f51d7399ec9a369dfbaf23a49

data/README.md

@@ -3,214 +3,596 @@
 
 [![Gem Version](https://badge.fury.io/rb/rails_jskit.svg)](http://badge.fury.io/rb/rails_jskit)
 
-rails_jskit is a gem that let's you seamlessly integrate rails with [JSkit](https://github.com/daytonn/jskit). View the example repo [here](https://github.com/daytonn/rails_jskit-example) or see it in action [here](https://jskit-rails-example.herokuapp.com/)
-
-[Documentation](http://daytonn.github.io/rails_jskit/documentation.html)
-
-### Dependencies
-* [lodash](https://lodash.com/) or [underscore](http://underscorejs.org/)
-* [jquery](https://jquery.com/) or equivalent
+rails_jskit is a gem that let's you seamlessly integrate rails with [JSkit](https://github.com/daytonn/jskit). View the example repo [here](https://github.com/daytonn/rails_jskit-example).
+
+* [Online Documentation](http://daytonn.github.io/rails_jskit/documentation.html)
+* [Dependencies](#dependencies)
+* [Installation](#installation)
+  - [Automatic Installation](#automatic-installation)
+  - [Manual Installation](#manual-installation)
+* [Documentation](#getting-started)
+  - [Application Object](#application-object)
+    * [Dispatcher](#dispatcher)
+    * [Controllers Object](#controllers-object)
+    * [Controller Factories](#controller-factories)
+  - [Controllers](#controllers)
+    * [Actions](#actions)
+    * [Mapped Actions](#mapped-actions)
+    * [The `all` Action](#the-all-action)
+    * [Creating an Application Controller](#creating-an-application-controller)
+    * [Passing Data To Actions](#passing-data-to-actions)
+    * [Elements](#elements)
+    * [Events](#events)
+
+* [Configuration](#configuration)
+* [Testing](#getting-started)
+  - [Controller Factories](#controller-factories)
+  - [Testing Actions](#testing-actions)
+  - [Testing Elements](#testing-elements)
+  - [Testing Events](#testing-events)
+
+Dependencies
+------------
 
-Make sure that the dependencies is required in your `application.js` file.
+RailsJskit requires `jquery` (or equivalent) and `lodash` (or equivalent). Require them in your `app/assets/javascripts/application.js` before `//= require rails_jskit`.
 
 ```js
+// app/assets/javascripts/application.js
 //= require lodash
 //= require jquery
 ```
 
--- or --
-
-```js
-//= require underscore
-//= require zepto
-```
-
 Installation
 ------------
 
 Add `rails_jskit` to your Gemfile:
 
-```rb
+```ruby
+# Gemfile
 gem "rails_jskit"
 ```
 
-Bundle it up:
+Bundle it up
 
 ```sh
 bundle install
 ```
 
-Usage
------
+###Automatic Installation
 
-Add the `jskit` helper to your layout (i.e. `app/views/layouts/application.html.erb`):
+RailsJskit comes with handy generators to get you started quickly. Use the generator to install jskit:
 
-```html
-<%= jskit %>
+```sh
+rails generate jskit:install
 ```
 
-Add the jskit javascript (i.e. `app/assets/javascripts/application.js`):
+Or you can install it the good old-fashioned way, by hand:
+
+###Manual Installation
+
+Create a `app/assets/javascripts/controllers/` directory and add rails_jskit to `app/assets/javascripts/application.js`:
 
 ```js
+// app/assets/javascripts/application.js
+...
 //= require rails_jskit
+//= require_tree ./controllers
+```
+
+Add `jskit` to your application layout:
+
+```erb
+# app/views/layouts/application.html.erb
+<!DOCTYPE html>
+<html>
+<head>
+  <title>JskitExample</title>
+  <%= stylesheet_link_tag 'application', media: 'all' %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+  <%= yield %>
+  <%= javascript_include_tag 'application' %>
+  <%= jskit %>
+</body>
+</html>
 ```
 
-That's it, now all controller actions will be triggered on the `JSkit` dispatcher.
+**That's it!** You're ready to use RailsJskit.
+
+Now all your controllers will be loaded at runtime but nothing will execute until events are dispatched.
+
+Documentation
+-------------
+
+### Application Object
+
+RailsJskit will automatically create a JSkit application object for you, using the configured `app_namespace` for the global variable name _(defaults to "App")_. This global namespace provides you a way to interact with your JSkit application. You can #{link_to "configure", "#configuration"} this setting in your initializer `(config/initializers/rails_jskit.rb)`.
+
+#### Dispatcher
+
+Every JSkit application has a `Dispatcher` object. This object is responsible for registering and triggering events in your application. In general you don't interact directly with the application's Dispatcher, though it's important to know what it is and what it's doing. By default, every controller created by your application will have it's own reference to the Dispatcher object. A controller's actions will automatically be registered on the Dispatcher when it's created, so you shouldn't need to interact with the Dispatcher directly.
+
+#### Controllers Object
+
+Every JSkit application also has a `Controllers` object that stores the Controllers instantiated by your application at runtime. Everytime you create a controller, an instance is created on the controllers object:
+
+```ruby
+
+// app/assets/javascripts/controllers/posts_controller.js
+App.createController("Posts", {
+  ...
+});
+
+App.Controllers.Posts;// Instantiated Posts controller object
+```
+
+#### Controller Factories
+
+In addition to instances of each controller, the factory used to create the controller is stored on the application object itself. The factory is a function that will create a freshly initialized controller, useful in testing environments:
+
+```ruby
+
+// app/assets/javascripts/controllers/posts_controller.js
+App.createController("Posts", {
+  ...
+});
+
+App.PostsController;// Factory function to create fresh Posts controller objects
+```
 
 ### Controllers
 
-JSkit offers controllers as a basic building block for JavaScript functionality. Making a folder inside `app/assets/javascripts` named `controllers` is a great place to put these:
+The basic component of JSkit is the Controller. Controllers allow you to coordinate JavaScript execution with your Rails controllers. For example, assuming you have a `PostsController` in `app/controllers/posts_controller.rb`.
 
-```sh
-mkdir app/assets/javascripts/controllers
+```ruby
+# app/controllers/posts_controller.rb
+class PostsController < ApplicationController
+  def index
+    render :index
+  end
+end
 ```
 
-Now simply require that entire directory in your `application.js` file:
+#### Actions
+
+To define JavaScript for that controller, create a corresponding JSkit controller in `app/assets/javascripts/controllers/posts_controller.js` and define it's `actions`. The actions array tells JSkit which functions you want automatically wired to the controller's events. If you wish to run javascript on the `index` action of the `PostsController`, it would look something like this:
 
 ```js
-//= require_tree ./controllers
+// app/assets/javascripts/controllers/posts_controller.js
+App.createController("Posts", {
+  actions: ["index"]
+
+  index: function() {
+    // behavior for posts#index
+  }
+});
 ```
 
-#### Events
+Now whenever your `PostsController` renders the `index` action, the JSkit controller's index method will execute. It's that simple.
+
+#### Mapped Actions
+
+You may find yourself wanting to wire up an action with a different function name than it's corresponding rails controlller, or you may want to assign the same function to multiple actions. This can be acheived by using a mapped action:
 
-There are three events triggered on every page rendered: a global event, a controller event and an action event. Given a `Posts` controller, when rendering the `index` action, you will notice the three events triggered where the `<%= jskit %>` snippet was placed:
+```js
+// app/assets/javascripts/controllers/posts_controller.js
+App.createController("Posts", {
+  actions: [{
+    edit: "setupForm",
+    create: "setupForm",
+    update: "setupform"
+  }],
+
+  ...
+  setupForm: function() {
+    // form setup
+  }
+  ...
+});
+```
+
+This will wire the three events `controllers:posts:edit`, `controllers:posts:create`, and `controllers:posts:upate` to the `setupForm` function.
+
+This simple convention is flexible enough to accomplish any sane JavaScript task for a given action.
+
+_Note: you can mix and match objects and strings within the actions array but it's probably best to define the string actions first and pass an object as the last item in the array. This is only for readability as JSkit does not care about the position of the actions in the array._
 
 ```js
-App.Dispatcher.trigger("controller:application:all");
-App.Dispatcher.trigger("controller:pages:all");
-App.Dispatcher.trigger("controller:pages:index");
+...
+actions: [
+  "index",
+  "show",
+  {
+    edit: "setupForm",
+    create: "setupForm",
+    update: "setupForm"
+  }
+]
 ```
 
-This allows you to integrate your JavaScript at key points in your rails application with minimal coupling. An event triggered with no corresponding `JSkit` controller or action defined has no effect. 
+#### The `all` action
 
-#### Application Controller
+There are times when you want a bit of JavaScript to run for every action of a given controller. In this case you can define an `all` method on the controller which will automatically be triggered on every action of the controller:
 
-It's common to have some JavaScript that runs on every page of your application. In the past, you may have slapped random bits of code inside a jQuery `$(document).ready` block but not with JSkit. JSkit makes an explicit yet minimally coupled connection between your Rails app and your client-side code. To define application-wide behavior, define an application controller in `app/assets/controller/application_controller.js`:
+```js
+...
+all: function() {
+  console.log("Happens on every action");
+}
+...
+```
+
+_Note: you don't have to add `all` to the actions array, JSkit knows what you mean._
+
+#### Creating an Application Controller
+
+In some cases, you may want some JavaScript to run on every single page of your application. Something like fading out flash notifications, or instantiating dynamic menus or something of that nature. In this case you can create an Application Controller at: `app/assets/javscripts/controllers/application_controller.js`
 
 ```js
+// app/assets/javscripts/controllers/application
 App.createController("Application", {
   all: function() {
-    // This handler will be triggered on all pages
+    setTimeout(function() {
+      $("#notifications").fadeOut();
+    }, 3000);
+
+    $("#menu").menuify();
   }
 });
 ```
 
-The `all` method is automatically wired to the `controller:application:all` event, which is triggered on each page via the `<%= jskit %>` snippet. You now have a simple, testable controller to define behavior in your application.
+There is nothing special about this controller except the fact that RailsJskit will trigger the `controller:application:all` event on every action of every controller. Which means that the `all` method will execute on every page.
+
+#### Passing Data To Actions
+
+Sometimes you may find yourself wanting to pass data from the Rails side of your application to the client side. The JSkit event system accounts for this and RailsJskit provides a simple interface to this functionality. JSkit has three payload methods, which are available to your application's controllers. The three methods correspond to the three levels of triggered events on any given page.
 
-All other controllers are defined in the same way, the only difference is that your other controllers will have actions defined. Assuming you have a `Posts` controller in ruby, whose index action needs a bit of JavaScript to spice up the template. You would simply create a corresponding `Posts` controller in `app/assets/javascripts/posts_controller.js`:
+  1. `set_app_payload` (sent with "controllers:application:all")
+  2. `set_controller_payload` (sent with "controllers:[controller name]:[action name]")
+  3. `set_action_payload` (sent with "controllers:[controller name][action name]")
+
+Let's assume you want to pass devise's `current_user` object to the application controller. For this you would use `app_payload`
+
+```ruby
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  before_action :jskit_app_payload
+
+  private
+
+  def jskit_app_payload
+    set_app_payload(current_user)
+  end
+end
+```
+
+This will pass the `current_user` as JSON in the `controllers:application:all` event:
 
 ```js
+App.Dispatcher.trigger("controller:application:all", { email: "user@example.com", first_name: "John", last_name: "Smith"... });
+```
+
+Your application controller can make use of this data by assigning the argument to the action function:
+
+```js
+// app/assets/javascripts/controllers/application_controller.js
+App.createController("Application", {
+  all: function(currentUser) {
+    App.currentUser = currentUser;// { email: "user@example.com", first_name: "John", last_name: "Smith"... }
+  }
+});
+```
+
+These payload methods will take any number of arguments and pass them in order to the event handler. This allows for a simple but flexible way to pass data to your client-side application.
+
+The `set_controller_payload` method and the `set_action_payload` work in the same way only they pass data to their specific events.
+
+```ruby
+# app/controllers/posts_controller.rb
+class PostsController < ApplicationController
+  before_action :jskit_controller_payload
+
+  def index
+    set_action_payload("Data from the PostsController#index action")
+  end
+
+  private jskit_controller_payload
+
+  def jskit_controller_payload
+    set_controller_payload("Data from the PostsController")
+  end
+end
+```
+
+This data can be accessed in the JSkit controller like so:
+
+```js
+// app/assets/javascript/controllers/posts_controller.js
 App.createController("Posts", {
   actions: ["index"],
-  
-  index: function() {
-    // do stuff on the index page
+
+  all: function(message) {
+    console.log(message);// "Data from the PostsController"
+  },
+
+  index: function(message) {
+    console.log(message);// "Data from the PostsController#index action"
   }
 });
 ```
 
-Here you can see that the `actions` array tells JSkit to wire up the `index` method to the `controller:posts:index` event. This event is automatically fired by the `<%= jskit %>` snippet.
+#### Elements
 
-#### Mapped Events
+It's guaranteed you'll end up saving a reference to an `HTMLElement` wrapped in `jQuery` _(the proverbial jQuery burrito)_. You do this so often, it really helps to have a shorthand for doing so. Consider the following code:
 
-Sometimes you may want to map an action to a method with a different name, or you may want to map multiple actions to the same method. This is accomplished using mapped actions. Instead of using a string in the actions array, use an object to map the action name to the controller's method:
+```js
+// app/assets/controllers/posts_controller.js
+App.createController("Posts", {
+  actions: ["index"],
+
+  cacheElements: function() {
+    this.$postList = $("ul#posts");
+    this.$commentToggleLink = $("a.comment-toggle");
+    this.$modalWindow = $("#modal-window");
+    this.$modalCloseButton = $("#modal-window-close");
+  },
+
+  index: function() {
+    this.cacheElements();
+    // do stuff with elements
+  }
+});
+```
+
+This is generally pretty clean code. It's easy to read and it's simple. The problem is that we're going to want to do the same thing in other actions. We can use the same `cacheElements` method but we may not need all the selectors.
+
+If we do want to scope elements to actions, we'll need a way to scope the selected elements to specific actions. JSkit allows you to define this behavior with a simple `elements` object on the controller. Which looks something like this:
 
 ```js
+// app/assets/controllers/posts_controller.js
 App.createController("Posts", {
-  actions: [
-    "index",
-    { new: "setupForm" },
-    { edit: "setupForm" },
-    { create: "setupForm" }
-  ],
-  
+  elements: {
+    index: {
+      postList: "ul#posts",
+      commentToggleLink: "a.comment-toggle",
+      modalWindow: "#modal-window",
+      modalCloseButton: "#modal-window-close"
+    }
+  },
+
   index: function() {
-    // do stuff on the index page
+    // do stuff with elements
+  }
+});
+```
+
+This keeps all the DOM selection one simple structure that cuts down on the clutter.
+
+_Note: all keys under each action will be set as variables prefixed with the `$` to indicate that it's a `jQuery` wrapped set._
+
+The above example would create three variables on the controller object when the `index` action is triggered:
+
+```js
+// app/assets/controllers/posts_controller.js
+App.createController("Posts", {
+  elements: {
+    index: {
+      postList: "ul#posts",
+      commentToggleLink: "a.comment-toggle",
+      modalWindow: "#modal-window",
+      modalCloseButton: "#modal-window-close"
+    }
   },
-  
-  setupForm: function() {
-    // setup the posts form
+
+  index: function() {
+    this.$postList;
+    this.$commentToggleLink;
+    this.$modalWindow;
+    this.$modalCloseButton;
   }
 });
 ```
 
-Here you can see that the `new`, `edit`, and `create` actions are all being wired up to the same method `setupForm`. This allows you to reuse common behavior that is needed accross multiple actions.
+#### Events
 
-Finally, you may wish to have some functionality that runs on every action of a controller, to do this, simply define an all method. The `all` method is automatically wired to the `controller:<controller name>:all` event:
+Another common piece of boilerplate code is registering for events on `jQuery` wrapped elements. You know, the meat and potatoes of js development. JSkit has a novel way of tidying up event registration as well. An action's elements can be wired up to event handler functions (defined on the controller) by adding them to the element key's value as an array (tuple):
 
 ```js
+// app/assets/controllers/posts_controller.js
 App.createController("Posts", {
-  ...
-  
-  all: function() {
-    // do something on every action of the controller
+  elements: {
+    index: {
+      launchModalButton: ["#launch-modal", { click: "openModalWindow" }],
+      modalCloseButton: ["#modal-window-close", { click: "closeModalWindow" }]
+    }
   },
-  
-  ...
+
+  openModalWindow: function() {
+    this.$modalWindow.removeClass("hidden");
+  },
+
+  closeModalWindow: function() {
+    this.$modalWindow.addClass("hidden");
+  }
 });
 ```
 
-This event structure is a simple and powerful way to coordinate your Rails application with the client-side code.
+This is a simple way reduce some of the repetetive code in your everyday JavaScript. It's also tested in JSkit itself, so you don't need to test that the events were registered properly.
 
-### Event Payloads
+_Note: if you are not doing anything else in an action but wiring elements and events, you can skip adding the action to the `actions` array, and creating a function for that action._
 
-In addition to simply triggering events, you may optionally pass data to these events. You can pass arbitrary data to any of the three events triggered on page render. To pass data to the application controller's `all` event:
+##### Multiple Events
 
+It is also possible to register multiple events on a given element, to do so simply add event keys to the event object for the given action:
 
-```rb
-class ApplicationController < ApplicationController
-  before_action :set_jskit_payload
-  
-  ...
-  
-  private 
-  
-  def set_jskit_payload
-    set_app_payload(current_user)
-  end
-end
+```js
+// app/assets/javscripts/controllers/posts_controller.js
+App.createController("Posts", {
+  elements: {
+    index: {
+      nameField: ["input#name", {
+        change: "handleNameFieldChange",
+        keyup: "handleNameFieldKeyup"
+      }]
+    }
+  },
+
+  handleNameFieldChange: function(evnt) {
+    // handle name field change
+  },
+
+  handleNameFieldKeyup: function(evnt) {
+    // handle name field keyup
+  }
+});
 ```
 
-This will pass the current user object to the `Application` controller. You can also pass multiple values:
+Configuration
+-------------
 
-```rb
-class ApplicationController < ApplicationController
-  before_action :set_jskit_payload
-  
-  ...
-  
-  private 
-  
-  def set_jskit_payload
-    set_app_payload(current_user, [1, 2, 3], { some: "hash" })
-  end
+At this point, RailsJskit only has one setting, the `app_namespace`. If you're fine with the default namespace of `App`, you don't need to change it. Otherwise create an initializer:
+
+```ruby
+# config/initializers/rails_jskit.rb
+RailsJskit.configure do |config|
+  config.app_namespace = "MyApp"
 end
 ```
 
-This will pass each item in the array as an argument to the event handler on the controller. Note that each item will have `to_json` called on it automatically, so there is no need to do it yourself. The above example will produce the following triggered event:
+Now you can refer to your application globally as `MyApp`.
 
 ```js
-...
-App.Dispatcher.trigger("controller:application:all", { first_name: "John", last_name: "Doe" }, [1, 2, 3], { "some": "hash" });
-...
+// app/assets/javascripts/controllers/application_controller.js
+MyApp.createController("Posts", {...});
 ```
 
-This allows you to share data from your Rails app without explicit knowldge of how your client-side code will consume it. You may also set the controller and action event payloads in the same way:
+Testing
+-------
 
-```rb
-class PostsController < ApplicationController
-  before_action :set_jskit_payload
-  
-  def index
-    set_action_payload("PostsController#index")
-  end
-  
-  private
-  
-  def set_jskit_payload
-    set_controller_payload("PostsController")
-  end
-end
+One of the main advantages of RailsJSkit is that it provides a simple structure that's easily tested. There are however, a few things you need to keep in mind while testing JSkit controllers.
+
+When testing, it's important to use the #{link_to "Controller Factories", "#controller-factories"} to create your test subjects. This ensures that you always have a fresh version of the controller that has not been mutated by previous tests. A basic jasmine/mocha style JSkit controller test looks something like this:
+
+```js
+// spec/javscripts/controllers/posts_controller_spec.js
+describe("PostsController", function() {
+  var subject;
+  beforeEach(function() {
+    subject = App.PostsController.create();// creates a fresh controller
+  });
+
+  describe("#index", function() {
+    it("has tests", function() {
+      expect(true).to.equal(true);
+    });
+  });
+});
+```
+
+### Testing Actions
+
+Testing actions is straight-forward, since they are just functions on your controller object, you can simply call them and test their behavior:
+
+```js
+// app/assets/javscripts/controller/posts_controller.js
+App.createController("Posts", {
+  actions: ["index"],
+
+  elements: {
+    index: {
+      pageContainer: "#container",
+    }
+  },
+
+  index: function(color) {
+    this.color = color;
+    this.$pageContainer.css("background-color", this.color);
+  }
+});
+```
+
+```js
+// spec/javscripts/controllers/posts_controller_spec.js
+describe("PostsController", function() {
+  var subject;
+  beforeEach(function() {
+    subject = App.PostsController.create();
+  });
+
+  describe("#index", function() {
+    it("sets the color variable with the given value", function() {
+      subject.index("#FF0000");
+      expect(subject.color).to.equal("#FF0000");
+    });
+
+    it("changes the page background color to the given color", function() {
+      subject.index("#FF0000");
+      expect(subject.$pageContainer.css("background-color")).to.equal("#FF0000");
+    });
+  });
+});
+```
+
+Obviously this is a contrived example but you can see that testing an action is as simple as testing a function.
+
+### Testing Elements
+
+While you don't have to test the functionality of JSkit itself, you may want to assert that a certain action has access to a given element. To do this we can simply test the values in the elements object, without having to add fixtures to the test DOM:
+
+```js
+// spec/javscripts/controllers/posts_controller_spec.js
+describe("PostsController", function() {
+  var subject;
+  beforeEach(function() {
+    subject = App.PostsController.create();
+  });
+
+  describe("#index", function() {
+    describe("elements", function() {
+      it("saves a reference to the #container element", function() {
+        expect(subject.elements.index.pageContainer).to.equal("#container");
+      });
+    });
+  });
+});
 ```
 
-This should be everything you need to design and test basic client-side interactions with JSkit. If you'd like to see a working example check out [this repo](https://github.com/daytonn/jskit_rails-example).
+### Testing Events
+
+Testing events is just as easy as testing elements:
+
+```js
+// app/assets/javscripts/controllers/posts_controller.js
+App.createController("Posts", {
+  elements: {
+    index: {
+      expandCommentsButton: ["#expand-comments", {
+        click: "handleExpandCommentsClick"
+      }]
+    }
+  },
+
+  handleExpandCommentsClick: function() {
+    ...
+  }
+});
+```
+
+```js
+// spec/javscripts/controllers/posts_controller_spec.js
+describe("PostsController", function() {
+  var subject;
+  beforeEach(function() {
+    subject = App.PostsController.create();
+  });
+
+  describe("#index", function() {
+    describe("events", function() {
+      it("wires up `handleExpandCommentsClick` on click of the $expandCommentsButton", function() {
+        expect(subject.events.index.expandCommentsButton[1].click).to.equal("handleExpandCommentsClick");
+      });
+    });
+  });
+});
+```

data/lib/generators/jskit/install/install_generator.rb

@@ -77,17 +77,6 @@ module Jskit
         "app/assets/javascripts/application.js"
       end
 
-      def add_js_to_manifest
-        if File.exists? js_manifest
-          if has_jquery?
-            insert_into_file js_manifest, "//= require lodash\n", before: "//= require jquery\n" unless has_lodash?
-          else
-            append_to_file js_manifest, "//= require lodash\n//= require jquery\n"
-          end
-          append_to_file js_manifest, "//= require rails_jskit\n//= require_tree ./controllers\n"
-        end
-      end
-
       private
 
       def application_js

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_jskit
 version: !ruby/object:Gem::Version
-  version: 5.0.0
+  version: 5.0.1
 platform: ruby
 authors:
 - Dayton Nolan
@@ -28,14 +28,14 @@ dependencies:
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency