pancake 0.1.8

data/lib/pancake/stack/bootloader.rb

@@ -0,0 +1,79 @@
+module Pancake
+  class Stack
+    inheritable_inner_classes :BootLoader
+
+    # The default bootloader is where the stack default bootloaders are stored
+    # These are shared across all bootloaders
+    class BootLoader # :nodoc:
+      extend ::Pancake::BootLoaderMixin
+    end
+
+  end # Stack
+end # Pancake
+
+#################### Define the bootloaders here #############################
+# :level => :init bootloaders only have the stack class available
+# They do not have :stack available
+# These are not run directly, but are run from inherited stacks
+Pancake::Stack::BootLoader.add(:mount_applications, :level => :init) do
+  def run!
+    # Mount any stacks this stack may have in it.
+    stack_class.roots.each do |root|
+      Dir["#{root}/mounts/*/pancake.init"].each{|f| load f if File.exists?(f)}
+    end
+  end
+end
+
+Pancake::Stack::BootLoader.add(:load_configuration, :level => :init) do
+  def run!
+    stack_class.roots.each do |root|
+      stack_class.paths_for(:config).each{|f| require f.join}
+    end
+  end
+end
+
+Pancake::Stack::BootLoader.add(:load_application, :level => :init) do
+  def run!
+    stack_class.roots.each do |root|
+      [:models, :controllers].each do |type|
+        stack_class.paths_for(type).each{|f| require f.join}
+      end
+    end
+  end
+end
+
+Pancake::Stack::BootLoader.add(:load_routes, :level => :init) do
+  def run!
+    stack_class.roots.each do |root|
+      stack_class.paths_for(:router).each{|f| require f.join}
+    end
+  end
+end
+
+###### -================== Stack Building BootLoaders
+# Pancake stacks need to be built with the following options
+# MyApp::BootLoader.run!({
+#   :stack_class  => self.class,
+#   :stack        => self,
+#   :app          => app,
+#   :app_name     => app_name,
+# })
+#
+#
+
+Pancake::Stack::BootLoader.add(:initialize_application) do
+  def run!
+    config[:app] ||= stack_class.new_app_instance
+  end
+end
+
+Pancake::Stack::BootLoader.add(:build_stack) do
+  def run!
+    mwares = stack_class.middlewares(Pancake.stack_labels)
+    app = Pancake::Middleware.build(config[:app], mwares)
+    app_config = Pancake.configuration.configs(config[:app_name])
+    app_config.app   = app
+    app_config.stack = stack_class
+    app_config.router.configuration = app_config
+  end
+end

data/lib/pancake/stack/configuration.rb

@@ -0,0 +1,44 @@
+module Pancake
+  class Stack
+
+    class Configuration < Pancake::Configuration::Base
+    end
+
+    # Provides access to the configuration block for the stack.
+    # If a block is provided, it opens the specific configuration instances anonymous class
+    # and allows you to edit it.
+    # If no block is provided, it just returns the configuration object.
+    #
+    # :api: public
+    def self.configuration(label = self, &block)
+      config = Pancake.configuration.configs[label] ||= self::Configuration.new
+      config.class.class_eval(&block) if block
+      config
+    end
+
+    def configuration(label = self.class)
+      yield self.class.configuration(label) if block_given?
+      self.class.configuration(label)
+    end
+
+  end # Stack
+end # Pancake
+
+####################
+# Setup the default configuration for each stack
+class Pancake::Stack::Configuration
+  default :router, lambda{ _router }, "The router for this stack"
+  
+  def _router
+    @_router ||= begin
+      unless stack.nil?
+        r = stack.router.dup
+        r.configuration = self
+        r.app = app
+        r.configuration = self
+        r
+      end
+                   
+    end
+  end
+end

data/lib/pancake/stack/router.rb

@@ -0,0 +1,21 @@
+module Pancake
+  class Stack
+    class Router < Pancake::Router; end
+    inheritable_inner_classes :Router
+
+    class_inheritable_accessor :_router
+    @_router = self::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,66 @@
+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
+
+    # Adds the file to the stack root.
+    #
+    # @param file - The file identifier
+    # @example
+    #   MyStack.add_root(__FILE__) # in a file in the root of the stack
+    def self.add_root(*args)
+      roots << Pancake.get_root(*args)
+    end
+
+    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/bootloaders.rb

@@ -0,0 +1,13 @@
+Pancake::Stacks::Short::BootLoader.add(:paths) do
+  def run!
+    stack_class.push_paths :public, "public"
+
+    stack_class::Controller.push_paths :views, ["app/views", "views"], "**/*"
+  end
+end
+
+Pancake::Stacks::Short::BootLoader.add(:default_middlewares, :before => :build_stack) do
+  def run!
+    stack_class.stack(:static_files).use(Pancake::Middlewares::Static, stack_class)
+  end
+end

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

@@ -0,0 +1,116 @@
+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
+
+
+        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"]
+
+          if logger
+            logger.info "Request: #{request.path}"
+            logger.info "Params: #{params.inspect}"
+          end
+
+          # 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
+
+          logger.info "Dispatching to #{params["action"].inspect}" if logger
+
+          # set the response header
+          headers["Content-Type"] = ct
+          Rack::Response.new(self.send(params["action"]), status, headers).finish
+
+        rescue Errors::HttpError => e
+          if logger
+            logger.error "Exception: #{e.message}"
+            logger.error e.backtrace.join("\n")
+          end
+          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)
+          raise error unless Pancake.handle_errors?
+          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/default/views/base.html.haml

@@ -0,0 +1,5 @@
+!!!
+%html
+  %body
+    -content_block :content do
+      %h1 Welcome to Pancake!

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

@@ -0,0 +1,187 @@
+module Pancake
+  module Stacks
+    class Short < Pancake::Stack
+      add_root(__FILE__, "default")
+
+      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 Usher 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 Usher
+      # @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 Usher 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 Usher
+      # @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 Usher 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 Usher
+      # @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 Usher 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 Usher
+      # @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 = controller_method_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__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
+        r = router.add(path, options)
+        r.name(name) if name
+        r
+      end
+
+      # provides for methods of the following form on Controller
+      #   :<method>_<sanitized_path>
+      #
+      # @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 actual controller method name to use for the action
+      #
+      # @api private
+      # @author Daniel Neighman
+      def self.controller_method_name(method, path)
+        "#{method}_#{sanitize_path(path)}"
+      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/lib/pancake/stacks/short.rb

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

data/lib/pancake.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'extlib/class'
+require 'extlib/boolean'
+require 'extlib/module'
+require 'extlib/nil'
+require 'extlib/numeric'
+require 'extlib/object'
+require 'extlib/symbol'
+require 'extlib/blank'
+require "extlib/dictionary"
+require 'extlib/logger'
+require 'usher'
+require 'usher/interface/rack_interface'
+require 'tilt'
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+module Pancake
+  autoload    :Logger,    "pancake/logger"
+  autoload    :Constants, "pancake/constants"
+
+  module Stacks
+    autoload :Short,      "pancake/stacks/short"
+  end
+
+  module Mixins
+    autoload :Publish,      "pancake/mixins/publish"
+    autoload :Render,       "pancake/mixins/render"
+    autoload :StackHelper, "pancake/mixins/stack_helper"
+  end
+
+  module Middlewares
+    autoload :Static,       "pancake/middlewares/static"
+    autoload :Logger,     "pancake/middlewares/logger"
+  end
+end
+
+require 'pancake/paths'
+require 'pancake/hooks/on_inherit'
+require 'pancake/hooks/inheritable_inner_classes'
+require 'pancake/core_ext/class'
+require 'pancake/core_ext/object'
+require 'pancake/core_ext/symbol'
+require 'pancake/configuration'
+require 'pancake/bootloaders'
+require 'pancake/mime_types'
+require 'pancake/middleware'
+require 'pancake/router'
+require 'pancake/master'
+require 'pancake/errors'
+require 'pancake/stack/stack'
+require 'pancake/stack/configuration'
+require 'pancake/stack/router'
+require 'pancake/stack/bootloader'
+require 'pancake/stack/app'
+require 'pancake/mixins/request_helper'
+require 'pancake/defaults/middlewares'
+require 'pancake/defaults/configuration'

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