kenji 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf14e401da97852b1581ed7c36fecb4ca5730150
-  data.tar.gz: 640b48b7bd7caaedd92c7a7071c74b09917c8cb2
+  metadata.gz: c5fdf8390ae9d6d9eec304907eeb51dfac87e44e
+  data.tar.gz: 6d7e9930d844f336ae34af1d0bcf54073ce99a48
 SHA512:
-  metadata.gz: ec8185bb579998a5108aa4059d7c229500fb0340ef098c5888897d76a3e66166939d1e99052f0071b9fae161c12d5675c9f44747a5753a053bfed08b8b8dbe4f
-  data.tar.gz: 8074e6d539c044abbb5bc031cb6f9a3c5978ed81440ea3482574f26663ff08e785b591f9458c60835379b4cc49a86ac814ef4971da4e9885b3f216189f78faef
+  metadata.gz: 13094758c7771669041badcffff388ca387cb547bb4965c5010dd176e82cf66e9b6e50d78baa891aa0206a26044bf3e2e6ed08238544dcf58b2a6c917e2ed415
+  data.tar.gz: c2e5133ae4a52328ce095843f6e7f78757035e5f46136aaf685909c3a273822b6052f314144c6179afd4540d86f9fc7b1ef6b250dc1e5a42ef791c301419f1e8

data/.hound.yml

@@ -0,0 +1,2 @@
+ruby:
+  config_file: .rubocop.yml

data/.rubocop.yml

@@ -0,0 +1,261 @@
+# Ignore Rubocop on some files...
+
+AllCops:
+  Exclude:
+    - 'spec/**/*'
+
+# Enabling of disabled-by-default checks:
+
+Style/CollectionMethods:
+  Enabled: true
+
+Style/Encoding:
+  Enabled: true
+
+######
+
+# Align the elements of a hash literal if they span more than one line.
+Style/AlignHash:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+# Align with the style guide.
+Style/CollectionMethods:
+  # Mapping from undesired method to desired_method
+  # e.g. to use `detect` over `find`:
+  #
+  # CollectionMethods:
+  #   PreferredMethods:
+  #     find: detect
+  PreferredMethods:
+    collect: 'map'
+    collect!: 'map!'
+    inject: 'reduce'
+    detect: 'find'
+    find_all: 'select'
+
+# Multi-line method chaining should be done with leading dots.
+Style/DotPosition:
+  EnforcedStyle: leading
+  SupportedStyles:
+    - leading
+    - trailing
+
+# Use empty lines between defs.
+Style/EmptyLineBetweenDefs:
+  # If true, this parameter means that single line method definitions don't
+  # need an empty line between them.
+  AllowAdjacentOneLineDefs: false
+
+Style/EmptyLinesAroundClassBody:
+  Enabled: false
+
+Style/EmptyLinesAroundModuleBody:
+  Enabled: false
+
+# Checks whether the source file has a utf-8 encoding comment or not
+# AutoCorrectEncodingComment must match the regex
+# /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+Style/Encoding:
+  Enabled: false
+
+
+# Checks use of for or each in multiline loops.
+Style/For:
+  EnforcedStyle: each
+
+# Built-in global variables are allowed by default.
+Style/GlobalVars:
+  AllowedVariables: []
+
+# `MinBodyLength` defines the number of lines of the a body of an if / unless
+# needs to have to trigger this cop
+Style/GuardClause:
+  MinBodyLength: 1
+
+# Checks the indentation of the first key in a hash literal.
+Style/IndentHash:
+  EnforcedStyle: special_inside_parentheses
+
+Style/LambdaCall:
+  EnforcedStyle: call
+  SupportedStyles:
+    - call
+    - braces
+
+Style/NonNilCheck:
+  IncludeSemanticChanges: true
+
+Style/MethodDefParentheses:
+  EnforcedStyle: require_parentheses
+
+Style/NumericLiterals:
+  MinDigits: 5
+
+# Allow safe assignment in conditions.
+Style/ParenthesesAroundCondition:
+  AllowSafeAssignment: true
+
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    '%':  ()
+    '%i': ()
+    '%q': ()
+    '%Q': ()
+    '%r': '{}'
+    '%s': ()
+    '%w': ()
+    '%W': ()
+    '%x': ()
+
+Style/Semicolon:
+  # Allow ; to separate several expressions on the same line.
+  AllowAsExpressionSeparator: true
+
+Style/SignalException:
+  EnforcedStyle: only_raise
+
+Style/SingleLineMethods:
+  AllowIfMethodIsEmpty: true
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: single_quotes
+
+Style/SpaceAroundBlockParameters:
+  EnforcedStyleInsidePipes: no_space
+
+Style/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Style/SpaceAroundOperators:
+  MultiSpaceAllowedForOperators:
+    - '='
+    - '=>'
+
+Style/SpaceBeforeBlockBraces:
+  EnforcedStyle: space
+
+Style/SpaceInsideBlockBraces:
+  EnforcedStyle: space
+  # Valid values are: space, no_space
+  EnforcedStyleForEmptyBraces: no_space
+  # Space between { and |. Overrides EnforcedStyle if there is a conflict.
+  SpaceBeforeBlockParameters: false
+
+Style/SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+  EnforcedStyleForEmptyBraces: no_space
+
+Style/SymbolProc:
+  # A list of method names to be ignored by the check.
+  # The names should be fairly unique, otherwise you'll end up ignoring lots of code.
+  IgnoredMethods:
+    - respond_to
+
+Style/TrailingBlankLines:
+  EnforcedStyle: final_newline
+
+Style/TrailingComma:
+  # If EnforcedStyleForMultiline is comma, the cop requires a comma after the
+  # last item of a list, but only for lists where each item is on its own line.
+  # If EnforcedStyleForMultiline is consistent_comma, the cop requires a comma
+  # after the last item of a list, for all lists.
+  EnforcedStyleForMultiline: comma
+  SupportedStyles:
+    - comma
+    - consistent_comma
+    - no_comma
+
+# TrivialAccessors doesn't require exact name matches and doesn't allow
+# predicated methods by default.
+Style/TrivialAccessors:
+  ExactNameMatch: false
+  AllowPredicates: false
+  # Allows trivial writers that don't end in an equal sign. e.g.
+  #
+  # def on_exception(action)
+  #   @on_exception=action
+  # end
+  # on_exception :restart
+  #
+  # Commonly used in DSLs
+  AllowDSLWriters: false
+  IgnoreClassMethods: false
+  Whitelist:
+    - to_ary
+    - to_a
+    - to_c
+    - to_enum
+    - to_h
+    - to_hash
+    - to_i
+    - to_int
+    - to_io
+    - to_open
+    - to_path
+    - to_proc
+    - to_r
+    - to_regexp
+    - to_str
+    - to_s
+    - to_sym
+
+
+Style/WhileUntilModifier:
+  MaxLineLength: 80
+
+Style/WordArray:
+  MinSize: 0
+  # The regular expression WordRegex decides what is considered a word.
+  WordRegex: !ruby/regexp '/\A[\p{Word}]+\z/'
+
+##################### Metrics ##################################
+
+Metrics/AbcSize:
+  # The ABC size is a calculated magnitude, so this number can be a Fixnum or
+  # a Float.
+  Max: 20
+
+Metrics/BlockNesting:
+  Max: 3
+
+Metrics/ClassLength:
+  CountComments: false  # count full line comments?
+  Max: 300
+
+# Avoid complex methods.
+Metrics/CyclomaticComplexity:
+  Max: 6
+
+Metrics/LineLength:
+  Max: 80
+  # To make it possible to copy or click on URIs in the code, we allow lines
+  # contaning a URI to be longer than Max.
+  AllowURI: true
+  URISchemes:
+    - http
+    - https
+
+Metrics/MethodLength:
+  CountComments: false  # count full line comments?
+  Max: 30
+
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true
+
+Metrics/PerceivedComplexity:
+  Max: 7
+
+##################### Lint ##################################
+
+# Allow safe assignment in conditions.
+Lint/AssignmentInCondition:
+  AllowSafeAssignment: true
+
+# Align ends correctly.
+Lint/EndAlignment:
+  AlignWith: keyword

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in factory_baby.gemspec
 gemspec
 
-gem 'inifile'
+gem 'inifile'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kenji (1.1.1)
+    kenji (1.1.2)
       json
       rack (~> 1.5.2)
 
@@ -10,7 +10,7 @@ GEM
   specs:
     diff-lcs (1.2.5)
     inifile (2.0.2)
-    json (1.8.1)
+    json (1.8.2)
     rack (1.5.2)
     rack-test (0.6.2)
       rack (>= 1.0)

data/README.md

@@ -39,9 +39,9 @@ look like this, in `controller/hello.rb`:
 
 ```ruby
 class HelloController < Kenji::Controller
-    get '/world' do
-        {hello: :world}
-    end
+  get '/world' do
+    {hello: :world}
+  end
 end
 ```
 
@@ -50,19 +50,19 @@ A more representative example might be:
 ```ruby
 class UserController < Kenji::Controller
 
-    # ...
+  # ...
 
-    get '/:id/friends' do |id|
-        # list friends for id
-    end
+  get '/:id/friends' do |id|
+    # list friends for id
+  end
 
-    post '/:id/friend/:id' do |id, friend_id|
-        # add connection from user id to friend_id
-    end
+  post '/:id/friend/:id' do |id, friend_id|
+    # add connection from user id to friend_id
+  end
 
-    delete '/:id/friend/:id' do |id, friend_id|
-        # delete connection from user id to friend_id
-    end
+  delete '/:id/friend/:id' do |id, friend_id|
+    # delete connection from user id to friend_id
+  end
 end
 ```
 
@@ -100,6 +100,14 @@ And already, your app is ready to go:
 
 ## Changelog
 
+#### 1.2.0
+
+- A new `exception_in_body` option (defaults to false) defines whether options
+  are returned to the HTTP response instead of the default “Something went
+  wrong...”
+- `kenji init` no longer generates a useless binary.
+- Internally, lots of style and best practices refactors.
+
 #### 1.1.2
 
 - The `respond_raw` method allows responding with raw data, instead of the
@@ -150,7 +158,7 @@ And already, your app is ready to go:
 
 - `before` command.
 - specs
-- passing 
+- passing
 
 ## Still to do
 

data/Rakefile

@@ -2,6 +2,6 @@ require 'bundler'
 Bundler::GemHelper.install_tasks
 require 'rspec/core'
 require 'rspec/core/rake_task'
-task :default => :spec
+task default: :spec
+task test:    :spec
 RSpec::Core::RakeTask.new(:spec)
-

data/bin/kenji

@@ -1,6 +1,5 @@
 #!/usr/bin/env ruby
 
-
 unless ARGV.first == 'init'
   puts 'Usage: kenji init [project-name]'
   Process.exit
@@ -17,28 +16,32 @@ path = File.realpath(path)
 init_source = File.realpath(File.dirname(File.dirname(__FILE__))) << '/inited'
 
 for_earch_item = lambda do |item, base|
-    next if item == '.' || item == '..'
-    item_to_create = item.gsub('__APP_NAME__', app_name)
-
-    
-    if File.directory?("#{init_source}/#{base}/#{item}")
-        Dir.mkdir("#{path}/#{base}/#{item_to_create}") unless File.directory?("#{path}/#{base}/#{item}")
-        puts "Initializing directory #{base}/#{item_to_create}"
-        Dir.foreach("#{init_source}/#{base}/#{item}") { |i| for_earch_item.call(i, "#{base}/#{item}") }
-    else
-        puts "Generating content for file #{base}/#{item_to_create}"
-        data = ''
-        f = File.open("#{init_source}/#{base}/#{item}", 'r')
-        while line = f.gets
-            data += (line.gsub('__APP_NAME__', app_name))
-        end
-        f.close
-        f = File.open("#{path}/#{base}/#{item_to_create}", 'w')
-        f.puts data
-        f.close
+  next if item == '.' || item == '..'
+  item_to_create = item.gsub('__APP_NAME__', app_name)
+
+
+  if File.directory?("#{init_source}/#{base}/#{item}")
+    unless File.directory?("#{path}/#{base}/#{item}")
+      Dir.mkdir("#{path}/#{base}/#{item_to_create}")
+    end
+    puts "Initializing directory #{base}/#{item_to_create}"
+    Dir.foreach("#{init_source}/#{base}/#{item}") do |i|
+      for_earch_item.call(i, "#{base}/#{item}")
+    end
+  else
+    puts "Generating content for file #{base}/#{item_to_create}"
+    data = ''
+    f = File.open("#{init_source}/#{base}/#{item}", 'r')
+    while (line = f.gets)
+      data += (line.gsub('__APP_NAME__', app_name))
     end
+    f.close
+    f = File.open("#{path}/#{base}/#{item_to_create}", 'w')
+    f.puts data
+    f.close
+  end
 end
 
-Dir.foreach(init_source) { |i| for_earch_item.call(i, '.') }
+Dir.foreach(init_source) {|i| for_earch_item.call(i, '.') }
 
 system("cd #{path}; bundle install")

data/kenji.gemspec

@@ -1,4 +1,4 @@
-$:.push File.expand_path('../lib', __FILE__)
+$LOAD_PATH.push(File.expand_path('../lib', __FILE__))
 require 'kenji/version'
 
 Gem::Specification.new do |s|
@@ -19,6 +19,6 @@ Gem::Specification.new do |s|
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.executables   = `git ls-files -- bin/*`.split("\n").map {|f| File.basename(f) }
   s.require_paths = ['lib']
 end

data/lib/kenji.rb

@@ -1,9 +1,11 @@
 require 'json'
 require 'kenji/controller'
 require 'kenji/app'
-require 'kenji/string_extensions'
+require 'kenji/string-extensions'
 require 'rack'
 
+using Kenji::StringExtensions
+
 module Kenji
   class Kenji
 
@@ -28,7 +30,7 @@ module Kenji
     # `options` is an options hash that accepts the following keys:
     #
     #   :directory => String (path)
-    #     
+    #
     #     this is the preferred way of setting the root directory, when
     #     necessary. you should either set a root directory (which defaults to
     #     the current working directory), or set a root_controller. both are
@@ -46,6 +48,10 @@ module Kenji
     #     when true, Kenji will catch exceptions, print them in stderr, and and
     #     return a standard 500 error
     #
+    #   :exception_in_body => true | false
+    #
+    #     if :catch_exceptions => true, return exception message in response
+    #
     #   :stderr => IO
     #
     #     an IO stread, this is where Kenji logging goes by default. defaults
@@ -58,23 +64,24 @@ module Kenji
       options ||= {}
 
       @headers = {
-        'Content-Type' => 'application/json'
+        'Content-Type' => 'application/json',
       }
       @status = 200
       @env = env
 
       # deal with legacy root argument behavior
       options[:directory] = File.expand_path(root) if root
-      
+
       @options = {
-        catch_exceptions: true,
-        root_controller: nil,
-        directory: File.expand_path(Dir.getwd),
-        stderr: $stderr
+        catch_exceptions:  true,
+        exception_in_body: false,
+        root_controller:   nil,
+        directory:         File.expand_path(Dir.getwd),
+        stderr:            $stderr,
       }.merge(options)
 
       @stderr = @options[:stderr]
-      @root = @options[:directory] + '/'
+      @root   = @options[:directory] + '/'
     end
 
     # This method does all the work!
@@ -98,16 +105,16 @@ module Kenji
 
         if @options[:root_controller]
           controller = controller_instance(@options[:root_controller])
-          subpath = segments.join('/')
-          out = controller.call(method, subpath).to_json
-          success = true
+          subpath    = segments.join('/')
+          out        = controller.call(method, subpath).to_json
+          success    = true
         else
           acc = ''; out = '', success = false
-          while head = segments.shift
+          while (head = segments.shift)
             acc = "#{acc}/#{head}"
-            # if we have a valid controller 
-            if controller = controller_for(acc)
-              subpath = '/'+segments.join('/')
+            # if we have a valid controller
+            if (controller = controller_for(acc))
+              subpath = '/' + segments.join('/')
               out = controller.call(method, subpath).to_json
               success = true
               break
@@ -119,27 +126,22 @@ module Kenji
 
         [@status, @headers, [out]]
       end
-    rescue Exception => e
+    rescue => e
       raise e unless @options[:catch_exceptions]
       # log exceptions
-      @stderr.puts e.inspect
+      @stderr.puts(e.inspect)
       e.backtrace.each {|b| @stderr.puts "  #{b}" }
-      response_500
+      response_500(e)
     end
 
-
-
     # Methods for users!
 
-
     # Sets one or multiple headers, as named arametres. eg.
-    # 
+    #
     #   kenji.header 'Content-Type' => 'hello/world'
     #
-    def header(hash={})
-      hash.each do |key, value|
-        @headers[key] = value
-      end
+    def header(hash = {})
+      @header.merge!(hash)
     end
 
     # Returns the response headers
@@ -161,16 +163,17 @@ module Kenji
       end if raw
       {} # default return value
     end
-    
+
     # Respond to the request
     #
-    def respond(code, message, hash={})
+    def respond(code, message, hash = {})
       @status = code
-      response = {            # default structure.
-        status: code,
+      response = { # default structure.
+        status:  code,
         message: message,
       }.merge(hash)
-      throw(:KenjiRespondControlFlowInterrupt, [@status, @headers, [response.to_json]])
+      throw(:KenjiRespondControlFlowInterrupt,
+            [@status, @headers, [response.to_json]])
     end
 
     # Respond with raw bytes
@@ -180,7 +183,7 @@ module Kenji
     def respond_raw(status = 200, data)
       @status = status
       body = data.is_a?(IO) ? data : [data]
-      throw(:KenjiRespondControlFlowInterrupt, [@status, @headers, data])
+      throw(:KenjiRespondControlFlowInterrupt, [@status, @headers, body])
     end
 
 
@@ -188,8 +191,15 @@ module Kenji
     private
 
     # 500 error
-    def response_500
-      [500, @headers, [{status: 500, message: 'Something went wrong...'}.to_json]]
+    def response_500(exception = nil)
+      message =
+        if exception.nil? || !@options[:exception_in_body]
+          'Something went wrong...'
+        else
+          exception.to_s
+        end
+
+      [500, @headers, [{status: 500, message: message}.to_json]]
     end
 
     # 404 error
@@ -203,10 +213,11 @@ module Kenji
     def controller_for(subpath)
       subpath = '/_' if subpath == '/'
       path = "#{@root}controllers#{subpath}.rb"
-      return nil unless File.exists?(path)
+      return nil unless File.exist?(path)
       require path
       controller_name = subpath.split('/').last.sub(/^_/, 'Root')
-      controller_class = Object.const_get(controller_name.to_s.to_camelcase+'Controller')
+      controller_class =
+        Object.const_get(controller_name.to_s.to_camelcase + 'Controller')
       controller_instance(controller_class)
     end
 
@@ -215,8 +226,8 @@ module Kenji
     #
     def controller_instance(controller_class)
       # ensure protocol compliance
-      unless (controller_class.method_defined?(:call) &&
-              controller_class.instance_method(:call).arity == 2)
+      unless controller_class.method_defined?(:call) \
+          && controller_class.instance_method(:call).arity == 2
         return
       end
       controller = controller_class.new
@@ -224,8 +235,6 @@ module Kenji
       return controller if controller
       nil # default return value
     end
-    
+
   end
-  
 end
-

data/lib/kenji/app.rb

@@ -1,6 +1,6 @@
 
 module Kenji
-  
+
   # Kenji::App is a simple wrapper class that helps avoid the awkward wrapping
   # in a lambda typically necessary for using Kenji as a Rack app. Instead,
   # simply do the following:
@@ -14,12 +14,14 @@ module Kenji
   #
   class App
 
-    def initialize(opts={})
+    def initialize(opts = {})
       @opts = opts
     end
 
     def call(env)
       Kenji.new(env, @opts).call
     end
+
   end
+
 end

data/lib/kenji/controller.rb

@@ -6,7 +6,7 @@ module Kenji
     attr_accessor :kenji
 
     # Routes below will accept routes in the format, eg.:
-    # 
+    #
     #     /hello/:id/children
     #
     # Can contain any number of :id, but must be in their own url segment.
@@ -56,20 +56,27 @@ module Kenji
     # segment or variable segment, and the leaf @action being the block
     #
     def self.route(*methods, path, &block)
+
       # bind the block to self as an instance method, so its context is correct
       define_method(:_tmp_route_action, &block)
       block = instance_method(:_tmp_route_action)
       remove_method(:_tmp_route_action)
+
       # store the block for each method
       methods.each do |method|
+
         node = ((@routes ||= {})[method] ||= {})
         segments = path.split('/')
-        segments = segments.drop(1) if segments.first == ''     # discard leading /'s empty segment
-        segments.each do |segment|                              # lazily create tree
-          segment = ':' if segment =~ /^:/                      # discard :variable name
+        # discard leading /'s empty segment
+        segments = segments.drop(1) if segments.first == ''
+        # lazily create tree
+        segments.each do |segment|
+          # discard :variable name
+          segment = ':' if segment =~ /^:/
           node = (node[segment.to_sym] ||= {})
         end
-        node[:@action] = block                                  # store block as leaf in @action
+        # store block as leaf in @action
+        node[:@action] = block
       end
       nil # void method
     end
@@ -84,7 +91,8 @@ module Kenji
     def self.pass(path, controller)
       node = (@passes ||= {})
       segments = path.split('/')
-      segments = segments.drop(1) if segments.first == ''     # discard leading /'s empty segment
+      # discard leading /'s empty segment
+      segments = segments.drop(1) if segments.first == ''
       segments.each do |segment|
         node = (node[segment.to_sym] ||= {})
         break if segment == '*'
@@ -92,7 +100,6 @@ module Kenji
       node[:@controller] = controller
     end
 
-
     # This lets you define before blocks.
     #
     #   class MyController < Kenji::Controller
@@ -108,7 +115,6 @@ module Kenji
       (@befores ||= []) << block
     end
 
-
     # Most likely only used by Kenji itself.
     # Override to implement your own routing, if you'd like.
     #
@@ -117,7 +123,8 @@ module Kenji
       self.class.befores.each {|b| b.bind(self).call }
 
       segments = path.split('/')
-      segments = segments.drop(1) if segments.first == ''     # discard leading /'s empty segment
+      # discard leading /'s empty segment
+      segments = segments.drop(1) if segments.first == ''
 
       # check for passes
       node = self.class.passes
@@ -138,19 +145,25 @@ module Kenji
       node = self.class.routes[method] || {}
       variables = []
       searching = true
-      segments.each do |segment|                              # traverse tree to find
+                              # traverse tree to find
+      segments.each do |segment|
         if searching && node[segment.to_sym]
-          node = node[segment.to_sym]                         # attempt to move down to the plain text segment
+          # attempt to move down to the plain text segment
+          node = node[segment.to_sym]
         elsif searching && node[:':']
-          node = node[:':']                                   # attempt to find a variable segment
-          variables << segment                                # either we've found a variable, or the `unless` below will trigger
+          # attempt to find a variable segment
+          node = node[:':']
+          # either we've found a variable, or the `unless` below will trigger
+          variables << segment
         else
-          return attempt_fallback(path)                       # route failed to match variable or segment node so attempt fallback
+          # route failed to match variable or segment node so attempt fallback
+          return attempt_fallback(path)
         end
       end
-      if node && action = node[:@action]                      # the block is stored in the @action leaf
+      # the block is stored in the @action leaf
+      if node && (action = node[:@action])
         return action.bind(self).call(*variables)
-      else                                                    # or, fallback if necessary store the block for each method
+      else # or, fallback if necessary store the block for each method
         return attempt_fallback(path)
       end
     end
@@ -175,13 +188,17 @@ module Kenji
     end
 
     private
+
     # Accessor for @routes
+
     def self.routes
       @routes || {}
     end
+
     def self.passes
       @passes || {}
     end
+
     def self.befores
       @befores || []
     end
@@ -190,24 +207,28 @@ module Kenji
       variables = {}
       match = false
 
-      while e = segments.shift
+      while (e = segments.shift)
         # return false unless node
         key = node.keys.first
-        if match = key.to_s.match(/^\:(\w+)/)
+        if (match = key.to_s.match(/^\:(\w+)/))
           node = node[key.to_sym]
           variables[match[1].to_sym] = e
           match = true
         else
           # if there is no match it should not pass
-          break unless match = node.has_key?(e.to_sym)
+          break unless (match = node.key?(e.to_sym))
           node = node[e.to_sym]
         end
 
         break if node[:@controller]
       end
 
-      { :match => match, :variables => variables, :controller => node[:@controller], :remaining_segments => segments }
+      {
+        match:              match,
+        variables:          variables,
+        controller:         node[:@controller],
+        remaining_segments: segments,
+      }
     end
   end
 end
-

data/lib/kenji/string-extensions.rb

@@ -0,0 +1,25 @@
+# Kenji string extensions
+
+module Kenji
+  module StringExtensions
+
+    refine String do
+
+      def to_underscore!
+        gsub!(/(.)([A-Z])/, '\1_\2').downcase!
+      end
+
+      def to_underscore
+        clone.to_underscore!
+      end
+
+      def to_camelcase!
+        replace(split('_').each(&:capitalize!).join(''))
+      end
+
+      def to_camelcase
+        clone.to_camelcase!
+      end
+    end
+  end
+end

data/lib/kenji/version.rb

@@ -1,4 +1,3 @@
 module Kenji
-  VERSION = '1.1.2'
+  VERSION = '1.2.0'
 end
-

data/spec/1/controllers/main.rb

@@ -5,10 +5,6 @@ class MainController < Kenji::Controller
     {status: 200, hello: :world}
   end
 
-  get '/crasher' do
-    raise
-  end
-
   post '/' do
     {status:1337}
   end

data/spec/7/controllers/main.rb

@@ -0,0 +1,8 @@
+
+class MainController < Kenji::Controller
+
+  get '/crasher' do
+    raise 'kaboom!'
+  end
+
+end

data/spec/kenji_spec.rb

@@ -1,4 +1,3 @@
-
 require 'rack'
 require 'rack/test'
 require 'rspec'
@@ -6,7 +5,6 @@ require 'rspec/mocks'
 
 require 'kenji'
 
-
 # NOTE: these tests make use of the controllers defined in test/controllers.
 
 def app_for(path, opts={})
@@ -23,7 +21,6 @@ describe Kenji::Kenji, 'expected responses' do
   context '1' do
     def app; app_for('1'); end
 
-
     it 'should return 404 for unknown routes (no controller)' do
       get '/sdlkjhb'
       expected_response = {status: 404, message: 'Not found!'}.to_json
@@ -38,13 +35,6 @@ describe Kenji::Kenji, 'expected responses' do
       last_response.status.should == 404
     end
 
-    it 'should return 500 for exceptions' do
-      get '/main/crasher'
-      expected_response = {status: 500, message: 'Something went wrong...'}.to_json
-      last_response.body.should == expected_response
-      last_response.status.should == 500
-    end
-
     it 'should route a GET call to a defined get call' do
       get '/main/hello'
       expected_response = {status: 200, hello: :world}.to_json
@@ -52,7 +42,6 @@ describe Kenji::Kenji, 'expected responses' do
     end
 
     [:post, :put, :delete, :patch].each do |method|
-
       it "should route a #{method.to_s.upcase} to a defined #{method.to_s} call" do
         send(method, '/main')
         expected_response = {status: 1337}.to_json
@@ -87,7 +76,6 @@ describe Kenji::Kenji, 'expected responses' do
       last_response.body.should == expected_response
       last_response.status.should == 123
     end
-
   end
 
   context '2' do
@@ -204,9 +192,58 @@ describe Kenji::Kenji, 'expected responses' do
       last_response.status.should == 500
     end
   end
-  
-  # TODO: Write unit tests for :catch_exceptions option.
+
+  context '7' do
+    context 'catch_exceptions is false' do
+      def app
+        app_for('7',
+                catch_exceptions: false)
+
+        it 'should raise' do
+          -> { get '/main/crasher' }.must_raise
+        end
+      end
+    end
+
+    context 'catch_exceptions is true' do
+      context :exception_in_body do
+        context 'exception_in_body is false' do
+          def app
+            app_for('7',
+                    catch_exceptions:  true,
+                    exception_in_body: false)
+          end
+
+          it 'should return 500 for exceptions' do
+            get '/main/crasher'
+            last_response
+              .body
+              .should == {status: 500,
+                          message: 'Something went wrong...'}.to_json
+            last_response.status.should == 500
+          end
+        end
+
+        context 'exception_in_body is true' do
+          def app
+            app_for('7',
+                    catch_exceptions:  true,
+                    exception_in_body: true)
+          end
+
+          it 'should return 500 for exceptions' do
+            get '/main/crasher'
+            last_response
+              .body
+              .should == {status:  500,
+                          message: 'kaboom!'}.to_json
+            last_response.status.should == 500
+          end
+        end
+      end
+    end
+  end
+
   # TODO: Write unit tests for Kenji::App
   # TODO: Write unit tests for new root directory behavior.
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kenji
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Kenneth Ballenegger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-09 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -89,6 +89,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".hound.yml"
+- ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -98,7 +100,6 @@ files:
 - inited/.gitignore
 - inited/Gemfile
 - inited/README.md
-- inited/__APP_NAME__
 - inited/config.ru
 - inited/controllers/main.rb
 - inited/lib/README.md
@@ -109,7 +110,7 @@ files:
 - lib/kenji.rb
 - lib/kenji/app.rb
 - lib/kenji/controller.rb
-- lib/kenji/string_extensions.rb
+- lib/kenji/string-extensions.rb
 - lib/kenji/version.rb
 - spec/1/controllers/main.rb
 - spec/2/controllers/_.rb
@@ -119,6 +120,7 @@ files:
 - spec/4/controllers/main.rb
 - spec/4/controllers/pass.rb
 - spec/5/controllers/main.rb
+- spec/7/controllers/main.rb
 - spec/kenji_spec.rb
 homepage: https://github.com/kballenegger/kenji
 licenses: []
@@ -152,5 +154,6 @@ test_files:
 - spec/4/controllers/main.rb
 - spec/4/controllers/pass.rb
 - spec/5/controllers/main.rb
+- spec/7/controllers/main.rb
 - spec/kenji_spec.rb
 has_rdoc: 

data/inited/__APP_NAME__

@@ -1,52 +0,0 @@
-#!/usr/bin/ruby
-
-class Main
-
-  def self.init
-    require 'rubygems'
-    require 'bundler/setup'
-    require $root+'/lib/kenji/kenji'
-    @@k = Kenji::Kenji.new({}, $root)
-  end
-
-  def self.main args
-    verb = args.first.to_sym unless args.empty?
-
-    # case verb
-    # when :import
-    #   puts "Calling import script..."
-    #   @@k.controller_for(:import)._caffeine @@k
-    # when :process
-    #   puts "Processing values..."
-    #   @@k.controller_for(:processing)._value @@k
-    # when :configure
-    #   require $root + '/lib/configure'
-    #   skip_update = (args[1] =~ /-?-?skip[-_]update/)
-    #   AnalyticsModule.configure __FILE__, skip_update
-    # else
-    #   puts <<-EOO
-    #   No verb defined. Usage: ./main [verb]
-    # 
-    #   configure [--skip-update]:
-    #       process the value of users
-    #       optionally, skip the self-update process
-    #   import:
-    #       import install from caffeine.io
-    #   process:
-    #       process the value of users
-    #   EOO
-    # end
-  end
-
-  def kenji
-    @@k
-  end
-end
-
-require 'pathname'
-$root = File.dirname Pathname.new(__FILE__).realpath.to_s
-
-Main.init unless ARGV.first == 'configure'
-if __FILE__ == $0
-  Main.main ARGV
-end

data/lib/kenji/string_extensions.rb

@@ -1,16 +0,0 @@
-# Kenji string extensions
-
-class String
-    def to_underscore!
-        self.gsub!(/(.)([A-Z])/,'\1_\2').downcase!
-    end
-    def to_underscore
-        self.clone.to_underscore!
-    end
-    def to_camelcase!
-        self.replace self.split('_').each{ |s| s.capitalize! }.join('')
-    end
-    def to_camelcase
-        self.clone.to_camelcase!
-    end
-end