turboboost 0.0.11 → 0.0.12

data/lib/turboboost/controller.rb

@@ -0,0 +1,111 @@
+module Turboboost
+  module Controller
+    extend ActiveSupport::Concern
+
+    CATCHABLE_ERRORS = {
+      'EOFError'                            => 500,
+      'Errno::ECONNRESET'                   => 500,
+      'Errno::EINVAL'                       => 500,
+      'Timeout::Error'                      => :request_timeout,
+      'Net::HTTPBadResponse'                => 500,
+      'Net::HTTPHeaderSyntaxError'          => 500,
+      'Net::ProtocolError'                  => 500,
+      'ActiveRecord::RecordNotFound'        => :not_found,
+      'ActiveRecord::StaleObjectError'      => :conflict,
+      'ActiveRecord::RecordInvalid'         => :unprocessable_entity,
+      'ActiveRecord::RecordNotSaved'        => :unprocessable_entity,
+      'ActiveModel::StrictValidationFailed' => :unprocessable_entity,
+      'ActiveModel::MissingAttributeError'  => :unprocessable_entity
+    }
+
+    included do
+      send :rescue_from, *(CATCHABLE_ERRORS.keys), with: :turboboost_error_handler
+    end
+
+    def turboboost_error_handler(error)
+      if request.xhr? && request.headers['HTTP_X_TURBOBOOST']
+        error_status = CATCHABLE_ERRORS[error.class.name]
+        response.headers['X-Turboboosted'] = '1'
+        if defined?(error.record)
+          render_turboboost_errors_for(error.record)
+        else
+          translation = I18n.t("turboboost.errors.#{error.class.name}")
+          message = translation.match('translation missing: (.+)') ? error.class.name : translation
+          render json: [message], status: error_status || 500, root: false
+        end
+      else
+        raise error
+      end
+    end
+
+    def render_turboboost_errors_for(record)
+      render json: record.errors.full_messages.to_a, status: :unprocessable_entity, root: false
+    end
+
+    def head_turboboost_success(turboboost_flash = {})
+      turboboost_flash = _turboboost_get_flash_messages(turboboost_flash)
+      head :ok, 'X-Flash' => turboboost_flash.to_json, 'X-Turboboosted' => '1'
+    end
+
+    def render(*args, &block)
+      if request.xhr? && request.headers['HTTP_X_TURBOBOOST']
+        turboboost_render(*args, &block)
+      else
+        super
+      end
+    end
+
+    def turboboost_render(*args, &block)
+      options = _normalize_render(*args, &block)
+      [:replace, :within, :append, :prepend, :before, :after].each do |h|
+        response.headers["X-#{h.capitalize}"] = options[h] if options[h]
+      end
+      response.headers['X-Flash'] = _turboboost_get_flash_messages(options).to_json
+      response.headers['X-Turboboosted'] = '1'
+      self.response_body = render_to_body(options)
+    end
+
+    def redirect_to(options = {}, response_status_and_flash = {})
+      if request.xhr? && request.headers['HTTP_X_TURBOBOOST']
+        turboboost_redirect_to(options, response_status_and_flash)
+      else
+        super
+      end
+    end
+
+    def turboboost_redirect_to(options = {}, response_status_and_flash = {})
+      raise ActionControllerError.new('Cannot redirect to nil!') unless options
+      raise AbstractController::DoubleRenderError if response_body
+
+      # set flash for turbo redirect headers
+      turboboost_flash = _turboboost_get_flash_messages(response_status_and_flash)
+
+      if Rails.version < '4.2'
+        self.location = _compute_redirect_to_location(options)
+      else
+        self.location = _compute_redirect_to_location(request, options)
+      end
+
+      head :ok, 'X-Flash' => turboboost_flash.to_json
+
+      flash.update(turboboost_flash) # set flash for rendered view
+    end
+
+    def _turboboost_get_flash_messages(response_status_and_flash = {})
+      turboboost_flash = {}
+      flash_types = defined?(self.class._flash_types) ? self.class._flash_types : [:alert, :notice]
+      flash_types.each do |flash_type|
+        if type = flash.delete(type)
+          turboboost_flash.update(type)
+        end
+        if type = response_status_and_flash.delete(flash_type)
+          turboboost_flash[flash_type] = type
+        end
+      end
+      if other_flashes = response_status_and_flash.delete(:flash)
+        turboboost_flash.update(other_flashes)
+      end
+      turboboost_flash
+    end
+  end
+end

data/lib/turboboost/form_helper.rb

@@ -0,0 +1,46 @@
+module Turboboost
+  # borrowed from - https://github.com/fs/turboforms/blob/master/lib/turboforms.rb
+  module FormHelper
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :form_for, :data_turboboost
+      alias_method_chain :form_tag, :data_turboboost
+    end
+
+    def form_for_with_data_turboboost(record_or_name_or_array, *args, &proc)
+      options = args.extract_options!
+
+      if options.key?(:turboboost) && options.delete(:turboboost)
+        options[:html] ||= {}
+        options[:html]['data-turboboost'] = true
+        options[:remote] = true
+      end
+
+      form_for_without_data_turboboost(record_or_name_or_array, *(args << options), &proc)
+    end
+
+    def form_tag_with_data_turboboost(record_or_name_or_array, *args, &proc)
+      options = args.extract_options!
+
+      if options.key?(:turboboost) && options.delete(:turboboost)
+        options[:data] ||= {}
+        options[:data]['turboboost'] = true
+        options[:remote] = true
+      end
+
+      form_tag_without_data_turboboost(record_or_name_or_array, *(args << options), &proc)
+    end
+
+    def convert_options_to_data_attributes(options, html_options)
+      if html_options
+        html_options = html_options.stringify_keys
+        if html_options.delete('turboboost')
+          html_options['data-remote'] = 'true'
+          html_options['data-turboboost'] = 'true'
+        end
+      end
+      super options, html_options
+    end
+  end
+end

data/lib/turboboost/version.rb

@@ -1,3 +1,3 @@
 module Turboboost
-  VERSION = '0.0.11'
+  VERSION = '0.0.12'
 end

data/test/controller_test.rb

@@ -1,124 +1,87 @@
 require 'test_helper'
-
-class PostsController < ApplicationController
-
-  respond_to :html
-  respond_to :js, only: [:create, :update, :destroy]
-
-  def create
-    post = Post.create!(post_params)
-    redirect_to posts_url, notice: "Post was successfully created."
-  end
-
-  def update
-    post = Post.find(params[:id])
-    post.update_attributes!(post_params)
-    redirect_to post_url(post), notice: "Post was successfully updated."
-  end
-
-  def destroy
-    post = Post.find(params[:id])
-    post.destroy!
-    redirect_to posts_url
-  end
-
-private
-
-  def post_params
-    params.require(:post).permit(:title, :user_id)
-  end
-
-end
-
-class UsersController < ApplicationController
-
-  def create
-    user = User.new(user_params)
-    if user.save
-      flash[:notice] = "User was successfully created."
-      redirect_to user_url(user)
-    else
-      respond_to do |format|
-        format.html { render :new }
-        format.js { render_turboboost_errors_for(user) }
-      end
-    end
-  end
-
-  def update
-    user = User.find(params[:id])
-    if user.update_attributes(user_params)
-      redirect_to user_url(user)
-    else
-      respond_to do |format|
-        format.html { redirect_to users_url }
-        format.js { render_turboboost_errors_for(user) }
-      end
-    end
-  end
-
-private
-
-  def user_params
-    params.require(:user).permit(:name, :email)
-  end
-
-end
+Dir[File.dirname(__FILE__) + '/controllers/*.rb'].each { |file| require file }
 
 class PostsControllerTest < ActionController::TestCase
-
   tests PostsController
 
   setup do
-    @request.headers["X-Turboboost"] = "1"
+    @request.headers['X-Turboboost'] = '1'
   end
 
-  test "On a successful turboboost request, return an empty response with headers containing the redirect location and flash message" do
-    xhr :post, :create, post: { title: "Foobar", user_id: "1" }
+  test 'On a successful turboboost request, return an empty response with headers containing the redirect location and flash message' do
+    xhr :post, :create, post: { title: 'Foobar', user_id: '1' }
 
     assert @response.body.strip.blank?
     assert_equal flash[:notice], 'Post was successfully created.'
-    assert_equal @response.headers["Location"], posts_url
-    assert_equal JSON.parse(@response.headers["X-Flash"])["notice"], 'Post was successfully created.'
+    assert_equal @response.headers['Location'], posts_url
+    assert_equal JSON.parse(@response.headers['X-Flash'])['notice'], 'Post was successfully created.'
   end
 
-  test "On an unsuccessful turboboost request, catch and return the error message(s) as an array" do
-    xhr :post, :create, post: { title: "Title", user_id: nil }
+  test 'On an unsuccessful turboboost request, catch and return the error message(s) as an array' do
+    xhr :post, :create, post: { title: 'Title', user_id: nil }
 
     assert_equal @response.status, 422
-    assert_equal @response.body.strip, ["User can't be blank"].to_json
+    assert_equal @response.body.strip, ['User can\'t be blank'].to_json
 
-    xhr :post, :create, post: { title: "Tit", user_id: nil }
+    xhr :post, :create, post: { title: 'Tit', user_id: nil }
 
     assert_equal @response.status, 422
-    assert_equal @response.body.strip, ["Title is too short.", "User can't be blank"].to_json
+    assert_equal @response.body.strip, ['Title is too short.', "User can't be blank"].to_json
   end
-
 end
 
-
 class UsersControllerTest < ActionController::TestCase
-
   tests UsersController
 
   setup do
-    @request.headers["X-Turboboost"] = "1"
+    @request.headers['X-Turboboost'] = '1'
   end
 
-  test "On a successful turboboost request, return an empty response with headers containing the redirect location and flash message" do
-    xhr :post, :create, user: { name: "Mike", email: "mike@mike.com" }
+  test 'On a successful turboboost request, return an empty response with headers containing the redirect location and flash message' do
+    xhr :post, :create, user: { name: 'Mike', email: 'mike@mike.com' }
 
-    assert @response.body.strip.blank?
+    assert_equal @response.body.strip.blank?, true
     assert_equal flash[:notice], 'User was successfully created.'
-    assert_equal @response.headers["Location"], user_url(1)
-    assert_equal JSON.parse(@response.headers["X-Flash"])["notice"], 'User was successfully created.'
+    assert_equal @response.headers['Location'], user_url(1)
+    assert_equal JSON.parse(@response.headers['X-Flash'])['notice'], 'User was successfully created.'
   end
 
-  test "On an unsuccessful turboboost request, explicitly render the error message(s)" do
-    xhr :post, :create, user: { name: "Mike", email: "mike at mike.com" }
+  test 'On an unsuccessful turboboost request, explicitly render the error message(s)' do
+    xhr :post, :create, user: { name: 'Mike', email: 'mike at mike.com' }
 
     assert_equal @response.status, 422
-    assert_equal @response.body.strip, ["Email is invalid"].to_json
+    assert_equal @response.body.strip, ['Email is invalid'].to_json
   end
+end
 
+class ItemsControllerTest < ActionController::TestCase
+  tests ItemsController
+
+  setup do
+    @request.headers['X-Turboboost'] = '1'
+  end
+
+  test 'On a failed turboboost get request, return custom internationalization messaging' do
+    xhr :get, :show, id: 123
+    i18n_message = I18n.t("turboboost.errors.ActiveRecord::RecordNotFound")
+    assert_equal @response.body.strip, [i18n_message].to_json
+  end
+
+  test 'On a successful turboboost post request, return rendering options in the headers' do
+    xhr :post, :create, item: { name: 'Bottle' }
+
+    assert_equal @response.headers['Location'], nil
+    assert_equal JSON.parse(@response.headers['X-Flash'])['notice'], 'Item was successfully created.'
+    assert_equal @response.headers['X-Within'], '#sidebar'
+    assert_equal @response.body.strip, "<div id=\"item\">Bottle</div>"
+  end
+
+  test 'On a successful turboboost update using render nothing: true, still return flash headers' do
+    @item = Item.create(name: 'Opener')
+    xhr :put, :update, id: @item.id, item: { name: 'Bottle Opener' }
+
+    assert_equal @response.headers['Location'], nil
+    assert_equal @response.body.strip, ''
+    assert_equal JSON.parse(@response.headers['X-Flash'])['notice'], 'Item updated.'
+  end
 end

data/test/controllers/items_controller.rb

@@ -0,0 +1,23 @@
+class ItemsController < ApplicationController
+  def show
+    item = Item.find(params[:id])
+    render json: item
+  end
+
+  def create
+    @item = Item.create!(item_params)
+    render :show, within: '#sidebar', flash: { notice: 'Item was successfully created.' }
+  end
+
+  def update
+    item = Item.find(params[:id])
+    item.update_attributes!(item_params)
+    render nothing: true, notice: 'Item updated.'
+  end
+
+  private
+
+  def item_params
+    params.require(:item).permit(:name)
+  end
+end

data/test/controllers/posts_controller.rb

@@ -0,0 +1,27 @@
+class PostsController < ApplicationController
+  respond_to :html
+  respond_to :js, only: [:create, :update, :destroy]
+
+  def create
+    Post.create!(post_params)
+    redirect_to posts_url, notice: 'Post was successfully created.'
+  end
+
+  def update
+    post = Post.find(params[:id])
+    post.update_attributes!(post_params)
+    redirect_to post_url(post), notice: 'Post was successfully updated.'
+  end
+
+  def destroy
+    post = Post.find(params[:id])
+    post.destroy!
+    redirect_to posts_url
+  end
+
+  private
+
+  def post_params
+    params.require(:post).permit(:title, :user_id)
+  end
+end

data/test/controllers/users_controller.rb

@@ -0,0 +1,32 @@
+class UsersController < ApplicationController
+  def create
+    user = User.new(user_params)
+    if user.save
+      flash[:notice] = 'User was successfully created.'
+      redirect_to user_url(user)
+    else
+      respond_to do |format|
+        format.html { render :new }
+        format.js { render_turboboost_errors_for(user) }
+      end
+    end
+  end
+
+  def update
+    user = User.find(params[:id])
+    if user.update_attributes(user_params)
+      redirect_to user_url(user)
+    else
+      respond_to do |format|
+        format.html { redirect_to users_url }
+        format.js { render_turboboost_errors_for(user) }
+      end
+    end
+  end
+
+  private
+
+  def user_params
+    params.require(:user).permit(:name, :email)
+  end
+end

data/test/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  turboboost:
+    errors:
+      "ActiveRecord::RecordNotFound": "Shoot, didn't find anything."

data/test/test_helper.rb

@@ -2,31 +2,39 @@ require 'rubygems'
 require 'bundler'
 Bundler.setup
 
-ENV["RAILS_ENV"] = "test"
+ENV['RAILS_ENV'] = 'test'
 
 require 'rails'
-require "active_record"
-require "action_controller"
-require "action_controller"
-require "action_controller/railtie"
+require 'active_record'
+require 'action_controller'
+require 'action_controller'
+require 'action_controller/railtie'
 require 'rails/test_help'
 require 'awesome_print'
+require 'responders' if Rails.version >= '4.2'
+require 'strong_parameters' if Rails.version < '4.0'
 require 'turboboost'
 
-ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+I18n.enforce_available_locales = true
+I18n.load_path << File.expand_path('../locales/en.yml', __FILE__)
+I18n.reload!
+
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
 
 class TestApp < Rails::Application; end
 Rails.application = TestApp
-Rails.configuration.secret_key_base = "abc123"
+Rails.configuration.secret_key_base = 'abc123'
 
 Turboboost::Routes = ActionDispatch::Routing::RouteSet.new
 Turboboost::Routes.draw do
   resources 'posts'
   resources 'users'
+  resources 'items'
 end
 
 class ApplicationController < ActionController::Base
   include Turboboost::Routes.url_helpers
+  self.view_paths = File.join(File.dirname(__FILE__), 'views')
 end
 
 class ActiveSupport::TestCase
@@ -36,38 +44,42 @@ class ActiveSupport::TestCase
 end
 
 class ActionView::TestCase
-
-  def default_url_options; {}; end
-
   include Turboboost::Routes.url_helpers
   include Turboboost::FormHelper
+  def default_url_options
+    {}
+  end
 
   setup do
     @controller = ApplicationController
   end
-
 end
 
 posts_table = %{CREATE TABLE posts (id INTEGER PRIMARY KEY, title VARCHAR(5), user_id INTEGER);}
 ActiveRecord::Base.connection.execute(posts_table)
 
 class Post < ActiveRecord::Base
-
   attr_accessor :title, :user_id
 
-  validates :title, length: { minimum: 5, message: "is too short." }
+  validates :title, length: { minimum: 5, message: 'is too short.' }
   validates :user_id, presence: true
-
 end
 
 users_table = %{CREATE TABLE users (id INTEGER PRIMARY KEY, name VARCHAR(5), email VARCHAR(255));}
 ActiveRecord::Base.connection.execute(users_table)
 
 class User < ActiveRecord::Base
-
   attr_accessor :name, :email
 
   validates :name, presence: true
   validates :email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, allow_blank: false }
+end
 
+items_table = %{CREATE TABLE items (id INTEGER PRIMARY KEY, name VARCHAR(5));}
+ActiveRecord::Base.connection.execute(items_table)
+
+class Item < ActiveRecord::Base
+  attr_accessor :name
+
+  validates :name, presence: true
 end