manveru-innate 2009.03.24 → 2009.04

data/lib/innate/action.rb

@@ -1,6 +1,6 @@
 module Innate
-  ACTION_MEMBERS = [ :node, :method, :params, :view, :layout, :instance, :exts,
-    :wish, :options, :variables, :value, :view_value, :engine ]
+  ACTION_MEMBERS = [ :node, :instance, :method, :params, :method_value, :view,
+    :view_value, :layout, :wish, :options, :variables, :engine, :path ]
 
   class Action < Struct.new(*ACTION_MEMBERS)
     # Create a new Action instance.
@@ -32,10 +32,7 @@ module Innate
     # @api stable
     # @author manveru
     def call
-      Current.actions << self
-      render
-    ensure
-      Current.actions.delete(self)
+      Current.actions ? wrap_in_current{ render } : render
     end
 
     # @return [Binding] binding of the instance for this Action
@@ -100,11 +97,12 @@ module Innate
       self.variables[:content] ||= nil
 
       instance.wrap_action_call(self) do
-        self.value = instance.__send__(method, *params) if method
-        self.view_value = File.read(view) if view
-        copy_variables
+        copy_variables # this might need another position after all
+        self.method_value = instance.__send__(method, *params) if method
+        self.view_value = ::File.read(view) if view
 
-        body, content_type = wrap_in_layout{ engine.call(self, view_value || value) }
+        body, content_type = wrap_in_layout{
+          engine.call(self, view_value || method_value || '') }
         options[:content_type] ||= content_type if content_type
         body
       end
@@ -116,6 +114,7 @@ module Innate
       action = dup
       action.view, action.method = layout_view_or_method(*layout)
       action.layout = nil
+      action.view_value = nil
       action.sync_variables(self)
       body, content_type = yield
       action.variables[:content] = body
@@ -123,8 +122,14 @@ module Innate
     end
 
     def layout_view_or_method(name, arg)
-      return arg, nil if name == :layout || name == :view
-      return nil, arg
+      [:layout, :view].include?(name) ? [arg, nil] : [nil, arg]
+    end
+
+    def wrap_in_current
+      Current.actions << self
+      yield
+    ensure
+      Current.actions.delete(self)
     end
 
     # Try to figure out a sane name for current action.
@@ -132,8 +137,14 @@ module Innate
       File.basename((method || view).to_s).split('.').first
     end
 
+    # Path to this action, including params, with the mapping of the current
+    # controller prepended.
+    def full_path
+      File.join(node.mapping, path)
+    end
+
     def valid?
-      method || view
+      node.needs_method? ? (method && view) : (method || view)
     end
   end
 end

data/lib/innate/adapter.rb

@@ -1,23 +1,16 @@
-module Rack
-  module Handler
-    autoload :Thin,               'rack/handler/thin'
-    autoload :Ebb,                'ebb'
-    autoload :SwiftipliedMongrel, 'rack/handler/swiftiplied_mongrel'
-
-    register 'thin',     'Rack::Handler::Thin'
-    register 'ebb',      'Rack::Handler::Ebb'
-    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
-  end
-end
+Rack::Handler.register('ebb', 'Rack::Handler::Ebb')
 
 module Innate
 
   # Lightweight wrapper around Rack::Handler, will apply our options in a
   # unified manner and deal with adapters that don't like to do what we want or
   # where Rack doesn't want to take a stand.
+  #
+  # Rack handlers as of 2009.03.25:
+  # cgi, fastcgi, mongrel, emongrel, smongrel, webrick, lsws, scgi, thin
 
   module Adapter
-    include Optional
+    include Optioned
 
     options.dsl do
       o "IP address or hostname that we respond to - 0.0.0.0 for all",
@@ -75,24 +68,9 @@ module Innate
 
     # Thin shouldn't give excessive output, especially not to $stdout
     def self.start_thin(app, config)
-      require 'thin'
       handler = Rack::Handler.get('thin')
       ::Thin::Logging.silent = true
       handler.run(app, config)
     end
-
-    # swiftcore has its own handler outside of rack
-    def self.start_emongrel(app, config)
-      require 'swiftcore/evented_mongrel'
-      handler = Rack::Handler.get('emongrel')
-      handler.run(app, config)
-    end
-
-    # swiftcore has its own handler outside of rack
-    def self.start_smongrel(app, config)
-      require 'swiftcore/swiftiplied_mongrel'
-      handler = Rack::Handler.get('smongrel')
-      handler.run(app, config)
-    end
   end
 end

data/lib/innate/cache/file_based.rb

@@ -3,6 +3,8 @@ module Innate
 
     # Used by caches that serialize their contents to the filesystem.
     module FileBased
+      attr_reader :filename
+
       def cache_setup(*args)
         @prefix = args.compact.join('-')
 

data/lib/innate/cache.rb

@@ -61,7 +61,7 @@ module Innate
     autoload :Marshal,   'innate/cache/marshal'
     autoload :FileBased, 'innate/cache/file_based'
 
-    include Optional
+    include Optioned
 
     options.dsl do
       o "Assign a cache to each of these names on Innate::Cache::setup",

data/lib/innate/current.rb

@@ -25,11 +25,11 @@ module Innate
       end
     end
 
-    # Setup new Request/Response/Session for this request/response cycle
-
-    def setup(env)
-      req = STATE[:request] = Request.new(env)
-      res = STATE[:response] = Response.new
+    # Setup new Request/Response/Session for this request/response cycle.
+    # The parameters are here to allow Ramaze to inject its own classes.
+    def setup(env, request = Request, response = Response, session = Session)
+      req = STATE[:request] = request.new(env)
+      res = STATE[:response] = response.new
       STATE[:actions] = []
       STATE[:session] = Session.new(req, res)
     end

data/lib/innate/dynamap.rb

@@ -18,6 +18,11 @@ module Innate
       remap(@originals.merge(location.to_s => object))
     end
 
+    def delete(location)
+      @originals.delete(location)
+      remap(@originals)
+    end
+
     def at(location)
       @originals[location]
     end

data/lib/innate/helper/cgi.rb

@@ -6,36 +6,49 @@ module Innate
 
   module Helper
     module CGI
-      # shortcut for Rack::Utils.escape
-      def url_encode(*args)
-        Rack::Utils.escape(*args.map{|a| a.to_s })
+      module_function
+
+      # Shortcut for Rack::Utils.escape
+      #
+      # @param [#to_s] input
+      # @return [String] URI-encoded representation of +input+
+      def url_encode(input)
+        Rack::Utils.escape(input.to_s)
       end
+      alias u url_encode
 
-      # shortcut for Rack::Utils.unescape
-      def url_decode(*args)
-        Rack::Utils.unescape(*args.map{|a| a.to_s })
+      # Shortcut for Rack::Utils.unescape
+      #
+      # @param [#to_s] input
+      # @return [String] URI-decoded representation of +input+
+      def url_decode(input)
+        Rack::Utils.unescape(input.to_s)
       end
 
-      # shortcut for Rack::Utils.escape_html
-      def html_escape(string)
-        Rack::Utils.escape_html(string)
+      # Shortcut for Rack::Utils.escape_html
+      #
+      # @param [#to_s] input
+      # @return [String]
+      def html_escape(input)
+        Rack::Utils.escape_html(input.to_s)
       end
 
-      # shortcut for CGI.unescapeHTML
-      def html_unescape(string)
-        ::CGI.unescapeHTML(string.to_s)
+      # Shortcut for CGI.unescapeHTML
+      #
+      # @param [#to_s] input
+      # @return [String]
+      def html_unescape(input)
+        ::CGI.unescapeHTML(input.to_s)
       end
 
       # safely escape all HTML and code
-      def h(string)
-        Rack::Utils.escape_html(string).gsub(/#([{@$]@?)/, '#\1')
+      def html_and_code_escape(input)
+        Rack::Utils.escape_html(input.to_s).gsub(/#([{@$]@?)/, '#\1')
       end
+      alias h html_and_code_escape
 
-      # one-letter versions help in case like #{h foo.inspect}
-      # ERb/ERuby/Rails compatible
-      alias u url_encode
-
-      module_function(:url_encode, :url_decode, :html_escape, :html_unescape, :h, :u)
+      # aliases are ignored by module_function...
+      module_function :u, :h
     end
   end
 end

data/lib/innate/helper/link.rb

@@ -28,12 +28,12 @@ module Innate
         hashes, names = args.partition{|arg| arg.respond_to?(:merge!) }
         hashes.each{|to_merge| hash.merge!(to_merge) }
 
+        escape = Rack::Utils.method(:escape)
         location = route_location(self)
-        front = Array[location, name, *names].join('/').squeeze('/')
+        front = Array[location, name, *names.map{|n| escape[n]}].join('/').squeeze('/')
 
         return URI(front) if hash.empty?
 
-        escape = Rack::Utils.method(:escape)
         query = hash.map{|k, v| "#{escape[k]}=#{escape[v]}" }.join(';')
         URI("#{front}?#{query}")
       end

data/lib/innate/helper/redirect.rb

@@ -57,7 +57,7 @@ module Innate
       end
 
       def raw_redirect(target, options = {}, &block)
-        header = {'Location' => target.to_s}
+        header = response.header.merge('Location' => target.to_s)
         status = options[:status] || 302
         body   = options[:body] || redirect_body(target)
 

data/lib/innate/helper/render.rb

@@ -0,0 +1,87 @@
+module Innate
+  module Helper
+    module Render
+      # Enables you to simply call:
+      #
+      # @example of added functionality
+      #   YourController.render_partial(:foo, :x => 42)
+      #
+      def self.included(into)
+        into.extend(self)
+      end
+
+      # Renders the full action in the way a real request would.
+      #
+      # Please be aware that, if this is the first request from a client, you
+      # will not have access to the session in the action being rendered, as no
+      # actual session has been put into place yet.
+      #
+      # It should work as expected on any subsequent requests.
+      #
+      # As usual, patches welcome.
+      #
+      # @api external
+      # @see Mock.session
+      # @author manveru
+      def render_full(path, query = {})
+        uri = URI(path.to_s)
+        uri.query = Rack::Utils.build_query(query)
+
+        if cookie = request.env['HTTP_COOKIE']
+          Mock.session do |mock|
+            mock.cookie = cookie
+            return mock.get(uri.to_s).body
+          end
+        else
+          Mock.get(uri.to_s).body
+        end
+      end
+
+      # Renders an action without any layout.
+      # You can further tweak the action to be rendered by passing a block.
+      #
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_partial(action_name, variables = {})
+        render_custom(action_name, variables) do |action|
+          action.layout = nil
+          yield(action) if block_given?
+        end
+      end
+
+      # Renders an action view, doesn't execute any methods and won't wrap it
+      # into a layout.
+      # You can further tweak the action to be rendered by passing a block.
+      #
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_view(action_name, variables = {})
+        render_custom(action_name, variables) do |action|
+          action.layout = nil
+          action.method = nil
+          yield(action) if block_given?
+        end
+      end
+
+      def render_custom(action_name, variables = {})
+        unless action = resolve(action_name.to_s)
+          raise(ArgumentError, "No Action %p on #{self}" % action_name)
+        end
+
+        action.sync_variables(self.action)
+        action.instance = action.node.new
+        action.variables = action.variables.merge(variables)
+
+        yield(action) if block_given?
+
+        if action.valid?
+          action.render
+        else
+          Log.warn("Invalid action: %p" % action)
+        end
+      end
+    end
+  end
+end

data/lib/innate/helper/send_file.rb

@@ -3,12 +3,20 @@ module Innate
     module SendFile
       # Not optimally performing but convenient way to send files by their
       # filename.
-      def send_file(filename, content_type = nil)
+      #
+      # I think we should remove this from the default helpers and move it into
+      # Ramaze, the functionality is almost never used, the naming is ambigous,
+      # and it doesn't use the send_file capabilities of frontend servers.
+      #
+      # So for now, I'll mark it for deprecation
+      def send_file(filename, content_type = nil, content_disposition = nil)
         content_type ||= Rack::Mime.mime_type(::File.extname(filename))
+        content_disposition ||= File.basename(filename)
 
         response.body = ::File.readlines(filename, 'rb')
         response['Content-Length'] = ::File.size(filename).to_s
         response['Content-Type'] = content_type
+        response['Content-Disposition'] = content_disposition
         response.status = 200
 
         throw(:respond, response)

data/lib/innate/helper.rb

@@ -11,6 +11,7 @@ module Innate
     def self.included(into)
       into.extend(HelperAccess)
       into.__send__(:include, Trinity)
+      into.helper(*HelpersHelper.options[:default])
     end
   end
 
@@ -63,34 +64,27 @@ module Innate
   #
   #   p Innate::HelpersHelper.each(:cgi, :link, :aspect)
   module HelpersHelper
-    EXTS = %w[rb so bundle]
+    include Optioned
 
-    # By default, lib/innate/ is added to the PATH, you may add your
-    # application root here so innate will look in your own helper/ directory.
-    PATH = []
+    options.dsl do
+      o "Paths that will be searched for helper files",
+        :paths, [Dir.pwd, File.dirname(__FILE__)]
 
-    # The namespaces that may container helper modules.
-    # Lookup is done from left to right.
-    POOL = []
+      o "Namespaces that will be searched for helper modules",
+        :namespaces, [Helper]
 
-    # all of the following are singleton methods
+      o "Filename extensions considered for helper files",
+        :exts, %w[rb so bundle]
 
-    module_function
-
-    def add_pool(pool)
-      POOL.unshift(pool)
-      POOL.uniq!
+      o "Default helpers, added on inclusion of the Helper module",
+        :default, [:aspect, :cgi, :flash, :link, :render, :redirect, :send_file]
     end
 
-    add_pool(Helper)
+    EXTS = %w[rb so bundle]
 
-    def add_path(path)
-      PATH.unshift(File.expand_path(path))
-      PATH.uniq!
-    end
+    # all of the following are singleton methods
 
-    add_path(File.dirname(__FILE__))
-    add_path('')
+    module_function
 
     # Yield all the modules we can find for the given names of helpers, try to
     # require them if not available.
@@ -158,10 +152,10 @@ module Innate
     # helper :foo_bar # => FooBar
     # helper :foo # => Foo
     def get(name)
-      name = name.to_s.split('_').map{|e| e.capitalize}.join
+      module_name = /^#{name.to_s.dup.delete('_')}$/i
 
-      POOL.each do |namespace|
-        found = namespace.constants.grep(/^#{name}$/i).first
+      options.namespaces.each do |namespace|
+        found = namespace.constants.grep(module_name).first
         return namespace.const_get(found) if found
       end
 
@@ -181,12 +175,9 @@ module Innate
     # Return a nice list of filenames in correct locations with correct
     # filename-extensions.
     def glob(name = '*')
-      "{#{paths.join(',')}}/helper/#{name}.{#{EXTS.join(',')}}"
-    end
-
-    # In case you want to do something better.
-    def paths
-      PATH
+      exts, paths = options.exts, options.paths
+      paths.uniq!
+      "{#{paths.join(',')}}/helper/#{name}.{#{exts.join(',')}}"
     end
   end
 end

data/lib/innate/log/hub.rb

@@ -38,7 +38,7 @@ module Innate
 
   class LogHub
     include Logger::Severity
-    include Optional
+    include Optioned
 
     attr_accessor :loggers, :program, :active
 

data/lib/innate/middleware_compiler.rb

@@ -47,27 +47,13 @@ module Innate
       cascade(*apps)
     end
 
-    def static(path)
-      require 'rack/contrib'
-      Rack::ETag.new(Rack::ConditionalGet.new(Rack::File.new(path)))
-    end
-
-    def directory(path)
-      require 'rack/contrib'
-      Rack::ETag.new(Rack::ConditionalGet.new(Rack::Directory.new(path)))
-    end
-
     def call(env)
       compile
       @compiled.call(env)
     end
 
-    def compiled?
-      @compiled
-    end
-
     def compile
-      compiled? ? self : compile!
+      @compiled ? self : compile!
     end
 
     def compile!

data/lib/innate/mock.rb

@@ -39,9 +39,8 @@ module Innate
         hash['HTTP_COOKIE'] ||= @cookie if @cookie
         response = Mock::mock(method, path, hash)
 
-        if cookie = response['Set-Cookie']
-          @cookie = cookie
-        end
+        cookie = response['Set-Cookie']
+        @cookie = cookie if cookie
 
         response
       end