grape-gen 0.0.1

data/template/faye.ru

@@ -0,0 +1,55 @@
+require_relative 'config/boot_faye'
+
+Faye::WebSocket.load_adapter('thin')
+Faye.logger = Logging.logger[:faye]
+
+class ServerClientSecretAuth
+  def initialize(secret)
+    @secret = secret
+  end
+  def outgoing(message, callback)
+    if message['channel'] =~ %r{^/meta}
+      callback.(message)
+      return message
+    end
+
+    message['ext'] ||= {}
+    # Set the auth token
+    message['ext']['faye_server_secret'] = @secret
+
+    # Carry on and send the message to the server
+    callback.(message)
+    message
+  end
+end
+
+faye_adapter_settings = {
+    mount: '/', timeout: 180,
+    extensions: [Faye::AuthExtension.new(ApplicationSettings.faye.server_secret)]
+}
+
+faye_adapter_settings[:engine] = {
+    type: Faye::Redis,
+    uri: ApplicationSettings.faye.redis.url
+}
+
+
+bayeux = Faye::RackAdapter.new(faye_adapter_settings)
+
+faye_client = bayeux.get_client
+faye_client.add_extension(ServerClientSecretAuth.new(ApplicationSettings.faye.server_secret))
+
+EventMachine.schedule do
+  redis_connection = EventMachine::Hiredis.connect(ApplicationSettings.faye.redis[:url])
+  redis_connection = Redis::Namespace.new(ApplicationSettings.faye.redis[:namespace], redis: redis_connection) if ApplicationSettings.faye.redis[:namespace]
+
+  pop = Proc.new do
+    redis_connection.blpop('faye.messages',1).callback do |list, msg|
+      faye_client.publish(*MultiJson.load(msg).values_at('channel','payload')) if msg
+      EventMachine.next_tick(pop)
+    end
+  end
+  EventMachine.next_tick(pop)
+end
+
+run bayeux

data/template/jobs/pong_time.rb

@@ -0,0 +1,11 @@
+module DelayedJobs
+  class PongTime
+    include Sidekiq::Worker
+
+    sidekiq_options unique: true
+
+    def perform
+      FayePublisher.publish('/time',Time.now.utc.to_s)
+    end
+  end
+end

data/template/lib/faye_auth_extension.rb

@@ -0,0 +1,61 @@
+require_relative 'warden/token_strategy'
+
+module Faye
+  class AuthExtension
+    def initialize(server_secret)
+      @server_secret = server_secret
+    end
+
+    def subscribe_authorized?(env, channel)
+      case channel
+        when
+          '/user/registered', '/time'
+          return true
+        when %r{^/user/([0-9]+)}
+          strategy = TokenStrategy.new(env)
+          return false unless strategy.valid? and (strategy.authenticate! == :success)
+          strategy.user.id == $1.to_i
+        else
+          false
+      end
+    end
+
+    def incoming(message, callback)
+      # Let non-subscribe messages through
+      if message['ext'] && (message['ext']['faye_server_secret'] == @server_secret)
+        message.delete('ext')
+        callback.call(message)
+        return message
+      end
+
+      unless message['channel'] =~ %r{^/meta}
+        if message['ext'].nil? || (message['ext']['faye_server_secret'] != @server_secret)
+          message['error'] = 'Unauthorized'
+        end
+
+        callback.call(message)
+        return message
+      end
+
+      unless message['channel'] == '/meta/subscribe'
+        callback.call(message)
+        return message
+      end
+
+      # Get subscribed channel and auth token
+      subscription = message['subscription']
+
+      message['ext'] ||= {}
+
+      env = {
+          'HTTP_X_AUTHORIZE' => message['ext']['X-Authorize']
+      }
+
+      message['error'] = 'Unauthorized' unless subscribe_authorized?(Hashie::Mash.new(env), subscription)
+
+      callback.call(message)
+
+      message
+    end
+  end
+end

data/template/lib/faye_publisher.rb

@@ -0,0 +1,63 @@
+require 'connection_pool'
+require 'em-synchrony/connection_pool'
+
+module FayePublisher
+  FakePublishing = Struct.new(:channel, :payload)
+  class << self
+    def fake!
+      @fake = true
+    end
+
+    def redis=(arg)
+      case arg
+        when
+        ::ConnectionPool,
+            EventMachine::Synchrony::ConnectionPool # Or its descendants
+          @redis = arg
+        else
+          @_config = arg
+      end
+    end
+
+    def redis
+      @redis ||= begin
+        config = ApplicationSettings.faye.redis
+        ConnectionPool::Wrapper.new(size: config[:size] || 10) do
+          connection = Redis.new(url: config[:url])
+          connection = Redis::Namespace.new(config[:namespace], redis: connection) if config[:namespace]
+          connection
+        end
+      end
+    end
+
+    def publish(channel, payload)
+      if @fake
+        fake_publishings.push(FakePublishing.new(channel, payload))
+        return true
+      end
+      redis.rpush(
+          'faye.messages',
+          MultiJson.dump(
+              channel: channel,
+              payload: payload
+          )
+      )
+    end
+
+    def configured?; @connection || @_config end
+
+    def publishings
+      raise 'FayePublisher is not configured in fake! mode' unless @fake
+      fake_publishings
+    end
+
+    def clear_publishings
+      @fake_publishings.clear
+    end
+
+    private
+    def fake_publishings
+      @fake_publishings ||= []
+    end
+  end
+end

data/template/lib/mongoid/tire_plugin.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module TirePlugin
+    extend ActiveSupport::Concern
+    included do
+      after_save :tire_reindex
+      after_destroy :tire_remove
+    end
+
+    private
+    def tire_reindex
+      SearchIndex.index(self)
+    end
+    def tire_remove
+      SearchIndex.remove(self)
+    end
+  end
+end

data/template/lib/warden/token_strategy.rb

@@ -0,0 +1,18 @@
+class TokenStrategy < Warden::Strategies::Base
+  def store?; false end
+  def valid?
+    env['HTTP_X_AUTHORIZE']
+  end
+  def access_token_type
+    :public
+  end
+  def authenticate!
+    user = Models::User.find_by(token: env['HTTP_X_AUTHORIZE'])
+
+    if user.nil?
+      fail!(:no_access)
+    else
+      success!(user)
+    end
+  end
+end

data/template/mailers/registration_mailer.rb

@@ -0,0 +1,17 @@
+class RegistrationMailer < MandrillMailer::TemplateMailer
+  default from: 'welcome@yourdomain.com'
+
+  def registered(user)
+    mandrill_mail(
+        template: 'registration',
+        subject: 'Welcome',
+        to: user.email,
+        vars: {
+            'USER_NAME' => user.display_name,
+            'CONFIRMATION_LINK' => user.email_approvement_code
+        },
+        important: true,
+        inline_css: true
+    )
+  end
+end

data/template/models/user.rb.tt

@@ -0,0 +1,75 @@
+module Models
+  class User
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include Mongoid::Paranoia
+  <%- if @es -%>
+    include Mongoid::TirePlugin
+  <%- end -%>
+    include BCrypt
+    include Workflow
+
+    field :display_name, type: String
+    field :email_submit_code, type: String
+    field :email
+    field :password_hash, type: String
+    field :role, type: Symbol, default: :guest
+    field :banned, type: Boolean
+    field :banned_at, type: DateTime
+    field :email_approvement_code, type: String
+    field :workflow_state, type: String, default: 'registered'
+    field :token, type: String
+
+    validates_presence_of :display_name, :email, :role
+    validates_uniqueness_of :email
+  <%- if @carrierwave-%>
+    mount_uploader :avatar, Uploaders::Avatar
+  <%- end -%>
+    workflow do
+      state :registered do
+        event :email_approved, transition_to: :approved
+      end
+
+      state :approved do
+        event :ban, transition_to: :banned
+      end
+
+      state :banned do
+        event :unban, transition_to: :approved
+      end
+    end
+
+    def email_approved
+      self.email_approvement_code = nil
+      self.generate_token!
+    end
+
+    def password=(value)
+      @password = Password.create(value)
+      self.password_hash = @password
+    end
+
+    def password
+      @password ||= Password.new(self.password_hash)
+    end
+
+    def generate_approvement_code!
+      hash_source = '%s-%s-%s'%[self.email, self.display_name, Time.now]
+      self.email_approvement_code = BCrypt::Password.create(hash_source, cost: 3).to_s[8..-1]
+    end
+
+    def generate_token!
+      hash_source = '%s-%s-%s'%[self.email, self.display_name, Time.now]
+      self.token = BCrypt::Password.create(hash_source, cost: 3).to_s[8..-1]
+    end
+
+    class << self
+      def register(fields)
+        user = new(fields)
+        user.generate_approvement_code!
+        user.save!
+        user
+      end
+    end
+  end
+end

data/template/public/faye.html

@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <title></title>
+    <link rel="stylesheet" href="style.css" />
+    <!--[if IE]>
+    <script src="http://html5shiv.googlecode.com/svn/trunk/html5.js"></script>
+    <![endif]-->
+    <script src="https://code.jquery.com/jquery-2.1.3.min.js"></script>
+    <script src="http://localhost:9393/faye/client.js"></script>
+
+    <script type="text/javascript">
+
+
+        $(function(){
+            var $body = $('body'), client = new Faye.Client('http://localhost:9393/faye/');
+
+            function subscriptionActive(subscription){
+                $body.append('<p>Subscription active '+ subscription +'</p>');
+            }
+
+            client.subscribe('/time', function(data){
+                $body.prepend('<p>Current time is '+ data +'</p>');
+            }).then(subscriptionActive.bind(null, '/time'));
+
+            client.subscribe('/user/registered', function(data){
+                $body.prepend('<p>Please, welcome '+ data.display_name +'</p>');
+            }).then(subscriptionActive.bind(null, '/user/registered'));
+        });
+    </script>
+</head>
+<body>
+
+</body>
+</html>

data/template/search_indexes/search_index.rb

@@ -0,0 +1,60 @@
+class SearchIndex < Tire::Index
+  NoIndexForModel = Class.new(StandardError)
+
+  def initialize(name)
+    super("#{RACK_ENV}_#{name}")
+  end
+
+  def type
+    @_type ||= model.to_s.underscore.gsub('/','_')
+  end
+
+  def model
+    "Models::#{self.class.name.chomp('Index')}".constantize
+  end
+
+  class << self
+    def create_indexes!
+      indexes.each do |index|
+        index.delete
+        index.create
+      end
+    end
+
+    def index(instance)
+      index = index_by_klass(instance.class)
+      index.store(instance)
+    rescue NoIndexForModel
+      # ignored
+    end
+
+    def remove(instance)
+      index = index_by_klass(instance.class)
+      index.remove(instance)
+    end
+
+    def reindex!
+      indexes.each do |index_instance|
+        index_instance.delete
+        index_instance.create
+        index_instance.model.all.each do |model_instance|
+          index(model_instance)
+        end
+      end
+    end
+
+    private
+    def index_by_klass(model_klass)
+      @_cache ||= {}
+      @_cache[model_klass] and (return @_cache[model_klass])
+      idx = indexes.find{|idx| idx.model == model_klass}
+      raise NoIndexForModel unless idx
+      @_cache[model_klass] = idx
+      idx
+    end
+
+    def indexes
+      @_indexes ||= ObjectSpace.each_object(Class).select{ |klass| klass < self }.map(&:new)
+    end
+  end
+end

data/template/search_indexes/user_index.rb

@@ -0,0 +1,20 @@
+class UserIndex < SearchIndex
+  def initialize
+    super('users')
+  end
+
+  def create
+    super(
+        mappings: {
+          type => {
+            # Your mappings here
+          }
+        }
+    )
+  end
+
+  def store(instance)
+    index_data = instance.attributes
+    super(index_data)
+  end
+end

data/template/spec/api/mounts/auth_spec.rb.tt

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'rspec_api_documentation/dsl'
+
+resource 'Authorization', focus: true do
+  <% if @mandrill %>
+  before(:each) { MandrillMailer.deliveries.clear }
+  <% end %>
+  post '/api/auth/register' do
+    example 'New user registration' do
+      new_user = FactoryGirl.attributes_for(:user).pick(:display_name, :email)
+
+      do_request(new_user)
+      expect(client.response).to succeed
+      <% if @mandrill %>
+      email = MandrillMailer::deliveries.detect { |mail|
+        mail.template_name == 'registration' &&
+            mail.message['to'].any? { |to| to['email'] == new_user[:email] }
+      }
+      <% end %>
+      expect(email).to_not be_nil
+    end
+  end
+
+  post '/api/auth/approve_email' do
+    example 'User email activation' do
+      user = FactoryGirl.create(:user)
+      user.generate_approvement_code!
+      user.save!
+      do_request(email: user.email, email_approvement_code: user.email_approvement_code)
+      expect(client.response).to succeed
+      expect(response_body).to include('display_name', 'email')
+      <% if @faye %>
+      expect(FayePublisher.publishings.length).to eq(1)
+      <% end %>
+    end
+  end
+end

data/template/spec/factories/user.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  to_create { |i| i.save }
+  factory :user, class: Models::User do
+    display_name { Faker::Name.title  }
+    email { Faker::Internet.email(display_name) }
+    role { :guest }
+  end
+end

data/template/spec/spec_helper.rb.tt

@@ -0,0 +1,132 @@
+require 'rubygems'
+require 'spork'
+require 'rack/test'
+require 'rack/test/methods'
+require 'rspec'
+require 'rspec_api_documentation'
+<% if @mandrill %>
+require 'mandrill_mailer/offline'
+<% end %>
+RACK_ENV = 'test' unless defined?(RACK_ENV)
+
+class TestApiClient < RspecApiDocumentation::RackTestClient
+  def response_body
+    body = JSON.load(last_response.body)
+    case body
+      when Array
+        body.map!{|item| Hashie::Mash.new(item) }
+      else
+        body
+    end
+  end
+
+  def response; last_response end
+end
+
+module RspecApiDocumentation::DSL
+  module Resource
+    def client
+      @client ||= TestApiClient.new(self)
+    end
+  end
+end
+
+Spork.prefork do
+  require File.expand_path(File.dirname(__FILE__) + '/../config/boot_spec')
+  require 'database_cleaner'
+  <% if @sidekiq %>
+  Sidekiq::Testing.fake!
+  <% end %>
+  <% if @faye %>
+  FayePublisher.fake!
+  <% end %>
+
+  <% if @dev_reload %>
+  Grape::RackBuilder.setup do
+    force_reloading true
+  end
+  <% end %>
+
+  RspecApiDocumentation.configure do |config|
+    config.app = RACK_APPLICATION
+  end
+
+  RSpec.configure do |conf|
+    FactoryGirl.reload
+
+    DatabaseCleaner.orm = :mongoid
+    DatabaseCleaner.strategy = :truncation
+
+    conf.include Rack::Test::Methods
+
+    conf.around(:each) do |example|
+      Logging.mdc.clear
+      SearchIndex.create_indexes!
+      DatabaseCleaner.cleaning { example.run }
+      Logging.mdc.clear
+    end
+  end
+
+  def app(app = nil, &blk)
+    @app ||= block_given? ? app.instance_eval(&blk) : app
+    @app ||= RACK_APPLICATION
+  end
+
+  RSpec::Matchers.define :succeed do |valid_codes = nil|
+    match do |*args|
+      case valid_codes
+        when Integer
+          actual.status == valid_codes
+        when Array
+          valid_codes.include?(actual.status)
+        else
+          (actual.status == 200) || (actual.status == 201)
+      end
+    end
+
+    match_when_negated do |*args|
+      case valid_codes
+        when Integer
+          actual.status == valid_codes
+        when Array
+          valid_codes.include?(actual.status)
+        else
+          actual.status > 201
+      end
+    end
+
+    failure_message do |actual|
+      case valid_codes
+        when Integer
+          "expected that #{actual} succeed with code #{valid_codes}, but got #{actual.status} error:\n#{actual.body}"
+        when Array
+          "expected that #{actual} succeed with one of #{valid_codes}, but got #{actual.status} error:\n#{actual.body}"
+        else
+          "expected that #{actual} succeed, but got #{actual.status} error:\n#{actual.body}"
+      end
+    end
+
+    failure_message_when_negated do |actual|
+      case valid_codes
+        when Integer
+          "expected that #{actual} fails with code #{valid_codes}, but got #{actual.status} error:\n#{actual.body}"
+        when Array
+          "expected that #{actual} fails with one of #{valid_codes}, but got #{actual.status} error:\n#{actual.body}"
+        else
+          "expected that #{actual} fails, but got #{actual.status} error:\n#{actual.body}"
+      end
+    end
+
+    description do
+      'respond with 200 or 201 status code'
+    end
+  end
+end
+
+class Spork::Forker
+  alias_method :_initialize, :initialize
+  def initialize(*args, &block)
+    Grape::Reload::Watcher.reload!
+    _initialize(*args, &block)
+  end
+end

data/template/uploaders/avatar_uploader.rb

@@ -0,0 +1,23 @@
+module Uploaders
+  class Avatar < CarrierWave::Uploader::Base
+    include CarrierWave::MiniMagick
+    # include CarrierWave::MiniMagick
+
+    # Choose what kind of storage to use for this uploader:
+    storage :file
+    # storage :fog
+
+    # Override the directory where uploaded files will be stored.
+    # This is a sensible default for uploaders that are meant to be mounted:
+    def store_dir
+      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+    end
+
+    # Provide a default URL as a default if there hasn't been a file uploaded:
+
+    # Create different versions of your uploaded files:
+    version :thumb do
+      process :resize_to_fit => [50, 50]
+    end
+  end
+end

data/template/views/v1/user/profile.json.jbuilder.tt

@@ -0,0 +1,4 @@
+json.(@user, :display_name, :email)
+<% if @carrierwave %>
+json.set! :avatar, @user.avatar.url if @user.avatar?
+<% end %>