hassox-pancake 0.1.6

data/lib/pancake/configuration.rb

@@ -0,0 +1,140 @@
+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
+
+end # Pancake

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/errors.rb

@@ -0,0 +1,61 @@
+module Pancake
+  module Errors
+    class HttpError < StandardError
+      class_inheritable_accessor :name, :code, :description
+
+      def name; self.class.name; end
+
+      def code; self.class.code; end
+
+      def description; self.class.description; end
+    end
+    
+    class NotFound < HttpError
+      self.name = "Not Found"
+      self.code = 404
+      self.description = "The requested resource could not be found but may be available again in the future."
+    end
+
+    class UnknownRouter < NotFound
+      self.description = "The router could not be found"
+    end
+    
+    class UnknownConfiguration < NotFound
+      self.description = "The configuration could not be found"
+    end
+        
+     class Unauthorized < HttpError
+       self.name = "Unauthorized"
+       self.code = 401
+       self.description = "Authentication is required to access this resource."
+     end
+     
+     class Forbidden < HttpError
+       self.name = "Forbidden"
+       self.code = 403
+       self.description = "Access to this resource is denied."
+     end
+
+     class Server < HttpError
+       attr_accessor :exceptions
+
+       self.name = "Server Error"
+       self.code = 500
+       self.description = "An internal server error"
+
+       def initialize(*args)
+         super
+         @exceptions = []
+       end
+     end
+
+     class NotAcceptable < HttpError
+       self.name =  "Not Acceptable"
+       self.code = 406
+       self.description = "The requeseted format could not be provided"
+     end
+     
+       
+     
+  end
+end

data/lib/pancake/generators.rb

@@ -0,0 +1,8 @@
+require 'thor'
+require 'extlib'
+
+require File.join(File.dirname(__FILE__), "generators", "base.rb")
+
+Dir[File.join(File.dirname(__FILE__), "generators", "*.rb")].each do |f|
+ require f unless f == 'base.rb'
+end

data/lib/pancake/generators/base.rb

@@ -0,0 +1,12 @@
+module Pancake
+  module Generators
+    class Base < Thor::Group
+      include Thor::Actions
+      
+      def self.source_root
+        File.join(File.dirname(__FILE__), "templates")
+      end
+      
+    end
+  end
+end

data/lib/pancake/generators/flat_generator.rb

@@ -0,0 +1,17 @@
+module Pancake
+  module Generators
+    class Flat < Base
+      argument :stack_name, :banner => "Name of stack"
+      
+      desc "Generates a stack"
+      def stack
+        say "Creating The Stack For #{stack_name}"
+        directory "flat/%stack_name%", stack_name
+        template  File.join(self.class.source_root, "common/dotgitignore"), "#{stack_name}/.gitignore"
+        template  File.join(self.class.source_root, "common/dothtaccess"),  "#{stack_name}/public/.htaccess"
+      end
+       
+       
+    end
+  end
+end

data/lib/pancake/generators/short_generator.rb

@@ -0,0 +1,17 @@
+module Pancake
+  module Generators
+    class Short < Base
+      argument :stack_name, :banner => "Name of stack"
+      
+      desc "Generates a short stack"
+      def stack
+        say "Creating The Short Stack For #{stack_name}"
+        directory "short/%stack_name%", stack_name
+        template  File.join(self.class.source_root, "common/dotgitignore"), "#{stack_name}/.gitignore"
+        template  File.join(self.class.source_root, "common/dothtaccess"),  "#{stack_name}/lib/#{stack_name}/public/.htaccess"
+      end
+       
+       
+    end
+  end
+end

data/lib/pancake/generators/stack_generator.rb

@@ -0,0 +1,17 @@
+module Pancake
+  module Generators
+    class Stack < Base
+      argument :stack_name, :banner => "Name of stack"
+      
+      desc "Generates a stack"
+      def stack
+        say "Creating The Stack For #{stack_name}"
+        directory "stack/%stack_name%", stack_name
+        template  File.join(self.class.source_root, "common/dotgitignore"), "#{stack_name}/.gitignore"
+        template  File.join(self.class.source_root, "common/dothtaccess"),  "#{stack_name}/lib/#{stack_name}/public/.htaccess"
+      end
+       
+       
+    end
+  end
+end

data/lib/pancake/generators/templates/common/dotgitignore

@@ -0,0 +1,22 @@
+.DS_Store
+log/*
+tmp/*
+TAGS
+*~
+.#*
+schema/schema.rb
+schema/*_structure.sql
+schema/*.sqlite3
+schema/*.sqlite
+schema/*.db
+*.sqlite
+*.sqlite3
+*.db
+src/*
+.hgignore
+.hg/*
+.svn/*
+gems/gems/*/
+gems/specifications/*
+!gems/gems/thor*/
+!gems/specifications/thor*

data/lib/pancake/generators/templates/common/dothtaccess

@@ -0,0 +1,17 @@
+# Sets the default handler for FastCGI scripts
+AddHandler fastcgi-script .fcgi               
+
+# If Apache2 is used together with mod_fcgid,
+# uncomment the line below and comment in the line 
+# above to set the correct script handler
+#AddHandler fcgid-script .fcgi
+
+RewriteEngine On
+
+RewriteRule ^$ index.html [QSA]
+RewriteRule ^([^.]+)$ $1.html [QSA]
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ merb.fcgi [QSA,L]
+
+
+ErrorDocument 500 "<h2>Application Error</h2>Merb could not be reached"

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

@@ -0,0 +1,8 @@
+class <%= stack_name.camel_case %> < Pancake::Stacks::Short
+  roots << Pancake.get_root(__FILE__)
+
+  get "/" do
+    "Welcome to Pancake!"
+  end
+end
+

data/lib/pancake/generators/templates/flat/%stack_name%/.gitignore

@@ -0,0 +1,21 @@
+.DS_Store
+log/*
+TAGS
+*~
+.#*
+schema/schema.rb
+schema/*_structure.sql
+schema/*.sqlite3
+schema/*.sqlite
+schema/*.db
+*.sqlite
+*.sqlite3
+*.db
+src/*
+.hgignore
+.hg/*
+.svn/*
+gems/gems/*/
+gems/specifications/*
+!gems/gems/thor*/
+!gems/specifications/thor*

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

@@ -0,0 +1,12 @@
+require 'rubygems'
+
+require 'pancake'
+require ::File.join(::File.expand_path(::File.dirname(__FILE__)), "<%= stack_name %>")
+
+# get the application to run.  The applicadtion 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
+app = Pancake.start(:root => Pancake.get_root(__FILE__)){ <%= stack_name.camel_case %>.stackup }
+
+run app