praxis 0.9 → 0.10.0

data/lib/praxis/request.rb

@@ -73,13 +73,8 @@ module Praxis
 
     def load_headers(context)
       return unless action.headers
-      defined_headers = action.headers.attributes.keys.each_with_object(Hash.new) do |name, hash|
-        env_name = if name == :CONTENT_TYPE || name == :CONTENT_LENGTH
-          name.to_s
-        else
-          "HTTP_#{name}"
-        end
-        hash[name] = self.env[env_name] if self.env.has_key? env_name
+      defined_headers = action.precomputed_header_keys_for_rack.each_with_object(Hash.new) do |(upper,original), hash|
+        hash[original] = self.env[upper] if self.env.has_key? upper
       end
       self.headers = action.headers.load(defined_headers, context)
     end

data/lib/praxis/request_stages/action.rb

@@ -1,19 +1,22 @@
 module Praxis
   module RequestStages
 
-    class Action < RequestStage
-
+    class Action < RequestStage 
+      
       def execute
         response = controller.send(action.name, **request.params_hash)
-        if response.kind_of? String
+        case response
+        when String
           controller.response.body = response
-        else
+        when Praxis::Response
           controller.response = response
-        end
-
+        else
+          raise "Action #{action.name} in #{controller.class} returned #{response.inspect}. Only Response objects or Strings allowed."
+        end  
         controller.response.request = request
+        nil # Action cannot return its OK request, as it would indicate the end of the stage chain
       end
-
+            
     end
 
   end

data/lib/praxis/request_stages/request_stage.rb

@@ -1,6 +1,9 @@
 module Praxis
   module RequestStages
 
+    # Special Stage what will hijack the run and execute methods to:
+    # 1- Run specific controller callbacks (in addition to any normal callbacks)
+    # 2- Shortcut the controller callback chain if any returns a Response object
     class RequestStage < Stage
       extend Forwardable
 
@@ -17,32 +20,64 @@ module Praxis
             if conditions.has_key?(:actions)
               next unless conditions[:actions].include? action.name
             end
-            block.call(controller)
+            result = block.call(controller)
+            return result if result && result.kind_of?(Praxis::Response)
           end
         end
+        nil
       end
-
+      
       def run
         setup!
         setup_deferred_callbacks!
+        
         execute_callbacks(self.before_callbacks)
-        execute_controller_callbacks(controller.class.before_callbacks)
-        result = execute
-        execute_controller_callbacks(controller.class.after_callbacks)
-        execute_callbacks(self.after_callbacks)
+        # Shortcut lifecycle if filters return a response (non-nil but non-response-class response is ignored)
+        r = execute_controller_callbacks(controller.class.before_callbacks)
+        return r if r
+
+        result = execute_with_around
+        # Still allow the after callbacks to shortcut it if necessary.
+        r = execute_controller_callbacks(controller.class.after_callbacks)
+        return r if r 
+        execute_callbacks(self.after_callbacks) 
 
         result
       end
 
-
+      def execute_with_around
+          cb = controller.class.around_callbacks[ path ]
+          if cb == nil || cb.empty?
+            execute
+          else
+            inner_proc = proc { execute }
+            
+            applicable = cb.select do |(conditions, handler)| 
+              if conditions.has_key?(:actions)
+                (conditions[:actions].include? action.name) ? true : false
+              else
+                true
+              end
+            end
+            
+            chain = applicable.reverse.inject(inner_proc) do |blk, (conditions, handler)|
+              if blk
+                proc{ handler.call(controller,blk) }
+              else
+                proc{ handler.call }
+              end
+            end  
+            chain.call
+          end
+      end
+      
       def execute
         raise NotImplementedError, 'Subclass must implement Stage#execute' unless @stages.any?
 
         @stages.each do |stage|
-          result = stage.run
-          return result if result.kind_of?(Praxis::Response)
+          shortcut = stage.run
+          return shortcut if shortcut && shortcut.kind_of?(Praxis::Response)
         end
-
         nil
       end
 

data/lib/praxis/request_stages/validate.rb

@@ -3,9 +3,13 @@ module Praxis
 
     class Validate < RequestStage
 
-      def setup!
-        @stages << RequestStages::ValidateParamsAndHeaders.new(:params_and_headers, context, parent: self)
-        @stages << RequestStages::ValidatePayload.new(:payload, context, parent: self)
+      def initialize(name, context,**opts)
+        super
+        # Add our sub-stages
+        @stages = [
+          RequestStages::ValidateParamsAndHeaders.new(:params_and_headers, context, parent: self),
+          RequestStages::ValidatePayload.new(:payload, context, parent: self) 
+        ]
       end
 
       def execute

data/lib/praxis/responses/http.rb

@@ -125,30 +125,6 @@ module Praxis
     end
 
 
-    # A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
-    class InternalServerError < Praxis::Response
-      self.status = 500
-
-      attr_accessor :error
-
-      def initialize(error: nil, **opts)
-        super(**opts)
-        @error = error
-      end
-
-      def format!(exception = @error) #_exception(exception)
-        if @error
-          msg = {
-            name: exception.class.name,
-            message: exception.message,
-            backtrace: exception.backtrace
-          }
-          msg[:cause] = format!(exception.cause) if exception.cause
-          @body = msg
-        end
-      end
-    end
-
     ApiDefinition.define do |api|
       self.constants.each do |class_name|
         response_class = self.const_get(class_name)

data/lib/praxis/responses/internal_server_error.rb

@@ -0,0 +1,40 @@
+module Praxis
+
+  module Responses
+
+    # A generic error message, given when an unexpected condition was encountered and no more specific message is suitable.
+    class InternalServerError < Praxis::Response
+      self.status = 500
+      attr_accessor :error
+
+      def initialize(error: nil, **opts)
+        super(**opts)
+        @headers['Content-Type'] = 'application/json' #TODO: might want an error mediatype
+        @error = error
+      end
+
+      def format!(exception = @error) #_exception(exception)
+        if @error
+          msg = {
+            name: exception.class.name,
+            message: exception.message,
+            backtrace: exception.backtrace
+          }
+          msg[:cause] = format!(exception.cause) if exception.cause
+          @body = msg
+        end
+      end
+    end
+
+  end
+
+  ApiDefinition.define do |api|
+    api.response_template :internal_server_error do
+      description "When an internal server error occurs..."
+      status 500
+      media_type "application/json"
+    end
+  end
+
+end
+

data/lib/praxis/responses/validation_error.rb

@@ -5,6 +5,7 @@ module Praxis
     class ValidationError < BadRequest
       def initialize(errors: nil, exception: nil, **opts)
         super(**opts)
+        @headers['Content-Type'] = 'application/json' #TODO: might want an error mediatype
         @errors = errors
         @exception = exception
       end

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '0.9'
+  VERSION = '0.10.0'
 end

data/lib/praxis.rb

@@ -30,6 +30,7 @@ module Praxis
   autoload :Bootloader, 'praxis/bootloader'
   autoload :Config, 'praxis/config'
   autoload :Controller, 'praxis/controller'
+  autoload :Callbacks, 'praxis/callbacks'
   autoload :Dispatcher, 'praxis/dispatcher'
   autoload :Exception, 'praxis/exception'
   autoload :FileGroup,'praxis/file_group'
@@ -70,30 +71,10 @@ module Praxis
     autoload :Validation, 'praxis/exceptions/validation'
   end
 
-  module Responses
-    autoload :Ok, 'praxis/responses/http'
-    autoload :Created, 'praxis/responses/http'
-    autoload :Accepted, 'praxis/responses/http'
-    autoload :NoContent, 'praxis/responses/http'
-    autoload :MultipleChoices, 'praxis/responses/http'
-    autoload :MovedPermanently, 'praxis/responses/http'
-    autoload :Found, 'praxis/responses/http'
-    autoload :SeeOther, 'praxis/responses/http'
-    autoload :NotModified, 'praxis/responses/http'
-    autoload :TemporaryRedirect, 'praxis/responses/http'
-    autoload :BadRequest, 'praxis/responses/http'
-    autoload :Unauthorized, 'praxis/responses/http'
-    autoload :Forbidden, 'praxis/responses/http'
-    autoload :NotFound, 'praxis/responses/http'
-    autoload :MethodNotAllowed, 'praxis/responses/http'
-    autoload :NotAcceptable, 'praxis/responses/http'
-    autoload :Conflict, 'praxis/responses/http'
-    autoload :PreconditionFailed, 'praxis/responses/http'
-    autoload :UnprocessableEntity, 'praxis/responses/http'
-    autoload :InternalServerError, 'praxis/responses/http'
-
-    autoload :ValidationError, 'praxis/responses/validation_error'
-  end
+  # Avoid loading responses (and templates) lazily as they need to be registered in time
+  require 'praxis/responses/http'
+  require 'praxis/responses/internal_server_error'
+  require 'praxis/responses/validation_error'
 
   module BootloaderStages
     autoload :FileLoader, 'praxis/bootloader_stages/file_loader'

data/praxis.gemspec

@@ -23,12 +23,12 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'rack', '~> 1'
   spec.add_dependency 'mustermann', '~> 0'
-  spec.add_dependency 'activesupport', '~> 4'
+  spec.add_dependency 'activesupport', '>= 3'
   spec.add_dependency 'ruport', '~> 1'
   spec.add_dependency 'mime', '~> 0'
   spec.add_dependency 'praxis-mapper', '~> 3.1'
-  spec.add_dependency 'praxis-blueprints', '~> 1.0'
-  spec.add_dependency 'attributor', '~> 2'
+  spec.add_dependency 'praxis-blueprints', '~> 1.1'
+  spec.add_dependency 'attributor', '~> 2.2'
   spec.add_dependency 'thor', '~> 0'
 
   spec.add_development_dependency 'bundler', '~> 1.6'

data/spec/functional_spec.rb

@@ -9,7 +9,7 @@ describe 'Functional specs' , focus: true do
   context 'index' do
     context 'with an incorrect response_content_type param' do
       it 'fails to validate the response' do
-        get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0'
+        get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0', nil, 'HTTP_FOO' => "bar"
         response = JSON.parse(last_response.body)
         expect(response['name']).to eq('Praxis::Exceptions::Validation')
         expect(response["message"]).to match(/Bad Content-Type/)
@@ -37,10 +37,18 @@ describe 'Functional specs' , focus: true do
   it 'works' do
     get '/clouds/1/instances/2?junk=foo&api_version=1.0'
     expect(last_response.status).to eq(200)
-    expect(JSON.parse(last_response.body)).to eq({"cloud_id" => 1, "id"=>2, "junk"=>"foo", "other_params"=>{"some_date"=>"2012-12-21T00:00:00+00:00"}, "payload"=>{"something"=>nil, "optional"=>"not given"}})
-    expect(last_response.headers).to eq({"Content-Type"=>"application/vnd.acme.instance", "Content-Length"=>"188"})
+    expect(JSON.parse(last_response.body)).to eq({"cloud_id" => 1, "id"=>2, "junk"=>"foo", 
+                                                  "other_params"=>{
+                                                    "some_date"=>"2012-12-21T00:00:00+00:00",
+                                                    "fail_filter"=>nil}, 
+                                                  "payload"=>{"something"=>nil, "optional"=>"not given"}})
+    expect(last_response.headers).to eq({"Content-Type"=>"application/vnd.acme.instance", "Content-Length"=>"213"})
   end
 
+  it 'returns early when making the before filter break' do
+    get '/clouds/1/instances/2?junk=foo&api_version=1.0&fail_filter=true'
+    expect(last_response.status).to eq(401)
+  end
 
   context 'bulk_create multipart' do
 
@@ -112,41 +120,53 @@ describe 'Functional specs' , focus: true do
       end
     end
 
-    context 'with unknown key in form' do
-      before do
-        junk = MIME::Text.new('junk_value')
-        form.add junk, 'junk_name'
+    context 'with a missing value in form' do
+      let(:form) do
+        form_data = MIME::Multipart::FormData.new
+
+        text = MIME::Text.new('DOCKER_HOST=tcp://127.0.0.1:2375')
+        form_data.add text, 'file', 'docker'
+
+        form_data
       end
 
+      let(:body) { form.body.to_s }
+      
       it 'returns an error' do
         post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
         response = JSON.parse(last_response.body)
+
         expect(response['name']).to eq('ValidationError')
-        expect(response["message"]).to match(/Unknown key received:/)
+        expect(response['errors']).to eq(["Attribute $.payload.key(\"destination_path\") is required"])
       end
 
     end
-
-    context 'with a missing value in form' do
+    
+    context 'with an extra key in the form' do
       let(:form) do
         form_data = MIME::Multipart::FormData.new
 
+        destination_path = MIME::Text.new('/etc/defaults')
+        form_data.add destination_path, 'destination_path'
+
         text = MIME::Text.new('DOCKER_HOST=tcp://127.0.0.1:2375')
         form_data.add text, 'file', 'docker'
 
+        # TEST EXTRA KEYS USING THE MULTIPART FORM
+        other = MIME::Text.new('I am extra')
+        form_data.add other, 'extra_thing'
+
         form_data
       end
 
       let(:body) { form.body.to_s }
+      subject(:response) { JSON.parse(last_response.body) }
       
-      it 'returns an error' do
+      before do
         post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type
-        response = JSON.parse(last_response.body)
-
-        expect(response['name']).to eq('ValidationError')
-        expect(response['errors']).to eq(["Attribute $.payload.get(\"destination_path\") is required"])
       end
-
+      its(:keys){ should eq(['destination_path','file','options'])}
+      its(['options']){ should eq({"extra_thing"=>"I am extra"})}
     end
 
   end
@@ -179,8 +199,33 @@ describe 'Functional specs' , focus: true do
         expect(last_response.body).to eq("NotFound. Your request speficied API version = \"50.0\". Available versions = \"1.0\".")
       end
     end
-
     
   end
 
+  context 'volumes' do
+    context 'when no authorization header is passed' do
+      it 'works as expected' do
+        get '/volumes/123?api_version=1.0&junk=stuff'#, nil, 'AUTHORIZATION' => 'foobar'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)).to eq({"id"=>123,
+                                                      "other_params"=>{
+                                                        "junk"=>"stuff",
+                                                        "some_date"=>"2012-12-21T00:00:00+00:00"}
+                                                     })
+        expect(last_response.headers["Content-Type"]).to eq("application/vnd.acme.volume")
+      end      
+    end
+    context 'when an authorization header is passed' do
+      it 'returns 401 when it does not match "secret" ' do
+        get '/volumes/123?api_version=1.0&junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'foobar'
+        expect(last_response.status).to eq(401)
+        expect(last_response.body).to match(/Authentication info is invalid/)
+      end
+      it 'succeeds as expected when it matches "secret" ' do
+        get '/volumes/123?api_version=1.0&junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'the secret'
+        expect(last_response.status).to eq(200)
+      end
+      
+    end
+  end
 end

data/spec/praxis/action_definition_spec.rb

@@ -13,7 +13,7 @@ describe Praxis::ActionDefinition do
       version '1.0'
       routing { prefix '/api/hello_world' }
       payload { attribute :inherited, String }
-      headers { header :inherited, String }
+      headers { header "Inherited", String }
       params  { attribute :inherited, String }
     end
   end
@@ -22,7 +22,7 @@ describe Praxis::ActionDefinition do
     described_class.new('foo', resource_definition) do
       routing { get '/:one' }
       payload { attribute :two, String }
-      headers { header :X_REQUESTED_WITH, 'XMLHttpRequest' }
+      headers { header "X_REQUESTED_WITH", 'XMLHttpRequest' }
       params  { attribute :one, String }
     end
   end
@@ -34,8 +34,8 @@ describe Praxis::ActionDefinition do
     its('params.attributes')   { should have_key :inherited }
     its('payload.attributes')  { should have_key :two }
     its('payload.attributes')  { should have_key :inherited }
-    its('headers.attributes')  { should have_key :X_REQUESTED_WITH }
-    its('headers.attributes')  { should have_key :INHERITED }
+    its('headers.attributes')  { should have_key "X_REQUESTED_WITH" }
+    its('headers.attributes')  { should have_key "Inherited" }
   end
 
   context '#responses' do
@@ -83,13 +83,21 @@ describe Praxis::ActionDefinition do
   end
 
   describe '#headers' do
+    it 'is backed by a Hash' do 
+      expect(subject.headers.type < Attributor::Hash).to be(true)
+    end
+
+    it 'is has case_sensitive_load enabled' do
+      expect(subject.headers.type.options[:case_insensitive_load]).to be(true) 
+    end
+
     it 'merges in more headers' do
       subject.headers do
-        header :more
+        header "more"
       end
 
       expect(subject.headers.attributes.keys).to match_array([
-        :X_REQUESTED_WITH, :INHERITED, :MORE
+        "X_REQUESTED_WITH", "Inherited", "more"
       ])
     end
   end

data/spec/praxis/callbacks_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe Praxis::Callbacks do
+  let(:controller){ double("controller", request: "request") }
+  
+  subject do
+    Class.new {
+      include Praxis::Callbacks
+
+#      implements PeopleResource
+
+      before :validate, actions: [:index] do |controller|
+        "before"
+      end
+
+      before actions: [:show] do |controller|
+      end
+
+      after :response, actions: [:show] do |controller|
+        "after"
+      end
+
+      around :action , actions: [:foobar] do |controller, callee|
+        controller.request
+        callee.call
+      end
+    }
+  end
+  
+  context '.before' do
+    let(:validate_conditions) { subject.before_callbacks[[:validate]][0][0] }
+    let(:validate_block) { subject.before_callbacks[[:validate]][0][1] }
+
+    it 'sets up the before_callbacks' do
+      expect(subject.before_callbacks.keys).to match_array([[:validate], [:action]])
+      expect(validate_conditions).to eq({:actions => [:index]})
+      expect(validate_block).to be_kind_of(Proc)
+      expect(validate_block.call(controller)).to eq("before")
+    end
+  end
+
+  context '.after' do
+    let(:response_conditions) { subject.after_callbacks[[:response]][0][0] }
+    let(:response_block) { subject.after_callbacks[[:response]][0][1] }
+
+    it 'sets up the after_callbacks' do
+      expect(subject.after_callbacks.keys).to match_array([[:response]])
+      expect(response_conditions).to eq({:actions => [:show]})
+      expect(response_block).to be_kind_of(Proc)
+      expect(response_block.call(controller)).to eq("after")
+    end
+  end
+  
+
+  context '.around' do
+    let(:callee_result){ "result" }
+    let(:callee){ double("callee", call: callee_result) }
+    let(:around_conditions) { subject.around_callbacks[[:action]][0][0] }
+    let(:around_block) { subject.around_callbacks[[:action]][0][1] }
+
+    it 'sets up the before_callbacks' do
+      expect(subject.around_callbacks.keys).to match_array([[:action]])
+      expect(around_conditions).to eq({:actions => [:foobar]})
+      expect(around_block).to be_kind_of(Proc)
+    end
+    it 'passes the right parameters to the block call' do
+      expect(controller).to receive(:request)
+      expect(callee).to receive(:call)
+      expect(around_block.call( controller,callee )).to eq(callee_result)
+    end
+  end
+  
+  # DONT DO THIS...this is just a test to show what would happen
+  context 'inheriting callbacks from base classes ' do
+    let!(:child1) {
+      Class.new(subject) do
+        before actions: [:child1] do |controller|
+          "before show child1"
+        end
+      end
+    }
+    let!(:child2) {
+      Class.new(subject) do
+        before actions: [:child2] do |controller|
+          "before show child2"
+        end
+      end
+    }
+
+    describe '.before_callbacks (but same for after and around)' do
+      context 'for child1 (and viceversa for child2)' do
+        let(:inherited_callbacks){ child1.before_callbacks }
+        it "will inherits not just the base callbacks, but child2 also!" do
+          expect(inherited_callbacks).to be_a(Hash)
+          expect(inherited_callbacks.keys).to eq([[:validate],[:action]])
+          action_callbacks = inherited_callbacks[[:action]]
+          expect(action_callbacks).to have(3).items
+          action_callback_options = action_callbacks.map{|options, block| options}
+          expect(action_callback_options).to eq([{:actions=>[:show]}, 
+                                                 {:actions=>[:child1]}, 
+                                                 {:actions=>[:child2]}])
+        end
+      end
+    end
+
+  end
+end

data/spec/praxis/controller_spec.rb

@@ -32,42 +32,4 @@ describe Praxis::Controller do
     end
   end
 
-  context '.actions' do
-    it 'gets the controller actions' do
-      expect(subject.actions.keys).to match_array([:index, :show])
-      expect(subject.actions[:index]).to be_kind_of(Praxis::ActionDefinition)
-      expect(subject.actions[:index].name).to eq(:index)
-    end
-  end
-
-  context '.action' do
-    it 'gets the index action of the controller' do
-      expect(subject.action(:index)).to be_kind_of(Praxis::ActionDefinition)
-      expect(subject.action(:index).name).to eq(:index)
-    end
-  end
-
-  context '.before' do
-    let(:validate_conditions) { subject.before_callbacks[[:validate]][0][0] }
-    let(:validate_block) { subject.before_callbacks[[:validate]][0][1] }
-
-    it 'sets up the before_callbacks' do
-      expect(subject.before_callbacks.keys).to match_array([[:validate], [:action]])
-      expect(validate_conditions).to eq({:actions => [:index]})
-      expect(validate_block).to be_kind_of(Proc)
-      expect(validate_block.call(*validate_conditions)).to eq("before")
-    end
-  end
-
-  context '.after' do
-    let(:response_conditions) { subject.after_callbacks[[:response]][0][0] }
-    let(:response_block) { subject.after_callbacks[[:response]][0][1] }
-
-    it 'sets up the after_callbacks' do
-      expect(subject.after_callbacks.keys).to match_array([[:response]])
-      expect(response_conditions).to eq({:actions => [:show]})
-      expect(response_block).to be_kind_of(Proc)
-      expect(response_block.call(*response_conditions)).to eq("after")
-    end
-  end
 end

data/spec/praxis/file_group_spec.rb

@@ -4,6 +4,11 @@ describe Praxis::FileGroup do
   let(:app) { Praxis::Application.instance }
   let(:layout) { app.file_layout }
 
+  context '#initialize' do 
+    it 'raises an error if given nil for the base path' do
+      expect { Praxis::FileGroup.new(nil) }.to raise_error(ArgumentError)
+    end
+  end
   context '#base' do
     it 'returns the base path for the group' do
       expect(layout[:design].base.to_s).to eq(File.join(app.root, 'design/'))