ember-rails 0.14.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 916d617e38b6defe34e9a4fda6e864399d699a44
-  data.tar.gz: f4cf0a357c14a700944c601a5ef20b433a471b46
+  metadata.gz: 857d69b6457718515597605b4b7a6fee74eea6b0
+  data.tar.gz: 054906e52dc2d3d04d9ae241c4cfde1871cff4df
 SHA512:
-  metadata.gz: 3f1dd4bc588c9fe62bd10e04d19424cab5a28ed601e890d965f2be2b5a18b010113601e1f2058d688e71c49e20cd56b21ec302c6965040fb2ce01687b73fa9b6
-  data.tar.gz: d9614b02448d13537139e0f2bcbaec40dc7f7857252a6181ddcdd2cc40993a1e38a215f1fd66458c3a8c33e352a0466842501fb705fd92ca45cfb83dc58d95de
+  metadata.gz: e8fd238eacab85e0de0658485283faf51469fda6227f5257d41aab71f31871d8ab601066a6f9d8c3f29724c62c91a2a80f75910912b271d4daf70ce8228172a7
+  data.tar.gz: 5e8ad49780dec29b586c2b9b37bda647477010f8f9434828f867abe545d4e30b7c7404bdba249243a7117134847c4c72dc9ff58cf4bd4075d8f314c7bd971160

data/README.md

@@ -1,23 +1,20 @@
-# ember-rails  [![Build Status](https://secure.travis-ci.org/emberjs/ember-rails.png?branch=master)](http://travis-ci.org/emberjs/ember-rails) [![Dependency Status](https://gemnasium.com/emberjs/ember-rails.png)](https://gemnasium.com/emberjs/ember-rails)
+# ember-rails  [![Build Status](https://secure.travis-ci.org/emberjs/ember-rails.svg?branch=master)](http://travis-ci.org/emberjs/ember-rails) [![Dependency Status](https://gemnasium.com/emberjs/ember-rails.png)](https://gemnasium.com/emberjs/ember-rails)
 
 ember-rails makes developing an [Ember.JS](http://emberjs.com/) application much easier in Rails 3.1+.
 
 The following functionalities are included in this gem:
 - Pre-compiling of your handlebars templates when building your asset pipeline.
-- Includes development and production copies of Ember, [Ember Data](https://github.com/emberjs/data) and [Handlebars](https://github.com/wycats/handlebars.js).
-- Includes [ActiveModel::Serializer](https://github.com/rails-api/active_model_serializers) for integration with Ember Data.
+- Inclusion of development and production copies of Ember, [Ember Data](https://github.com/emberjs/data) and [Handlebars](https://github.com/wycats/handlebars.js).
+- Inclusion of [ActiveModel::Serializer](https://github.com/rails-api/active_model_serializers) for integration with Ember Data.
 
-You can see an example of how to use the gem [here](https://github.com/keithpitt/ember-rails-example). There is also a great tutorial by [Dan Gebhardt](https://twitter.com/#!/dgeb) called "[Beginning Ember.js on Rails](http://www.cerebris.com/blog/2012/01/24/beginning-ember-js-on-rails-part-1/)" which is a great read if you're just starting out with Rails and Ember.js
+You can see an example of how to use the gem [here](https://github.com/keithpitt/ember-rails-example). There is also a great tutorial by [Dan Gebhardt](https://twitter.com/#!/dgeb) called "[Beginning Ember.js on Rails](http://www.cerebris.com/blog/2012/01/24/beginning-ember-js-on-rails-part-1/)" which is a great read if you're just starting out with Rails and Ember.js.
 
 ## Getting started
 * Add the gem to your application Gemfile:
 
 ```ruby
 gem 'ember-rails'
-gem 'ember-source', '1.1.2' # or the version you need
-
-# optional since Handlebars 1.0.0 was released
-#gem 'handlebars-source', '~> 1.0.12' # or the version you need
+gem 'ember-source', '~> 1.9.0' # or the version you need
 ```
 
 * Run `bundle install`
@@ -29,9 +26,19 @@ rails generate ember:bootstrap
 
 * Restart your server (if it's running)
 
+## Building a new project from scratch
 
-Notes:
+Rails supports the ability to build projects from a template source ruby file.
+
+To build an Ember centric Rails project you can simply type the following into your command line:
 
+```
+rails new my_app -m http://emberjs.com/edge_template.rb
+```
+
+Read more about [Rails application templates](http://edgeguides.rubyonrails.org/rails_application_templates.html) and take a look at the edge_template.rb [source code](https://github.com/emberjs/website/blob/master/source/edge_template.rb).
+
+Notes:
 
 To install the latest builds of ember and ember-data. It should be noted that the
 examples in the [getting started guide](http://emberjs.com/guides/getting-started/)
@@ -41,35 +48,34 @@ have been designed to use the released version of ember:
 rails generate ember:install
 ```
 
-You'll probably need to clear out your cache after doing this with
+You'll probably need to clear out your cache after doing this with:
 
 ```shell
 rake tmp:clear
 ```
 
+Also, ember-rails includes some flags for the bootstrap generator:
+
+```
+--ember-path or -d   # custom ember path
+--skip-git or -g     # skip git keeps
+--javascript-engine  # engine for javascript (js, coffee or em)
+--app-name or -n     # custom ember app name
+```
+
+
 ## For CoffeeScript support
 
-1. Add coffee-rails to the Gemfile
+Add coffee-rails to the Gemfile
 ```ruby
 gem 'coffee-rails'
 ```
 
-2. Run the bootstrap generator in step 4 with an extra flag instead:
+Run the bootstrap generator in step 4 with an extra flag instead:
 ```sh
 rails g ember:bootstrap -g --javascript-engine coffee
 ```
 
-Note:
-
-Ember-rails include some flags options for bootstrap generator:
-
-```
---ember-path or -d # custom ember path
---skip-git or -g # skip git keeps
---javascript-engine  # engine for javascript (js or coffee)
---app-name or -n # custom ember app name
-```
-
 ## For EmberScript support
 
 [EmberScript](http://www.emberscript.com) is a dialect of CoffeeScript
@@ -88,45 +94,90 @@ You can now use the flag `--javascript-engine=em` to specify EmberScript
 assets in your generators, but all of the generators will default to
 using an EmberScript variant first.
 
+Note:
+
+Ember-rails include some flags options for bootstrap generator:
+
+```
+--ember-path or -d # custom ember path
+--skip-git or -g # skip git keeps
+--javascript-engine  # engine for javascript (js, coffee or em)
+--app-name or -n # custom ember app name
+```
+
 ## Configuration Options
 
-The following options are availabe for configuration in your application or environment level
+The following options are available for configuration in your application or environment-level
 config files (`config/application.rb`, `config/environments/development.rb`, etc.):
 
-* `config.ember.variant` - Used to determine which Ember variant to use. Valid options: `:development`, `:production`.
-* `config.ember.app_name` - Used to specify a default application name for all generators.
-* `config.ember.ember_path` - Used to specify a default custom root path for all generators.
-* `config.handlebars.precompile` - Used to enable or disable precompilation. Default value: `true`.
-* `config.handlebars.templates_root` - Set the root path (under `app/assets/javascripts`) for templates
-  to be looked up in. Default value: `"templates"`.
-* `config.handlebars.templates_path_separator` - The path separator to use for templates. Default value: `'/'`.
-* `config.handlebars.output_type` - Configures the style of output (options are `:amd` and `:global`).
-  Default value: `:global`.
+| Configuration Option                         | Description                                                                                                         |
+|----------------------------------------------|---------------------------------------------------------------------------------------------------------------------|
+| `config.ember.variant`                       | Determines which Ember variant to use. Valid options: `:development`, `:production`. Defaults to `:production` in production, and `:development` everywhere else.                               |
+| `config.ember.app_name`                      | Specificies a default application name for all generators.                                                          |
+| `config.ember.ember_path`                    | Specifies a default custom root path for all generators.                                                            |
+| `config.handlebars.precompile`               | Enables or disables precompilation. Default value: `true`.                                                          |
+| `config.handlebars.templates_root`           | Sets the root path (under `app/assets/javascripts`) for templates to be looked up in. Default value: `"templates"`. |
+| `config.handlebars.templates_path_separator` | The path separator to use for templates. Default value: `'/'`.                                                      |
+| `config.handlebars.output_type`              | Configures the style of output (options are `:amd` and `:global`). Default value: `:global`.                        |
+| `config.handlebars.amd_namespace`            | Configures the module prefix for AMD formatted output. Default value: `nil`.                        |
+| `config.handlebars.ember_template`           | Default which Ember template type to compile. Valid options: `'Handlebars', `HTMLBars`. Defaults to 'Handlebars`' when `Ember::VERSION` is under 1.10.0, `HTMLBars` when `Ember::VERSION` is over 1.10.0. |
+
+Note:
+
+In a mountable engine, ember-rails will not recognize any configurations.
+Instead, use command line options.
+
+## Enabling Features with Feature Flags
+See [the guide](http://emberjs.com/guides/configuring-ember/feature-flags/#toc_flagging-details) and check [features.json](https://github.com/emberjs/ember.js/blob/master/features.json) for the version of Ember you're using.
+
+If a feature is set to false, you will need to compile ember from source yourself to include it.
+
+### Important note for projects that render JSON responses
+
+ember-rails includes [active_model_serializers](https://github.com/rails-api/active_model_serializers) which affects how ActiveModel and ActiveRecord objects get serialized to JSON, such as when using `render json:` or `respond_with`. By default active_model_serializers adds root elements to these responses (such as adding `{"posts": [...]}` for `render json: @posts`) which will affect the structure of your JSON responses.
+
+To disable this effect on your JSON responses, put this in an initializer:
+```Ruby
+# Stop active_model_serializers from adding root elements to JSON responses.
+ActiveModel::Serializer.root = false
+ActiveModel::ArraySerializer.root = false
+```
+
+See the [active_model_serializers](https://github.com/rails-api/active_model_serializers) documentation for a more complete understanding of other effects this dependency might have on your app.
 
 ## Architecture
 
 Ember does not require an organized file structure. However, ember-rails allows you
 to use `rails g ember:bootstrap` to create the following directory structure under `app/assets/javascripts`:
 
-    controllers/
-    helpers/
-    components/
-    models/
-    routes/
-    templates/
-    templates/components
-    views/
+```
+├── adapters
+├── components
+├── controllers
+├── helpers
+├── mixins
+├── models
+├── practicality.js.coffee
+├── router.js.coffee
+├── routes
+├── store.js.coffee
+├── templates
+│   └── components
+└── views
+```
 
 Additionally, it will add the following lines to `app/assets/javascripts/application.js`.
 By default, it uses the Rails Application's name and creates an `rails_app_name.js`
-file to setup application namespace and initial requires:
-
-    //= require handlebars
-    //= require ember
-    //= require ember-data
-    //= require_self
-    //= require rails_app_name
-    RailsAppName = Ember.Application.create();
+file to set up application namespace and initial requires:
+
+```javascript
+//= require handlebars
+//= require ember
+//= require ember-data
+//= require_self
+//= require rails_app_name
+RailsAppName = Ember.Application.create();
+```
 
 *Example:*
 
@@ -146,6 +197,10 @@ file to setup application namespace and initial requires:
       create  app/assets/javascripts/templates/.gitkeep
       create  app/assets/javascripts/templates/components
       create  app/assets/javascripts/templates/components/.gitkeep
+      create  app/assets/javascripts/mixins
+      create  app/assets/javascripts/mixins/.gitkeep
+      create  app/assets/javascripts/adapters
+      create  app/assets/javascripts/adapters/.gitkeep
       create  app/assets/javascripts/app.js
 
 If you want to avoid `.gitkeep` files, use the `skip git` option like
@@ -158,8 +213,7 @@ and including the assets in your layout:
 
     <%= javascript_include_tag "templates/admin_panel" %>
 
-If you want to strip template root from template names, add `templates_root` option to your application configuration block.
-By default, `templates_root` is `'templates'`.
+If you want to avoid the `templates` prefix, set the `templates_root` option in your application configuration block:
 
     config.handlebars.templates_root = 'ember_templates'
 
@@ -184,40 +238,36 @@ Now a single line in the layout loads everything:
 
     <%= javascript_include_tag "templates/all" %>
 
-If you use Slim or Haml templates, you can use handlebars filter :
-
-    handlebars:
-        <button {{action anActionName}}>OK</button>
-
-It will be translated as :
-
-    <script type="text/x-handlebars">
-        <button {{action anActionName}}>OK</button>
-    </script>
-
 ### Note about ember components
 
 When necessary, ember-rails adheres to a conventional folder structure. To create an ember component you must define the handlebars file *inside* the *components* folder under the templates folder of your project to properly register your handlebars component file.
 
 *Example*
 
-With the following folder structure:
+Given the following folder structure:
 
-    components/
-    controllers/
-    helpers/
-    models/
-    routes/
-    templates/
-      components/
-        my-component.handlebars
-    views/
+```
+├── adapters
+├── components
+├── controllers
+├── helpers
+├── mixins
+├── models
+├── practicality.js.coffee
+├── router.js.coffee
+├── routes
+├── store.js.coffee
+├── templates
+│   └── components
+│       └── my-component.handlebars
+└── views
+```
 
-and a *my-component.handlebars* file with the following contents
+and a `my-component.handlebars` file with the following contents:
 
     <h1>My Component</h1>
 
-will produce the following handlebars output
+It will produce the following handlebars output:
 
     <script type="text/x-handlebars" id="components/my-component">
       <h1>My Component</h1>
@@ -227,33 +277,6 @@ You can reference your component inside your other handlebars template files by
 
      {{ my-component }}
 
-### A note about upgrading ember-rails and components
-The ember-rails project now includes generators for components. If you have an exisitng project and need
-to compile component files you will need to include the components folder as part of the asset pipeline.
-A typical project expects two folders for *components* related code:
-
-* `assets/javascripts/components/` to hold the component javascript source
-* `assets/javascripts/templates/components/` to hold the handlebars templates for your components
-
-Your asset pipeline require statements should include reference to both e.g.
-
-RailsAppName.js
-```
-//= require_tree ./templates
-//= require_tree ./components
-```
-
-or
-
-RailsAppName.js.coffee
-```
-#= require_tree ./templates
-#= require_tree ./components
-```
-
-These are automatically generated for you in new projects you when you run the `ember:bootstrap` generator.
-
-
 ## Specifying Different Versions of Ember/Handlebars/Ember-Data
 
 By default, ember-rails ships with the latest version of
@@ -265,7 +288,7 @@ To specify a different version that'll be used for both template
 precompilation and serving to the browser, you can specify the desired
 version of one of the above-linked gems in the Gemfile, e.g.:
 
-    gem 'ember-source', '1.0.0'
+    gem 'ember-source', '1.7.0'
 
 You can also specify versions of 'handlebars-source' and
 'ember-data-source', but note that an appropriate 'handlebars-source'
@@ -303,6 +326,22 @@ or for ember-data
 
     rails generate ember:install --tag=v1.0.0-beta.2 --ember-data
 
+## CSRF Token
+
+Rails [`protect_from_forgery`](http://api.rubyonrails.org/classes/ActionController/RequestForgeryProtection/ClassMethods.html#method-i-protect_from_forgery) requires CSRF token for every XHR except GET.
+The CSRF token is normally found in `app/views/layouts/application.html.*` inserted with the rails helper: [`csrf_meta_tags`](http://api.rubyonrails.org/classes/ActionView/Helpers/CsrfHelper.html#method-i-csrf_meta_tags).
+
+When you use [jquery-ujs](https://github.com/rails/jquery-ujs),
+the CSRF token will be sent to the rails application on every XHR automatically.
+If not so, the following JavaScript is required in your code.
+
+``` javascript
+$.ajaxPrefilter(function(options, originalOptions, xhr) {
+  var token = $('meta[name="csrf-token"]').attr('content');
+  xhr.setRequestHeader('X-CSRF-Token', token);
+});
+```
+
 ## Note on Patches/Pull Requests
 
 1. Fork the project.

data/lib/ember/rails/engine.rb

@@ -5,12 +5,15 @@ require 'sprockets/railtie'
 module Ember
   module Rails
     class Engine < ::Rails::Engine
-      config.handlebars = ActiveSupport::OrderedOptions.new
+      Ember::Handlebars::Template.configure do |handlebars_config|
+        config.handlebars = handlebars_config
 
-      config.handlebars.precompile = true
-      config.handlebars.templates_root = "templates"
-      config.handlebars.templates_path_separator = '/'
-      config.handlebars.output_type = :global
+        config.handlebars.precompile = true
+        config.handlebars.templates_root = 'templates'
+        config.handlebars.templates_path_separator = '/'
+        config.handlebars.output_type = :global
+        config.handlebars.ember_template = Ember::VERSION =~ /\A1.[0-9]\./ ? 'Handlebars' : 'HTMLBars'
+      end
 
       config.before_initialize do |app|
         Sprockets::Engines #force autoloading

data/lib/ember/rails/version.rb

@@ -1,5 +1,5 @@
 module Ember
   module Rails
-    VERSION = '0.14.0'
+    VERSION = '0.18.0'
   end
 end

data/lib/ember_rails.rb

@@ -1,9 +1,15 @@
 require 'rails'
-require 'ember/rails/version'
-require 'ember/rails/engine'
 require 'ember/source'
 require 'ember/data/source'
-require 'handlebars/source'
+require 'ember/rails/version'
+require 'ember/rails/engine'
+
+# Use handlebars if it possible. Because it is an optional feature.
+begin
+  require 'handlebars/source'
+rescue LoadError => e
+  raise e unless e.message == 'cannot load such file -- handlebars/source'
+end
 
 module Ember
   module Rails
@@ -20,25 +26,39 @@ module Ember
         require "generators/ember/resource_override"
       end
 
-      initializer "ember_rails.setup_vendor", :after => "ember_rails.setup", :group => :all do |app|
+      initializer "ember_rails.setup_vendor_on_locale", :after => "ember_rails.setup", :group => :all do |app|
         variant = app.config.ember.variant || (::Rails.env.production? ? :production : :development)
 
-        # Copy over the desired ember, ember-data, and handlebars bundled in
-        # ember-source, ember-data-source, and handlebars-source to a tmp folder.
+        # Allow a local variant override
+        ember_path = app.root.join("vendor/assets/ember/#{variant}")
+        app.assets.prepend_path(ember_path.to_s) if ember_path.exist?
+      end
+
+      initializer "ember_rails.copy_vendor_to_local", :after => "ember_rails.setup", :group => :all do |app|
+        variant = app.config.ember.variant || (::Rails.env.production? ? :production : :development)
+
+        # Copy over the desired ember and ember-data bundled in
+        # ember-source and ember-data-source to a tmp folder.
         tmp_path = app.root.join("tmp/ember-rails")
-        ext = variant == :production ? ".prod.js" : ".js"
         FileUtils.mkdir_p(tmp_path)
-        FileUtils.cp(::Ember::Source.bundled_path_for("ember#{ext}"), tmp_path.join("ember.js"))
-        FileUtils.cp(::Ember::Data::Source.bundled_path_for("ember-data#{ext}"), tmp_path.join("ember-data.js"))
-        app.assets.append_path(tmp_path)
 
-        # Make the handlebars.js and handlebars.runtime.js bundled
-        # in handlebars-source available.
-        app.assets.append_path(File.expand_path('../', ::Handlebars::Source.bundled_path))
+        if variant == :production
+          ember_ext = ".prod.js"
+        else
+          ember_ext = ".debug.js"
+          ember_ext = ".js" unless File.exist?(::Ember::Source.bundled_path_for("ember#{ember_ext}")) # Ember.js 1.9.0 or earlier has no "ember.debug.js"
+        end
+        FileUtils.cp(::Ember::Source.bundled_path_for("ember#{ember_ext}"), tmp_path.join("ember.js"))
+        ember_data_ext = variant == :production ? ".prod.js" : ".js"
+        FileUtils.cp(::Ember::Data::Source.bundled_path_for("ember-data#{ember_data_ext}"), tmp_path.join("ember-data.js"))
 
-        # Allow a local variant override
-        ember_path = app.root.join("vendor/assets/ember/#{variant}")
-        app.assets.prepend_path(ember_path.to_s) if ember_path.exist?
+        app.assets.append_path(tmp_path)
+      end
+
+      initializer "ember_rails.setup_vendor", :after => "ember_rails.copy_vendor_to_local", :group => :all do |app|
+        app.assets.append_path(::Ember::Source.bundled_path_for(nil))
+        app.assets.append_path(::Ember::Data::Source.bundled_path_for(nil))
+        app.assets.append_path(File.expand_path('../', ::Handlebars::Source.bundled_path)) if defined?(::Handlebars::Source)
       end
 
       initializer "ember_rails.es5_default", :group => :all do |app|