kenji 1.0 → 1.1.1

data/README.md

@@ -81,7 +81,7 @@ have:
 Getting started with Kenji could not be any easier. All it takes is a few lines
 and a terminal:
 
-    $ gem install kenji         # (once kenji is on the rubygems main source)
+    $ gem install kenji
     $ kenji init app_name; cd app_name
     $ rackup                    # launch the webserver
 
@@ -100,6 +100,30 @@ And already, your app is ready to go:
 
 ## Changelog
 
+#### 1.1.1
+
+- No longer catching ArgumentErrors when calling the block for a route.  This
+  fixes a bug where Kenji incorrectly responds with a 404 when the block is
+  passed the wrong number of arguments.
+- Fixed logic for matching a pass.  the path now must match the pass exactly
+  whereas before the pass would match if any subset of the path matched the
+  pass.
+
+#### 1.1
+
+- Kenji::App is a simply wrapper that can and should be used in `config.ru`
+  files. It avoids the need to wrap the Kenji initialization in a lambda.
+- Kenji's stderr is now configurable as an option.
+- The new option `catch_exceptions` (default true) configures whether Kenji
+  will automatically rescue and log exceptions.
+- The root path argument to initializing Kenji is now deprecated, and replaced
+  with the `directory` named option. It is only necessary to set this when not
+  using a `root_controller`.
+
+#### 1.0
+
+- ? TODO: fill me in
+
 #### 0.7
 
 - Pass can now contain variables, that get set as @ivars on the controller.

data/lib/kenji/app.rb

@@ -0,0 +1,25 @@
+
+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:
+  #
+  #   run Kenji::App.new(directory: Dir.getwd)
+  #
+  # Any options passed will also be forwarded to Kenji.
+  #
+  # Kenji::App has one instance for the app, unlike Kenji::Kenji which has one
+  # instance per request.
+  #
+  class App
+
+    def initialize(opts={})
+      @opts = opts
+    end
+
+    def call(env)
+      Kenji.new(env, @opts).call
+    end
+  end
+end

data/lib/kenji/controller.rb

@@ -6,11 +6,14 @@ 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.
-    # Colon-prefixed segments become variables, passed onto the given block as arguments.
-    # The name given to the variable is irrelevant, and is thrown away: /hello/:/children is equivalent to the example above.
-    # Given block must have correct arity.
+    # Colon-prefixed segments become variables, passed onto the given block as
+    # arguments. The name given to the variable is irrelevant, and is thrown
+    # away: /hello/:/children is equivalent to the example above. Given block
+    # must have correct arity.
 
     # Route GET
     def self.get(path, &block)
@@ -46,9 +49,9 @@ module Kenji
 
     # Route a given path to the correct block, for any given methods
     #
-    # Note: this works by building a tree for the path,
-    # each node being a path segment or variable segment, and the leaf @action being the block
-
+    # Note: this works by building a tree for the path, each node being a path
+    # 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)
@@ -139,16 +142,11 @@ module Kenji
           node = node[:':']                                   # attempt to find a variable segment
           variables << segment                                # either we've found a variable, or the `unless` below will trigger
         else
-          variables << segment                                # dump the remaining segments if we cannot drill down further
-          searching = false
+          return attempt_fallback(path)                       # route failed to match variable or segment node so attempt fallback
         end
       end
       if node && action = node[:@action]                      # the block is stored in the @action leaf
-        begin
-          return action.bind(self).call(*variables)
-        rescue ArgumentError                                  # assuming argument error means route not defined
-          return attempt_fallback(path)                       # TODO: might want to check arity instead
-        end
+        return action.bind(self).call(*variables)
       else                                                    # or, fallback if necessary store the block for each method
         return attempt_fallback(path)
       end
@@ -197,8 +195,9 @@ module Kenji
           variables[match[1].to_sym] = e
           match = true
         else
-          match = node.has_key?(e.to_sym)
-          node = node[e.to_sym] if match
+          # if there is no match it should not pass
+          break unless match = node.has_key?(e.to_sym)
+          node = node[e.to_sym]
         end
 
         break if node[:@controller]

data/lib/kenji/version.rb

@@ -1,5 +1,4 @@
-
 module Kenji
-  VERSION = '1.0'
+  VERSION = '1.1.1'
 end
 

data/lib/kenji.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'kenji/controller'
+require 'kenji/app'
 require 'kenji/string_extensions'
 require 'rack'
 
@@ -20,32 +21,65 @@ module Kenji
     #
     # `env` should be the environment hash provided by Rack.
     #
-    # `root` is the root directory (as output by File.expand_path) of the Kenji
-    # directory structure.
+    # *deprecated* `root` is the root directory (as output by File.expand_path)
+    # of the Kenji directory structure. This is deprecated, please use the
+    # :directory option below.
     #
     # `options` is an options hash that accepts the following keys:
     #
-    #   - :auto_cors => true | false    # automatically deal with
-    #                                     CORS / Access-Control
-    #   - :root_controller => Object    # when set, Kenji will not attempt to
-    #                                     discover controllers based on
-    #                                     convention, but rather will always
-    #                                     use this controller. use `pass` to
-    #                                     build a controller hierarchy
+    #   :auto_cors => true | false
     #
-    def initialize(env, root, options = {})
+    #     automatically deal with CORS / Access-Control
+    #
+    #   :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
+    #     not necessary, as the directory is only used for auto-discovering
+    #     controllers.
+    #
+    #   :root_controller => Object
+    #
+    #     when set, Kenji will not attempt to discover controllers based on
+    #     convention, but rather will always use this controller. use `pass` to
+    #     build a controller hierarchy
+    #
+    #   :catch_exceptions => true | false
+    #
+    #     when true, Kenji will catch exceptions, print them in stderr, and and
+    #     return a standard 500 error
+    #
+    #   :stderr => IO
+    #
+    #     an IO stread, this is where Kenji logging goes by default. defaults
+    #     to $stderr
+    #
+    def initialize(env, *rest)
+      raise ArgumentError unless rest.count == 2 || rest.count == 1
+      root, options = *rest
+      options, root = root, options if root.is_a?(Hash)
+      options ||= {}
+
       @headers = {
         'Content-Type' => 'application/json'
       }
       @status = 200
-      @root = File.expand_path(root) + '/'
-      @stderr = $stderr
       @env = env
+
+      # deal with legacy root argument behavior
+      options[:directory] = File.expand_path(root) if root
       
       @options = {
         auto_cors: true,
-        root_controller: nil
+        catch_exceptions: true,
+        root_controller: nil,
+        directory: File.expand_path(Dir.getwd),
+        stderr: $stderr
       }.merge(options)
+
+      @stderr = @options[:stderr]
+      @root = @options[:directory] + '/'
     end
 
     # This method does all the work!
@@ -78,10 +112,8 @@ module Kenji
           while head = segments.shift
             acc = "#{acc}/#{head}"
             if controller = controller_for(acc)                   # if we have a valid controller 
-              begin
-                subpath = '/'+segments.join('/')
-                out = controller.call(method, subpath).to_json
-              end
+              subpath = '/'+segments.join('/')
+              out = controller.call(method, subpath).to_json
               success = true
               break
             end
@@ -93,6 +125,7 @@ module Kenji
         [@status, @headers, [out]]
       end
     rescue Exception => e
+      raise e unless @options[:catch_exceptions]
       @stderr.puts e.inspect                                    # log exceptions
       e.backtrace.each {|b| @stderr.puts "  #{b}" }
       response_500

data/spec/5/controllers/main.rb

@@ -3,8 +3,21 @@ module Spec5
     get '/' do
       { :foo => 'bar' }
     end
+
     get '/path' do
       { :baz => 'bar' }
     end
+
+    get '/foo/:foo_id/:bar_id' do |foo_id|
+    	{ :baz => 'bar' }
+    end
+
+    get "/bar/:foo_id/:bar_id" do |foo_id, bar_id, baz_id|
+    	{ :baz => 'bar' }
+    end
+
+    get "/foobar/:foo_id/:bar_id" do |foo_id, bar_id|
+    	{ :foo => foo_id, :bar => bar_id }
+    end
   end
 end

data/spec/kenji_spec.rb

@@ -17,7 +17,7 @@ def app_for(path, opts={})
   end
 end
 
-describe Kenji::Kenji, 'expected reponses' do
+describe Kenji::Kenji, 'expected responses' do
   include Rack::Test::Methods
 
   context '1' do
@@ -106,6 +106,10 @@ describe Kenji::Kenji, 'expected reponses' do
       last_response.body.should == expected_response
     end
 
+    it 'should not match subsets of the route' do
+      get 'something/child/foo'
+      last_response.status.should == 404
+    end
   end
 
   context '3' do
@@ -183,6 +187,27 @@ describe Kenji::Kenji, 'expected reponses' do
       put '/main/foo/foo_id/pass/pass_id'
       last_response.status.should == 404
     end
+
+    it "should pass variables to blocks" do
+      get "/foobar/foo_id/bar_id"
+      expected_response = { :foo => "foo_id", :bar => "bar_id" }.to_json
+      last_response.body.should == expected_response
+      last_response.status.should == 200
+    end
+
+    it "should throw ArgumentError when there are too many arguments" do
+      get "foo/foo_id/bar_id"
+      last_response.status.should == 500
+    end
+
+    it "should throw ArgumentError when there are too few arguments" do
+      get "bar/foo_id/bar_id"
+      last_response.status.should == 500
+    end
   end
+  
+  # TODO: Write unit tests for :catch_exceptions option.
+  # TODO: Write unit tests for Kenji::App
+  # TODO: Write unit tests for new root directory behavior.
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kenji
 version: !ruby/object:Gem::Version
-  version: '1.0'
+  version: 1.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-16 00:00:00.000000000 Z
+date: 2013-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -117,6 +117,7 @@ files:
 - inited/tmp/always_restart.txt
 - kenji.gemspec
 - lib/kenji.rb
+- lib/kenji/app.rb
 - lib/kenji/controller.rb
 - lib/kenji/string_extensions.rb
 - lib/kenji/version.rb