How easily integrate Rails' ActionCable into your Angular2/ionic2 application

  source 'https://rubygems.org'
  ruby '2.3.1'


  gem 'rails', '~> 5.0.0', '>= 5.0.0.1'
  gem 'pg', '~> 0.18'
  gem 'puma', '~> 3.0'
  gem 'active_model_serializers'
  gem 'decent_exposure', '~> 3.0.0'
  gem 'kaminari'
  gem 'redis'
  gem 'rack-cors', require: 'rack/cors'

  group :development, :test do
    gem 'pry'
    gem 'rspec-rails', '~> 3.5'
    gem 'rspec-collection_matchers'
    gem 'factory_girl_rails'
    gem 'rubocop'
    gem 'simplecov', require: false
    gem 'database_cleaner'
    gem 'shoulda-matchers'
    gem 'faker'
  end

  group :development do
    gem 'listen', '~> 3.0.5'
    gem 'spring'
    gem 'spring-watcher-listen', '~> 2.0.0'
    gem 'rubocop'
  end

  gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw, :jruby]

   controllers/application_controller.rb:

      #frozen_string_literal: true
    class ApplicationController < ActionController::API
      include AbstractController::Helpers
    end

	controllers/v1/base_controller.rb:

     #frozen_string_literal: true
    class V1::BaseController < ApplicationController
      private

      def render_api(object, status = :ok)
        if object.respond_to?(:errors) && object.errors.present?
          render json: { message: object.errors.full_messages.to_sentence }, status: :unprocessable_entity
        else
          render json: object, status: status
        end
      end
    end

  channels/chat_channel.rb:

  #frozen_string_literal: true
  class ChatChannel < ApplicationCable::Channel
    def subscribed
      stream_from 'chat'
    end
  end

    models/message.rb:

    #frozen_string_literal: true
    class Message < ApplicationRecord
      validates :body, :sender, presence: true

      after_create :broadcast

      private

      def broadcast
        ActionCable.server.broadcast('chat', as_json.merge(action: 'CreateMessage'))
      end
    end

    controllers/v1/messages_controller.rb:

    #frozen_string_literal: true
    class V1::MessagesController < V1::BaseController
      expose :message
      expose :messages, -> { Message.order(created_at: :desc).page(params[:page]).per(15) }


      def index
        render_api(messages)
      end


      def create
        message.save
        render_api(message, :created)
      end


      private


      def message_params
        params.require(:message).permit(:body, :sender)
      end
    end

   serializers/message_serializer.rb

    #frozen_string_literal: true
    class MessageSerializer < ActiveModel::Serializer
      attributes :id, :body, :sender, :created_at, :updated_at
    end

 config/routes.rb:

 #frozen_string_literal: true
  Rails.application.routes.draw do
    mount ActionCable.server => '/cable'
    scope 'api' do
      namespace :v1 do
        resources :messages, only: [:index, :create]
      end
    end
  end

   config/application.rb:

    #frozen_string_literal: true
    require_relative 'boot'


    require 'rails'
    #Pick the frameworks you want:
    require 'active_model/railtie'
    require 'active_job/railtie'
    require 'active_record/railtie'
    require 'action_controller/railtie'
    require 'action_mailer/railtie'
    require 'action_view/railtie'
    require 'action_cable/engine'
    # require "sprockets/railtie"
    require 'rails/test_unit/railtie'


    # Require the gems listed in Gemfile, including any gems
    # you've limited to :test, :development, or :production.
    Bundler.require(*Rails.groups)


    module Ng2CableExample
      class Application < Rails::Application
        config.api_only = true


        # Enable CORS
        config.middleware.use Rack::Cors do
          allow do
            origins '*'
            resource '*', headers: :any, methods: [:get, :post, :options, :put, :patch, :delete]
          end
        end
      end
    end

  config/initializers/action_cable.rb

   #frozen_string_literal: true
  Rails.application.config.action_cable.disable_request_forgery_protection = true

  spec/rails_helper.rb:

  #frozen_string_literal: true
  ENV['RAILS_ENV'] ||= 'test'
  require File.expand_path('../../config/environment', __FILE__)
  #Prevent database truncation if the environment is production
  abort('The Rails environment is running in production mode!') if Rails.env.production?
  require 'spec_helper'
  require 'rspec/rails'
  require 'database_cleaner'
  require 'simplecov'
  require 'rspec/collection_matchers'


  ActiveRecord::Migration.maintain_test_schema!
  SimpleCov.start


  RSpec.configure do |config|
    Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
    config.fixture_path = "#{::Rails.root}/spec/fixtures"
    config.include FactoryGirl::Syntax::Methods
    config.include Requests::JsonHelpers, type: :controller
    config.use_transactional_fixtures = true
    config.infer_spec_type_from_file_location!
    config.filter_rails_from_backtrace!


    config.before(:suite) do
      DatabaseCleaner.clean_with(:truncation)
    end


    config.before(:each) do
      DatabaseCleaner.strategy = :transaction
    end
  end


  Shoulda::Matchers.configure do |config|
    config.integrate do |with|
      with.test_framework :rspec
      with.library :rails
    end
  end

  spec/support/request_helpers.rb:

  #frozen_string_literal: true
  module Requests
    module JsonHelpers
      def json
        @json ||= JSON.parse(response.body)
      end
    end
  end

  spec/factories/messages.rb:

  #frozen_string_literal: true
  FactoryGirl.define do
    factory :message do
      body { Faker::Lorem.sentence }
      sender { Faker::Name.name }
    end
  end

  spec/controller/v1/messages_controller_spec.rb:

  #frozen_string_literal: true
  require 'rails_helper'


  RSpec.describe V1::MessagesController, type: :controller do
    let!(:message) { create(:message) }
    let(:message_params) { attributes_for(:message) }


    describe '#index' do
      it do
        get :index
        expect(json).not_to be_empty
      end
    end


    describe '#create' do
      it 'successfully create' do
        post :create, params: { message: message_params }
        expect(response).to be_success
      end


      it 'validation failed' do
        post :create, params: { message: { body: '' } }
        expect(response).to have_http_status(422)
      end
    end
  end