pancake 0.1.8

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Daniel Neighman
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,95 @@
+__This read me is getting thrown to get there in little bits of time snatched between other bits of snatched time... it will be magnificient, eventually... please bare with it...__
+
+h3. Whats this then
+
+A tool for making pancake stacks. Where, as you know, pancake == ruby web thing.
+
+It essentially takes the awesome "rack":rack.github.com and "rack router":http://github.com/carllerche/rack-router/ and mixes it with flour and water and eggs to bind it together into a pancake thin layer of goodness providing a structured way of orgnaising (stacking) your assortment of ruby web things. In doing so, it  allows you to provide each of your ruby web things (lets call them "middlewares") with some underlying contextual functionality.
+
+h3. Why stack pancakes?
+
+Well, simply put, reuse! I'm building something... and what do you know i need another forum/asset manager/bla thing etc. Typically I can:
+
+  * Write/include the functionality directly in to my current app.
+  * Add a second app, theme it up similarly and use apache/nginx/other configs to glue it up, and perhaps come up with a devious approach for auth with some cunning SSO... or not
+
+What we'd like to facilitate with pancake is you take your existing much loved forum/asset manager/bla thing etc and mount it into pancake, sharing auth and other contextual information between apps.
+
+Insert helpful diagram here...
+
+h3. Getting Started
+
+h4. You'll need to have installed (as well as your usual ruby stuffs)...
+
+* wycats-thor 
+* Carllerches rack router
+
+h4. Installing
+
+<pre>
+  $sudo gem install hassox-pancake
+</pre>
+
+h4. Create your own stack
+
+<pre>
+  $pancake-gen stack yummy-app
+</pre>
+
+h4. Does it work?
+
+(I've used curl here, feel free to use your point your browser to http://localhost:9292/ instead)
+<pre>
+  $cd yummy-app/lib/yummy-app
+  $rackup config.ru
+  Loading Development Environment
+</pre>
+
+Now in your browser, visit http://localhost:9292/
+Or, with curl like here:
+<pre>
+  $curl -I localhost:9292
+  127.0.0.1 - - [26/Jul/2009 15:42:55] "HEAD / HTTP/1.1" 404 9 0.0011
+  HTTP/1.1 404 Not Found
+  Connection: close
+  Date: Sun, 26 Jul 2009 05:42:55 GMT
+  Content-Type: text/plain
+  Content-Length: 9
+</pre>
+
+You should see 'NOT FOUND' in your browser window and something like this appear in your rackup console window.
+
+<pre>
+  127.0.0.1 - - [26/Jul/2009 15:42:55] "GET / HTTP/1.1" 404 9 0.0011
+</pre>
+
+That 404 is good news! The stack is running.. we just haven't cooked any pancakes yet, theres nothing to find. Next step add something...
+
+h4. Routing
+
+Edit config/router.rb with:
+<pre>
+  home = lambda {|e| [200,{"Content-Type" => "text/plain", "Content-Length" => "12"}, "Welcome home" ]}
+  
+  YummyApp.add_routes do |r|
+    r.map "/", :to => home
+  end
+</pre>
+Now, restart the server (^C) and try again:
+<pre>
+  $rackup config.ru
+  Loading Development Environment
+</pre>
+Reload you page and you should see "Welcome home".
+And, in your console window, rack should log the request like so:
+<pre>
+  127.0.0.1 - - [26/Jul/2009 16:16:23] "GET / HTTP/1.1" 200 12 0.0012
+  127.0.0.1 - - [26/Jul/2009 16:16:23] "GET /favicon.ico HTTP/1.1" 200 12 0.0012
+</pre>
+
+h4. Whats next:
+
+Well we don't want to be writing our apps as lambdas jemmied into the router, instead next we start to build stacks, out of other middlewares... merbs, other pancake stacks, some sinatra, more rack ups or what ever.
+
+To be continued...
+

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "pancake"
+    gem.summary = %Q{Eat Pancake Stacks for Breakfast}
+    gem.description = %Q{Eat Pancake Stacks for Breakfast}
+    gem.email = "has.sox@gmail.com"
+    gem.homepage = "http://github.com/hassox/pancake"
+    gem.authors = ["Daniel Neighman"]
+    gem.add_development_dependency "rspec"
+    gem.add_dependency "usher", ">=0.5.5"
+    gem.add_dependency "mynyml-rack-accept-media-types"
+    gem.require_path = 'lib'
+    gem.autorequire = 'pancake'
+    gem.bindir = "bin"
+    gem.executables = %w( pancake-gen )
+    gem.files = %w(LICENSE README.textile Rakefile TODO) + Dir.glob("{lib,spec,bin}/**/{*,.[a-z]*}")
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_opts = %w(--format progress --color)
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pancake #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TODO

@@ -0,0 +1,17 @@
+TODO:
+
+* Add default middleware to the short stack
+* Add a default base template and some default css to the short stack
+* Add a global logger
+* Add some view helpers
+** url, link_to, form_for, form_field_helpers (can we use formtastic), v[:data]
+* Add partial support
+* Add sass support so that a stack can compile sass
+* Add a mechanism for a rake task to be called on the parent and all mounted stacks
+* Add a way to cache public files into the pancake roots public directory
+* Add bundler support
+* Do some introductory posts
+* optimise template lookup
+* Add caching / symlinking option for static middlware to prevent lookup
+* Add a rake task to copy / symlink all mounted apps public files into the public Pancake.public directory
+

data/bin/jeweler

@@ -0,0 +1,19 @@
+#!/opt/local/bin/ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'jeweler' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem 'jeweler', version
+load Gem.bin_path('jeweler', 'jeweler', version)

data/bin/pancake-gen

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'thor'
+require 'thor/runner'
+require 'pancake/generators'
+
+# TODO update for pancake to have a version
+case ARGV.shift
+when "stack"
+  Pancake::Generators::Stack.start
+when "short"
+  Pancake::Generators::Short.start
+when "micro"
+  Pancake::Generators::Micro.start
+else
+  puts "Unknown Generator"
+end

data/bin/rubyforge

@@ -0,0 +1,19 @@
+#!/opt/local/bin/ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'rubyforge' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+version = ">= 0"
+
+if ARGV.first =~ /^_(.*)_$/ and Gem::Version.correct? $1 then
+  version = $1
+  ARGV.shift
+end
+
+gem 'rubyforge', version
+load Gem.bin_path('rubyforge', 'rubyforge', version)

data/lib/pancake/bootloaders.rb

@@ -0,0 +1,180 @@
+require 'set'
+module Pancake
+  module BootLoaderMixin
+    include Enumerable
+    class Base
+      # :api: :public
+      attr_accessor :config
+      
+      # Sets options for the bootloder
+      # By including conditions in the bootloader when you declare it
+      # You can selectively run bootloaders later
+      # :api: private
+      def self.options=(opts={}) # :nodoc:
+        @options = opts
+        @options[:level] ||= :default
+      end
+      
+      # Provides access to the bootloader options
+      # :api: private
+      def self.options # :nodoc:
+        @options ||= {}
+      end
+      
+      def stack
+        raise "No Stack Configured" unless @config[:stack]
+        @config[:stack]
+      end
+      
+      def stack_class
+        raise "No Stack Class Configured" unless @config[:stack_class]
+        @config[:stack_class]
+      end
+      
+      def initialize(config)
+        @config = config
+      end
+      
+      # Creates a new instance and runs it
+      # :api: private
+      def self.call(config)
+        new(config).run!
+      end
+      
+      # Checks the conditions with the options of the bootloader
+      # To see if this one should be run
+      # Only the central bootloaders with the conditions will be checked
+      # :api: private
+      def self.run?(conditions = {}) 
+        opts = options
+        if conditions.keys.include?(:only)
+          return conditions[:only].all?{|k,v| opts[k] == v}
+        end
+        if conditions.keys.include?(:except)
+          return conditions[:except].all?{|k,v| opts[k] != v}
+        end
+        true
+      end
+    end
+    
+    def self.extended(base)
+      base.class_eval do
+        class_inheritable_reader :_bootloaders, :_central_bootloaders, :_bootloader_map
+        @_bootloaders, @_central_bootloaders = {}, []
+        @_bootloader_map = Hash.new{|h,k| h[k] = {:before => [], :after => []}}
+      end
+    end
+    
+    # Provides access to an individual bootloader
+    # :api: public
+    def [](name)
+      _bootloaders[name]
+    end
+    
+    # Add a bootloader.  Inside the block we're inside a class definition.  
+    # Requirements: define a +run!+ method
+    #
+    # Example
+    #   FooStack::BootLoader.add(:foo) do
+    #     def run!
+    #       # stuff
+    #     end
+    #   end
+    # 
+    # :api: public
+    def add(name, opts = {}, &block)
+      _bootloaders[name] = Class.new(Pancake::BootLoaderMixin::Base, &block)
+      raise "You must declare a #run! method on your bootloader" unless _bootloaders[name].method_defined?(:run!)
+      before = opts[:before]
+      after  = opts[:after]
+      
+      if opts[:level]
+        levels << opts[:level]
+        levels.uniq!
+      end
+      
+      # If there are no before or after keys, add it to the central bootloaders
+      if before
+        _bootloader_map[before][:before] << name
+      elsif after
+        _bootloader_map[after][:after] << name
+      else
+        _central_bootloaders << name unless _central_bootloaders.include?(name)
+      end
+      _bootloaders[name].options = opts
+      _bootloaders[name]
+    end      
+    
+    # Runs the bootloaders in order
+    # :api: private 
+    def run!(options = {}) # :nodoc:
+      unless options.keys.include?(:only) || options.keys.include?(:except)
+        options[:only] = {:level => :default}
+      end
+      conditions = if options[:only]
+        {:only => options.delete(:only)}
+      else
+        {:except => options.delete(:except)}
+      end
+      options[:stack_class] ||= stack
+
+      each(conditions) do |name, bl|
+        bl.call(options)
+      end
+    end
+    
+    # Set the stack that this bootloader is responsible for.
+    # :api: private
+    def stack=(stack) # :nodoc:
+      @stack = stack
+    end
+    
+    # Access to the stack that this bootloader is responsible for
+    # :api: public
+    def stack
+      @stack ||= Object.full_const_get(self.name.split("::")[0..-2].join("::"))
+    end
+    
+    # Resets the bootloaders on the stack
+    # :api: public
+    def reset!
+      _central_bootloaders.clear
+      _bootloaders.clear
+      _bootloader_map.clear
+    end
+    
+    # Yields each bootloader in order along with it's name
+    # 
+    # Example
+    #   FooStack::BootLoader.each do |name, bootloader|
+    #     # do stuff
+    #   end
+    # 
+    # :api: public
+    def each(conditions = {})
+      _map_bootloaders(_central_bootloaders, conditions).each do |n|
+        yield n, _bootloaders[n]
+      end
+    end
+    
+    private
+    # Map out the bootloaders by name to run.
+    # :api: private
+    def _map_bootloaders(*names)
+      conditions = Hash === names.last ? names.pop : {}
+      names.flatten.map do |name|
+        if _bootloaders[name].run?(conditions)
+          r = []
+          r << _map_bootloaders(_bootloader_map[name][:before])
+          r << name
+          r << _map_bootloaders(_bootloader_map[name][:after])
+        end
+      end.flatten.compact
+    end
+    
+    def levels
+      @levels ||= [:default]
+    end
+
+  end # BootLoaders
+end # Pancake

data/lib/pancake/configuration.rb

@@ -0,0 +1,145 @@
+module Pancake
+  class Configuration
+
+    class Base
+      class_inheritable_reader :defaults
+      @defaults = Hash.new{|h,k| h[k] = {:value => nil, :description => ""}}
+
+      # Set a default on the the configuartion
+      class << self
+
+        # Set a default for this configuration class
+        # Provide a field/method name and a value to set this to.
+        # If you don't provide a value, and instead provide a block, then
+        # a proc will be called lazily when requested.
+        #
+        # Example
+        #   config_klass = Pancake::Configuration.make
+        #   config_class.default :foo, :bar, "This foo is a bar"
+        #   config = config_class.new
+        #
+        # :api: public
+        def default(meth, *args, &block)
+          value, description = args
+          if block
+            description = value
+            value = block
+          end
+          defaults[meth][:value]       = value
+          defaults[meth][:description] = description || ""
+        end
+
+        # Provides aaccess to the description for a default setting
+        #
+        # :api: public
+        def description_for(field)
+          defaults.keys.include?(field) ? defaults[field][:description] : ""
+        end
+      end
+
+      # access to the singleton class
+      # :api: private
+      def singleton_class # :nodoc:
+        class << self; self; end
+      end
+
+      # Access to the configuration defaults via the instance.  Defers to the
+      # clas smethod for defaults
+      # :api: public
+      def defaults
+        self.class.defaults
+      end
+
+      # Access to the class descritpion for defaults
+      # :api: public
+      def description_for(field)
+        self.class.description_for(field)
+      end
+
+      # Access to the currently set values for this configuration object
+      # :api: public
+      def values
+        @values ||= {}
+      end
+
+      private
+      def method_missing(name, *args)
+        if name.to_s =~ /(.*?)=$/
+          set_actual_value($1.to_sym, args.first)
+        else
+          if defaults.keys.include?(name) # We don't want to trigger a default value if we're blindly setting it
+            # If the default is a proc, do not cache it
+            case defaults[name][:value]
+            when Proc
+              instance_eval(&defaults[name][:value])
+            else
+              val = defaults[name][:value]
+              val = val.dup rescue val
+              set_actual_value(name, val)
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      # Caches the values via a method rather than going through method_missing
+      # :api: private
+      def set_actual_value(name, val) # :nodoc:
+        singleton_class.class_eval <<-RUBY
+          def #{name}=(val)                               # def foo=(val)
+            values[#{name.inspect}] = val                 #   values[:foo] = val
+          end                                             # end
+
+          def #{name}                                     # def foo
+            values[#{name.inspect}]                       #   values[:foo]
+          end                                             # end
+        RUBY
+        values[name] = val
+      end
+
+    end # Base
+
+    class << self
+
+      # Make a new configuration class
+      # :api: public
+      def make(&block)
+        Class.new(Pancake::Configuration::Base, &block)
+      end
+
+    end # self
+  end # Configuration
+
+  class PancakeConfig < Configuration::Base
+    def stacks(label = nil)
+      @stacks ||=  {}
+      result = label.nil? ? @stacks : @stacks[label]
+      yield result if block_given?
+      result
+    end
+
+    def configs(label = nil)
+      @configs ||= Hash.new do |h,k|
+        if (k.is_a?(Class) || k.is_a?(Module)) && defined?(k::Configuration)
+          h[k] = k::Configuration.new
+        else
+          nil
+        end
+      end
+      result = label.nil? ? @configs : @configs[label]
+      yield result if block_given?
+      result
+    end
+  end
+
+  def self.configuration
+    @configuration ||= PancakeConfig.new
+  end
+
+  def self.reset_configuration
+    @configuration = nil
+  end
+
+end # Pancake
+

data/lib/pancake/constants.rb

@@ -0,0 +1,5 @@
+module Pancake
+  module Constants
+    ENV_LOGGER_KEY = "rack.logger"
+  end
+end

data/lib/pancake/core_ext/class.rb

@@ -0,0 +1,44 @@
+class Class
+  # Taken from extlib but uses a full Marshall.dump rather than just a dup.
+  # This may not work for some data types.  The data must be marshalable to use this method.
+  #
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def deep_copy_class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self == #{self} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar && !ivar.is_a?(Module) && !ivar.is_a?(Numeric) ? Marshal.load(Marshal.dump(ivar)) : ivar
+        end
+      RUBY
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end # unless
+    end # ivars.each
+  end # self.deep_inheritable_reader
+  
+  def deep_copy_class_inheritable_accessor(*ivars)
+    deep_copy_class_inheritable_reader(*ivars)
+    class_inheritable_writer(*ivars)
+  end
+end # Class

data/lib/pancake/core_ext/object.rb

@@ -0,0 +1,22 @@
+class Object
+  extend ::Pancake::Hooks::InheritableInnerClasses
+end
+
+# Vendored from http://eigenclass.org/hiki/instance_exec
+# 2009-06-02
+# Adapted for ruby 1.9 where the method is deinfed on Object
+unless Object.method_defined?(:instance_exec)
+  class Object
+   # Like instace_eval but allows parameters to be passed.
+    def instance_exec(*args, &block)
+      mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+      Object.class_eval{ define_method(mname, &block) }
+      begin
+        ret = send(mname, *args)
+      ensure
+        Object.class_eval{ undef_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+end

data/lib/pancake/core_ext/symbol.rb

@@ -0,0 +1,15 @@
+# Taken from Rails d6b9f8410c990b3d68d1970f1461a1d385d098d7 20090731
+unless :to_proc.respond_to?(:to_proc)
+  class Symbol
+    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+    #
+    #   # The same as people.collect { |p| p.name }
+    #   people.collect(&:name)
+    #
+    #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+    #   people.select(&:manager?).collect(&:salary)
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end

data/lib/pancake/defaults/configuration.rb

@@ -0,0 +1,22 @@
+class Pancake::PancakeConfig
+  default :log_path,        Proc.new{ "log/pancake_#{Pancake.env}.log"}
+  default :log_level,       :info
+  default :log_delimiter,   " ~ "
+  default :log_auto_flush,  true
+  default :log_to_file,     Proc.new{ Pancake.env == "production" }
+  default :log_stream,      Proc.new{ _log_stream }
+
+  def _log_stream
+    if Pancake.configuration.log_to_file
+      log_dir = File.expand_path(File.join(Pancake.root, File.dirname(log_path)))
+      FileUtils.mkdir_p(log_dir)
+      File.join(log_dir, File.basename(log_path))
+    else
+      STDOUT
+    end
+  end
+
+  def reset_log_stream!
+    values.delete(:log_stream)
+  end
+end

data/lib/pancake/defaults/middlewares.rb

@@ -0,0 +1 @@
+Pancake.stack(:logger).use(Pancake::Middlewares::Logger)