short_stack 0.1.1

data/lib/pancake/generators/templates/short/%stack_name%/VERSION.tt

@@ -0,0 +1 @@
+0.0.0

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%.rb.tt

@@ -0,0 +1,14 @@
+require 'short_stack'
+require 'haml'
+
+class <%= ActiveSupport::Inflector.camelize(stack_name) %> < ShortStack
+  add_root(__FILE__, "<%= stack_name %>")
+
+  # Hook to use before we mount any applications
+  # before_mount_applications do
+  # end
+
+  initialize_stack
+end
+
+require ::File.join(Pancake.get_root(__FILE__, "<%= stack_name %>"), "<%= stack_name %>")

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/%stack_name%.rb.tt

@@ -0,0 +1,6 @@
+class <%= ActiveSupport::Inflector.camelize(stack_name) %>
+  get "/" do
+    render :root
+  end
+end
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config.ru.tt

@@ -0,0 +1,11 @@
+require 'pancake'
+require ::File.join(::File.expand_path(::File.dirname(__FILE__)), "..", "<%= stack_name %>")
+
+# get the application to run.  The application in the Pancake.start block
+# is the master application.  It will have all requests directed to it through the
+# pancake middleware
+# This should be a very minimal file, but should be used when any stand alone code needs to be included
+<%= ActiveSupport::Inflector.camelize(stack_name) %>.include_pancake_stack!
+app = Pancake.start(:root => Pancake.get_root(__FILE__)){ <%= ActiveSupport::Inflector.camelize(stack_name) %>.stackup(:master => true) }
+
+run app

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/config.rb.tt

@@ -0,0 +1,23 @@
+# Enter any global configuration for the stack in this file.
+<% klass_name = ActiveSupport::Inflector.camelize(stack_name) %>
+class <%= klass_name %>
+  # include middleware for the development stack
+  # Labels can be set in the config/environments/<env>.rb file to limit
+  # middleware loading.
+  # stack(:middleware_name, :labels => [:development, :production]).use(MiddlewareClass)
+
+  class self::Configuration
+    # Add defaults to your stack configuration.
+    # This is scoped to this stack, and is inhertied into child stacks
+    #
+    # Fixed value defaults:
+    #   default :var_name, :value, "A description of the variable"
+    #
+    # Lazy Defaults:
+    #   default :var_name, lambda{ configuration_method }, "Some Description"
+
+    # Declare methods on your configuraiton
+    # def configuration_method; #stuff; end
+  end
+end
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/development.rb.tt

@@ -0,0 +1,15 @@
+Pancake.logger.info "Loading Development Environment"
+
+# Pancake.handle_errors!(true) # uncomment to have the stack handle any errors that occur
+
+class <%= ActiveSupport::Inflector.camelize(stack_name) %>
+  # include middleware for the development stack
+  # stack(:middleware_name).use(MiddlewareClass)
+end
+
+# Add code to hooks.  Default available hooks:
+# :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
+
+# <%= ActiveSupport::Inflector.camelize(stack_name) %>.before_build_stack do
+#   # stuff to do
+# end

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/production.rb.tt

@@ -0,0 +1,16 @@
+Pancake.logger.info "Loading Production Environment"
+
+Pancake.handle_errors!(true) # uncomment to have the stack handle any errors that occur
+<% klass_name = ActiveSupport::Inflector.camelize(stack_name) %>
+class <%= klass_name %>
+  # include middleware for the development stack
+  # stack(:middleware_name).use(MiddlewareClass)
+end
+
+# Add code to hooks.  Default available hooks:
+# :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
+
+# <%= klass_name %>.before_build_stack do
+#   # stuff to do
+# end
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/config/environments/staging.rb.tt

@@ -0,0 +1,15 @@
+Pancake.logger.info "Loading Staging Environment"
+
+Pancake.handle_errors!(true) # uncomment to have the stack handle any errors that occur
+<% klass_name = ActiveSupport::Inflector.camelize(stack_name) %>
+class <%= klass_name %>
+  # include middleware for the development stack
+  # stack(:middleware_name).use(MiddlewareClass)
+end
+
+# Add code to hooks.  Default available hooks:
+# :before_build_stack, :before_mount_applications, :after_initialize_application, :after_build_stack
+
+# <%= klass_name %>.before_build_stack do
+#   # stuff to do
+# end

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/tasks/%stack_name%.rake.tt

@@ -0,0 +1,4 @@
+namespace :<%= stack_name %> do
+  # Create your tasks here
+end
+

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/views/layouts/application.html.haml

@@ -0,0 +1,5 @@
+!!!5
+
+%html
+  %body
+    = yield

data/lib/pancake/generators/templates/short/%stack_name%/lib/%stack_name%/views/root.html.haml

@@ -0,0 +1,2 @@
+- inherits_from :base
+

data/lib/pancake/generators/templates/short/%stack_name%/pancake_init.rb.tt

@@ -0,0 +1 @@
+require ::File.join(::File.expand_path(::File.dirname(__FILE__)), "lib", "<%= stack_name %>")

data/lib/pancake/generators/templates/short/%stack_name%/spec/%stack_name%_spec.rb.tt

@@ -0,0 +1,11 @@
+require ::File.expand_path(::File.dirname(__FILE__) + '/spec_helper')
+
+describe <%= ActiveSupport::Inflector.camelize(stack_name) %> do
+  def app
+    <%= stack_name %>.stackup
+  end
+
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/lib/pancake/generators/templates/short/%stack_name%/spec/spec_helper.rb.tt

@@ -0,0 +1,13 @@
+require 'spec'
+require 'rack/test'
+require 'pancake'
+
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require '<%= stack_name -%>'
+
+Spec::Runner.configure do |config|
+  config.include(Rack::Test::Methods)
+  config.include(Pancake::Test::Matchers)
+end

data/lib/short_stack.rb

@@ -0,0 +1,213 @@
+require 'pancake'
+require 'short_stack/middleware'
+require 'short_stack/controller'
+
+class ShortStack < Pancake::Stack
+  add_root(__FILE__, "short_stack/default")
+
+  push_paths(:models,"models", "**/*.rb")
+
+  # Make sure that the stack has been initialized
+  # Before we inherit any children.
+  # Otherwise they might not be loaded yet
+  before_inner_class_inheritance do |parent|
+    parent.initialize_stack
+  end
+
+  def self.new_endpoint_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
+
+  def self.helpers(&blk)
+    m = Module.new(&blk)
+    self::Controller.class_eval{ include m }
+  end
+
+  def self.template(*args)
+    self::Controller.template(*args)
+  end
+
+  def self.base_template_name
+    self::Controller.base_template_name
+  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
+
+  # Matches any method to the route
+  # @api public
+  def self.any(path, opts={}, &block)
+    define_published_action(:any, 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)
+    r = router.add(path, options)
+    r.send(method) unless method == :any
+    r.name(name) if name
+    r.to(:action => action_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 # ShortStack
+

data/lib/short_stack/controller.rb

@@ -0,0 +1,185 @@
+class ShortStack < Pancake::Stack
+  inheritable_inner_classes :Controller
+
+  class Controller
+    extend  Pancake::Mixins::Publish
+    include Pancake::Mixins::Render
+    include Pancake::Mixins::RequestHelper
+    include Pancake::Mixins::ResponseHelper
+    include Pancake::Mixins::StackHelper
+
+    inheritable_inner_classes :ViewContext
+
+    class self::ViewContext
+      include Pancake::Mixins::RequestHelper
+      include AnyView
+
+      # No way to get the env into the view context... this is not good :(
+      def env
+        _view_context_for.env
+      end
+
+      def self.template(name_or_template, opts = {})
+        opts[:format] ||= content_type
+        super
+      end
+
+      def template(name_or_template, opts={})
+        opts[:format] ||= content_type
+        super
+      end
+
+      def _template_name_for(name, opts = {})
+        opts[:format] ||= :html
+        "#{name}.#{opts[:format]}"
+      end
+    end
+
+    extlib_inheritable_accessor :_handle_exception
+
+    push_paths(:views, ["app/views", "views"], "**/*")
+
+    DEFAULT_EXCEPTION_HANDLER = lambda do |error|
+      if layout = env['layout']
+        layout.content = render :error, :error => error
+        layout
+      else
+        render :error, :error => error
+      end
+    end unless defined?(DEFAULT_EXCEPTION_HANDLER)
+
+    # @api private
+    def self.call(env)
+      app = new(env)
+      app.dispatch!
+    end
+
+    def layout
+      env['layout']
+    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
+
+    attr_writer :action
+    def action
+      @action ||=  begin
+        rr = request.env['router.response']
+        action = rr && rr.dest && rr.dest[:action]
+      end
+    end
+
+    # Dispatches to an action based on the params["action"] parameter
+    def dispatch!
+      if logger
+        logger.info "Request: #{request.path}"
+        logger.info "Params: #{params.inspect}"
+      end
+
+
+      # Check that the action is available
+      raise Pancake::Errors::NotFound, "No Action Found" unless allowed_action?(action)
+
+      @action_opts  = actions[action]
+
+      negotiate_content_type!(@action_opts.formats, params)
+
+      # Set the layout defaults before the action is rendered
+      if layout && stack_class.default_layout
+        layout.template_name = stack_class.default_layout
+      end
+
+      layout.format = params['format'] if layout
+
+      logger.info "Dispatching to #{action.inspect}" if logger
+
+      result = catch(:halt){ self.send(action) }
+
+      case result
+      when Array
+        result
+      when Rack::Response
+        result.finish
+      when String
+        out = if layout
+          layout.content = result
+          layout
+        else
+          result
+        end
+        Rack::Response.new(out, status, headers).finish
+      else
+        Rack::Response.new((result || ""), status, headers).finish
+      end
+
+    rescue Pancake::Errors::HttpError => e
+      if logger && log_http_error?(e)
+        logger.error "Exception: #{e.message}"
+        logger.error e.backtrace.join("\n")
+      end
+      handle_request_exception(e)
+    rescue Exception => e
+      if Pancake.handle_errors?
+        server_error = Pancake::Errors::Server.new(e.message)
+        server_error.exceptions << e
+        server_error.set_backtrace e.backtrace
+      else
+        server_error = e
+      end
+      handle_request_exception(server_error)
+    end
+
+    def log_http_error?(error)
+      true
+    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.class, error.message, error.backtrace) 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 self._template_name_for(name, opts)
+      opts[:format] ||= :html
+      [
+        "#{name}.#{opts[:format]}",
+        "#{name}"
+      ]
+    end
+
+    def _tempate_name_for(name, opts = {})
+      opts[:format] ||= content_type
+      self.class._template_name_for(name, opts)
+    end
+  end # Controller
+end # Short