kenji 0.5 → 0.6.5

data/README.md

@@ -1,6 +1,3 @@
-*Project is still actively in development.*
-
-
 # Kenji
 
 Kenji is a lightweight backend framework for Ruby.
@@ -26,17 +23,17 @@ Kenji wants you to organize your code into logical units of code, aka. controlle
 
 The canonical Hello World example for the URL `/hello/world` in Kenji would look like this, in `controller/hello.rb`:
 
-````ruby
+```ruby
 class HelloController < Kenji::Controller
     get '/world' do
         {hello: :world}
     end
 end
-````
+```
 
 A more representative example might be:
 
-````ruby
+```ruby
 class UserController < Kenji::Controller
 
     # ...
@@ -53,7 +50,7 @@ class UserController < Kenji::Controller
         # delete connection from user id to friend_id
     end
 end
-````
+```
 
 
 ### Data Transport
@@ -80,5 +77,27 @@ And already, your app is ready to go:
 
 ## Requirements & Assumptions
 
-- Requires rubygems and bundler.
+- Requires RubyGems and Bundler.
+- Requires Rack
 - Requires Ruby 1.9.
+
+
+## Changelog
+
+#### 0.6.5
+
+- Automatically handle CORS / Access-Control.
+- Use throw / catch instead of raise / rescue for control flow.
+
+#### Before TODO: figure out when
+
+- `before` command.
+- specs
+- passing 
+
+## Still to do
+
+- The auto-generated project template should be updated.
+- The controller naming convention should not contain a 'Controller' suffix.
+- Route multiple URLs for the same route?
+

data/lib/kenji/controller.rb

@@ -86,11 +86,30 @@ module Kenji
       node[:@controller] = controller
     end
 
+
+    # This lets you define before blocks.
+    #
+    #   class MyController < Kenji::Controller
+    #     before do
+    #       # eg. ensure authentication, you can use kenji.respond in here.
+    #     end
+    #   end
+    #   
+    def self.before(&block)
+      define_method(:_tmp_before_action, &block)
+      block = instance_method(:_tmp_before_action)
+      remove_method(:_tmp_before_action)
+      (@befores ||= []) << block
+    end
+
     
     # Most likely only used by Kenji itself.
     # Override to implement your own routing, if you'd like.
     #
     def call(method, path)
+
+      self.class.befores.each {|b| b.bind(self).call }
+
       segments = path.split('/')
       segments = segments.drop(1) if segments.first == ''     # discard leading /'s empty segment
 
@@ -104,11 +123,12 @@ module Kenji
       end
       if node[:@controller]
         instance = node[:@controller].new
+        instance.kenji = kenji if instance.respond_to?(:kenji=)
         return instance.call(method, remaining_segments.join('/'))
       end
 
       # regular routing
-      node = self.class.routes[method]
+      node = self.class.routes[method] || {}
       variables = []
       searching = true
       segments.each do |segment|                              # traverse tree to find 
@@ -140,6 +160,8 @@ module Kenji
         else
           return fallback
         end
+      else
+        kenji.respond(404, 'Not found!')
       end
     end
 
@@ -151,6 +173,9 @@ module Kenji
     def self.passes
       @passes || {}
     end
+    def self.befores
+      @befores || []
+    end
   end
 end
 

data/lib/kenji/version.rb

@@ -1,5 +1,5 @@
 
 module Kenji
-  VERSION = '0.5'
+  VERSION = '0.6.5'
 end
 

data/lib/kenji.rb

@@ -10,52 +10,89 @@ module Kenji
 
     # Setting `kenji.status = 203` will affect the status code of the response.
     attr_accessor :status
+    # Exceptions will be printed here, and controllers are expected to log to
+    # this IO buffer:
+    attr_accessor :stderr
 
     # Methods for rack!
 
     # Constructor...
     #
-    def initialize(env, root)
+    # `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.
+    #
+    # `options` is an options hash that accepts the following keys:
+    #
+    #   - :auto_cors => true | false    # automatically deal with
+    #                                     CORS / Access-Control
+    #
+    def initialize(env, root, options = {})
       @headers = {
         'Content-Type' => 'application/json'
       }
       @status = 200
       @root = File.expand_path(root) + '/'
+      @stderr = $stderr
       @env = env
+      
+      @options = {
+        auto_cors: true
+      }.merge(options)
     end
 
     # This method does all the work!
     #
     def call
-      path = @env['PATH_INFO']
-      
-      # deal with static files
-      static = "#{@root}public#{path}"
-      return Rack::File.new("#{@root}public").call(@env) if File.file?(static)
-
-
-      # new routing code
-      segments = path.split('/')
-      segments = segments.drop(1) if segments.first == ''       # discard leading /'s empty segment
-      segments.unshift('')
-
-      acc = ''; out = 'null'
-      while head = segments.shift
-        acc = "#{acc}/#{head}"
-        if controller = controller_for(acc)                    # if we have a valid controller 
-          begin
-            out = controller.call(@env['REQUEST_METHOD'].downcase.to_sym, '/'+segments.join('/')).to_json
-          rescue KenjiRespondControlFlowInterrupt => e
-            out = e.response
-          rescue Exception => e
-            p e, e.backtrace                                   # log exceptions
-            raise e
+
+      auto_cors if @options[:auto_cors]
+
+      catch(:KenjiRespondControlFlowInterrupt) do
+        path = @env['PATH_INFO']
+
+        # deal with static files
+        static = "#{@root}public#{path}"
+        return Rack::File.new("#{@root}public").call(@env) if File.file?(static)
+
+
+        # new routing code
+        segments = path.split('/')
+        segments = segments.drop(1) if segments.first == ''       # discard leading /'s empty segment
+        segments.unshift('')
+
+        acc = ''; out = '', success = false
+        while head = segments.shift
+          acc = "#{acc}/#{head}"
+          if controller = controller_for(acc)                     # if we have a valid controller 
+            begin
+              method = @env['REQUEST_METHOD'].downcase.to_sym
+              subpath = '/'+segments.join('/')
+              out = controller.call(method, subpath).to_json
+            end
+            success = true
+            break
           end
-          break
         end
+
+        return response_404 unless success
+
+        [@status, @headers, [out]]
       end
+    rescue Exception => e
+      @stderr.puts e.inspect                                    # log exceptions
+      e.backtrace.each {|b| @stderr.puts "  #{b}" }
+      response_500
+    end
+
+    # 500 error
+    def response_500
+      [500, @headers, [{status: 500, message: 'Something went wrong...'}.to_json]]
+    end
 
-      [@status, @headers, [out]]
+    # 404 error
+    def response_404
+      [404, @headers, [{status: 404, message: 'Not found!'}.to_json]]
     end
 
 
@@ -96,7 +133,7 @@ module Kenji
         :message => message
       }
       hash.each { |k,v| response[k]=v }
-      raise KenjiRespondControlFlowInterrupt.new(response.to_json)
+      throw(:KenjiRespondControlFlowInterrupt, [@status, @headers, [response.to_json]])
     end
 
 
@@ -104,6 +141,23 @@ module Kenji
     # Private methods
     private
 
+    # Deals with silly HTTP CORS Access-Control restrictions by automatically
+    # allowing all requests.
+    #
+    def auto_cors
+      origin = env['HTTP_ORIGIN']
+      header 'Access-Control-Allow-Origin' => origin if origin
+
+      if env['REQUEST_METHOD'] == 'OPTIONS'
+        header 'Access-Control-Allow-Methods' => 'OPTIONS, GET, POST, PUT, DELETE'
+
+        if requested_headers = env['HTTP_ACCESS_CONTROL_REQUEST_HEADERS']
+          header 'Access-Control-Allow-Headers' => requested_headers
+        end
+        respond(200, 'CORS is allowed.')
+      end
+    end
+
     # Will attempt to fetch the controller, and verify that it is a implements call 
     #
     def controller_for(subpath)
@@ -122,12 +176,5 @@ module Kenji
     
   end
   
-
-  class KenjiRespondControlFlowInterrupt < StandardError
-    attr_accessor :response
-    def initialize(response)
-        @response = response
-    end
-  end # early exit containing a response
 end
 

data/spec/1/controllers/main.rb

@@ -5,6 +5,10 @@ class MainController < Kenji::Controller
     {status: 200, hello: :world}
   end
 
+  get '/crasher' do
+    raise
+  end
+
   post '/' do
     {status:1337}
   end
@@ -16,4 +20,9 @@ class MainController < Kenji::Controller
   delete '/' do
     {status:1337}
   end
+
+  get '/respond' do
+    kenji.respond(123, 'hello')
+    raise # never called
+  end
 end

data/spec/3/controllers/before.rb

@@ -0,0 +1,11 @@
+
+class BeforeController < Kenji::Controller
+
+  before do
+    kenji.respond(302, 'redirect...')
+  end
+
+  get '/hello' do
+    {status: 200, hello: :world}
+  end
+end

data/spec/kenji_spec.rb

@@ -2,6 +2,7 @@
 require 'rack'
 require 'rack/test'
 require 'rspec'
+require 'rspec/mocks'
 
 require 'kenji'
 
@@ -9,57 +10,114 @@ require 'kenji'
 # NOTE: these tests make use of the controllers defined in test/controllers.
 
 def app_for(path)
-    lambda do |env|
-      Kenji::Kenji.new(env, File.dirname(__FILE__)+'/'+path).call
-    end
+  lambda do |env|
+    kenji = Kenji::Kenji.new(env, File.dirname(__FILE__)+'/'+path)
+    kenji.stderr = double(puts: nil)
+    kenji.call
+  end
 end
 
-describe Kenji do
-
+describe Kenji::Kenji, 'expected reponses' do
   include Rack::Test::Methods
-  def app; app_for('1'); end
 
+  context '1' do
+    def app; app_for('1'); end
 
-  it 'should return "null" for unknown routes' do
-    get '/sdlkjhb'
-    last_response.body.should == 'null'
-  end
 
-  it 'should route a GET call to a defined get call' do
-    get '/main/hello'
-    expected_response = {status: 200, hello: :world}.to_json
-    last_response.body.should == expected_response
-  end
+    it 'should return 404 for unknown routes (no controller)' do
+      get '/sdlkjhb'
+      expected_response = {status: 404, message: 'Not found!'}.to_json
+      last_response.body.should == expected_response
+      last_response.status.should == 404
+    end
 
-  [:post, :put, :delete].each do |method|
+    it 'should return 404 for unknown routes (no route on valid controller)' do
+      get '/main/sdlkjhb'
+      expected_response = {status: 404, message: 'Not found!'}.to_json
+      last_response.body.should == expected_response
+      last_response.status.should == 404
+    end
 
-    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
+    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
+      last_response.body.should == expected_response
+    end
+
+    [:post, :put, :delete].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
+        last_response.body.should == expected_response
+      end
+    end
+
+    it 'should return "null" for unsupported methods' do
+      post '/main/hello'
+      expected_response = {status: 404, message: 'Not found!'}.to_json
+      last_response.body.should == expected_response
+      last_response.status.should == 404
+    end
+
+    it 'should use throw / catch to respond immediately with kenji.respond' do
+      get '/main/respond'
+      expected_response = {status: 123, message: 'hello'}.to_json
+      last_response.body.should == expected_response
+      last_response.status.should == 123
+    end
+
+    it 'should automatically allow CORS for simple requests' do
+      header 'Origin', 'foo'
+      get '/main/hello'
+      last_response.header['Access-Control-Allow-Origin'].should == 'foo'
+    end
+
+    it 'should automatically allow CORS for complex requests' do
+      header 'Origin', 'foo'
+      header 'Access-Control-Request-Headers', 'Bar'
+      options '/main/hello'
+      last_response.header['Access-Control-Allow-Origin'].should == 'foo'
+      last_response.header['Access-Control-Allow-Methods'].should == 'OPTIONS, GET, POST, PUT, DELETE'
+      last_response.header['Access-Control-Allow-Headers'].should == 'Bar'
     end
-  end
 
-  it 'should return "null" for unsupported methods' do
-    post '/main/hello'
-    last_response.body.should == 'null'
   end
 
-end
+  context '2' do
+    def app; app_for('2'); end
 
-describe Kenji do
-  include Rack::Test::Methods
-  def app; app_for('2'); end
+    it 'should use root controller' do
+      get '/'
+      expected_response = {status: 200, controller_used: :root}.to_json
+      last_response.body.should == expected_response
+    end
+
+    it 'should pass routing down to child controllers' do
+      get '/child/foo'
+      expected_response = {status: 200, foo: :bar}.to_json
+      last_response.body.should == expected_response
+    end
 
-  it 'should use root controller' do
-    get '/'
-    expected_response = {status: 200, controller_used: :root}.to_json
-    last_response.body.should == expected_response
   end
 
-  it 'should pass routing down to child controllers' do
-    get '/child/foo'
-    expected_response = {status: 200, foo: :bar}.to_json
-    last_response.body.should == expected_response
+  context '3' do
+    def app; app_for('3'); end
+
+    it 'should call before block' do
+      get '/before/hello'
+      expected_response = {status: 302, message: 'redirect...'}.to_json
+      last_response.body.should == expected_response
+      last_response.status.should == 302
+    end
+
   end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kenji
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.6.5
   prerelease: 
 platform: ruby
 authors:
@@ -79,6 +79,7 @@ files:
 - spec/1/controllers/main.rb
 - spec/2/controllers/_.rb
 - spec/2/controllers/child.rb
+- spec/3/controllers/before.rb
 - spec/kenji_spec.rb
 homepage: https://github.com/kballenegger/kenji
 licenses: []
@@ -108,5 +109,6 @@ test_files:
 - spec/1/controllers/main.rb
 - spec/2/controllers/_.rb
 - spec/2/controllers/child.rb
+- spec/3/controllers/before.rb
 - spec/kenji_spec.rb
 has_rdoc: