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

@@ -0,0 +1,8 @@
+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

README.md

@@ -1,119 +1,66 @@
 # 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
-
-The EmberCLI community recently unified the various deployment techniques into a
-single, core-team supported project: [ember-cli-deploy][ember-cli-deploy].
-
-This project attempts to streamline the process of pushing and serving
-EmberCLI-built static assets.
-
-To integrate with `ember-cli-deploy`'s ["Lightning Fast Deploys"][lightning]
-(using the Redis adapter), instantiate an `EmberCli::Deploy::Redis`
-in your controller:
-
-```ruby
-require "ember_cli/deploy/redis"
-
-class ApplicationController < ActionController::Base
-  def index
-    @deploy = EmberCli::Deploy::Redis.new(namespace: "frontend")
-
-    render text: @deploy.html, layout: false
-  end
-end
-```
+## Setup
 
-`EmberCli::Deploy::Redis` takes a `namespace` (the name of your app declared in
-your initializer) and handles all interaction with the Redis instance.
+First, [configure your application to integrate with
+`ember-cli-rails`][ember-cli-rails-setup].
 
-This is great for `staging` and `production` deploys, but introduces an extra
-step in the feedback loop during development.
+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:
 
-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:
+[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",
-      index_html: index_html,
-    )
-
-    render text: @deploy.html, layout: false
-  end
-
-  private
-
-  def index_html
-    if serve_with_ember_cli_rails?
-      render_to_string(:index)
-    end
-  end
+# config/initializers/ember.rb
 
-  def serve_with_ember_cli_rails?
-    ! %w[production staging].include?(Rails.env)
-  end
+EmberCli.configure do |config|
+  config.app :frontend, deploy: { production: EmberCli::Deploy::Redis }
 end
 ```
 
-Additionally, having access to the outbound HTML beforehand also enables
-controllers to inject additional markup, such as metadata, CSRF tokens, or
-analytics tags:
+Finally, set `ENV["REDIS_URL"]` to the URL
+[ember-cli-deploy-redis references][redis-config].
 
+[redis-config]: https://github.com/ember-cli-deploy/ember-cli-deploy-redis#configuration-options
 
-```ruby
-require "ember_cli/deploy/redis"
-
-class ApplicationController < ActionController::Base
-  def index
-    @deploy = EmberCli::Deploy::Redis.new(
-      namespace: "frontend",
-      index_html: index_html,
-    )
-
-    @deploy.append_to_head(render_to_string(partial: "my_csrf_and_metadata")
-    @deploy.append_to_body(render_to_string(partial: "my_analytics")
+## Deploy
 
-    render text: @deploy.html, layout: false
-  end
-  # ...
-end
-```
+Deploy your application through [ember-cli-deploy-redis][deploy].
 
-[ember-cli-deploy]: https://github.com/ember-cli/ember-cli-deploy
-[lightning]: https://github.com/ember-cli/ember-cli-deploy#lightning-approach-workflow
+[deploy]: https://github.com/ember-cli-deploy/ember-cli-deploy-redis#quick-start
 
 ## Development
 

lib/ember_cli/deploy/page.rb

@@ -1,82 +1,53 @@
 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
-        redis_client.get(current_key).presence || deployment_not_activated!
-      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