hassox-pancake 0.1.6

data/lib/pancake/stack/router.rb

@@ -0,0 +1,18 @@
+module Pancake
+  class Stack
+    class_inheritable_accessor :_router
+    @_router = Pancake::Router.new
+    
+    def self.router
+      yield _router if block_given?
+      _router
+    end
+    
+    def self.with_router
+      yield router if block_given?
+      router
+    end
+
+  end
+end
+

data/lib/pancake/stack/stack.rb

@@ -0,0 +1,57 @@
+module Pancake
+  class Stack
+    attr_accessor :app_name
+
+    # extend Hooks::InheritableInnerClasses
+    extend Hooks::OnInherit
+    extend Pancake::Middleware
+    extend Pancake::Paths
+
+    # Push the default paths in for this stack
+    push_paths(:config,       "config",               "config.rb")
+    push_paths(:config,       "config/environments",  "#{Pancake.env}.rb")
+    push_paths(:models,       "app/models",           "**/*.rb")
+    push_paths(:controllers,  "app/controllers",      "**/*.rb")
+    push_paths(:router,       "config",               "router.rb")
+
+    #Iterates the list of roots in the stack, and initializes the app found their
+    def self.initialize_stack
+      raise "Application root not set" if roots.empty?
+
+      # Run any :init level bootloaders for this stack
+      self::BootLoader.run!(:stack_class => self, :only => {:level => :init})
+
+      @initialized = true
+    end # initiailze stack
+
+    def self.initialized?
+      !!@initialized
+    end
+
+    def initialize(app = nil, opts = {})
+      @app_name = opts.delete(:app_name) || self.class
+      self.class.initialize_stack unless self.class.initialized?
+      Pancake.configuration.stacks[@app_name] = self
+
+      # setup the configuration for this stack
+      Pancake.configuration.configs[@app_name] = opts[:config] if opts [:config]
+      self.configuration(@app_name)
+      yield self.configuration(@app_name) if block_given?
+
+      self.class::BootLoader.run!({
+        :stack_class  => self.class,
+        :stack        => self,
+        :app          => app,
+        :app_name     => @app_name,
+        :except       => {:level => :init}
+      }.merge(opts))
+    end
+
+    # Construct a stack using the application, wrapped in the middlewares
+    # :api: public
+    def self.stackup(opts = {}, &block)
+      app = new(nil, opts, &block)
+      Pancake.configuration.configs[app.app_name].router
+    end # stackup
+  end # Stack
+end # Pancake

data/lib/pancake/stacks/short.rb

@@ -0,0 +1,2 @@
+  require 'pancake/stacks/short/stack'
+  require 'pancake/stacks/short/controller'

data/lib/pancake/stacks/short/controller.rb

@@ -0,0 +1,105 @@
+module Pancake
+  module Stacks
+    class Short
+      inheritable_inner_classes :Controller
+
+      class Controller
+        extend  Mixins::Publish
+        include Mixins::Render
+        include Mixins::RequestHelper
+        include Mixins::StackHelper
+
+        class_inheritable_accessor :_handle_exception
+
+        push_paths :views, ["app/views", "views"], "**/*"
+        
+        DEFAULT_EXCEPTION_HANDLER = lambda do |error|
+          "#{error.name}: #{error.description}"
+        end unless defined?(DEFAULT_EXCEPTION_HANDLER)
+        
+        # @api private
+        def self.call(env)
+          app = new(env)
+          app.dispatch!
+        end
+
+        # @api public
+        attr_accessor :status
+
+        def initialize(env)
+          @env, @request = env, Rack::Request.new(env)
+          @status = 200
+        end
+
+        # Provides access to the request params
+        # @api public
+        def params
+          request.params
+        end
+
+        # Dispatches to an action based on the params["action"] parameter
+        def dispatch!
+          params["action"] ||= params[:action]
+          params[:format]  ||= params["format"]
+ 
+          # Check that the action is available
+          raise Errors::NotFound, "No Action Found" unless allowed_action?(params["action"])
+          
+          @action_opts  = actions[params["action"]]
+          if params[:format]
+            @content_type, ct, @mime_type = Pancake::MimeTypes.negotiate_by_extension(params[:format].to_s, @action_opts.formats)
+          else
+            @content_type, ct, @mime_type = Pancake::MimeTypes.negotiate_accept_type(env["HTTP_ACCEPT"], @action_opts.formats)
+          end
+          
+          raise Errors::NotAcceptable unless @content_type
+ 
+          # set the response header
+          headers["Content-Type"] = ct
+          Rack::Response.new(self.send(params["action"]), status, headers).finish
+          
+        rescue Errors::HttpError => e
+          handle_request_exception(e)
+        rescue Exception => e
+          server_error = Errors::Server.new
+          server_error.exceptions << e
+          handle_request_exception(server_error)
+        end
+
+        def content_type
+          @content_type
+        end
+
+        def self.handle_exception(&block)
+          if block_given?
+            self._handle_exception = block
+          else
+            self._handle_exception || DEFAULT_EXCEPTION_HANDLER
+          end
+        end
+          
+        def handle_request_exception(error)
+          self.status = error.code
+          result = instance_exec error, &self.class.handle_exception
+          Rack::Response.new(result, status, headers).finish
+        end
+        
+        private
+        def allowed_action?(action)
+          self.class.actions.include?(action.to_s)
+        end
+
+        public
+        def self.roots
+          stack_class.roots
+        end
+
+        def _tempate_name_for(name, opts)
+          opts[:format] ||= content_type
+          "#{name}.#{opts[:format]}"
+        end
+      end # Controller
+
+    end # Short
+  end # Stacks
+end # Pancake

data/lib/pancake/stacks/short/stack.rb

@@ -0,0 +1,194 @@
+module Pancake
+  module Stacks
+    class Short < Pancake::Stack
+
+      def self.new_app_instance
+        self::Controller
+      end
+
+      # Marks a method as published.
+      # This is done implicitly when using the get, post, put, delete methods on a Stacks::Short
+      # But can be done explicitly
+      #
+      # @see Pancake::Mixins::Publish#publish
+      # @api public
+      def self.publish(*args)
+        @published = true
+        self::Controller.publish(*args)
+      end
+
+      # @see Pancake::Mixins::Publish#as
+      def self.as(*args)
+        self::Controller.as(*args)
+      end
+
+      # @see Pancake::Mixins::Publish#provides
+      def self.provides(*formats)
+        self::Controller.provides(*formats)
+      end
+
+      def self.handle_exception(*args, &block)
+        self::Controller.handle_exception(*args, &block)
+      end
+      
+      # Gets a resource at a given path
+      #
+      # The block should finish with the final result of the action
+      #
+      # @param [String] path  - a url path that conforms to Rack::Router match path.
+      # @param block - the contents of the block are executed when the path is matched.
+      #
+      # @example
+      #   get "/posts(/:year(/:month(/:date))" do
+      #     # do stuff to get posts and render them
+      #   end
+      #
+      # @see Rack::Router
+      # @api public
+      # @author Daniel Neighman
+      def self.get(path, opts = {}, &block)
+        define_published_action(:get, path, opts, block)
+      end
+
+      # Posts a resource to a given path
+      #
+      # The block should finish with the final result of the action
+      #
+      # @param [String] path - a url path that conforms to Rack::Router match path.
+      # @param block - the contents of the block are executed when the path is matched.
+      #
+      # @example
+      #   post "/posts" do
+      #     # do stuff to post  /posts and render them
+      #   end
+      #
+      # @see Rack::Router
+      # @api public
+      # @author Daniel Neighman
+      def self.post(path, opts = {}, &block)
+        define_published_action(:post, path, opts,  block)
+      end
+
+      # Puts a resource to a given path
+      #
+      # The block should finish with the final result of the action
+      #
+      # @param [String] path - a url path that conforms to Rack::Router match path.
+      # @param block - the contents of the block are executed when the path is matched.
+      #
+      # @example
+      #   put "/posts" do
+      #     # do stuff to post  /posts and render them
+      #   end
+      #
+      # @see Rack::Router
+      # @api public
+      # @author Daniel Neighman
+      def self.put(path, opts = {}, &block)
+        define_published_action(:put, path, opts, block)
+      end
+
+      # Deletes the resource at a given path
+      #
+      # The block should finish with the final result of the action
+      #
+      # @param [String] path - a url path that conforms to Rack::Router match path.
+      # @param block - the contents of the block are executed when the path is matched.
+      #
+      # @example
+      #   delete "/posts/foo-is-post" do
+      #     # do stuff to post foo-is-post and render the result
+      #   end
+      #
+      # @see Rack::Router
+      # @api public
+      # @author Daniel Neighman
+      def self.delete(path, opts = {}, &block)
+        define_published_action(:delete, path, opts, block)
+      end
+
+      private
+      # Defines an action on the inner Controller class of this stack.
+      # Also sets it as published if it's not already published.
+      #
+      # @param [Symbol] method - a smbol specifying the HTTP method
+      # @param [String] path - a string specifying the path to map the url to
+      # @api private
+      # @author Daniel Neighman
+      def self.define_published_action(method, path, opts, block)
+        self::Controller.publish unless @published
+        @published = nil
+
+        action_name = next_action_name(method,path)
+        attach_action(action_name, block)
+
+        attach_route(method, path, action_name, opts)
+      end
+
+      # Does the work of actually defining the action on the Controller Class
+      #
+      # @param [String] - the name of the method to create on the Controller class
+      # @api private
+      # @author Daniel Neighman
+      def self.attach_action(method_name, block)
+        self::Controller.class_eval do
+          define_method(method_name, &block)
+        end
+      end
+
+      # Supplies the path as a route to the stack router
+      #
+      # @param method [Symbol]
+      #
+      # @example
+      #   attach_route(:get, "/foo/bar", "get_00001__foo_bar")
+      #
+      # @api private
+      # @author Daniel Neighman
+      def self.attach_route(method, path, action_name, options)
+        name = options.delete(:_name)
+        options[:conditions] ||= {}
+        options[:conditions][:request_method] = method.to_s.upcase
+        options[:default_values] ||= {}
+        options[:default_values][:action] = action_name
+        options[:_exact] = true unless options[:_exact] == false
+        r = router.add(path, options)
+        r.name(name) if name
+        r
+      end
+
+      # provides for methods of the following form on Controller
+      #   :<method>_<number>_<sanitized_path>
+      # where <number> is incremented
+      #
+      # @param [Symbol] method - the HTTP method to look for
+      # @param [String] path - the url path expression to encode into the method name
+      #
+      # @return [String] - The next method name to use that won't clash with previously configured actions
+      #
+      # @api private
+      # @author Daniel Neighman
+      def self.next_action_name(method, path)
+        last = self::Controller.public_instance_methods.grep(%r[#{method}_\d+]).sort.reverse.first
+        next_method = 0
+        unless last.nil?
+          last =~ %r[#{method}_(\d+)]
+          next_method = $1
+        end
+        sprintf("#{method}_%04d_#{sanitize_path(path)}", next_method)
+      end
+
+      # sanitizes a path so it's able to be used as a method name
+      #
+      # @param [String] path - the path to sanitize
+      #
+      # @return [String] the sanitized version of the path safe to use as a method name
+      # @api private
+      # @author Daniel Neighman
+      def self.sanitize_path(path)
+        path.gsub(/\W/, "_")
+      end
+
+    end # Short
+  end # Stacks
+end # Pancake

data/spec/helpers/helpers.rb

@@ -0,0 +1,20 @@
+module Pancake
+  module Spec
+    module Helpers
+      def clear_constants(*classes)
+        classes.flatten.each do |klass|
+          begin            
+            Object.class_eval do
+              remove_const klass
+            end
+          rescue => e
+          end
+        end
+      end # clear_constnat3
+      
+      def env_for(path = "/", opts = {})
+        Rack::MockRequest.env_for(path, opts)
+      end
+    end # Helpers
+  end # Spec
+end # Pancake

data/spec/helpers/matchers.rb

@@ -0,0 +1,25 @@
+module Pancake
+  module Matchers
+    
+    class InheritFrom
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(target)
+        @target = target
+        @target.ancestors.include?(@expected)
+      end
+      
+      def failure_message
+        "expected #{@target} to inherit from #{@expected} but did not"
+      end
+    end
+    
+    def inherit_from(expected)
+      InheritFrom.new(expected)
+    end
+    
+    
+  end # Matchers
+end # Pancake

data/spec/pancake/bootloaders_spec.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Pancake::Stack::BootLoader" do
+  
+  before(:each) do
+    $captures = []
+    
+    class ::FooStack < Pancake::Stack
+      roots << File.join(Pancake.get_root(__FILE__), "..", "fixtures", "foo_stack")
+    end
+  end
+  
+  after(:each) do
+    clear_constants(:FooStack)
+  end
+  
+  it "should not add the bootloader without it having a run! method" do
+    lambda do
+      FooStack::BootLoader.add(:foo){|s,c| :here }
+    end.should raise_error
+  end
+  
+  it "should allow me to add an application specific BootLoader" do
+    FooStack::BootLoader.add(:my_initializer){ def run!; :foo; end}  
+    FooStack::BootLoader[:my_initializer].call({}).should == :foo
+  end
+  
+  it "should provide a bootloader instance" do
+    FooStack::BootLoader.add(:my_initializer){ def run!; :foo; end}
+    FooStack::BootLoader[:my_initializer].should inherit_from(Pancake::BootLoaderMixin::Base)
+  end
+  
+  it "should allow me to add multiple boot loaders" do
+    FooStack::BootLoader.add(:foo){ def run!; :foo; end}
+    FooStack::BootLoader.add(:bar){ def run!; :bar; end}
+    FooStack::BootLoader[:foo].call({}).should == :foo
+    FooStack::BootLoader[:bar].call({}).should == :bar
+  end
+  
+  it "should allow me to add a bootloader before another" do
+    $captures.should be_empty
+    FooStack::BootLoader.add(:foo){ def run!; $captures << :foo; end}
+    FooStack::BootLoader.add(:bar){ def run!; $captures << :bar; end}
+    FooStack::BootLoader.add(:baz, :before => :bar){ def run!; $captures << :baz; end}
+    FooStack.new
+    $captures.should == [:foo, :baz, :bar]
+  end
+  
+  it "should allow me to add a bootloader after another" do
+    $captures.should be_empty
+    FooStack::BootLoader.add(:foo){ def run!; $captures << :foo; end}
+    FooStack::BootLoader.add(:bar){ def run!; $captures << :bar; end}
+    FooStack::BootLoader.add(:baz, :after => :foo){ def run!; $captures << :baz; end}
+    FooStack.new
+    $captures.should == [:foo, :baz, :bar]
+  end
+  
+  it "should provide an arbitrarily complex setup" do
+    $captures.should be_empty
+    FooStack::BootLoader.add(:foo                       ){ def run!; $captures << :foo; end}
+    FooStack::BootLoader.add(:bar                       ){ def run!; $captures << :bar; end}
+    FooStack::BootLoader.add(:baz,    :after  => :foo   ){ def run!; $captures << :baz; end}
+    FooStack::BootLoader.add(:paz,    :before => :baz   ){ def run!; $captures << :paz; end}
+    FooStack::BootLoader.add(:fred,   :before => :bar   ){ def run!; $captures << :fred; end}
+    FooStack::BootLoader.add(:barney, :after  => :fred  ){ def run!; $captures << :barney; end}
+    
+    FooStack.new
+    $captures.should == [:foo, :paz, :baz, :fred, :barney, :bar]
+  end
+  
+  describe "types" do
+  
+    it "should run bootloaders marked as :init" do
+      FooStack::BootLoader.add(:bar, :level => :init ){ def run!; $captures << [:bar, :init   ]; end}
+      FooStack::BootLoader.add(:baz, :level => :init ){ def run!; $captures << [:baz, :init   ]; end}
+      FooStack::BootLoader.add(:paz, :level => :init, :before => :baz){ def run!; $captures << [:paz, :init]; end}
+      
+      FooStack::BootLoader.run!(:only => {:level => :init})
+      $captures.should == [[:bar, :init], [:paz, :init], [:baz, :init]]
+    end
+    
+    it "should run init or then default level bootloaders individually" do
+      FooStack::BootLoader.add(:foo                  ){ def run!; $captures << [:foo, :default]; end}
+      FooStack::BootLoader.add(:grh                  ){ def run!; $captures << [:grh, :default]; end} 
+      FooStack::BootLoader.add(:bar, :level => :init ){ def run!; $captures << [:bar, :init   ]; end}
+      FooStack::BootLoader.add(:ptf, :before => :grh ){ def run!; $captures << [:ptf, :default]; end} 
+      FooStack::BootLoader.add(:baz, :level => :init ){ def run!; $captures << [:baz, :init   ]; end}
+      FooStack::BootLoader.add(:paz, :level => :init, :before => :baz){ def run!; $captures << [:paz, :init]; end}
+      
+      FooStack.new
+      $captures.should == [[:bar, :init], [:paz, :init], [:baz, :init], [:foo, :default], [:ptf, :default], [:grh, :default]]
+    end
+    
+    it "should inherit from the default boot loaders" do
+      ::Pancake::Stack::BootLoader.add(:default_boot_loader_test){def run!; end}
+      class ::Bario < Pancake::Stack; end
+      Bario::BootLoader.map{|n,bl| n}.should include(:default_boot_loader_test)
+    end
+    
+    it "should let me pass options to the bootloaders and pass them on" do
+      FooStack::BootLoader.add(:foo){ def run!; config[:result] << :foo; end}
+      FooStack::BootLoader.add(:bar){ def run!; config[:result] << :bar; end}
+      
+      opts = { :result => [] }
+      FooStack.new(nil, opts)
+      opts[:result].should == [:foo, :bar]
+    end
+  end
+end