culpa 1.1.0 → 1.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YmFjM2ViYTZiMTdlNDM0OTI2Mjg5YzUyN2VkOWIwMTMyMDc3YTgxMg==
+    ZWI1MTZlY2MxNTkwZjkwZGVmYjQ4YzliMzQxMDg1YjJiMzg3YThiOA==
   data.tar.gz: !binary |-
-    Y2VkODYxZGUwNWI2MzU3Yjg5OGZmOTI5NmI3NzljNGE3OWZjYThhNg==
+    NmJmZjVkNDY3ZTYwMDJjZTc0ZjJjOTViMzA4YmNlOWYwZjY0OWY5NQ==
 SHA512:
   metadata.gz: !binary |-
-    MTRhNDdhNWVmMTBjOTY1ZDJmOTViYTRkYTVhZDRjZmY1YjQ2ODNmZTNiOTAw
-    M2YzNTM3ZjE2ZmMyZTk1Y2Y0YjVhOTljMWE0NzFiNTljMjVkMzMxYWMwNDVk
-    YjM3OGQxMGI5ODk1YzljYjc3NWU2YjNjYjVjNmE4YjA1ZmEwM2Q=
+    ZTBhNTg3N2RkZmIzNjRjMzQwYzNiNGUyZjJjOTE0N2NhM2FkNGU5ODZiMWVk
+    NGI2ZDJhNTMyMmI5ZmUwN2YyZGI3YjUwZGM4YjNmZDk0ODBjMWI0ZDIyZmI5
+    YzI5MzdlZTcwOTZkNjAwOWE2ZjE0ZmQzZmFhMjcwMWFkZjExMmE=
   data.tar.gz: !binary |-
-    NDUxYmQ5ZjllODdhMDU1NGFjN2I0NWZlYTBmNmMzOWI2YmQ4MDlkN2ZmOTA3
-    ZDc4M2I3MmNjY2IzYjVkZTFiYmQyYTRlYzZjM2Q1ZjljYTI4MDkwMDk1ZWJi
-    MTM3YmM1MTUxMTg3OTBlZGVlODQ5MzkzZDc0YmZkYTRjYTMyNTQ=
+    NDliZGU4NmU0Y2IxY2EwODcxOWFhYmRhZWVjODg0MjFmOWVjMDhiMjliZjc2
+    YzcyYmM0YzEzNTUzNzUwYzkyNWFjZmFiOGJkNzA0NzI2NzcwNTI3YmQ1MGI4
+    Nzk2YWI1MTBkYmRmMThjNzgzZTQyNmIzMjRkNWQ4ZWY3YjdmMDU=

data/bin/culpa

@@ -21,6 +21,7 @@ def create_project(project_path)
   FileUtils.mkdir "#{project_path}/public"
   FileUtils.touch "#{project_path}/public/.keep"
   FileUtils.mkdir "#{project_path}/config"
+  FileUtils.mkdir "#{project_path}/config/dockerized"
   FileUtils.touch "#{project_path}/config/brickchains.rb"
   FileUtils.mkdir "#{project_path}/config/initializers"
   FileUtils.touch "#{project_path}/config/initializers/.keep"
@@ -37,6 +38,12 @@ def create_project(project_path)
   dockerfile_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/Dockerfile' )
   FileUtils.cp dockerfile_rackup_path, "#{project_path}/Dockerfile"
 
+  puts '==> Copying Docker dependencies'
+  nginx_conf_path = File.join( File.dirname(__FILE__), '../templates/culpa/nginx.conf' )
+  supervisord_path = File.join( File.dirname(__FILE__), '../templates/culpa/supervisord.conf' )
+  FileUtils.cp nginx_conf_path, "#{project_path}/config/dockerized/nginx.conf"
+  FileUtils.cp supervisord_path, "#{project_path}/config/dockerized/supervisord.conf"
+
   puts '==> Copying default public folder content'
   index_html_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/index.html' )
   FileUtils.cp index_html_rackup_path, "#{project_path}/public/index.html"
@@ -100,7 +107,12 @@ end
 def start_server
   require 'rack'
   ENV['RACK_ENV'] ||= 'development'
-  Rack::Handler.default.run(Culpa::Application.new, Port: 4748)
+  case ENV['RACK_ENV']
+  when 'development'
+    Rack::Handler.default.run(Culpa::Application.new, Port: 4748)
+  when 'production'
+    Rack::Handler.default.run(Culpa::Application.new, Host: '/var/run/culpa.sock')
+  end
 end
 
 case ARGV[0]

data/lib/culpa/action.rb

@@ -1,59 +1,14 @@
 class Action
 
-  RETURN_CODES = {
-      # Information codes
-      continue: 100,
-      switching_procotols: 101,
-      # Success codes
-      ok: 200,
-      created: 201,
-      accepted: 202,
-      non_authoritative_information: 203,
-      no_content: 204,
-      reset_content: 205,
-      partial_content: 206,
-      # Redirection codes
-      multiple_choices: 300,
-      moved_permanently: 301,
-      moved_temporarily: 302,
-      see_other: 303,
-      not_modified: 304,
-      use_proxy: 305,
-      temporary_redirect: 307,
-      permanent_redirect: 308,
-      too_many_redirects: 310,
-      # Clients error codes
-      bad_request: 400,
-      unauthorized: 401,
-      payment_required: 402,
-      forbidden: 403,
-      not_found: 404,
-      method_not_allowed: 405,
-      not_acceptable: 406,
-      proxy_authentication_required: 407,
-      request_time_out: 408,
-      conflict: 409,
-      gone: 410,
-      length_required: 411,
-      precondition_failed: 412,
-      request_entity_too_large: 413,
-      request_uri_too_long: 414,
-      unsupported_media_type: 415,
-      request_range_unsatisfiable: 416,
-      expectation_failed: 417,
-      im_a_tea_pot: 418,
-      bad_mapping: 412,
-      unavailable_for_legal_reason: 451,
-      # Server error codes
-      internal_server_error: 500,
-      not_implemented: 501,
-      bad_gateway: 502,
-      proxy_error: 502,
-      service_unavailable: 503,
-      gateway_time_out: 504,
-      bandwidth_limit_exceeded: 509,
-      unknown_error: 520
-  }
+  require_relative 'renderer_describer'
+
+  @@renderers = {}
+
+  def self.load_renderers
+    Dir[File.join( File.dirname(__FILE__), 'renderers/*.rb' )].each do |renderer|
+      @@renderers.merge!(RendererDescriber.new(renderer).result)
+    end
+  end
 
   attr_reader :e, :r
 
@@ -67,7 +22,6 @@ class Action
   def initialize(envelope, request)
     @e = envelope
     @r = request
-    @to_render = nil
   end
 
   def method_missing(sym)
@@ -75,42 +29,10 @@ class Action
   end
 
   def render(options={})
+    keyword = options.keys.first
     options[:headers] ||= {}
-    if options.has_key? :json
-      if options[:json]
-        to_render = {
-           format: :json,
-           status: RETURN_CODES[options[:status]] || 200,
-           headers: { 'Content-Type' => 'application/json' }.merge(options[:headers]),
-           object: options[:json]
-        }
-      else
-      to_render = {
-         format: :status,
-         headers: options[:headers],
-         status: RETURN_CODES[options[:or_status]]
-      }
-      end
-    elsif options.has_key? :file
-      to_render = {
-         format: :file_from_path,
-         headers: {
-             'Content-Type' => options[:content_type] || 'application/octet-stream',
-             'Content-Disposition' => "#{options[:disposition].to_s || 'attachment'}; filename=#{options[:filename] || 'unknown'}",
-         }.merge(options[:headers]),
-         status: RETURN_CODES[options[:status]] || 200,
-         object: Culpa::FileStreamer.new(options[:file])
-      }
-      to_render[:headers]['Content-Length'] = options[:size] if options.has_key? :size
-    elsif options.has_key? :status
-      to_render = {
-         format: :status,
-         headers: options[:headers],
-         status: RETURN_CODES[options[:status]]
-      }
-    else
-     raise Culpa::UnknownRenderCall.new
-    end
+    raise Culpa::UnknownRenderCall.new unless @@renderers.include?(keyword)
+    to_render = @@renderers[keyword].call(options, @envelope)
     raise RenderNow.new(to_render)
   end
 

data/lib/culpa/brickchain_helpers.rb

@@ -15,6 +15,16 @@ module Culpa
       asb.chs.each { |call_holder| call_holder.thread.join }
     end
 
+    def render_coliseum(file)
+      coliseum = ColiseumDSL.new("./coliseums/#{file}.rb", envelope)
+      raise Action::RenderNow.new({
+         format: :json,
+         status: RendererDescriber::RETURN_CODES[coliseum.culpa_status] || 200,
+         headers: { 'Content-Type' => 'application/json' }.merge(coliseum.culpa_headers),
+         object: coliseum.dsl_attributes
+      })
+    end
+
     def method_missing(sym)
       return CallHolder.new(sym.to_s, @envelope, @request)
     end

data/lib/culpa/coliseum_dsl.rb

@@ -0,0 +1,65 @@
+require 'multi_json'
+
+class ColiseumDSL
+
+  attr_reader :dsl_attributes, :culpa_status, :culpa_headers
+
+  def initialize(to_eval, envelope, eval_args=nil)
+    @dsl_attributes = {}
+    @culpa_headers = {}
+    @culpa_envelope = envelope
+    if to_eval.is_a?(String)
+      self.instance_eval(File.read(to_eval), to_eval)
+    else
+      self.instance_exec eval_args, &to_eval
+    end
+  end
+
+  def e
+    @culpa_envelope
+  end
+
+  def set_status_code!(code)
+    @culpa_status = code
+  end
+
+  def add_http_headers!(hdrs={})
+    @culpa_headers.merge!(hdrs)
+  end
+
+  def array!(opts, &blk)
+    if opts.is_a? Hash
+      sym, items = opts.first
+      @dsl_attributes[sym] = []
+      items.each do |item|
+        @dsl_attributes[sym] << ColiseumDSL.new(blk, @culpa_envelope, item).dsl_attributes
+      end
+    else
+      @dsl_attributes = []
+      opts.each do |item|
+        @dsl_attributes << ColiseumDSL.new(blk, @culpa_envelope, item).dsl_attributes
+      end
+    end
+  end
+
+  def extract!(target, *attrs)
+    attrs.each do |att|
+      @dsl_attributes[att] = target.send(att)
+    end
+  end
+
+  def method_missing(sym, *args, &blk)
+    @dsl_attributes[sym] = if ::Kernel.block_given?
+      ColiseumDSL.new(blk, @culpa_envelope).dsl_attributes
+    else
+      if args.count == 0
+        nil
+      elsif args.count == 1
+        args[0]
+      else
+        args
+      end
+    end
+  end
+
+end

data/lib/culpa/path_parser.rb

@@ -6,13 +6,15 @@ module Culpa
       @@route_patterns
     end
 
-    # Parsing a path
+    ##
+    # Parse a path and return the results of the parse
     def self.parse(pattern, path)
       result = path.match(pattern[:regex])
       return unless result
       return Hash[result.names.map{ |name| name }.zip(result.captures)]
     end
 
+    ##
     # Use the brickchains to build the cache of route
     def self.create_route_cache(brickchains, global_prefix)
       custom_routes = []
@@ -47,18 +49,21 @@ module Culpa
       @@route_patterns = custom_routes + fixed_routes
     end
 
-    # Transforms a string to its equivalent for the compose_regex
+    ##
+    # Transform a string to its equivalent for the compose_regex
     def self.dir_to_regex(dir)
       return dir unless dir.start_with? ':'
       "(?<#{dir[1..dir.length-1]}>\\w+)"
     end
 
-    # Composing a regex from a human-readable http path pattern
+    ##
+    # Compose a regex from a human-readable http path pattern
     def self.compose_regex(url)
       regex = url.split('/').map{ |dir| self.dir_to_regex(dir) }.join('/')
       Regexp.new("^#{regex}$")
     end
 
+    ##
     # Search for the routes, extracts informations and returns
     # the router method name and the request informations
     def self.extract_vars(path, call_options)
@@ -74,6 +79,7 @@ module Culpa
       end
     end
 
+    ##
     # Try to return the router method name or infer it automatically
     def self.infer_method_name(pattern, params, verb)
       if params.has_key?('sub_call')

data/lib/culpa/renderer_describer.rb

@@ -0,0 +1,68 @@
+class RendererDescriber
+
+  RETURN_CODES = {
+      # Information codes
+      continue: 100,
+      switching_procotols: 101,
+      # Success codes
+      ok: 200,
+      created: 201,
+      accepted: 202,
+      non_authoritative_information: 203,
+      no_content: 204,
+      reset_content: 205,
+      partial_content: 206,
+      # Redirection codes
+      multiple_choices: 300,
+      moved_permanently: 301,
+      moved_temporarily: 302,
+      see_other: 303,
+      not_modified: 304,
+      use_proxy: 305,
+      temporary_redirect: 307,
+      permanent_redirect: 308,
+      too_many_redirects: 310,
+      # Clients error codes
+      bad_request: 400,
+      unauthorized: 401,
+      payment_required: 402,
+      forbidden: 403,
+      not_found: 404,
+      method_not_allowed: 405,
+      not_acceptable: 406,
+      proxy_authentication_required: 407,
+      request_time_out: 408,
+      conflict: 409,
+      gone: 410,
+      length_required: 411,
+      precondition_failed: 412,
+      request_entity_too_large: 413,
+      request_uri_too_long: 414,
+      unsupported_media_type: 415,
+      request_range_unsatisfiable: 416,
+      expectation_failed: 417,
+      im_a_tea_pot: 418,
+      bad_mapping: 412,
+      unavailable_for_legal_reason: 451,
+      # Server error codes
+      internal_server_error: 500,
+      not_implemented: 501,
+      bad_gateway: 502,
+      proxy_error: 502,
+      service_unavailable: 503,
+      gateway_time_out: 504,
+      bandwidth_limit_exceeded: 509,
+      unknown_error: 520
+  }
+
+  attr_reader :result
+
+  def initialize(file)
+    self.instance_eval(File.read(file), file)
+  end
+
+  def describe_renderer(keyword, &blk)
+    @result = {keyword => blk}
+  end
+
+end

data/lib/culpa/renderers/coliseum.rb

@@ -0,0 +1,21 @@
+##
+# This renderer loads the ColiseumDSL to eval the
+# passed file, and renders it as a JSON.
+##
+
+require_relative '../coliseum_dsl'
+
+describe_renderer :coliseum do |options, envelope|
+
+  coliseum = ColiseumDSL.new("./coliseums/#{options[:coliseum]}.rb", envelope)
+
+  sent_headers = { 'Content-Type' => 'application/json' }.merge(options[:headers]).merge(coliseum.culpa_headers)
+
+  {
+     format: :json,
+     status: RETURN_CODES[options[:status]] || RETURN_CODES[coliseum.culpa_status] || 200,
+     headers: sent_headers,
+     object: coliseum.dsl_attributes
+  }
+
+end

data/lib/culpa/renderers/file.rb

@@ -0,0 +1,33 @@
+##
+# This renderer loads the FileStreamer helper
+# used to stream a file to the client.
+##
+
+class FileStreamer
+  def initialize(element)
+    @element = element
+  end
+  def each(&blk)
+    @element.each(&blk)
+  ensure
+    @element.close
+  end
+end
+
+describe_renderer :file do |options, envelope|
+
+  to_render = {
+     format: :file_from_path,
+     headers: {
+         'Content-Type' => options[:content_type] || 'application/octet-stream',
+         'Content-Disposition' => "#{options[:disposition].to_s || 'attachment'}; filename=#{options[:filename] || 'unknown'}",
+     }.merge(options[:headers]),
+     status: RETURN_CODES[options[:status]] || 200,
+     object: FileStreamer.new(options[:file])
+  }
+
+  to_render[:headers]['Content-Length'] = options[:size] if options.has_key? :size
+
+  to_render
+
+end

data/lib/culpa/renderers/json.rb

@@ -0,0 +1,24 @@
+##
+# This renderer helps render a JSON.
+# You can add a or_status: :status_code to the render json: {...}
+# to render a status code if the passed object to render is nil.
+##
+
+describe_renderer :json do |options, envelope|
+
+  if options[:json]
+    {
+       format: :json,
+       status: RETURN_CODES[options[:status]] || 200,
+       headers: { 'Content-Type' => 'application/json' }.merge(options[:headers]),
+       object: options[:json]
+    }
+  else
+    {
+       format: :status,
+       headers: options[:headers],
+       status: RETURN_CODES[options[:or_status]]
+    }
+  end
+
+end

data/lib/culpa/renderers/status.rb

@@ -0,0 +1,11 @@
+##
+# This renderer helps to return a simple status code the client
+## 
+
+describe_renderer :status do |options, envelope|
+  {
+     format: :status,
+     headers: options[:headers],
+     status: RETURN_CODES[options[:status]]
+  }
+end

data/lib/culpa/routes_builder.rb

@@ -1,5 +1,10 @@
 module Culpa
 
+  ##
+  # This class helps to build the routes.
+  # This class is used to understand and parse the DSL of the brickchains.rb file.
+  ##
+
   class RoutesBuilder
 
     attr_reader :result

data/lib/culpa/test_helpers.rb

@@ -4,14 +4,20 @@ require 'rspec/expectations'
 
 module CulpaHelpers
 
+  ##
+  # Helper to access the result of the last call
   def last_call
     @@last_call
   end
 
+  ##
+  # Helper to call a brick
   def call_brick(brick_name)
     @@last_call = BrickCall.new(brick_name)
   end
 
+  ##
+  # Class used to mock a brick call
   class BrickCall
 
     attr_reader :from_done
@@ -49,14 +55,18 @@ module CulpaHelpers
 
   end
 
+  ##
+  # expect(last_call).to have_status(:i_am_a_teapot)
   RSpec::Matchers.define :have_status do |expected|
     match do |actual|
       actual.from(described_class) unless actual.from_done or described_class.nil?
       bc = actual.call
-      bc[:to_render][:status] == Action::RETURN_CODES[expected]
+      bc[:to_render][:status] == RendererDescriber::RETURN_CODES[expected]
     end
   end
 
+  ##
+  # expect(last_call).to have_headers({'X-Header-1' => 'ASD' .... })
   RSpec::Matchers.define :have_headers do |expected|
     match do |actual|
       expected.each do |k,v|
@@ -69,6 +79,8 @@ module CulpaHelpers
     end
   end
 
+  ##
+  # expect(last_call).to have_body({a: 'a' ... }) (Can be a JSON or anything else)
   RSpec::Matchers.define :have_body do |expected|
     match do |actual|
       actual.from(described_class) unless actual.from_done or described_class.nil?
@@ -77,6 +89,8 @@ module CulpaHelpers
     end
   end
 
+  ##
+  # expect(last_call).to have_envelope({a: 'a' ... })
   RSpec::Matchers.define :have_envelope do |expected|
     match do |actual|
       actual.from(described_class) unless actual.from_done or described_class.nil?

data/lib/culpa.rb

@@ -1,25 +1,26 @@
-require 'rubygems'
 require 'bundler'
-require 'json'
+require 'multi_json'
 require 'yaml'
 require 'logger'
 
 require_relative 'culpa/envelope'
 require_relative 'culpa/path_parser'
-require_relative 'culpa/file_streamer'
 require_relative 'culpa/routes_builder'
 require_relative 'culpa/brickchain_helpers'
 
-CULPA_VERSION='1.1.0'
+CULPA_VERSION='1.2.0'
 
 ACTIONS_PATH ||= './actions/*.rb'
 MODELS_PATH ||= './models/*.rb'
 INITIALIZERS_PATH ||= './config/initializers/*.rb'
 
+# Require the initializers
 Dir[INITIALIZERS_PATH].each do |file|
   require file
 end
 
+# Load all the actions in a module
+# so it can be safely load
 module Actions
   require_relative 'culpa/action'
   Dir[ACTIONS_PATH].each do |file|
@@ -27,26 +28,36 @@ module Actions
   end
 end
 
+# The main module of the application
 module Culpa
 
+  # Error called when a sub_call is not defined and it can't be inferred
   class UnpredictableSubCallError < StandardError; end
+  # Error raised when a brickchain didn't called a render at all
   class NoRenderCalled < StandardError; end
+  # Error raised when a brick tried to render with an unknown renderer
   class UnknownRenderCall < StandardError; end
+  # Error raised when the route is not found in the router (aka 404)
   class RouteNotFoundError < StandardError; end
 
+  # Loading models directly in the Culpa module, so it can be accessed easily.
   Dir[MODELS_PATH].each do |file|
     require file
   end
 
+  # This class is the one instancied by Rack.
   class Application
 
     def initialize(options = {})
-      # Loading brickchains definitions
+      # Loading brickchains definitions and the associated routes
       bc_path = options[:brickchains] || './config/brickchains.rb'
       route_builder = RoutesBuilder.new(File.read(bc_path))
-      @public_folder = options[:public] || route_builder.public_folder || './public'
       @router = route_builder.result
       PathParser.create_route_cache(@router, route_builder.prefix || '')
+      # Setting static file directory
+      @public_folder = options[:public] || route_builder.public_folder || './public'
+      # Loading renderers
+      Action.load_renderers
       # Logging helper
       @logger = Logger.new(options[:log_output] || STDOUT)
       @logger.level = case ENV['RACK_ENV']
@@ -58,6 +69,7 @@ module Culpa
                           # :nocov:
                       end
       @logger.info 'Culpa fully initialized'
+      # If in dev or test env, serve the static assets
       if %w(development test).include? ENV['RACK_ENV']
         @rack_file = Rack::File.new(@public_folder)
       end
@@ -66,9 +78,11 @@ module Culpa
     ##
     # Rack entrypoint
     def call(env)
+      # Checking if it is a static file before calling the router
       path = env['PATH_INFO']
       if @rack_file && (File.exists?("#{@public_folder}#{path}") || path == '/')
         env['PATH_INFO'] = '/index.html' if path == '/'
+        @logger.info "Serving static file : #{path}"
         return @rack_file.call(env)
       end
       @logger.info "Received request : #{path}"
@@ -79,7 +93,7 @@ module Culpa
       }
       # Parse body if in JSON, otherwise pass the rack.input directly
       if env['CONTENT_TYPE'] == 'application/json'
-        body = JSON.parse(env['rack.input'].read)
+        body = MultiJson.load(env['rack.input'].read)
         request[:input] = if body.has_key?('data')
                             body['data']
                           else
@@ -92,13 +106,17 @@ module Culpa
       # Extract vars from path, take route decision and go !
       method_name, f_request = PathParser.extract_vars(path, request)
       call_brickchain method_name, f_request
-    rescue UnpredictableSubCallError, JSON::ParserError
+    rescue UnpredictableSubCallError, MultiJson::ParseError
+      # The sub_call wasn't predictacle, or the body wans't correct JSON.
+      # In both cases, it is a bad_request.
       rack_error 400
-    rescue RouteNotFoundError
+    rescue RouteNotFoundError => err
+      # The good old 404 not found
       @logger.info "Route not found : #{env['PATH_INFO']}"
       rack_error 404
     rescue StandardError => err
-      if ENV['RACK_ENV'] == 'development'
+      # Something went wrong executing the chain !
+      if ENV['RACK_ENV'] != 'test'
         # :nocov:
         @logger.error "#{err.to_s}\n#{err.backtrace.join("\n")}"
         # :nocov:
@@ -106,33 +124,41 @@ module Culpa
       rack_error 500
     end
 
+    ##
+    # Call a brickchain using the method_name associated to it
     def call_brickchain(router_method_name, options)
+      # Loading the router method
       raise RouteNotFoundError.new unless @router.has_key? router_method_name
+      route = @router[router_method_name]
       @logger.info "Executing brickchain : #{router_method_name}"
+      # Preparing brickchain scopped variables
       envelope = Envelope.new
       request = EnvelopeRequest.new(options)
-      route = @router[router_method_name]
+      # Execute before blocks in the brickchain
       route[:before].each do |before_block|
         BrickchainExecutor.new(envelope, request).instance_eval(&before_block)
       end if route.has_key? :before
-
+      # Execute the brickchain itself
       if route.has_key? :block
         BrickchainExecutor.new(envelope, request).instance_eval(&route[:block])
       else
         ch = CallHolder.new(route[:brick_name], envelope, request)
         ch.from(route[:class_name])
       end
-
+      # If we come to this point, the brickchain haven't raised the RenderNow.
+      # It means there is a problem with the brickchain since it has a path
+      # that didn't render.
       raise NoRenderCalled.new
     rescue Action::RenderNow => renderer
       return do_render(renderer.to_render)
     end
 
-    # Renders a json or anything else
+    ##
+    # Method called after a correct Action::RenderNow have been raised
     def do_render(to_render)
       body = case to_render[:format]
                when :json
-                 [ to_render[:object].to_json ]
+                 [ ::MultiJson.dump(to_render[:object], pretty: ENV['RACK_ENV'] == 'development' ) ]
                when :file_from_path, :file_from_io
                  to_render[:object]
                when :status
@@ -142,7 +168,7 @@ module Culpa
     end
 
     ##
-    # Rack pre-formatted error
+    # Return a rack pre-formatted error
     def rack_error(code)
       [code.to_s, {}, []]
     end

data/templates/culpa/Dockerfile

@@ -1,8 +1,14 @@
 FROM ruby:2.3
 MAINTAINER Your Name <your@email.com>
 
-# Set RACK_ENV to production
-ENV RACK_ENV production
+# Install nginx and copy default configuration
+RUN apt-get update &&  \
+    apt-get install -y nginx supervisor && \
+    apt-get clean && \
+    apt-get autoclean && \
+    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+COPY ./config/dockerized/nginx.conf /etc/nginx/nginx.conf
+COPY ./config/dockerized/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
 
 # Create app folder
 RUN mkdir -p /srv/app
@@ -19,7 +25,7 @@ RUN bundle install
 ADD ./ /srv/app
 
 # Expose culpa port
-EXPOSE 4748
+EXPOSE 80
 
 # Command to start the application
-CMD ["/usr/local/bundle/bin/culpa", "server"]
+CMD ["/usr/bin/supervisord"]

data/templates/culpa/Gemfile

@@ -1,6 +1,6 @@
 source 'https://rubygems.org'
 
-gem 'culpa', '~> 1.1'
+gem 'culpa', '~> 1.2'
 
 # Use rspec to test your project.
 gem 'rspec', '~> 3.4'

data/templates/culpa/nginx.conf

@@ -0,0 +1,47 @@
+user www-data;
+worker_processes 4;
+pid /run/nginx.pid;
+daemon off;
+
+events {
+	worker_connections 768;
+}
+
+http {
+	sendfile on;
+	tcp_nopush on;
+	tcp_nodelay on;
+	keepalive_timeout 65;
+	types_hash_max_size 2048;
+
+	include /etc/nginx/mime.types;
+	default_type application/octet-stream;
+
+	ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
+	ssl_prefer_server_ciphers on;
+
+	access_log /var/log/nginx/access.log;
+	error_log /var/log/nginx/error.log;
+
+	gzip on;
+	gzip_disable "msie6";
+
+  upstream app {
+    server unix:/var/run/culp.sock fail_timeout=0;
+  }
+
+  server {
+    listen 80;
+    root /srv/app/public;
+    try_files $uri/index.html $uri @app;
+    location @app {
+        proxy_pass http://app;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header Host $http_host;
+        proxy_redirect off;
+    }
+    client_max_body_size 4G;
+    keepalive_timeout 10;
+  }
+
+}

data/templates/culpa/supervisord.conf

@@ -0,0 +1,10 @@
+[supervisord]
+nodaemon=true
+
+[program:culpa]
+command=/usr/local/bundle/bin/culpa server
+directory=/srv/app
+environment=RACK_ENV="production"
+
+[program:nginx]
+command=/usr/sbin/nginx

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culpa
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jérémy SEBAN
@@ -52,6 +52,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.12'
 description: Culpa is a framework following MEA principles. Learn more on http://culpaframework.org/.
 email: jeremy@seban.eu
 executables:
@@ -63,9 +77,14 @@ files:
 - lib/culpa.rb
 - lib/culpa/action.rb
 - lib/culpa/brickchain_helpers.rb
+- lib/culpa/coliseum_dsl.rb
 - lib/culpa/envelope.rb
-- lib/culpa/file_streamer.rb
 - lib/culpa/path_parser.rb
+- lib/culpa/renderer_describer.rb
+- lib/culpa/renderers/coliseum.rb
+- lib/culpa/renderers/file.rb
+- lib/culpa/renderers/json.rb
+- lib/culpa/renderers/status.rb
 - lib/culpa/routes_builder.rb
 - lib/culpa/test_helpers.rb
 - templates/culpa/Dockerfile
@@ -74,6 +93,8 @@ files:
 - templates/culpa/generators/action.tmpl
 - templates/culpa/index.html
 - templates/culpa/logo.png
+- templates/culpa/nginx.conf
+- templates/culpa/supervisord.conf
 homepage: http://culpaframework.org/
 licenses:
 - MIT

data/lib/culpa/file_streamer.rb

@@ -1,14 +0,0 @@
-module Culpa
-
-  class FileStreamer
-    def initialize(element)
-      @element = element
-    end
-    def each(&blk)
-      @element.each(&blk)
-    ensure
-      @element.close
-    end
-  end
-
-end