culpa 1.2.5 → 1.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YzY2MDJlN2VhZDdhZDk4YjIwZThmZDYxYzg5MmVlYzA4MDEzNTAxNw==
+    ZWZkYmJjYzczZWEyZDQyNDM2OTEyYTQ1NjljNjZhZmRjZThiZjRjMQ==
   data.tar.gz: !binary |-
-    OTA3M2E4ZWQxY2Q4NzA2YmFhNmZiYWQ0NDAyM2NiNzc0ZjIyZGU4Mw==
+    M2I4Njg2NmUwZjk1MGExMTNmMjIxYmY2NmIzMTgwMTZkM2UwZTgyYQ==
 SHA512:
   metadata.gz: !binary |-
-    ODk1ZGNjZWUxZTIwZDQyNTQzN2QzMjNjZmNhMzMyODE5YjRlMTU5NmU0Nzkx
-    NTcwZTU0NGMyY2YwMzhlZmNlOWU2NTE1Y2VhZWZmMjA1NTJlMTEyODQzMDNk
-    ZTQ1NDFhMmI0ODc2MTY2OGE5OTUzOTQwNzIwODI3MDJmZWI5Njk=
+    ZjUxMjFiZTdkZTg0ZjQ2YjEyYjAyNTZiMzNiNTM1NmFlMDI0YjEyMGQ4NjBl
+    YTcxYThkYTEyYWM2N2YyNTRhZjA5Nzg3OTBiMjFiZTViNWQ2YTA2MjJkMzEz
+    NDM5NzdkYTNiMjc2NDMyY2NmMTZmOWUyZDMzNTdkNzIwYmUzNDE=
   data.tar.gz: !binary |-
-    MWVkODhmNjM5Zjc5MDVjODY0MmVkYzkxZjIzMWFmZmRkOTc4NGM5ZjhmNzY1
-    YTc4NmQ2MTUzYmI0YzdiNDcxZmZjNzAxOTM5Yzc3Mjc4ZDZmMWZlOTU2YWRm
-    Mzg5Njg2MDE4MzhhYTcxOWRmY2UwNzUyZmFmY2E0ZWVlMjk2MjI=
+    NGFiN2Y0ODc5ZmU4OTcwM2MwY2Y3NDM1MTY0NGMxYzZjZWU2MGQzYmEyYmQ5
+    OWMxOGI2MmU1OGI0OTZiNTA0OTY5OTNiMGMzMmEwMDE5MTliYzI0NTRmNjNj
+    YTlhOGZlYmNjZGNkZjk5OGZlMzkzYjNiOGJkZTVkMWJkNmVhM2M=

data/bin/culpa

@@ -27,27 +27,27 @@ def create_project(project_path)
   FileUtils.touch "#{project_path}/config/initializers/.keep"
 
   puts '==> Copying standard gemfile'
-  gemfile_path = File.join( File.dirname(__FILE__), '../templates/culpa/Gemfile' )
+  gemfile_path = File.join(File.dirname(__FILE__), '../templates/culpa/Gemfile')
   FileUtils.cp gemfile_path, "#{project_path}/Gemfile"
 
   puts '==> Copying standard config.ru'
-  config_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/config.ru' )
+  config_rackup_path = File.join(File.dirname(__FILE__), '../templates/culpa/config.ru')
   FileUtils.cp config_rackup_path, "#{project_path}/config.ru"
 
   puts '==> Copying Dockerfile'
-  dockerfile_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/Dockerfile' )
+  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' )
+  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' )
+  index_html_rackup_path = File.join(File.dirname(__FILE__), '../templates/culpa/index.html')
   FileUtils.cp index_html_rackup_path, "#{project_path}/public/index.html"
-  logo_png_rackup_path = File.join( File.dirname(__FILE__), '../templates/culpa/logo.png' )
+  logo_png_rackup_path = File.join(File.dirname(__FILE__), '../templates/culpa/logo.png')
   FileUtils.cp logo_png_rackup_path, "#{project_path}/public/logo.png"
 
   puts '==> Switching to project directory'
@@ -67,7 +67,7 @@ def create_project(project_path)
     fo.puts "require 'culpa/test_helpers'"
     File.foreach(spec_helper_path) do |li|
       fo.puts li
-      fo.puts "  config.include CulpaHelpers" if li == "=end\n"
+      fo.puts '  config.include CulpaHelpers' if li == "=end\n"
     end
   end
   FileUtils.rm(spec_helper_path)
@@ -97,7 +97,7 @@ def generate_action
     )
   )
   @snake_name = ARGV[2]
-  @name = ARGV[2].split('_').map{|w| w.capitalize}.join
+  @name = ARGV[2].split('_').map(&:capitalize).join
   @bricks = ARGV.drop(3)
   rendered_action = ERB.new(erb_template).result
   action_file = "./actions/#{@snake_name}.rb"
@@ -116,19 +116,18 @@ def start_server
 end
 
 case ARGV[0]
-  when 'new', 'n'
-    create_project ARGV[1]
-  when 'console', 'c'
-    binding.pry
-  when 'server', 's'
-    start_server
-  when 'generate', 'g'
-    case ARGV[1]
-      when 'action'
-        generate_action
-      else
-        puts 'Unknown generator'
-    end
+when 'new', 'n'
+  create_project ARGV[1]
+when 'console', 'c'
+when 'server', 's'
+  start_server
+when 'generate', 'g'
+  case ARGV[1]
+  when 'action'
+    generate_action
   else
-    display_help
+    puts 'Unknown generator'
+  end
+else
+  display_help
 end

data/lib/culpa.rb

@@ -8,11 +8,11 @@ require_relative 'culpa/path_parser'
 require_relative 'culpa/routes_builder'
 require_relative 'culpa/brickchain_helpers'
 
-CULPA_VERSION='1.2.5'
+CULPA_VERSION = '1.2.3'.freeze
 
-ACTIONS_PATH ||= './actions/*.rb'
-MODELS_PATH ||= './models/*.rb'
-INITIALIZERS_PATH ||= './config/initializers/*.rb'
+ACTIONS_PATH ||= './actions/*.rb'.freeze
+MODELS_PATH ||= './models/*.rb'.freeze
+INITIALIZERS_PATH ||= './config/initializers/*.rb'.freeze
 
 # Require the initializers
 Dir[INITIALIZERS_PATH].each do |file|
@@ -30,7 +30,7 @@ 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
@@ -58,17 +58,8 @@ module Culpa
       @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']
-                        when 'development', 'test'
-                          Logger::DEBUG
-                        else
-                          # :nocov:
-                          Logger::WARN
-                          # :nocov:
-                      end
-      @logger.info 'Culpa fully initialized'
+      # Loading logger
+      logger_initialize(options[:log_output] || STDOUT)
       # 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)
@@ -79,32 +70,29 @@ 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}"
+      static_asset = try_static_asset(env)
+      return static_asset if static_asset
+      # Calling the router
+      @logger.info "Received request : #{env['PATH_INFO']}"
       # Request preparation
       request = {
-          verb: env['REQUEST_METHOD'].downcase.to_sym,
-          params: Rack::Utils.parse_nested_query(env['QUERY_STRING'])
+        verb: env['REQUEST_METHOD'].downcase.to_sym,
+        params: Rack::Utils.parse_nested_query(env['QUERY_STRING'])
       }
       # Parse body if in JSON, otherwise pass the rack.input directly
       if env['CONTENT_TYPE'] == 'application/json'
         body = MultiJson.load(env['rack.input'].read)
-        request[:input] = if body.has_key?('data')
+        request[:input] = if body.key?('data')
                             body['data']
                           else
                             body
                           end
-        request[:params]['sub_call'] = body['sub_call'] if body.has_key? 'sub_call'
+        request[:params]['sub_call'] = body['sub_call'] if body.key? 'sub_call'
       else
         request[:input] = env['rack.input']
       end
       # Extract vars from path, take route decision and go !
-      method_name, f_request = PathParser.extract_vars(path, request)
+      method_name, f_request = PathParser.extract_vars(env['PATH_INFO'], request)
       call_brickchain method_name, f_request
     rescue UnpredictableSubCallError, MultiJson::ParseError
       # The sub_call wasn't predictacle, or the body wans't correct JSON.
@@ -118,17 +106,30 @@ module Culpa
       # Something went wrong executing the chain !
       if ENV['RACK_ENV'] != 'test'
         # :nocov:
-        @logger.error "#{err.to_s}\n#{err.backtrace.join("\n")}"
+        @logger.error "#{err}\n#{err.backtrace.join("\n")}"
         # :nocov:
       end
       rack_error 500
     end
 
+    private
+
+    ##
+    # Serving static assets
+    def try_static_asset(env)
+      path = env['PATH_INFO']
+      if @rack_file && (File.exist?("#{@public_folder}#{path}") || path == '/')
+        path = '/index.html' if path == '/'
+        @logger.info "Serving static file : #{path}"
+        return @rack_file.call(env)
+      end
+    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
+      raise RouteNotFoundError unless @router.key? router_method_name
       route = @router[router_method_name]
       @logger.info "Executing brickchain : #{router_method_name}"
       # Preparing brickchain scopped variables
@@ -137,9 +138,9 @@ module Culpa
       # 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
+      end if route.key? :before
       # Execute the brickchain itself
-      if route.has_key? :block
+      if route.key? :block
         BrickchainExecutor.new(envelope, request).instance_eval(&route[:block])
       else
         ch = CallHolder.new(route[:brick_name], envelope, request)
@@ -148,7 +149,7 @@ module Culpa
       # 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
+      raise NoRenderCalled
     rescue Action::RenderNow => renderer
       return do_render(renderer.to_render)
     end
@@ -157,14 +158,14 @@ module Culpa
     # Method called after a correct Action::RenderNow have been raised
     def do_render(to_render)
       body = case to_render[:format]
-               when :json
-                 [ ::MultiJson.dump(to_render[:object], pretty: ENV['RACK_ENV'] == 'development' ) ]
-               when :file_from_path, :file_from_io
-                 to_render[:object]
-               when :status
-                 []
+             when :json
+               [::MultiJson.dump(to_render[:object], pretty: ENV['RACK_ENV'] == 'development')]
+             when :file_from_path, :file_from_io
+               to_render[:object]
+             when :status
+               []
              end
-      [ to_render[:status], to_render[:headers], body ]
+      [to_render[:status], to_render[:headers], body]
     end
 
     ##
@@ -173,6 +174,18 @@ module Culpa
       [code.to_s, {}, []]
     end
 
+    def logger_initialize(log_output)
+      # Logging helper
+      @logger = Logger.new(log_output)
+      @logger.level = case ENV['RACK_ENV']
+                      when 'development', 'test'
+                        Logger::DEBUG
+                      else
+                        # :nocov:
+                        Logger::WARN
+                        # :nocov:
+                      end
+      @logger.info 'Culpa fully initialized'
+    end
   end
-
 end

data/lib/culpa/action.rb

@@ -1,11 +1,10 @@
 class Action
-
   require_relative 'renderer_describer'
 
   @@renderers = {}
 
   def self.load_renderers
-    Dir[File.join( File.dirname(__FILE__), 'renderers/*.rb' )].each do |renderer|
+    Dir[File.join(File.dirname(__FILE__), 'renderers/*.rb')].each do |renderer|
       @@renderers.merge!(RendererDescriber.new(renderer).result)
     end
   end
@@ -28,12 +27,11 @@ class Action
     @r.send(sym)
   end
 
-  def render(options={})
+  def render(options = {})
     keyword = options.keys.first
     options[:headers] ||= {}
-    raise Culpa::UnknownRenderCall.new unless @@renderers.include?(keyword)
+    raise Culpa::UnknownRenderCall unless @@renderers.include?(keyword)
     to_render = @@renderers[keyword].call(options, @e)
-    raise RenderNow.new(to_render)
+    raise RenderNow, to_render
   end
-
 end

data/lib/culpa/brickchain_helpers.rb

@@ -1,7 +1,6 @@
 module Culpa
 
   class BrickchainExecutor
-
     attr_reader :envelope
 
     def initialize(envelope, request)
@@ -15,24 +14,24 @@ module Culpa
       asb.chs.each { |call_holder| call_holder.thread.join }
     end
 
+    def e
+      @envelope
+    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
-      })
+      raise Action::RenderNow, 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)
+      CallHolder.new(sym.to_s, @envelope, @request)
     end
-
   end
 
   class AsyncBrickchain
-
     attr_reader :envelope
     attr_reader :chs
 
@@ -46,14 +45,12 @@ module Culpa
       @chs << CallHolder.new(sym.to_s, @envelope, @request, true)
       @chs.last
     end
-
   end
 
   class CallHolder
-
     attr_reader :thread
 
-    def initialize(brickname, envelope, request, async=false)
+    def initialize(brickname, envelope, request, async = false)
       @brickname = brickname
       @envelope = envelope
       @request = request
@@ -71,12 +68,12 @@ module Culpa
     def sub_from(action_name)
       action = get_action(action_name.to_s)
       action.send @brickname
-      return false
+      false
     end
 
     def get_action(name)
-      action_name = name.split('_').map{|w| w.capitalize}.join
-      return Actions.const_get(action_name).new(@envelope, @request)
+      action_name = name.split('_').map(&:capitalize).join
+      Actions.const_get(action_name).new(@envelope, @request)
     end
 
   end

data/lib/culpa/coliseum_dsl.rb

@@ -1,17 +1,14 @@
-require 'multi_json'
-
 class ColiseumDSL
-
   attr_reader :dsl_attributes, :culpa_status, :culpa_headers
 
-  def initialize(to_eval, envelope, eval_args=nil)
+  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)
+    if to_eval.is_a? String
+      instance_eval File.read(to_eval), to_eval
     else
-      self.instance_exec eval_args, &to_eval
+      instance_exec eval_args, &to_eval
     end
   end
 
@@ -23,7 +20,7 @@ class ColiseumDSL
     @culpa_status = code
   end
 
-  def add_http_headers!(hdrs={})
+  def add_http_headers!(hdrs = {})
     @culpa_headers.merge!(hdrs)
   end
 
@@ -45,33 +42,28 @@ class ColiseumDSL
   def extract!(target, *attrs)
     attrs.each do |att|
       @dsl_attributes[att] = if target.is_a? Hash
-        if target.has_key? att
-          target[att]
-        else
-          nil
-        end
-      else
-        begin
-          target.send(att)
-        rescue
-          nil
-        end
-      end
+                               target[att] if target.key? att
+                             else
+                               begin
+                                 target.send(att)
+                               rescue
+                                 nil
+                               end
+                             end
     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
+                             ColiseumDSL.new(blk, @culpa_envelope).dsl_attributes
+                           else
+                             if args.count.zero?
+                               nil
+                             elsif args.count == 1
+                               args[0]
+                             else
+                               args
+                             end
+                           end
   end
-
 end

data/lib/culpa/envelope.rb

@@ -1,12 +1,10 @@
 module Culpa
-
   class MustHaveFailed < StandardError; end
 
   class Envelope
-
     def must_have!(*args)
       args.each do |arg|
-        raise MustHaveFailed.new("Envelope must_have! failed on #{arg}") unless instance_variable_defined? "@#{arg}"
+        raise MustHaveFailed, "Envelope must_have! failed on #{arg}" unless instance_variable_defined? "@#{arg}"
       end
     end
 
@@ -19,30 +17,28 @@ module Culpa
 
     def method_missing(sym, *args)
       sym = sym.to_s
-      @semaphore.synchronize {
+      @semaphore.synchronize do
         if sym.end_with? '='
-          instance_variable_set "@#{sym.gsub('=','')}", args[0]
+          instance_variable_set "@#{sym.delete('=')}", args[0]
         else
-          return instance_variable_get "@#{sym.gsub('=','')}"
+          return instance_variable_get "@#{sym.delete('=')}"
         end
-      }
+      end
     end
 
     def ==(other_envelope)
       return false unless other_envelope.is_a? Envelope
       return false unless other_envelope.instance_variables.count == instance_variables.count
-      instance_variables.select{ |iv|
+      instance_variables.select do |iv|
         iv != :@semaphore
-      }.each { |iv|
+      end.each do |iv|
         return false unless instance_variable_get(iv) == other_envelope.instance_variable_get(iv)
-      }
-      return true
+      end
+      true
     end
-
   end
 
   class EnvelopeRequest
-
     attr_accessor :verb
     attr_accessor :path
     attr_accessor :input
@@ -53,7 +49,5 @@ module Culpa
         instance_variable_set "@#{name}", value
       end
     end
-
   end
-
 end

data/lib/culpa/path_parser.rb

@@ -1,7 +1,5 @@
 module Culpa
-
   class PathParser
-
     def self.route_patterns
       @@route_patterns
     end
@@ -11,20 +9,20 @@ module Culpa
     def self.parse(pattern, path)
       result = path.match(pattern[:regex])
       return unless result
-      return Hash[result.names.map{ |name| name }.zip(result.captures)]
+      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 = []
-      brickchains.each do |name,data|
-        next unless data.has_key?(:options) and data[:options] and data[:options].has_key?(:url)
+      brickchains.each do |name, data|
+        next unless data.key?(:options) && data[:options] && data[:options].key?(:url)
         item = {
-          regex: self.compose_regex(global_prefix + data[:options][:url]),
+          regex: compose_regex(global_prefix + data[:options][:url]),
           router_method_name: name
         }
-        item[:verb] = data[:options][:verb] if data[:options].has_key? :verb
+        item[:verb] = data[:options][:verb] if data[:options].key? :verb
         custom_routes << item
       end
       fixed_routes = [
@@ -33,7 +31,7 @@ module Culpa
             get: 'list',
             post: 'create'
           },
-          regex: self.compose_regex(global_prefix + '/:res_name')
+          regex: compose_regex(global_prefix + '/:res_name')
         }, {
           infer: {
             get: 'get',
@@ -41,9 +39,9 @@ module Culpa
             patch: 'update',
             delete: 'delete'
           },
-          regex: self.compose_regex(global_prefix + '/:res_name/:id')
+          regex: compose_regex(global_prefix + '/:res_name/:id')
         }, {
-          regex: self.compose_regex(global_prefix + '/:res_name/:id/:sub_call')
+          regex: compose_regex(global_prefix + '/:res_name/:id/:sub_call')
         }
       ]
       @@route_patterns = custom_routes + fixed_routes
@@ -53,13 +51,13 @@ module Culpa
     # 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+)"
+      "(?<#{dir[1..dir.length - 1]}>\\w+)"
     end
 
     ##
     # 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('/')
+      regex = url.split('/').map { |dir| dir_to_regex(dir) }.join('/')
       Regexp.new("^#{regex}$")
     end
 
@@ -68,13 +66,13 @@ module Culpa
     # the router method name and the request informations
     def self.extract_vars(path, call_options)
       @@route_patterns.each do |data|
-        next unless params = self.parse(data, path)
+        next unless (params = parse data, path)
         call_options[:params].merge!(params)
-        if data.has_key?(:router_method_name)
-          raise RouteNotFoundError.new if data.has_key?(:verb) and call_options[:verb] != data[:verb]
+        if data.key?(:router_method_name)
+          raise RouteNotFoundError if data.key?(:verb) && call_options[:verb] != data[:verb]
           return data[:router_method_name], call_options
         else
-          return self.infer_method_name(data, call_options[:params], call_options[:verb]), call_options
+          return infer_method_name(data, call_options[:params], call_options[:verb]), call_options
         end
       end
     end
@@ -82,17 +80,15 @@ module Culpa
     ##
     # 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')
+      if params.key?('sub_call')
         return "#{params['sub_call']}_#{params['res_name']}".to_sym
       end
 
-      unless pattern[:infer].is_a?(Hash) and pattern[:infer].has_key?(verb)
-        raise UnpredictableSubCallError.new
+      unless pattern[:infer].is_a?(Hash) && pattern[:infer].key?(verb)
+        raise UnpredictableSubCallError
       end
 
-      return "#{pattern[:infer][verb]}_#{params['res_name']}".to_sym
+      "#{pattern[:infer][verb]}_#{params['res_name']}".to_sym
     end
-
   end
-
 end

data/lib/culpa/renderer_describer.rb

@@ -1,68 +1,66 @@
 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
-  }
+    # 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
+  }.freeze
 
   attr_reader :result
 
   def initialize(file)
-    self.instance_eval(File.read(file), file)
+    instance_eval(File.read(file), file)
   end
 
   def describe_renderer(keyword, &blk)
-    @result = {keyword => blk}
+    @result = { keyword => blk }
   end
-
 end

data/lib/culpa/renderers/coliseum.rb

@@ -6,16 +6,14 @@
 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
+    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

@@ -7,6 +7,7 @@ class FileStreamer
   def initialize(element)
     @element = element
   end
+
   def each(&blk)
     @element.each(&blk)
   ensure
@@ -14,20 +15,18 @@ class FileStreamer
   end
 end
 
-describe_renderer :file do |options, envelope|
-
+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])
+    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[:headers]['Content-Length'] = options[:size] if options.key? :size
 
   to_render
-
 end

data/lib/culpa/renderers/json.rb

@@ -4,21 +4,19 @@
 # to render a status code if the passed object to render is nil.
 ##
 
-describe_renderer :json do |options, envelope|
-
+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]
+      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]]
+      format: :status,
+      headers: options[:headers],
+      status: RETURN_CODES[options[:or_status]]
     }
   end
-
 end

data/lib/culpa/renderers/status.rb

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

data/lib/culpa/routes_builder.rb

@@ -1,12 +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
     attr_reader :prefix
     attr_reader :public_folder
@@ -28,7 +26,7 @@ module Culpa
       @public_folder = folder
     end
 
-    def brickchain(name,*opts,&blk)
+    def brickchain(name, *opts, &blk)
       @result[name] = {
         options: opts[0],
         block: blk
@@ -37,11 +35,11 @@ module Culpa
     end
 
     def before(&blk)
-      @before=[] unless @before
+      @before = [] unless @before
       @before << blk
     end
 
-    def brickchain_context(name, &blk)
+    def brickchain_context(_name, &blk)
       @result.merge!(RoutesBuilder.new(blk).result)
     end
 
@@ -54,10 +52,9 @@ module Culpa
           class_name: name,
           brick_name: item
         }
-          @result["#{item}_#{name}".to_sym][:before] = @before if @before
+        @result["#{item}_#{name}".to_sym][:before] = @before if @before
       end
     end
-
   end
 
   class BlockToArray
@@ -65,9 +62,9 @@ module Culpa
     def initialize
       @culpa_bta_result = []
     end
+
     def method_missing(sym)
       @culpa_bta_result << sym.to_s
     end
   end
-
 end

data/lib/culpa/test_helpers.rb

@@ -3,7 +3,6 @@ require_relative 'action'
 require 'rspec/expectations'
 
 module CulpaHelpers
-
   ##
   # Helper to access the result of the last call
   def last_call
@@ -19,7 +18,6 @@ module CulpaHelpers
   ##
   # Class used to mock a brick call
   class BrickCall
-
     attr_reader :from_done
 
     def initialize(brick_name)
@@ -52,14 +50,13 @@ module CulpaHelpers
     rescue Action::RenderNow => renderer
       return @call_cache = { to_render: renderer.to_render, envelope: @envelope }
     end
-
   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?
+      actual.from(described_class) unless actual.from_done || described_class.nil?
       bc = actual.call
       bc[:to_render][:status] == RendererDescriber::RETURN_CODES[expected]
     end
@@ -69,10 +66,10 @@ module CulpaHelpers
   # 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|
-        actual.from(described_class) unless actual.from_done or described_class.nil?
+      expected.each do |k, _v|
+        actual.from(described_class) unless actual.from_done || described_class.nil?
         bc = actual.call
-        return false unless bc[:to_render][:headers].has_key?(k) and
+        return false unless bc[:to_render][:headers].key?(k) &&
                             bc[:to_render][:headers][k] == expected[k]
       end
       true
@@ -83,7 +80,7 @@ module CulpaHelpers
   # 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?
+      actual.from(described_class) unless actual.from_done || described_class.nil?
       bc = actual.call
       bc[:to_render][:object] == expected
     end
@@ -93,10 +90,9 @@ module CulpaHelpers
   # 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?
+      actual.from(described_class) unless actual.from_done || described_class.nil?
       bc = actual.call
       bc[:envelope] == Culpa::Envelope.new(expected)
     end
   end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: culpa
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: '1.3'
 platform: ruby
 authors:
 - Jérémy SEBAN