Integrate with ember-cli-rails

EmberCLI-Rails supports configuring alternative [deployment strategies].

Modify the gem to properly expose itself as a deployment strategy.

[deployment strategies]:https://github.com/thoughtbot/ember-cli-rails#deployment-strategies

Author: seanpdoyle

CHANGELOG.md

@@ -1,6 +1,12 @@
 master
 ------
 
+* Integrate with `ember-cli-rails` deployment strategies. [#4]
+* Rename `EmberCLI` module to `EmberCli`. [#4]
+* Rename `ember-cli` directories to `ember_cli`. [#4]
+
+[#4]: https://github.com/seanpdoyle/ember-cli-rails-deploy-redis/pull/4
+
 0.0.2
 -----
 

README.md

@@ -1,119 +1,124 @@
 # EmberCli::Deploy::Redis
 
-[EmberCLI Rails] is an integration story between (surprise suprise) EmberCLI and
-Rails 3.1 and up.
+[EmberCLI Rails] is a tool to unify your EmberCLI and Rails Workflows.
 
 [ember-cli-deploy] is a simple, flexible deployment for your Ember CLI app.
 
-[ember-deploy-redis] is the redis-adapter implementation to use Redis with ember-deploy.
+[ember-cli-deploy-redis] is an `ember-cli-deploy` plugin to upload `index.html`
+to a Redis store.
 
-`ember-cli-rails-deploy-redis` wires up all three.
+`ember-cli-rails-deploy-redis` is a gem that integrates all three.
 
-[EmberCLI Rails]: https://github.com/rwz/ember-cli-rails
-[ember-cli-deploy]: https://github.com/ember-cli/ember-cli-deploy
-[ember-deploy-redis]: https://github.com/LevelbossMike/ember-deploy-redis
+This project streamlines the process of pushing and serving EmberCLI-built
+assets from Rails.
 
-## Installation
+[EmberCLI Rails]: https://github.com/thoughtbot/ember-cli-rails
+[ember-cli-deploy]: http://ember-cli.com/ember-cli-deploy/
+[ember-cli-deploy-redis]: https://github.com/ember-cli-deploy/ember-cli-deploy-redis
+
+## Install
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'ember-cli-rails-deploy-redis'
+group :production do
+  gem "ember-cli-rails-deploy-redis"
+end
 ```
 
 And then execute:
 
 ```bash
-$ bundle
+$ bundle install
 ```
 
-## Usage
+## Setup
 
-The EmberCLI community recently unified the various deployment techniques into a
-single, core-team supported project: [ember-cli-deploy][ember-cli-deploy].
+First, [configure your application to integrate with
+`ember-cli-rails`][ember-cli-rails-setup].
 
-This project attempts to streamline the process of pushing and serving
-EmberCLI-built static assets.
+Then, to integrate with `ember-cli-deploy`'s ["Lightning Fast Deploys"][lightning]
+(using the Redis adapter) in `production`, instantiate configure EmberCLI-Rails
+to deploy with the `EmberCli::Deploy::Redis` strategy:
 
-To integrate with `ember-cli-deploy`'s ["Lightning Fast Deploys"][lightning]
-(using the Redis adapter), instantiate an `EmberCli::Deploy::Redis`
-in your controller:
+[ember-cli-rails-setup]: https://github.com/thoughtbot/ember-cli-rails#setup
 
 ```ruby
-require "ember_cli/deploy/redis"
-
-class ApplicationController < ActionController::Base
-  def index
-    @deploy = EmberCli::Deploy::Redis.new(namespace: "frontend")
+# config/initializers/ember.rb
 
-    render text: @deploy.html, layout: false
-  end
+EmberCli.configure do |config|
+  config.app :frontend, deploy: { production: EmberCli::Deploy::Redis }
 end
 ```
 
-`EmberCli::Deploy::Redis` takes a `namespace` (the name of your app declared in
-your initializer) and handles all interaction with the Redis instance.
+Finally, set `ENV["REDIS_URL"]` to the URL
+[ember-cli-deploy-redis references][redis-config].
 
-This is great for `staging` and `production` deploys, but introduces an extra
-step in the feedback loop during development.
+[redis-config]: https://github.com/ember-cli-deploy/ember-cli-deploy-redis#configuration-options
 
-Luckily, `EmberCli::Deploy::Redis` also accepts an `index_html` override, which
-will replace the call to the Redis instance. This allows integration with the
-normal `ember-cli-rails` workflow:
+## Deploy
 
-```ruby
-require "ember_cli/deploy/redis"
+Deploy your application through [ember-cli-deploy-redis][deploy].
 
-class ApplicationController < ActionController::Base
-  def index
-    @deploy = EmberCli::Deploy::Redis.new(
-      namespace: "frontend",
-      index_html: index_html,
-    )
+[deploy]: https://github.com/ember-cli-deploy/ember-cli-deploy-redis#quick-start
 
-    render text: @deploy.html, layout: false
-  end
+## Use without `ember-cli-rails`
 
-  private
+Although this gem was designed to integrate with `ember-cli-rails`, there isn't
+a direct dependency on it.
 
-  def index_html
-    if serve_with_ember_cli_rails?
-      render_to_string(:index)
-    end
-  end
+Similar behavior can be achieved by using a gem like [`html_page`][html_page]:
 
-  def serve_with_ember_cli_rails?
-    ! %w[production staging].include?(Rails.env)
-  end
-end
-```
+[html_page]: https://github.com/seanpdoyle/html_page
 
-Additionally, having access to the outbound HTML beforehand also enables
-controllers to inject additional markup, such as metadata, CSRF tokens, or
-analytics tags:
+```rb
+require "html_page"
 
+class EmberHelper
+  def render_html(html)
+    capturer = HtmlPage::Capture.new(self, &block)
 
-```ruby
-require "ember_cli/deploy/redis"
+    head, body = capturer.capture
 
-class ApplicationController < ActionController::Base
-  def index
-    @deploy = EmberCli::Deploy::Redis.new(
-      namespace: "frontend",
-      index_html: index_html,
+    renderer = HtmlPage::Renderer.new(
+      content: html,
+      head: head,
+      body: body,
     )
 
-    @deploy.append_to_head(render_to_string(partial: "my_csrf_and_metadata")
-    @deploy.append_to_body(render_to_string(partial: "my_analytics")
+    render inline: renderer.render
+  end
+end
+
+class EmberController
+  def index
+    redis = EmberCli::Deploy::Redis.new(ember_app)
 
-    render text: @deploy.html, layout: false
+    @html_from_redis = redis.index_html
+
+    render layout: false
+  end
+
+  private
+
+  def ember_app
+    OpenStruct.new(name: "my-ember-app")
   end
-  # ...
 end
 ```
 
-[ember-cli-deploy]: https://github.com/ember-cli/ember-cli-deploy
-[lightning]: https://github.com/ember-cli/ember-cli-deploy#lightning-approach-workflow
+```erb
+<!-- app/views/ember/index.html.erb -->
+<%= render_html @html_from_redis do |head, body| %>
+  <% head.append do %>
+    <title>Appended to the `head` element</title>
+  <% end %>
+
+  <% body.append do %>
+    <p>Appended to the `body` element</p>
+  <% end %>
+<% end %>
+```
 
 ## Development
 

lib/ember_cli/deploy/page.rb

@@ -1,83 +1,54 @@
 require "active_support/core_ext/object/blank"
-require "ember_cli/deploy/page"
 require "redis"
 
 module EmberCli
   module Deploy
     class Redis
-      def initialize(namespace:, index_html: nil, redis_client: build_client)
-        @redis_client = redis_client
-        @namespace = namespace
-        @index_html = index_html
-        @body_markup = []
-        @head_markup = []
+      def initialize(app)
+        @app = app
       end
 
-      def append_to_body(markup)
-        body_markup << markup
-      end
-
-      def append_to_head(markup)
-        head_markup << markup
+      def index_html
+        redis_client.get(deploy_key).presence || index_html_missing!
       end
 
-      def html
-        if index_html.present?
-          page = Page.new(html: index_html)
-
-          body_markup.each do |markup|
-            page.append_to_body(markup)
-          end
+      private
 
-          head_markup.each do |markup|
-            page.append_to_head(markup)
-          end
+      attr_reader :app
 
-          page.build
-        else
-          index_html_missing!
-        end
+      def redis_client
+        @redis_client ||= ::Redis.new(url: ENV.fetch("REDIS_URL"))
       end
 
-      private
-
-      attr_reader :body_markup, :head_markup, :namespace, :redis_client
-
-      def index_html
-        @index_html ||= redis_client.get(deploy_key).presence
+      def namespace
+        app.name
       end
 
       def current_key
         "#{namespace}:current"
       end
 
       def deploy_key
-        key = redis_client.get(current_key).presence || deployment_not_activated!
-        "#{namespace}:#{key}"
-      end
+        key = redis_client.get(current_key).presence ||
+              deployment_not_activated!
 
-      def build_client
-        ::Redis.new(url: ENV.fetch("REDIS_URL"))
+        "#{namespace}:#{key}"
       end
 
       def index_html_missing!
-        message = <<-FAIL
+        raise KeyError.new <<-FAIL
         HTML for #{deploy_key} is missing.
 
         Did you forget to call `ember deploy`?
         FAIL
-
-        raise KeyError, message
       end
 
       def deployment_not_activated!
-        message = <<-FAIL
+        raise KeyError.new <<-FAIL
         #{current_key} is empty.
 
         Did you forget to call `ember deploy:activate`?
         FAIL
-
-        raise KeyError, message
       end
     end
   end