hassox-pancake 0.1.6

data/lib/pancake/mixins/publish.rb

@@ -0,0 +1,125 @@
+require File.join(File.dirname(__FILE__), "publish", "action_options")
+module Pancake
+  module Mixins
+    module Publish
+      
+      def self.extended(base)
+        base.class_eval do
+          class_inheritable_accessor :actions, :formats
+          self.actions = {}
+          self.formats = [:html]
+        end
+      end
+    
+      # Accepts a list of symbols representing the formats each action in the
+      # controller will return. By default the list consists only of :html 
+      #
+      #   provides :html, :xml
+      #
+      # @api public
+      def provides(*args)
+        self.formats = args
+      end
+        
+      # Causes the next method added immediately after it’s call to be defined 
+      # as an action. It also generates an instance of ActionOptions, which 
+      # encapsulates all the parameters the action accepts/expects and also
+      # the formats that it can potentially return.
+      #
+      #   publish :id => as_integer(:req)
+      #   def show
+      #     ...
+      #   end
+      #
+      # The example above publishes the action "show" and configures the 
+      # following options for it:
+      #
+      # - The parameter 'id' will be coerced into an Integer
+      # - It also must not be blank, it is required.
+      #
+      # The publish declaration can also create much more sophisticated 
+      # constraints. You can declare a parameter as optional, give it a default
+      # value if it is missing.
+      #
+      # Here, 'start' and 'end' are required — the default — and are coerced into
+      # date values. The 'page' parameter is optional, with the default being 1.
+      #
+      #   publish :start => as_date, :end => as_date :page => as_integer(1)
+      #
+      # For a list of the built in coercions look in the API for methods prefixed
+      # with 'as_'. These are intended to be used in your publish declarations.
+      #
+      # #publish can also handle the specification of formats for an action. It
+      # accepts an additional two options, :provides and :only_provides.
+      #
+      # To the list of globally declared formats, :provides adds additional 
+      # formats to an action.
+      # 
+      #   publish :provides => :xml
+      #
+      # The :only_provides option overrides any globally declared formats for an
+      # action.
+      #
+      #   publish :only_provides => [:json, :xml]
+      #
+      # @api public
+      def publish(opts = {})
+        @pending_publication_opts = opts
+      end
+    
+      # Used when declaring configuration for parameters in the publish
+      # declaration. It returns an array of the type, default value an 
+      # additional options.
+      #
+      # @param type [Object] The
+      #
+      # The current supported types are
+      # - :integer
+      # - :date
+      # - :string
+      #
+      # For details on the options supported by each type, please see the 
+      # corresponding methods declared in the ActionOptions class. These methods
+      # are named as the type, prefixed with 'validate_and_coerce_'
+      #
+      #
+      # @example
+      #   Here is an example where we declare an integer and that it is required
+      #
+      #     as(:integer, :req)
+      #
+      #   Or that it is optional, but has a default value if it is missing.
+      #
+      #     as(:integer, 21)
+      #
+      # @api public
+      def as(type, default = :req, opts = {})
+        [type, default, opts]
+      end
+    
+      # Takes a parameters hash, and validates each entry against the options
+      # defined for this action. It will flag required params when missing, 
+      # insert defaults or coerce values into the desired type. It mutates
+      # the params hash itself.
+      #
+      # @api private
+      def validate_and_coerce_params(action, params)
+        actions[action].validate_and_coerce(params)
+      end
+    
+    
+      # This hook is used in conjunction with the #publish method to expose 
+      # instance methods as actions. Obviously, it should never be called 
+      # directly :)
+      #
+      # @api private
+      def method_added(name)
+        super
+        if @pending_publication_opts
+          self.actions[name.to_s] = ActionOptions.new(formats, @pending_publication_opts)
+          @pending_publication_opts = nil
+        end
+      end
+    end # Publish
+  end # Mixins
+end # Pancake

data/lib/pancake/mixins/publish/action_options.rb

@@ -0,0 +1,104 @@
+module Pancake
+  module Mixins
+    module Publish
+      class ActionOptions
+        attr_reader :params, :formats, :default
+        CONFIG_OPTIONS = [:provides, :only_provides]
+      
+        # Generates a new instance of the class. This instance encapsulates the
+        # options and logic needed to validate the parameters being input into
+        # a controller action. First argument is a list of symbols for the 
+        # formats it supports. The second is hash of options. Typically this 
+        # hash is generated by the publish declaration in a controller.
+        #
+        # TODO: Allow params to be grouped together
+        #
+        # @api private
+        def initialize(default_formats, opts)
+         # Extract the params — excluding configuration — and turn the keys into
+         # strings. Additionally, check to see if someone has passed in a a raw
+         # value rather than using one of our as_* methods.
+         @params = opts.inject({}) do |memo, opt|
+           unless CONFIG_OPTIONS.include? opt[0]
+             unless opt[1].is_a?(Array)
+               raise "Parameter values must be specified with an as_* method. You passed in a #{opt[1].class.to_s}"
+             end
+             memo[opt[0].to_s] = opt[1] 
+           end
+           memo
+         end     
+          @formats = extract_format_options(default_formats, opts)
+        end
+
+        # Accepts a hash of parameters and replaces each entry with it’s
+        # coerced or default value. If an expected param is missing, it will
+        # raise an error.
+        #
+        # TODO: Flag missing params rather than just raising an error 
+        # TODO: Allow defaults to be dynamically generated, i.e. method call
+        #
+        # @api private
+        def validate_and_coerce(incoming_params)
+          missing = []
+          params.each do |name, config|
+            type, default, opts = config
+            value = incoming_params[name]
+
+            if !value.nil? && value != ""
+              incoming_params[name] = send("validate_and_coerce_#{type}", value, opts)
+            else
+              if default == :req
+                missing << [name, type]
+              elsif default != :opt
+                incoming_params[name] = default
+              end
+            end
+          end
+          [incoming_params, missing]
+        end
+      
+        private
+      
+        # Accepts a string and turns it into an integer. The opts argument is
+        # only there to satisfy the interface. it is not used.
+        #
+        # @api private
+        def validate_and_coerce_integer(value, opts)
+          value.to_i
+        end
+
+        # Accepts a string and turns it into a date. The opts argument is
+        # only there to satisfy the interface. it is not used.
+        #
+        # @api private
+        def validate_and_coerce_date(value, opts)
+          Date.parse(value)
+        end
+      
+        # Turns the incoming value into a string. The opts argument is
+        # only there to satisfy the interface. it is not used.
+        #
+        # @api private
+        def validate_and_coerce_string(value, opts)
+          value.to_s
+        end
+
+        # Extracts the format options from a hash. It is used to compile the 
+        # list of formats that an action can provide. It accepts an array of
+        # symbols representing the base formats and will add to or overwrite 
+        # them based on the options in the hash.
+        #
+        # @api private
+        def extract_format_options(defaults, opts)
+          @formats = if opts[:provides]
+            defaults + [opts[:provides]].flatten
+          elsif opts[:only_provides]
+            [opts[:only_provides]].flatten
+          else
+            defaults
+          end
+        end
+      end # ActionOptions
+    end # Publish
+  end # Mixins
+end # Pancake

data/lib/pancake/mixins/render.rb

@@ -0,0 +1,61 @@
+module Pancake
+  module Mixins
+    module Render
+      class TemplateNotFound < Pancake::Errors::NotFound; end
+      
+      def self.included(base)
+        base.class_eval do
+          extend  Pancake::Mixins::Render::ClassMethods
+          include Pancake::Mixins::Render::InstanceMethods
+          
+          unless ancestors.include?(Pancake::Paths)
+            extend Pancake::Paths
+          end
+        end
+      end
+      
+      module ClassMethods
+        
+        def _view_cache
+          @_view_cache ||= {}
+        end
+
+        def _find_template(name)
+          renderer = _view_cache[name]
+          return renderer if renderer
+          
+          renderer_path = unique_paths_for(:views, :invert => true).detect do |path|
+            path.last =~ %r[(#{name})\.\w+$]
+          end
+          
+          raise TemplateNotFound unless renderer_path
+          _view_cache[name] = Tilt.new(renderer_path.join)
+        end
+      end # ClassMethods
+      
+      module InstanceMethods
+        def render(*args)
+          opts = Hash === args.last ? args.pop : {}
+          name = args.shift
+          
+          return opts[:text] if opts[:text]
+          
+          # Get the template name to use
+          template = _template_name_for(name, opts)
+          
+          # get the render template for that name
+          renderer = self.class._find_template(template)
+          
+          # Render the results
+          renderer.render(self, opts)
+        end
+        
+        private
+        def _template_name_for(name, opts)
+          opts[:format] ||= params[:format] || :html
+          "#{name}.#{opts[:format]}"
+        end
+      end # InstanceMethods
+    end # Render
+  end # Mixins
+end # Pancake

data/lib/pancake/mixins/request_helper.rb

@@ -0,0 +1,92 @@
+module Pancake
+  module Mixins
+    # Some helpers for requests that come in handy for applications that
+    # are part of stacks
+    module RequestHelper
+
+      # A setter for the rack environment
+      # @api public
+      def env=(env)
+        @env = env
+      end
+
+      # An accessor for the rack environment variable
+      # @api public
+      def env
+        @env
+      end
+      
+      def headers
+        @headers ||= {}
+      end
+
+      def status
+        @status ||= 200
+      end
+
+      def status=(st)
+        @status = st
+      end
+            
+      # Generate a url for the current stacks router.
+      #
+      # @example
+      #   class MyApp
+      #     router do |r|
+      #       r.add("/foo").name(:foo)
+      #     end
+      #
+      #     include Pancake::RequestHelper
+      #     # snip
+      #     def call(env)
+      #       @env = env
+      #       url(:foo) # => "/foo"
+      #     end
+      #   end
+      #
+      # @see Usher
+      # @see Pancake::Router
+      # @api public
+      # @author Daniel Neighman
+      def url(name, opts = {})
+        konfig = request.env[Pancake::Router::CONFIGURATION_KEY]
+        konfig.router.generate(name, opts)
+      end
+      
+      # Generate a url for any registered configuration with a router
+      #
+      # @example
+      #   # an application declared with MyApp.stackup(:app_name =>
+      #:some_app)
+      #   url_for(:some_app, :my_named_route)
+      #
+      #   # An application with no name specified
+      #   url_for(MyApp, :my_named_route)
+      #
+      # @see Usher
+      # @see Pancake::Router
+      # @api public
+      # @author Daniel Neighman
+      def url_for(app_name, name_or_opts, opts = {})
+        if konfig = Pancake.configuration.configs[app_name]
+          konfig.router.generate(name_or_opts, opts)
+        else
+          raise Pancake::Errors::UnknownConfiguration
+        end
+      end
+   
+      # A handy request method that gets hold of the current request
+      # object for the current rack request.
+      # Any including class _must_ provide an +env+ method that exposes
+      # the rack request environment
+      #
+      # @see Rack::Request
+      # @api public
+      # @author Daniel Neighman
+      def request
+        @request ||= Rack::Request.new(env)
+      end
+      
+    end # RequestHelper
+  end # Mixins
+end # Pancake

data/lib/pancake/mixins/stack_helper.rb

@@ -0,0 +1,44 @@
+module Pancake
+  module Mixins
+    module StackHelper
+      def self.included(base)
+        base.class_inheritable_accessor :_stack_class
+        base.extend ClassMethods
+        base.class_eval do
+          include ::Pancake::Mixins::StackHelper::InstanceMethods
+        end
+        base.stack_class
+      end
+
+      module ClassMethods
+        def stack_class
+          return @_stack_class if @_stack_class
+          klass = nil
+          ns = name.split("::")
+          until ns.empty? || klass
+            r = Object.full_const_get(ns.join("::"))
+            if r.ancestors.include?(::Pancake::Stack)
+              klass = r
+            else
+              ns.pop
+            end
+          end
+          if klass.nil?
+            raise "#{name} is not from a stack" unless _stack_class
+          else
+            self._stack_class = r
+          end
+          _stack_class
+        end
+      end
+      
+
+      module InstanceMethods
+        def stack_class
+          self.class.stack_class
+        end
+      end
+      
+    end # StackHelper
+  end # Mixins
+end # Pancake

data/lib/pancake/mixins/url.rb

@@ -0,0 +1,10 @@
+module Pancake
+  module Url
+    module Generation
+      def url(name, opts = {})
+        konfig = request.env[Pancake::Router::CONFIGURATION_KEY]
+        konfig.router.generate(name, opts)
+      end
+    end # Generation
+  end # Url
+end # Pancake

data/lib/pancake/more/controller.rb

@@ -0,0 +1,4 @@
+path = File.dirname(__FILE__)
+%w(
+  controller/base
+).each {|file| require File.join(path, file)}