grape-gen 0.0.1

data/template/config/boot_spec.rb.tt

@@ -0,0 +1,85 @@
+# Defines our constants
+RACK_ENV = ENV['RACK_ENV'] || 'development' unless defined?(RACK_ENV)
+APP_ROOT = File.expand_path('../..', __FILE__) unless defined?(APP_ROOT)
+
+# Load our dependencies
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup'
+require 'yaml'
+
+# Load initializers
+Bundler.require(
+    :framework,
+    :db,
+<% if @sidekiq -%>
+    :sidekiq,
+<% end -%>
+<% if @mandrill -%>
+    :mailer,
+<% end -%>
+    :utils,
+<% if @es -%>
+    :elastic_search,
+<% end -%>
+    RACK_ENV
+)
+
+require_relative 'settings'
+
+ApplicationSettings.source File.expand_path('config/application.yml', APP_ROOT)
+ApplicationSettings.root = APP_ROOT
+
+require_relative 'database'
+
+Dir[ApplicationSettings.root('config/initializers/em-patches/*.rb')].each {|initializer| require initializer} unless RACK_ENV == 'test'
+Dir[ApplicationSettings.root('config/initializers/*.rb')].each {|initializer|
+  require initializer unless initializer =~ /(faye|sidekiq|tire|mandrill)/
+}
+<% if @sidekiq %>
+require 'sidekiq/testing'
+<% end %>
+
+<% if @dev_reload %>
+RACK_APPLICATION = Grape::RackBuilder.setup do
+    %w{api models lib uploaders models abilities jobs search_indexes mailers}.each do |path|
+        add_source_path ApplicationSettings.root("#{path}/**/*.rb")
+        add_source_path ApplicationSettings.root("#{path}/*.rb")
+    end
+
+    use Warden::Manager do |config|
+        config.strategies.add(:access_token, TokenStrategy)
+        config.default_strategies :access_token
+        config.failure_app = API::Application
+        config.intercept_401 = false
+    end
+
+    use Rack::Config do |env|
+        env['api.tilt.root'] = ApplicationSettings.root('views')
+    end
+
+    mount 'API::Application', to: '/api'
+
+    logger Logging.logger[:rackbuilder]
+end.boot!.application
+<% else %>
+%w{lib models uploaders models abilities jobs search_indexes mailers api}.each do |path|
+    Dir[ApplicationSettings.root("#{path}/**/*.rb")].each {|f| require f}
+end
+
+RACK_APPLICATION = Rack::Builder.new do
+    use Warden::Manager do |config|
+        config.strategies.add(:access_token, TokenStrategy)
+        config.default_strategies :access_token
+        config.failure_app = API::Application
+        config.intercept_401 = false
+    end
+
+    use Rack::Config do |env|
+        env['api.tilt.root'] = ApplicationSettings.root('views')
+    end
+
+    map '/api' do
+        run API::Application
+    end
+end
+<% end %>

data/template/config/database.rb.tt

@@ -0,0 +1,6 @@
+<%- case @orm
+ when 'mongoid' -%>
+Mongoid.load!(ApplicationSettings.root('config', 'database.yml'), RACK_ENV)
+Mongoid.logger = Logging.logger[:database]
+Moped.logger = Logging.logger[:database]
+<%- end -%>

data/template/config/database.yml.tt

@@ -0,0 +1,21 @@
+development: &dev
+  sessions:
+    default:
+      database: <%= @app_name %>
+      hosts:
+        - 127.0.0.1
+
+      options:
+        pool_size: 100
+
+production: *dev
+
+test:
+  sessions:
+    default:
+      database: <%= @app_name %>_test
+      hosts:
+        - 127.0.0.1
+
+      options:
+        pool_size: 100

data/template/config/initializers/carrierwave.rb

@@ -0,0 +1,3 @@
+CarrierWave.configure do |config|
+  config.root = ApplicationSettings.root
+end

data/template/config/initializers/core_ext.rb

@@ -0,0 +1,14 @@
+class DateTime
+  alias_method :to_s, :iso8601
+end
+
+class Time
+  alias_method :to_s, :iso8601
+end
+
+class Hash
+  def pick(*keys)
+    keys = keys.first if keys.first.kind_of? Array
+    Hash[keys.zip(values_at(*keys))]
+  end
+end

data/template/config/initializers/em-patches/carrierwave.rb

@@ -0,0 +1,13 @@
+require 'em-synchrony'
+require 'carrierwave/processing/mini_magick'
+
+module CarrierWave
+  module MiniMagick
+    alias_method :old_manipulate!, :manipulate!
+    def manipulate!(&block)
+      EventMachine::Synchrony.defer do
+        old_manipulate!(&block)
+      end
+    end
+  end
+end

data/template/config/initializers/em-patches/faye.rb

@@ -0,0 +1,4 @@
+require_relative 'redis_lazy_evaluated_pool'
+require_relative '../../../lib/faye_publisher'
+
+FayePublisher.redis = RedisLazyEvaluatedPool.pool_with_config(ApplicationSettings.faye.redis.to_hash.deep_symbolize_keys)

data/template/config/initializers/em-patches/lazy_evaluated_pool.rb

@@ -0,0 +1,35 @@
+require 'em-synchrony/connection_pool'
+
+class LazyEvaluatedPool < EventMachine::Synchrony::ConnectionPool
+  def initialize(opts, &block)
+    @reserved  = {}   # map of in-progress connections
+    @available = []   # pool of free connections
+    @pending   = []   # pending reservations (FIFO)
+    @config = opts
+    opts[:size].times do
+      @available.push(block) if block_given?
+    end
+  end
+
+  private
+  def acquire(fiber)
+    if conn = @available.pop
+      conn = self.instance_eval(&conn) if conn.respond_to?(:call)
+      @reserved[fiber.object_id] = conn
+      conn
+    else
+      Fiber.yield @pending.push fiber
+      acquire(fiber)
+    end
+  end
+
+  class << self
+    def pool_with_config(config, &block)
+      config[:size] ||= 10
+      LazyEvaluatedPool.new(config, &(block || connection))
+    end
+    private
+    def connection; raise 'Please, override connection method or supply block' end
+  end
+end
+

data/template/config/initializers/em-patches/mandrill.rb

@@ -0,0 +1,45 @@
+# Patch mandrill API to play ball with EventMachine
+module Mandrill
+  class API
+    def initialize(apikey=nil, debug=false)
+      @host = 'https://mandrillapp.com'
+      @path = '/api/1.0/'
+
+      @debug = debug
+
+      unless apikey
+        if ENV['MANDRILL_APIKEY']
+          apikey = ENV['MANDRILL_APIKEY']
+        else
+          apikey = read_configs
+        end
+      end
+
+      raise Error, 'You must provide a Mandrill API key' unless apikey
+      @apikey = apikey
+    end
+
+    def call(url, params={})
+      defer = EventMachine::DefaultDeferrable.new
+      params[:key] = @apikey
+      params = JSON.generate(params)
+      http = Mandrill::API.request.get(path: "#{@path}#{url}.json", headers: {'Content-Type' => 'application/json'}, body: params, keepalive: true)
+      http.callback do |r|
+        cast_error(r.response) if r.response_header.status != 200
+        defer.succeed(JSON.parse(r.response))
+      end
+
+      http.errback do |r|
+        raise Mandrill::ServiceUnavailableError.new
+      end
+
+      EventMachine::Synchrony.sync defer
+    end
+
+    class << self
+      def request
+        EventMachine::HttpRequest.new('https://mandrillapp.com/api/1.0/')
+      end
+    end
+  end
+end

data/template/config/initializers/em-patches/redis.rb

@@ -0,0 +1,13 @@
+require 'em-synchrony/em-hiredis'
+
+unless defined?(REDIS_CONNECTION)
+  module EventMachine
+    module Hiredis
+      class BaseClient
+        def async_command(*args)
+          old_method_missing(*args)
+        end
+      end
+    end
+  end
+end

data/template/config/initializers/em-patches/redis_lazy_evaluated_pool.rb

@@ -0,0 +1,19 @@
+require 'redis-namespace'
+require_relative 'redis'
+require_relative 'lazy_evaluated_pool'
+
+class RedisLazyEvaluatedPool < LazyEvaluatedPool
+  CONFIG_DEFAULTS = {
+      url: 'redis://localhost:6379/0',
+      size: 10
+  }
+  private
+  def self.connection
+    Proc.new {
+      config = RedisLazyEvaluatedPool::CONFIG_DEFAULTS.merge (@config|| {}).deep_symbolize_keys
+      connection = EventMachine::Hiredis.connect(config[:url])
+      connection = Redis::Namespace.new(config[:namespace], redis: connection) if config[:namespace]
+      connection
+    }
+  end
+end

data/template/config/initializers/em-patches/sidekiq.rb

@@ -0,0 +1,46 @@
+require 'sidekiq'
+require_relative 'redis'
+
+module Sidekiq
+  def self.redis=(hash)
+    if hash.is_a?(LazyEvaluatedPool)
+      @redis = hash
+    else
+      @_config_hash = hash
+    end
+  end
+  class Client
+    private
+    def raw_push(payloads)
+      @redis_pool.execute(false) do |conn|
+        # No need to wait MULTI command to finish
+        conn.async_command :multi
+        # Atomic push commands is also async
+        atomic_push(conn, payloads)
+        # After pipeline is built, call synced EXEC command
+        conn.exec
+      end
+      true
+    end
+
+    def atomic_push(conn, payloads)
+      if payloads.first['at']
+        conn.async_command(:zadd, 'schedule',payloads.map do |hash|
+                                  at = hash.delete('at').to_s
+                                  [at, Sidekiq.dump_json(hash)]
+                                end)
+      else
+        q = payloads.first['queue']
+        to_push = payloads.map { |entry| Sidekiq.dump_json(entry) }
+        conn.async_command(:sadd, 'queues', q)
+        conn.async_command(:lpush,"queue:#{q}", to_push)
+      end
+    end
+  end
+end
+
+Sidekiq.configure_client do |config|
+  config.redis = RedisLazyEvaluatedPool.pool_with_config(ApplicationSettings.sidekiq.redis)
+end
+
+SIDEKIQ_ON_EM = true

data/template/config/initializers/em-patches/tire.rb

@@ -0,0 +1,8 @@
+require 'tire/http/clients/faraday'
+
+Tire.configure do
+  Tire::HTTP::Client::Faraday.faraday_middleware = Proc.new do |builder|
+    builder.adapter :em_synchrony
+  end
+  client Tire::HTTP::Client::Faraday
+end

data/template/config/initializers/faye.rb

@@ -0,0 +1,3 @@
+require_relative '../../lib/faye_publisher'
+
+FayePublisher.redis = ApplicationSettings.faye.redis unless FayePublisher.configured?

data/template/config/initializers/grape.rb

@@ -0,0 +1,11 @@
+module Grape
+  module Formatter
+    module Json
+      class << self
+        def call(object, env)
+          MultiJson.dump(object)
+        end
+      end
+    end
+  end
+end

data/template/config/initializers/logging.rb

@@ -0,0 +1,38 @@
+require 'logging'
+
+logger_config = YAML.load(File.read(ApplicationSettings.root('config/logging.yml')))[RACK_ENV.to_s].deep_symbolize_keys
+
+apply_logger_config = ->(logger, config, buffering_options) do
+  logger.level = config[:level] || :debug
+  logger.additive = config[:additive] if logger.respond_to? 'additive='
+  logger.add_appenders(
+      (config[:appenders] || { default: {type: 'stdout'} }).map do |key, value|
+        case value
+          when String
+            Logging.appenders.send(key, value, buffering_options)
+          when Hash
+            layout = value.delete(:layout)
+            if layout
+              if layout.kind_of? String
+                value[:layout] = Logging.layouts.pattern(pattern: layout)
+              else
+                layout_type = layout.delete(:type) || :basic
+                value[:layout] = Logging.layouts.send(layout_type, layout)
+              end
+            end
+
+            Logging.appenders.send(value[:type] || key, logger.name, buffering_options.merge!(value).symbolize_keys!)
+          else
+            Logging.appenders.send(key, logger.name, buffering_options)
+        end
+      end
+  )
+end
+
+buferring_options = [:auto_flushing, :immediate_at, :flush_period]
+bufferring = Hash[buferring_options.zip(logger_config.values_at(*buferring_options))]
+routes = logger_config.delete(:routes) || []
+
+apply_logger_config.call(Logging.logger.root, logger_config, bufferring)
+
+routes.each { |route, settings| apply_logger_config.call(Logging.logger[route], settings, bufferring) }

data/template/config/initializers/mandrill.rb

@@ -0,0 +1 @@
+MandrillMailer.config.api = ApplicationSettings.mandrill.api_key

data/template/config/initializers/patches/redis_namespace.rb

@@ -0,0 +1,96 @@
+class Redis
+  class Namespace
+    def call_with_namespace(command, *args, &block)
+      handling = COMMANDS[command.to_s.downcase]
+
+      if handling.nil?
+        fail("Redis::Namespace does not know how to handle '#{command}'.")
+      end
+
+      (before, after) = handling
+
+      # Add the namespace to any parameters that are keys.
+      case before
+        when :first
+          args[0] = add_namespace(args[0]) if args[0]
+        when :all
+          args = add_namespace(args)
+        when :exclude_first
+          first = args.shift
+          args = add_namespace(args)
+          args.unshift(first) if first
+        when :exclude_last
+          last = args.pop unless args.length == 1
+          args = add_namespace(args)
+          args.push(last) if last
+        when :exclude_options
+          if args.last.is_a?(Hash)
+            last = args.pop
+            args = add_namespace(args)
+            args.push(last)
+          else
+            args = add_namespace(args)
+          end
+        when :alternate
+          args.each_with_index { |a, i| args[i] = add_namespace(a) if i.even? }
+        when :sort
+          args[0] = add_namespace(args[0]) if args[0]
+          if args[1].is_a?(Hash)
+            [:by, :store].each do |key|
+              args[1][key] = add_namespace(args[1][key]) if args[1][key]
+            end
+
+            args[1][:get] = Array(args[1][:get])
+
+            args[1][:get].each_index do |i|
+              args[1][:get][i] = add_namespace(args[1][:get][i]) unless args[1][:get][i] == "#"
+            end
+          end
+        when :eval_style
+          # redis.eval() and evalsha() can either take the form:
+          #
+          #   redis.eval(script, [key1, key2], [argv1, argv2])
+          #
+          # Or:
+          #
+          #   redis.eval(script, :keys => ['k1', 'k2'], :argv => ['arg1', 'arg2'])
+          #
+          # This is a tricky + annoying special case, where we only want the `keys`
+          # argument to be namespaced.
+          if args.last.is_a?(Hash)
+            args.last[:keys] = add_namespace(args.last[:keys])
+          else
+            args[1] = add_namespace(args[1])
+          end
+        when :scan_style
+          options = (args.last.kind_of?(Hash) ? args.pop : {})
+          options[:match] = add_namespace(options.fetch(:match, '*'))
+          args << options
+
+          if block
+            original_block = block
+            block = proc { |key| original_block.call rem_namespace(key) }
+          end
+      end
+
+      d = EventMachine::DefaultDeferrable.new
+
+      # Dispatch the command to Redis and store the result.
+      result = @redis.send(command, *args, &block)
+
+      result.callback do |result|
+        case after
+          when :all
+            result = rem_namespace(result)
+          when :first
+            result[0] = rem_namespace(result[0]) if result
+          when :second
+            result[1] = rem_namespace(result[1]) if result
+        end
+        d.succeed(result)
+      end
+
+      d
+    end
+  end
+end

data/template/config/initializers/sidekiq.rb

@@ -0,0 +1,15 @@
+require 'redis-namespace'
+
+if RACK_ENV == 'test'
+  require 'sidekiq/testing'
+  Sidekiq::Testing.fake!
+else
+  Sidekiq.configure_server do |config|
+    config.redis = ApplicationSettings.sidekiq.redis
+  end
+
+  Sidekiq.configure_client do |config|
+    config.redis = ApplicationSettings.sidekiq.redis unless defined?(SIDEKIQ_ON_EM)
+  end
+end
+Sidekiq::Logging.logger = Logging.logger[:sidekiq]

data/template/config/initializers/tire.rb

@@ -0,0 +1,6 @@
+require 'tire/http/clients/faraday'
+
+Tire.configure do
+  url ApplicationSettings.elasticsearch.url
+  logger Logging.logger[:elasticsearch]
+end

data/template/config/initializers/workflow.rb

@@ -0,0 +1,31 @@
+module Workflow
+  module Adapter
+    module Mongoid
+      def self.included(klass)
+        klass.send :include, InstanceMethods
+      end
+      module InstanceMethods
+        def load_workflow_state
+          send(self.class.workflow_column)
+        end
+
+        def persist_workflow_state(new_value)
+          update_attributes(self.class.workflow_column => new_value)
+        end
+
+        def before_validation
+          attributes[self.class.workflow_column] = current_state.to_s
+          super
+        end
+      end
+    end
+  end
+end
+
+module Mongoid
+  module Document
+    module ClassMethods
+      def workflow_adapter; Workflow::Adapter::Mongoid end
+    end
+  end
+end

data/template/config/logging.yml.tt

@@ -0,0 +1,39 @@
+development: &dev
+  # Autoflush logs after 100 messages
+  auto_flushing: 1
+  # Flush logs each N seconds, empty to disable
+  flush_period:
+  # Log all levels by default
+  level: :debug
+  # Root appenders
+  appenders:
+    stdout: true
+
+production:
+  # Flush logs each N seconds, empty to disable
+  flush_period: 3
+  immediate_at:
+      - :exception
+      - :error
+      - :fatal
+  level: :fatal
+
+  routes:
+    database:
+      additive: false
+      level: :debug
+      appenders:
+        default:
+          type: rolling_file
+          filename: log/database.log
+    <% if @faye %>
+    faye:
+      additive: false
+      level: :debug
+      appenders:
+        default:
+          type: rolling_file
+          filename: log/faye.log
+    <% end %>
+
+test: *dev

data/template/config/settings.rb

@@ -0,0 +1,24 @@
+require 'logging'
+require 'settingslogic'
+Logging.init :devel, :debug, :response, :info, :warn, :error, :fatal
+
+class ApplicationSettings < Settingslogic
+  namespace RACK_ENV.to_s
+  class << self
+    def root=(value)
+      instance[:app_root] = value
+    end
+
+    def root(*path)
+      return File.expand_path(File.join(path), instance[:app_root]) if path
+      instance[:app_root]
+    end
+
+    # @return [String]
+    def api_absolute_url(uri)
+      "#{api_root}#{uri}"
+    end
+
+    # @return [String]
+  end
+end

data/template/config/sidekiq.yml.tt

@@ -0,0 +1,22 @@
+---
+:concurrency: 3
+:pidfile: tmp/pids/sidekiq.pid
+development:
+:concurrency: 3
+production:
+:concurrency: 3
+:queues:
+- default
+:schedule:
+#  'DelayedJobs::YourJob':
+#    every: 10s
+#    queue: default
+#    description: Sample job schedule
+<% if @faye %>
+  'DelayedJobs::PongTime':
+    every: 5s
+    queue: default
+    description: Notify connected faye users about current time
+<% end %>
+
+

data/template/config.ru.tt

@@ -0,0 +1,8 @@
+#!/usr/bin/env rackup -s thin
+require_relative 'config/boot'
+
+use Rack::Static, urls: {'/faye' => 'faye.html'}, root: 'public'
+
+use Rack::FiberPool, size: 50
+
+run RACK_APPLICATION