hassox-pancake 0.1.6

data/lib/pancake/more/controller/base.rb

@@ -0,0 +1,34 @@
+module Pancake
+  # TODOS:
+  # * Sketch out how action dispatch will work
+  # * What helpers do we need for dealing with different formats?
+  # * What are the different errors that might arise in dispatch? 404 etc.
+  # * Get before and after hooks working. These wrap around all action calls
+  #   by default, so the hooks in extlib aren’t useful. Additionally, the 
+  #   the dispatch step gives us a point to hook in before and after the call.
+  class Controller
+    extend Mixins::Publish
+    
+    def self.call(env)
+      new(env)      
+    end
+    
+    def initialize(env)
+     
+    end
+    
+    # Returns the rack environment
+    def request
+      
+    end
+    
+    # Returns a hash of parameters 
+    def params
+
+    end
+    
+    def render(opts = {})
+      
+    end
+  end # Controller
+end # Pancake

data/lib/pancake/paths.rb

@@ -0,0 +1,218 @@
+module Pancake
+  # Pancake::Paths provides a mixin for path management.
+  # A path consists of a name, and paths + globs, and makes use of the Klass.roots that have been set as
+  # file roots for each path and glob to be applied to.
+  # Each name may have many (path + glob)s, so that many root paths may be added to the same name
+  #
+  # @example Adding Paths:
+  #   class Foo
+  #     extend Pancake::Paths
+  #   end
+  #
+  #   Foo.push_paths(:model, "relative/path/to/models", "**/*.rb")
+  #   Foo.push_paths(:model, "another/path/to/models", "**/*.rb")
+  #   Foo.push_paths(:model, "yet/another")
+  #
+  # This will make available the directory and or full file paths for :model in the order they
+  # were declared.
+  #
+  # When no glob is provided, the glob will be returned as nil
+  #
+  # @example Reading Paths:
+  #   Foo.dirs_for(:model) == ["#{root}/relative/path/to/models", "#{root}/another/path/to/models", "#{root}/yet/another"]
+  #
+  #   Foo.dirs_and_glob_for(:model) == [
+  #     ["#{root}/relative/path/to/models",         "**/*.rb"],
+  #     ["#{root}//another/path/to/models",         "**/*.rb"],
+  #     ["#{root}//yet/another",                    nil]
+  #   ]
+  #
+  #   Foo.paths_for(:model) == [
+  #     ["#{root}/relative/path/to/models",   "/model1.rb"],
+  #     ["#{root}/path/to/models",            "/model2.rb"],
+  #     ["#{root}/path/to/models/sub",        "/model1.rb"],
+  #     ["#{root}/another/path/to/models",    "/model3.rb"]
+  #   ]
+  #
+  # The paths are fully inheritable once they have extended a class.
+  module Paths
+    class NoPathsGiven < ArgumentError; end
+
+    def self.extended(base) #:nodoc:#
+      base.class_eval do
+        deep_copy_class_inheritable_reader :_load_paths, :roots
+        @_load_paths = Dictionary.new
+        @roots = []
+      end
+    end
+
+    # Push a named path and optional glob onto the list of paths associated with <name>
+    #
+    # @param [Symbol]         name  The name to associate with the given path and glob
+    # @param [String, Array]  paths A path or paths to associate with the namd and glob
+    # @param [String, Nil]    glob  The glob to associate with the given path(s) and name
+    #
+    # @example No Glob:
+    #   MyClass.push_paths(:foo, "path/for/foo")
+    #
+    # @example Using a Glob:
+    #   MyClass.push_paths(:foo, "path/for/foo", "**/*.rb")
+    #
+    # @example Using Multiple paths:
+    #   MyClass.push_paths(:foo, ["path/one", "path/two"], "**/*.rb")
+    #
+    # @raise [Pancake::NoPathsGiven] raised when an empty paths array is provided
+    # @author Daniel Neighman
+    # @since 0.1.1
+    # @api public
+    def push_paths(name, paths, glob = nil)
+      paths = [paths].flatten
+      raise NoPathsGiven if paths.blank?
+      _load_paths[name] ||= []
+      _load_paths[name] << [paths, glob]
+    end
+
+    # Provides the directories or raw paths that are associated with a given name.
+    #
+    # @param        [Symbol]    name  The name for the paths group
+    # @param        [Hash]      opts  An options hash
+    # @option opts  [Boolean]   :invert (false) inverts the order of the returned paths
+    #
+    # @example Read Directories:
+    #   MyClass.dirs_for(:models)
+    #
+    # @example Inverted Read:
+    #   MyClass.dirs_for(:models, :invert => true)
+    #
+    # @return [Array] An array of the paths
+    #   Returned in declared order unless the :invert option is set
+    # @api public
+    # @since 0.1.1
+    # @author Daniel Neighman
+    def dirs_for(name, opts = {})
+      if _load_paths[name].blank?
+        []
+      else
+        result = []
+        invert = !!opts[:invert]
+        load_paths = invert ? _load_paths[name].reverse : _load_paths[name]
+        roots.each do |root|
+          load_paths.each do |paths, glob|
+            paths = paths.reverse if invert
+            result << paths.map{|p| File.join(root, p)}
+          end
+        end
+        result.flatten
+      end # if
+    end
+
+    # Provides the list of paths (directories) and the associated globs for a given name.
+    #
+    # @param        [Symbol]    name    The name of the path group
+    # @param        [Hash]      opts    A hash of options
+    # @option opts  [Boolean]   :invert (false) Inverts the order of the paths
+    #
+    # @example
+    #   MyClass.dirs_and_glob_for(:models)
+    #
+    # @return [Array] An array of [path, glob] arrays
+    #   Returned in declared order unless the :invert option is set
+    # @api public
+    # @since 0.1.1
+    # @author Daniel Neighman
+    def dirs_and_glob_for(name, opts = {})
+      if _load_paths[name].blank?
+        []
+      else
+        result = []
+        invert = !!opts[:invert]
+        load_paths = invert ? _load_paths[name].reverse : _load_paths[name]
+        roots.each do |root|
+          load_paths.each do |paths, glob|
+            paths = paths.reverse if invert
+            paths.each do |path|
+              result << [File.join(root, path), glob]
+            end # paths.each
+          end # load_paths.each
+        end # roots.each
+        result
+      end # if
+    end
+
+    # Provides an expanded, globbed list of paths and files for a given name.
+    #
+    # @param        [Symbol]  name    The name of the paths group
+    # @param        [Hash]    opts    An options hash
+    # @option opts  [Boolean] :invert (false) Inverts the order of the returned values
+    #
+    # @example
+    #   MyClass.paths_for(:model)
+    #   MyClass.paths_for(:model, :invert => true)
+    #
+    # @return [Array]
+    #   An array of [path, file] arrays.  These may be joined to get the full path.
+    #   All matched files for [paths, glob] will be returned in declared and then found order unless +:invert+ is true.
+    #   Any path that has a +nil+ glob associated with it will be excluded.
+    #
+    # @api public
+    # @since 0.1.1
+    # @author Daniel Neighman
+    def paths_for(name, opts = {})
+      result = []
+      dirs_and_glob_for(name, opts).each do |path, glob|
+        next if glob.nil?
+        paths = Dir[File.join(path, glob)]
+        paths = paths.reverse if opts[:invert]
+        paths.each do |full_path|
+          result << [path, full_path.gsub(path, "")]
+        end
+      end
+      result
+    end
+
+    # Provides an expanded, globbed list of paths and files for a given name.
+    # The result includes only the last matched file of a given sub path and name.
+    #
+    # @param        [Symbol]    name    The name of the paths group
+    # @param        [Hash]      opts    An options hash
+    # @option opts  [Boolean]   :invert (false) Inverts the order of returned paths and files
+    #
+    # @example
+    #   #Given the following:
+    #   #  /path/one/file1.rb
+    #   #  /path/one/file2.rb
+    #   #  /path/two/file1.rb
+    #
+    #     MyClass.push_path(:files, ["/path/one", "/path/two"], "**/*.rb")
+    #
+    #   MyClass.unique_paths_for(:files)
+    #   MyClass.unique_paths_for(:files, :invert => true)
+    #
+    # @return [Array]
+    #   Returns an array of [path, file] arrays
+    #   Results are retuned in declared order.  Only unique files are returned (the file part - the path)
+    #   In the above example, the following would be returned for the standard call
+    #     [
+    #       ["#{root}/path/one", "/file2.rb"],
+    #       ["#{root}/path/two", "/file1.rb"]
+    #     ]
+    #   For the inverted example the following is returned:
+    #     [
+    #       ["#{root}/path/one/file2.rb"],
+    #       ["#{root}/path/one/file1.rb"]
+    #     ]
+    #
+    # @api public
+    # @since 0.1.1
+    # @author Daniel Neighman
+    def unique_paths_for(name, opts = {})
+      tally = {}
+      output = []
+      paths_for(name, opts).reverse.each do |ary|
+        tally[ary[1]] ||= ary[0]
+        output << ary if tally[ary[1]] == ary[0]
+      end
+      output.reverse
+    end # unique_paths_for
+  end
+end

data/lib/pancake/router.rb

@@ -0,0 +1,99 @@
+module Pancake
+  # Get the ability to mark this as a consuming route.
+  class ::Usher::Route
+    attr_accessor :consuming
+  end
+
+  # Generate a url for any pancake configuration that has a router
+  #
+  # @example
+  #   Pancake.url(UserManamgent, :login) # => "/users/login"
+  # @api public
+  def self.url(app_name, name_or_opts, opts = {})
+    config = Pancake.configuration.configs(app_name)
+    the_router = if config && config.router
+      config.router
+    elsif app_name.respond_to?(:router)
+      app_name.router
+    else
+      raise Pancake::Errors::UnknownRouter
+    end
+    the_router.url(name_or_opts, opts)
+  end
+  
+  # The pancake router is a customized version of the Usher router.
+  # Usher is a fast tree based router that can generate routes, have
+  # nested routers, and even generate from nested routers.
+  # @see http://github.com/joshbuddy/usher
+  # @since 0.1.2
+  # @author Daniel Neighman
+  class Router < Usher::Interface::RackInterface
+    CONFIGURATION_KEY = "pancake.request.configuration".freeze
+    
+    class RackApplicationExpected < ArgumentError; end
+    attr_accessor :configuration
+    
+    # Mounts an application in the router as a sub application in the
+    # url space.  This will route directly to the sub application and
+    # skip any middlewares etc.
+    def mount(mounted_app, path, options = {})
+      raise RackApplicationExpected unless mounted_app.respond_to?(:call)
+      exact_match = options.delete(:_exact)
+      route = add(path, options)
+      route.consuming = true
+      route.match_partially! unless exact_match
+      route.to(mounted_app)
+    end
+
+    # Adds a route to the router.
+    # @see Usher::Interface::RackInterface#add
+    def add(path, opts = {}, &block)
+      opts = cooerce_options_to_usher(opts)
+      route = super(path, opts)
+      if block_given?
+        route.to(block)
+      end
+      route
+    end
+    
+    # Generate a url
+    def url(name_or_path, options = {})
+      if Hash === name_or_path
+        name = nil
+        options = name_or_path
+      else
+        name = name_or_path
+      end
+      generate(name, options)
+    end
+
+    def call(env)
+      orig_config = env[CONFIGURATION_KEY]
+      env[CONFIGURATION_KEY] = configuration
+      super(env)
+    ensure
+      env[CONFIGURATION_KEY] = orig_config
+    end
+    
+    private
+    # Canoodles the options into a format that usher is happy to
+    # accept.  This is so that we can have a different interface from
+    # the raw usher when we're first declaring the route.
+    # @api private
+    def cooerce_options_to_usher(opts)
+      defaults = opts.delete(:_defaults)
+      opts[:default_values] ||= {}
+      opts[:default_values].merge!(defaults) if defaults
+      opts
+    end
+
+    # Overwrites the method in Rack::Interface::RackInterface to mash
+    # the usher.params into the rack request.params
+    # @api private
+    def after_match(request, response)
+      super
+      consume_path!(request, response) if !response.partial_match? && response.path.route.consuming
+      request.params.merge!(request.env['usher.params']) unless request.env['usher.params'].empty?
+    end
+  end
+end

data/lib/pancake/stack/app.rb

@@ -0,0 +1,10 @@
+module Pancake
+  class Stack
+    # get a new instance of the application for this stack
+    # Ovewrite this to provide custom application initialization
+    # :api: overwritable
+    def self.new_app_instance
+      MISSING_APP
+    end
+  end # Pancake
+end # Pancake

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