ember-cli-rails 0.3.5 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 269cca62213a6466d7e7b58d80d5c9f31b005d0a
-  data.tar.gz: 5a01d70f39f4f687fcce55cbb4b67a84917606da
+  metadata.gz: e0ced9f81d08893b0a32775f612145b178f26186
+  data.tar.gz: da368e823ef425a5dd400d87cac02ed2d4761142
 SHA512:
-  metadata.gz: 3c35c6382b5f46a36b8c1f86fda2dcb334cb195449de7f2e8fdd9d50edac0ca547891e6a0fc101d9d6b18f2232c0b56064abf02cf9844455fd05d6d6091dba82
-  data.tar.gz: b60d52853245dd408059a991f6e12f23d3b2ef2163b54d8e4423555bb85e0427fe05f99d9aceb91fd29f8ef710e506ea41d6446f04c524884110db67ca2c654a
+  metadata.gz: f097c1b1201e2a1d46ae8f78eaf0ba550dadb36ea10768dbce51840ad1d9a633d80a22160e5cb41e03f4c3727b15f923b9b5c73b685888c65322ba56a216129e
+  data.tar.gz: e2829b586d65a12e8592e3f74ebe501eb443f1ab713bd241ef42215d4772cf24c61f2dcfdec05ac1bdad4d285595ac3bd549b9711fdd0e868dc36ffa0ca83600

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+master
+------
+
+0.4.0
+-----
+
+* Extend `include_ember_index_html` helper to accept a block. The contents of
+  the block will be injected into the page
+* Drop support for Ruby `< 2.1.0` and Rails `4.0.0, < 3.2.0`
+* Introduce `rails g ember-cli:heroku` generator to configure a project for
+  deploying to Heroku
+* Introduce `include_ember_index_html` helper
+
 0.3.5
 -----
 

data/LICENSE.txt

@@ -1,3 +1,4 @@
+Copyright (c) 2015 Sean Doyle and thoughtbot, inc.
 Copyright (c) 2014 Pavel Pravosud
 
 MIT License

data/README.md

@@ -1,16 +1,16 @@
-# EmberCLI Rails
+# Ember CLI Rails
 
-EmberCLI Rails is an integration story between (surprise suprise) EmberCLI and
+Ember CLI Rails is an integration story between (surprise surprise) Ember CLI and
 Rails 3.1 and up. It is designed to provide an easy way to organize your Rails backed
-EmberCLI application with a specific focus on upgradeability. Rails and Ember
-[slash EmberCLI] are maintained by different teams with different goals. As
+Ember CLI application with a specific focus on upgradeability. Rails and Ember
+[slash Ember CLI] are maintained by different teams with different goals. As
 such, we believe that it is important to ensure smooth upgrading of both
 aspects of your application.
 
 A large contingent of Ember developers use Rails. And Rails is awesome. With
 the upcoming changes to Ember 2.0 and the Ember community's desire to unify
-around EmberCLI it is now more important than ever to ensure that Rails and
-EmberCLI can coexist and development still be fun!
+around Ember CLI it is now more important than ever to ensure that Rails and
+Ember CLI can coexist and development still be fun!
 
 To this end we have created a minimum set of features (which we will outline
 below) to allow you keep your Rails workflow while minimizing the risk of
@@ -19,7 +19,7 @@ upgrade pain with your Ember build tools.
 For example, end-to-end tests with frameworks like Cucumber should just work.
 You should still be able leverage the asset pipeline, and all the conveniences
 that Rails offers. And you should get all the new goodies like ES6 modules and
-EmberCLI addons too! Without further ado, let's get in there!
+Ember CLI addons too! Without further ado, let's get in there!
 
 ## Installation
 
@@ -46,12 +46,15 @@ end
 
 ##### options
 
-- app - this represents the name of the EmberCLI application.
+- `app` - this represents the name of the Ember CLI application.
 
-- path - the path, where your EmberCLI applications is located. The default
+- `build_timeout` - seconds to allow Ember to build the application before
+  timing out
+
+- `path` - the path where your Ember CLI application is located. The default
   value is the name of your app in the Rails root.
 
-- enable - a lambda that accepts each requests' path. The default value is a
+- `enable` - a lambda that accepts each request's path. The default value is a
   lambda that returns `true`.
 
 ```ruby
@@ -63,20 +66,24 @@ EmberCLI.configure do |c|
 end
 ```
 
-Once you've updated your initializer to taste, you need to install the
-[ember-cli-rails-addon](https://github.com/rondale-sc/ember-cli-rails-addon).
+Once you've updated your initializer to taste, install Ember CLI if it is not already installed, and use it to generate your Ember CLI app in the location/s specified in the initializer. For example:
+
+```sh
+cd frontend
+ember init
+```
 
-For each of your EmberCLI applications install the addon with:
+You will also need to install the [ember-cli-rails-addon](https://github.com/rondale-sc/ember-cli-rails-addon). For each of your Ember CLI applications, run:
 
 ```sh
-npm install --save-dev ember-cli-rails-addon@0.0.11
+npm install --save-dev ember-cli-rails-addon@0.0.13
 ```
 
-And that's it!
+And that's it! You should now be able to start up your Rails server and see your Ember CLI app.
 
-### Multiple EmberCLI apps
+### Multiple Ember CLI apps
 
-In the initializer you may specify multiple EmberCLI apps, each of which can be
+In the initializer you may specify multiple Ember CLI apps, each of which can be
 referenced with the view helper independently. You'd accomplish this like so:
 
 ```ruby
@@ -88,35 +95,124 @@ end
 
 ## Usage
 
-You render your EmberCLI app by including the corresponding JS/CSS tags in whichever
-Rails view you'd like the Ember app to appear.
+First, specify in your controller that you don't want to render the layout
+(since EmberCLI's `index.html` is a fully-formed HTML document):
+
+```rb
+# app/controllers/application.rb
+class ApplicationController < ActionController::Base
+  def index
+    render layout: false
+  end
+end
+```
+
+To render the EmberCLI generated `index.html` into the view,
+use the `include_ember_index_html` helper:
+
+
+```erb
+<!-- /app/views/application/index.html.erb -->
+<%= include_ember_index_html :frontend %>
+```
+
+To inject markup into page, pass in a block that accepts the `head`, and
+(optionally) the `body`:
+
+```erb
+<!-- /app/views/application/index.html.erb -->
+<%= include_ember_index_html :frontend do |head| %>
+  <%= head.append do %>
+    <%= csrf_meta_tags %>
+  <% end %>
+<% end %>
+```
+
+The asset paths will be replaced with asset pipeline generated paths.
 
-For example, if you had the following Rails app
+*NOTE*
+
+This helper **requires** that the `index.html` file exists.
+
+If you see `Errno::ENOENT` errors in development, your requests are timing out
+before EmberCLI finishes compiling the application.
+
+To prevent race conditions, increase your `build_timeout` to ensure that the
+build finishes before your request is processed.
+
+### Rendering the EmberCLI generated JS and CSS
+
+In addition to rendering the EmberCLI generated `index.html`, you can inject the
+`<script>` and `<link>` tags into your Rails generated views:
+
+```erb
+<!-- /app/views/application/index.html.erb -->
+<%= include_ember_script_tags :frontend %>
+<%= include_ember_stylesheet_tags :frontend %>
+```
+
+### Other routes
+
+Rendering Ember applications at routes other than `/` requires additional setup to avoid an Ember `UnrecognizedURLError`.
+
+For instance, if you had Ember applications named  `:frontend` and `:admin_panel` and you wanted to serve them at `/frontend` and `/admin_panel`, you would set up the following Rails routes:
 
 ```rb
 # /config/routes.rb
 Rails.application.routes.draw do
   root 'application#index'
+  get  'frontend'    => 'frontend#index'
+  get  'admin_panel' => 'admin_panel#index'
 end
 
-# /app/controllers/application_controller.rb
-class ApplicationController < ActionController::Base
+# /app/controllers/frontend_controller.rb
+class FrontendController < ActionController::Base
+  def index
+    render :index
+  end
+end
+
+# /app/controllers/admin_panel_controller.rb
+class AdminPanelController < ActionController::Base
   def index
     render :index
   end
 end
 ```
 
-and if you had created an Ember app `:frontend` in your initializer, then you
-could render your app at the `/` route with the following view:
+Additionally, you would have to modify each Ember app's `baseURL` to point to the correct route:
 
-```erb
-<!-- /app/views/application/index.html.erb -->
-<%= include_ember_script_tags :frontend %>
-<%= include_ember_stylesheet_tags :frontend %>
+```javascript
+/* /app/frontend/config/environment.js */
+module.exports = function(environment) {
+  var ENV = {
+    modulePrefix: 'frontend',
+    environment: environment,
+    baseURL: '/frontend', // originally '/'
+    ...
+  }
+}
+
+/* /app/admin_panel/config/environment.js */
+module.exports = function(environment) {
+  var ENV = {
+    modulePrefix: 'admin_panel',
+    environment: environment,
+    baseURL: '/admin_panel',  // originally '/'
+    ...
+  }
+}
 ```
+Lastly, you would configure each app's `router.js` file so that `rootURL` points to the `baseURL` you just created:
 
-Your Ember application will now be served at the `/` route.
+```javascript
+/* app/frontend/app/router.js */
+var Router = Ember.Router.extend({
+  rootURL:  config.baseURL, // add this line
+  location: config.locationType
+});
+```
+Repeat for `app/admin_panel/app/router.js`. Now your Ember apps will render properly at the alternative routes.
 
 ## CSRF Tokens
 
@@ -167,9 +263,21 @@ example, `/ember-tests`) and the name of the Ember app.
 For example, to view tests of the `frontend` app, visit
 `http://localhost:3000/ember-tests/frontend`.
 
+## Serving from multi-process servers in development
+
+If you're using a multi-process server ([Puma], [Unicorn], etc.) in development,
+make sure it's configured to run a single worker process.
+
+Without restricting the server to a single process, [it is possible for multiple
+EmberCLI runners to clobber each others' work][#94].
+
+[Puma]: https://github.com/puma/puma
+[Unicorn]: https://rubygems.org/gems/unicorn
+[#94]: https://github.com/thoughtbot/ember-cli-rails/issues/94#issuecomment-77627453
+
 ## Enabling LiveReload
 
-In order to get LiveReload up and running with EmberCLI Rails, you can install
+In order to get LiveReload up and running with Ember CLI Rails, you can install
 [guard](https://github.com/guard/guard) and
 [guard-livereload](https://github.com/guard/guard-livereload) gems, run `guard
 init` and then add the following to your `Guardfile`.
@@ -182,12 +290,12 @@ guard "livereload" do
 end
 ```
 
-This tells Guard to watch your EmberCLI app for any changes to the JavaScript,
+This tells Guard to watch your Ember CLI app for any changes to the JavaScript,
 Handlebars, HTML, or CSS files within `app` path. Take note that other
 extensions can be added to the line (such as `coffee` for CoffeeScript) to
 watch them for changes as well.
 
-*NOTE:* EmberCLI creates symlinks in `your-appname/tmp` directory, which cannot
+*NOTE:* Ember CLI creates symlinks in `your-appname/tmp` directory, which cannot
  be handled properly by Guard. This might lead to performance issues on some
  platforms (most notably on OSX), as well as warnings being printed by latest
  versions of Guard. As a work-around, one might use
@@ -202,62 +310,58 @@ directories %w[app config lib spec your-appname/app]
 
 ## Heroku
 
-In order to deploy EmberCLI Rails app to Heroku:
+To configure your Ember CLI Rails app to be ready to deploy on Heroku:
 
-First, enable Heroku Multi Buildpack by running the following command:
+1. Run `rails g ember-cli:heroku` generator
+1. [Add the NodeJS buildpack][buildpack] and configure NPM to include the
+   `bower` dependency's executable file.
 
 ```sh
-heroku buildpacks:set https://github.com/heroku/heroku-buildpack-multi
+heroku buildpacks:add --index 1 https://github.com/heroku/heroku-buildpack-nodejs
+heroku config:set NPM_CONFIG_PRODUCTION=false
 ```
 
-Next, specify which buildpacks to use by creating a `.buildpacks` file in the project root containing:
+You should be ready to deploy.
 
-```
-https://github.com/heroku/heroku-buildpack-nodejs
-https://github.com/heroku/heroku-buildpack-ruby
-```
+**NOTE** Run the generator each time you introduce additional EmberCLI
+applications into the project.
 
-Add `rails_12factor` gem to your production group in Gemfile, then run `bundle
-install`:
+[buildpack]: https://devcenter.heroku.com/articles/using-multiple-buildpacks-for-an-app#adding-a-buildpack
 
-```ruby
-gem "rails_12factor", group: :production
-```
-
-Add a `package.json` file containing `{}` to the root of your Rails project.
-This is to make sure it'll be detected by the NodeJS buildpack.
+## Capistrano
 
-Make sure you have `bower` as a npm dependency of your ember-cli app.
+To deploy an EmberCLI-Rails application with Capistrano, make sure your
+EmberCLI app's `package.json` file includes the `bower` package as a development
+dependency:
 
-Add a `postinstall` task to your EmberCLI app's `package.json`. This will
-ensure that during the deployment process, Heroku will install all dependencies
-found in both `node_modules` and `bower_components`.
-
-```javascript
+```json
 {
-  # ...
-  "scripts": {
-    # ...
-    "postinstall": "node_modules/bower/bin/bower install"¬
+  "devDependencies": {
+    "bower": "*"
   }
 }
 ```
 
-ember-cli-rails adds your ember apps' build process to the rails asset compilation process.
+## Experiencing Slow Build/Deploy Times?
+Remove `ember-cli-uglify` from your `package.json` file, and run
+`npm remove ember-cli-uglify`. This will improve your build/deploy
+time by about 10 minutes.
 
-Now you should be ready to deploy.
+The reason build/deploy times were slow is because ember uglified the JS and
+then added the files to the asset pipeline. Rails would then try and uglify
+the JS again, and this would be considerably slower than normal.
 
 ## Additional Information
 
-When running in the development environment, EmberCLI Rails runs `ember build`
+When running in the development environment, Ember CLI Rails runs `ember build`
 with the `--output-path` and `--watch` flags on. The `--watch` flag tells
-EmberCLI to watch for file system events and rebuild when an EmberCLI file is
+Ember CLI to watch for file system events and rebuild when an Ember CLI file is
 changed. The `--output-path` flag specifies where the distribution files will
-be put. EmberCLI Rails does some fancy stuff to get it into your asset path
+be put. Ember CLI Rails does some fancy stuff to get it into your asset path
 without polluting your git history. Note that for this to work, you must have
 `config.consider_all_requests_local = true` set in
 `config/environments/development.rb`, otherwise the middleware responsible for
-building EmberCLI will not be enabled.
+building Ember CLI will not be enabled.
 
 Alternatively, if you want to override the default behavior in any given Rails
 environment, you can manually set the `config.use_ember_middleware` and
@@ -290,6 +394,17 @@ if (environment === 'development') {
 
 [ember-cli-mirage]: http://ember-cli-mirage.com/docs/latest/
 
+### `SKIP_EMBER`
+
+To disable asset compilation entirely, set an environment variable
+`SKIP_EMBER=1`.
+
+This can be useful when an application's frontend is developed locally with
+EmberCLI-Rails, but deployed separately (for example, with
+[ember-cli-deploy][ember-cli-deploy]).
+
+[ember-cli-deploy]: https://github.com/ember-cli/ember-cli-deploy
+
 #### Ember Dependencies
 
 Ember has several dependencies. Some of these dependencies might already be
@@ -307,10 +422,54 @@ end
 
 jQuery and Handlebars are the main use cases for this flag.
 
+## Ruby and Rails support
+
+This project supports:
+
+* Ruby versions `>= 2.1.0`
+* Rails `3.2.x` and `>=4.1.x`.
+
+To learn more about supported versions and upgrades, read the [upgrading guide].
+
+[upgrading guide]: /UPGRADING.md
+
 ## Contributing
 
-1. Fork it (https://github.com/rwz/ember-cli-rails/fork)
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
+See the [CONTRIBUTING] document.
+Thank you, [contributors]!
+
+  [CONTRIBUTING]: CONTRIBUTING.md
+  [contributors]: https://github.com/thoughtbot/ember-cli-rails/graphs/contributors
+
+## License
+
+Open source templates are Copyright (c) 2015 thoughtbot, inc.
+It contains free software that may be redistributed
+under the terms specified in the [LICENSE] file.
+
+[LICENSE]: /LICENSE.txt
+
+## About
+
+ember-cli-rails was originally created by
+[Pavel Pravosud][rwz] and
+[Jonathan Jackson][rondale-sc].
+
+ember-cli-rails is maintained by [Sean Doyle][seanpdoyle] and [Jonathan
+Jackson][rondale-sc].
+
+[rwz]: https://github.com/rwz
+[rondale-sc]: https://github.com/rondale-sc
+[seanpdoyle]: https://github.com/seanpdoyle
+
+![thoughtbot](https://thoughtbot.com/logo.png)
+
+ember-cli-rails is maintained and funded by thoughtbot, inc.
+The names and logos for thoughtbot are trademarks of thoughtbot, inc.
+
+We love open source software!
+See [our other projects][community]
+or [hire us][hire] to help build your product.
+
+  [community]: https://thoughtbot.com/community?utm_source=github
+  [hire]: https://thoughtbot.com/hire-us?utm_source=github

data/app/helpers/ember_rails_helper.rb

@@ -1,9 +1,25 @@
+require "ember-cli/capture"
+
 module EmberRailsHelper
-  def include_ember_script_tags(name, options={})
-    javascript_include_tag *EmberCLI[name].exposed_js_assets, options
+  def include_ember_index_html(name, &block)
+    markup_capturer = EmberCLI::Capture.new(sprockets: self, &block)
+
+    head, body = markup_capturer.capture
+
+    html = EmberCLI[name].index_html(
+      sprockets: self,
+      head: head,
+      body: body,
+    )
+
+    render inline: html
+  end
+
+  def include_ember_script_tags(name, **options)
+    javascript_include_tag(*EmberCLI[name].exposed_js_assets, options)
   end
 
-  def include_ember_stylesheet_tags(name, options={})
-    stylesheet_link_tag *EmberCLI[name].exposed_css_assets, options
+  def include_ember_stylesheet_tags(name, **options)
+    stylesheet_link_tag(*EmberCLI[name].exposed_css_assets, options)
   end
 end

data/lib/ember-cli/app.rb

@@ -1,8 +1,10 @@
 require "timeout"
+require "ember-cli/html_page"
+require "ember-cli/asset_resolver"
 
 module EmberCLI
   class App
-    ADDON_VERSION = "0.0.12"
+    ADDON_VERSION = "0.0.13"
     EMBER_CLI_VERSIONS = [ "~> 0.1.5", "~> 0.2.0", "~> 1.13" ]
 
     class BuildError < StandardError; end
@@ -11,7 +13,7 @@ module EmberCLI
 
     delegate :root, to: :paths
 
-    def initialize(name, options={})
+    def initialize(name, **options)
       @name, @options = name.to_s, options
       @paths = PathSet.new(self)
     end
@@ -21,13 +23,29 @@ module EmberCLI
         prepare
         silence_build{ exec command }
         check_for_build_error!
+        copy_index_html_file
         true
       end
     end
 
     def install_dependencies
-      exec "#{bundler_path} install" if gemfile_path.exist?
-      exec "#{npm_path} install"
+      if gemfile_path.exist?
+        exec "#{bundler_path} install"
+      end
+
+      exec "#{npm_path} prune && #{npm_path} install"
+
+      if bower_path.nil?
+        fail <<-FAIL
+          Bower is required by EmberCLI.
+
+          Install it with:
+
+              $ npm install -g bower
+        FAIL
+      else
+        exec "#{bower_path} prune && #{bower_path} install"
+      end
     end
 
     def run
@@ -36,6 +54,7 @@ module EmberCLI
       cmd = command(watch: true)
       @pid = exec(cmd, method: :spawn)
       Process.detach pid
+      copy_index_html_file
       set_on_exit_callback
     end
 
@@ -49,12 +68,32 @@ module EmberCLI
       @pid = nil
     end
 
+    def index_html(sprockets:, head:, body:)
+      asset_resolver = AssetResolver.new(
+        app: self,
+        sprockets: sprockets,
+      )
+      html_page = HtmlPage.new(
+        asset_resolver: asset_resolver,
+        content: index_file.read,
+        head: head,
+        body: body,
+      )
+
+      html_page.render
+    end
+
     def exposed_js_assets
-      %W[#{name}/vendor #{name}/#{ember_app_name}]
+      [vendor_assets, application_assets]
     end
+    alias exposed_css_assets exposed_js_assets
 
-    def exposed_css_assets
-      %W[#{name}/vendor #{name}/#{ember_app_name}]
+    def vendor_assets
+      "#{name}/vendor"
+    end
+
+    def application_assets
+      "#{name}/#{ember_app_name}"
     end
 
     def wait
@@ -150,6 +189,7 @@ module EmberCLI
 
     def prepare
       @prepared ||= begin
+        check_dependencies!
         check_addon!
         check_ember_cli_version!
         reset_build_error!
@@ -189,8 +229,39 @@ module EmberCLI
       end
     end
 
+    def check_dependencies!
+      unless node_modules_present?
+        fail <<-MSG.strip_heredoc
+          EmberCLI app dependencies are not installed. From your Rails application root please run:
+
+            $ bundle exec rake ember:install
+
+          If you do not require Ember at this URL, you can restrict this check using the `enable`
+          option in the EmberCLI initializer.
+        MSG
+      end
+    end
+
+    def assets_path
+      paths.assets.join(name)
+    end
+
+    def copy_index_html_file
+      if environment == "production"
+        FileUtils.cp(assets_path.join("index.html"), index_file)
+      end
+    end
+
+    def index_file
+      if environment == "production"
+        applications_path.join("#{name}.html")
+      else
+        dist_path.join("index.html")
+      end
+    end
+
     def symlink_to_assets_root
-      assets_path.join(name).make_symlink dist_path.join("assets")
+      assets_path.make_symlink dist_path.join("assets")
     rescue Errno::EEXIST
       # Sometimes happens when starting multiple Unicorn workers.
       # Ignoring...
@@ -200,14 +271,18 @@ module EmberCLI
       Rails.configuration.assets.precompile << /\A#{name}\//
     end
 
-    def command(options={})
-      watch = ""
-      if options[:watch]
-        watch = "--watch"
-        watch += " --watcher #{watcher}" if watcher
+    def command(watch: false)
+      watch_flag = ""
+
+      if watch
+        watch_flag = "--watch"
+
+        if watcher
+          watch_flag += " --watcher #{watcher}"
+        end
       end
 
-      "#{ember_path} build #{watch} --environment #{environment} --output-path #{dist_path} #{log_pipe}"
+      "#{ember_path} build #{watch_flag} --environment #{environment} --output-path #{dist_path} #{log_pipe}"
     end
 
     def log_pipe
@@ -223,7 +298,17 @@ module EmberCLI
     end
 
     def package_json
-      @package_json ||= JSON.parse(package_json_file_path.read).with_indifferent_access
+      @package_json ||=
+        JSON.parse(package_json_file_path.read).with_indifferent_access
+    end
+
+    def addon_package_json
+      @addon_package_json ||=
+        JSON.parse(addon_package_json_file_path.read).with_indifferent_access
+    end
+
+    def addon_version
+      addon_package_json.fetch("version")
     end
 
     def dev_dependencies
@@ -231,8 +316,12 @@ module EmberCLI
     end
 
     def addon_present?
-      dev_dependencies["ember-cli-rails-addon"] == ADDON_VERSION &&
-        addon_package_json_file_path.exist?
+      addon_package_json_file_path.exist? &&
+        addon_version == ADDON_VERSION
+    end
+
+    def node_modules_present?
+      node_modules_path.exist?
     end
 
     def excluded_ember_deps
@@ -240,19 +329,17 @@ module EmberCLI
     end
 
     def env_hash
-      ENV.clone.tap do |vars|
-        vars.store "RAILS_ENV", Rails.env
-        vars.store "DISABLE_FINGERPRINTING", "true"
-        vars.store "EXCLUDE_EMBER_ASSETS", excluded_ember_deps
-        vars.store "BUNDLE_GEMFILE", gemfile_path.to_s if gemfile_path.exist?
+      ENV.to_h.tap do |vars|
+        vars["RAILS_ENV"] = Rails.env
+        vars["DISABLE_FINGERPRINTING"] = "true"
+        vars["EXCLUDE_EMBER_ASSETS"] = excluded_ember_deps
+        vars["BUNDLE_GEMFILE"] = gemfile_path.to_s if gemfile_path.exist?
       end
     end
 
-    def exec(cmd, options={})
-      method_name = options.fetch(:method, :system)
-
+    def exec(cmd, method: :system)
       Dir.chdir root do
-        Kernel.public_send(method_name, env_hash, cmd, err: :out)
+        Kernel.public_send(method, env_hash, cmd, err: :out)
       end
     end
 

data/lib/ember-cli/asset_resolver.rb

@@ -0,0 +1,54 @@
+module EmberCLI
+  class AssetResolver
+    def initialize(app:, sprockets:)
+      @app = app
+      @sprockets = sprockets
+    end
+
+    def resolve_urls(html_content)
+      mappings.reduce(html_content) do |resolved_content, (asset, new_path)|
+        resolved_content.gsub(%{"assets/#{asset}"}, %{"#{new_path}"})
+      end
+    end
+
+    private
+
+    def mappings
+      {
+        "#{name}.js" => application.js,
+        "#{name}.css" => application.css,
+        "vendor.js" => vendor.js,
+        "vendor.css" => vendor.css,
+      }
+    end
+
+    def name
+      @app.name
+    end
+
+    def application
+      AssetPath.new(@sprockets, @app.application_assets)
+    end
+
+    def vendor
+      AssetPath.new(@sprockets, @app.vendor_assets)
+    end
+
+    class AssetPath
+      def initialize(sprockets, assets)
+        @sprockets = sprockets
+        @assets = assets
+      end
+
+      def js
+        @sprockets.asset_path(@assets, type: :javascript)
+      end
+
+      def css
+        @sprockets.asset_path(@assets, type: :stylesheet)
+      end
+    end
+
+    private_constant :AssetPath
+  end
+end

data/lib/ember-cli/capture.rb

@@ -0,0 +1,76 @@
+module EmberCLI
+  SKIP_CAPTURE = ["", ""].freeze
+
+  class Capture
+    def initialize(sprockets:, &block)
+      @sprockets = sprockets
+      @block = block
+    end
+
+    def capture
+      if block.present?
+        capture_block
+      else
+        SKIP_CAPTURE
+      end
+    end
+
+    private
+
+    attr_reader :block, :sprockets
+
+    def capture_block
+      if block.arity > 0
+        block.call(*block_arguments)
+      end
+
+      [captured_head.content, captured_body.content]
+    end
+
+    def block_arguments
+      [captured_head, captured_body].first(block.arity)
+    end
+
+    def captured_body
+      @captured_body ||= Block.new(sprockets)
+    end
+
+    def captured_head
+      @captured_head ||= begin
+        if block.arity < 1
+          BlockWithoutArguments.new(sprockets, &block)
+        else
+          Block.new(sprockets)
+        end
+      end
+    end
+
+    class BlockWithoutArguments
+      def initialize(sprockets, &block)
+        @sprockets = sprockets
+        @block = block
+      end
+
+      def content
+        @sprockets.capture(&@block)
+      end
+    end
+    private_constant :BlockWithoutArguments
+
+    class Block
+      def initialize(sprockets)
+        @sprockets = sprockets
+        @content = []
+      end
+
+      def append(&block)
+        @content.push(@sprockets.capture(&block))
+      end
+
+      def content
+        @content.join
+      end
+    end
+    private_constant :Block
+  end
+end

data/lib/ember-cli/configuration.rb

@@ -4,7 +4,7 @@ module EmberCLI
   class Configuration
     include Singleton
 
-    def app(name, options={})
+    def app(name, **options)
       apps.store name, App.new(name, options)
     end
 
@@ -17,6 +17,10 @@ module EmberCLI
       @tee_path = Helpers.which("tee")
     end
 
+    def bower_path
+      @bower_path ||= Helpers.which("bower")
+    end
+
     def npm_path
       @npm_path ||= Helpers.which("npm")
     end

data/lib/ember-cli/html_page.rb

@@ -0,0 +1,56 @@
+module EmberCLI
+  class HtmlPage
+    def initialize(content:, asset_resolver:, head: "", body: "")
+      @content = content
+      @asset_resolver = asset_resolver
+      @head = head
+      @body = body
+    end
+
+    def render
+      if has_head_tag?
+        insert_head_content
+      end
+
+      if has_body_tag?
+        insert_body_content
+      end
+
+      html
+    end
+
+    private
+
+    def has_head_tag?
+      head_tag_index >= 0
+    end
+
+    def has_body_tag?
+      body_tag_index >= 0
+    end
+
+    def insert_head_content
+      html.insert(head_tag_index, @head.to_s)
+    end
+
+    def insert_body_content
+      html.insert(body_tag_index, @body.to_s)
+    end
+
+    def html
+      @html ||= resolved_html
+    end
+
+    def head_tag_index
+      html.index("</head") || -1
+    end
+
+    def body_tag_index
+      html.index("</body") || -1
+    end
+
+    def resolved_html
+      @asset_resolver.resolve_urls(@content)
+    end
+  end
+end

data/lib/ember-cli/path_set.rb

@@ -37,6 +37,10 @@ module EmberCLI
       EmberCLI.root.join("assets").tap(&:mkpath)
     end
 
+    define_path :applications do
+      Rails.root.join("public", "_apps").tap(&:mkpath)
+    end
+
     define_path :gemfile do
       root.join("Gemfile")
     end
@@ -49,6 +53,10 @@ module EmberCLI
       root.join("package.json")
     end
 
+    define_path :node_modules do
+      root.join("node_modules")
+    end
+
     define_path :ember do
       root.join("node_modules", ".bin", "ember").tap do |path|
         fail <<-MSG.strip_heredoc unless path.executable?
@@ -70,6 +78,10 @@ module EmberCLI
       app_options.fetch(:tee_path){ configuration.tee_path }
     end
 
+    define_path :bower do
+      app_options.fetch(:bower_path) { configuration.bower_path }
+    end
+
     define_path :npm do
       app_options.fetch(:npm_path){ configuration.npm_path }
     end

data/lib/ember-cli/version.rb

@@ -1,3 +1,3 @@
 module EmberCLI
-  VERSION = "0.3.5".freeze
+  VERSION = "0.4.0".freeze
 end

data/lib/generators/ember-cli/heroku/USAGE

@@ -0,0 +1,17 @@
+Description:
+    Configures a project for deploying to Heroku.
+
+    Once the generator is complete, execute the following:
+
+        heroku buildpacks:add --index 1 https://github.com/heroku/heroku-buildpack-nodejs
+        heroku config:set NPM_CONFIG_PRODUCTION=false
+
+Example:
+    rails generate ember-cli:heroku
+
+    This will install the following gems:
+        rails_12factor
+
+    This will create:
+        bin/heroku_install
+        package.json

data/lib/generators/ember-cli/heroku/heroku_generator.rb

@@ -0,0 +1,26 @@
+module EmberCLI
+  class HerokuGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+
+    namespace "ember-cli:heroku"
+
+    def copy_package_json_file
+      template "package.json.erb", "package.json"
+    end
+
+    def copy_setup_heroku_file
+      template "bin_heroku_install.erb", "bin/heroku_install"
+      run "chmod a+x bin/heroku_install"
+    end
+
+    def inject_12factor_gem
+      gem "rails_12factor", group: [:staging, :production]
+    end
+
+    def app_paths
+      EmberCLI.apps.values.map do |app|
+        app.root.relative_path_from(Rails.root)
+      end
+    end
+  end
+end

data/lib/generators/ember-cli/heroku/templates/bin_heroku_install.erb

@@ -0,0 +1,13 @@
+#!/usr/bin/env sh
+
+set -e
+
+bower="$(pwd)/node_modules/.bin/bower"
+
+for app in <%= app_paths.map { |app_path| %{"#{app_path}"} }.join(" ") -%>; do
+  cd $app &&
+    npm prune &&
+    npm install &&
+    $bower prune &&
+    $bower install
+done

data/lib/generators/ember-cli/heroku/templates/package.json.erb

@@ -0,0 +1,15 @@
+{
+  "scripts": {
+    "postinstall": "./bin/heroku_install"
+  },
+  "devDependencies": {
+    "bower": "*"
+  },
+  "cacheDirectories": [
+    <%- app_paths.each do |app_path| -%>
+    "<%= app_path %>/node_modules",
+    "<%= app_path %>/bower_components",
+    <%- end -%>
+    "node_modules"
+  ]
+}

data/lib/tasks/ember-cli.rake

@@ -15,4 +15,11 @@ namespace :ember do
   end
 end
 
-task "assets:precompile" => "ember:compile" unless EmberCLI.skip?
+unless EmberCLI.skip?
+  # Hook into assets:precompile:all for Rails 3.1+
+  if Rails::VERSION::MAJOR < 4
+    task "assets:precompile:all" => "ember:compile"
+  else
+    task "assets:precompile" => "ember:compile"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ember-cli-rails
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors:
 - Pavel Pravosud
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-03 00:00:00.000000000 Z
+date: 2015-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
@@ -28,7 +28,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '5'
@@ -63,18 +63,25 @@ files:
 - config/routes.rb
 - lib/ember-cli-rails.rb
 - lib/ember-cli/app.rb
+- lib/ember-cli/asset_resolver.rb
+- lib/ember-cli/capture.rb
 - lib/ember-cli/configuration.rb
 - lib/ember-cli/engine.rb
 - lib/ember-cli/helpers.rb
+- lib/ember-cli/html_page.rb
 - lib/ember-cli/middleware.rb
 - lib/ember-cli/path_set.rb
 - lib/ember-cli/runner.rb
 - lib/ember-cli/version.rb
+- lib/generators/ember-cli/heroku/USAGE
+- lib/generators/ember-cli/heroku/heroku_generator.rb
+- lib/generators/ember-cli/heroku/templates/bin_heroku_install.erb
+- lib/generators/ember-cli/heroku/templates/package.json.erb
 - lib/generators/ember-cli/init/USAGE
 - lib/generators/ember-cli/init/init_generator.rb
 - lib/generators/ember-cli/init/templates/initializer.rb
 - lib/tasks/ember-cli.rake
-homepage: https://github.com/rwz/ember-cli-rails
+homepage: https://github.com/thoughtbot/ember-cli-rails
 licenses:
 - MIT
 metadata: {}
@@ -86,7 +93,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -94,8 +101,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Integration between Ember CLI and Rails
 test_files: []
+has_rdoc: