manveru-innate 2009.04.18 → 2009.05

data/lib/innate/cache/file_based.rb

@@ -2,6 +2,9 @@ module Innate
   class Cache
 
     # Used by caches that serialize their contents to the filesystem.
+    # Right now we do not lock around write access to the file outside of the
+    # process, that means that all FileBased caches are not safe for use if you
+    # need more than one instance of your application.
     module FileBased
       attr_reader :filename
 

data/lib/innate/cache/marshal.rb

@@ -3,8 +3,11 @@ require 'pstore'
 module Innate
   class Cache
     # Keeps every cache in a separate file like this:
-    #
     # /tmp/innate-cache-marshal/delta-manveru-session.marshal
+    #
+    # The Marshal cache is not safe for use between multiple processes, it is
+    # also slow compared to other caches, so generally the use of it is
+    # discouraged.
     class Marshal
       include Cache::API
       include Cache::FileBased

data/lib/innate/cache/memory.rb

@@ -1,8 +1,7 @@
 module Innate
   class Cache
     # Memory cache is simply a Hash with the Cache::API, it's the reference
-    # implementation for every other cache.
-
+    # implementation for every other cache and the default cache.
     class Memory < Hash
       include Cache::API
 

data/lib/innate/cache/yaml.rb

@@ -3,8 +3,11 @@ require 'yaml/store'
 module Innate
   class Cache
     # Keeps every cache in a separate file like this:
-    #
     # /tmp/innate-cache-yaml/delta-manveru-session.yaml
+    #
+    # The YAML cache is not safe for use between multiple processes, it is also
+    # very slow compared to other caches, so generally the use of it is
+    # discouraged.
     class YAML
       include Cache::API
       include Cache::FileBased

data/lib/innate/current.rb

@@ -2,9 +2,9 @@ require 'innate/request'
 require 'innate/response'
 
 module Innate
-  # Uses STATE to scope request/response/session per Fiber/Thread so we can
-  # reach them from anywhere in the code without passing around the objects
-  # directly.
+  # We track the current request/response/session (Trinity) in Thread.current
+  # so we can reach them from anywhere in the code without passing around the
+  # objects directly.
   class Current
     extend Trinity
 
@@ -16,22 +16,20 @@ module Innate
       end
     end
 
-    # Wrap into STATE, run setup and call the app inside STATE.
-
+    # Run setup and call the app
     def call(env)
-      STATE.wrap do
-        setup(env)
-        @app.call(env)
-      end
+      setup(env)
+      @app.call(env)
     end
 
     # 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)
+      current = Thread.current
+      req = current[:request] = request.new(env)
+      res = current[:response] = response.new
+      current[:actions] = []
+      current[:session] = Session.new(req, res)
     end
   end
 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.rb

@@ -165,19 +165,21 @@ module Innate
     # Figure out files that might have the helper we ask for and then require
     # the first we find, if any.
     def try_require(name)
-      if found = Dir[glob(name)].first
+      if found = find_helper(name.to_s)
         require(found) || true
       else
         raise(LoadError, "Helper #{name} not found")
       end
     end
 
-    # Return a nice list of filenames in correct locations with correct
-    # filename-extensions.
-    def glob(name = '*')
-      exts, paths = options.exts, options.paths
-      paths.uniq!
-      "{#{paths.join(',')}}/helper/#{name}.{#{exts.join(',')}}"
+    def find_helper(name)
+      options.paths.uniq.find do |path|
+        base = ::File.join(path, 'helper', name)
+        options.exts.find do |ext|
+          full = "#{base}.#{ext}"
+          return full if ::File.file?(full)
+        end
+      end
     end
   end
 end

data/lib/innate/helper/aspect.rb

@@ -94,28 +94,28 @@ module Innate
           AOP[self][:before_all] = block
         end
 
-        def before(name, &block)
-          AOP[self][:before][name] = block
+        def before(*names, &block)
+          names.each{|name| AOP[self][:before][name] = block }
         end
 
         def after_all(&block)
           AOP[self][:after_all] = block
         end
 
-        def after(name, &block)
-          AOP[self][:after][name] = block
+        def after(*names, &block)
+          names.each{|name| AOP[self][:after][name] = block }
         end
 
-        def wrap(name, &block)
-          before(name, &block)
-          after(name, &block)
+        def wrap(*names, &block)
+          before(*names, &block)
+          after(*names, &block)
         end
 
         def add_action_wrapper(order, method_name)
           if wrap = trait[:wrap]
-            wrap.merge(SortedSet[[order, method_name]])
+            wrap.merge(SortedSet[[order, method_name.to_s]])
           else
-            trait :wrap => SortedSet[[order, method_name]]
+            trait :wrap => SortedSet[[order, method_name.to_s]]
           end
         end
       end

data/lib/innate/helper/cgi.rb

@@ -46,6 +46,9 @@ module Innate
         Rack::Utils.escape_html(input.to_s).gsub(/#([{@$]@?)/, '#\1')
       end
       alias h html_and_code_escape
+
+      # aliases are ignored by module_function...
+      module_function :u, :h
     end
   end
 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

@@ -5,7 +5,6 @@ module Innate
       #
       # @example of added functionality
       #   YourController.render_partial(:foo, :x => 42)
-      #
       def self.included(into)
         into.extend(self)
       end
@@ -20,6 +19,14 @@ module Innate
       #
       # As usual, patches welcome.
       #
+      # @example usage
+      #
+      #   render_full('/blog/article/1')
+      #   render_full('/blog/article/1', :lang => :de)
+      #
+      # Please note that you have to give the full path in the same way you'd
+      # do in a direct request with curl or a browser.
+      #
       # @api external
       # @see Mock.session
       # @author manveru
@@ -38,17 +45,44 @@ module Innate
       end
 
       # Renders an action without any layout.
+      # You can further tweak the action to be rendered by passing a block.
+      #
+      # @example usage
+      #
+      #   render_partial(:index)
+      #   render_partial(:index, :title => :foo)
+      #
+      # Please note that you only have to supply the action name, if your
+      # action requires arguments then you have to pass a name suitable for
+      # that.
+      #
+      # @example usage with action that requires arguments
+      #
+      #   # requires two arguments
+      #   def foo(a, b)
+      #   end
+      #
+      #   # pass two suitable arguments
+      #   render_partial('foo/1/2')
+      #
       # @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.
+      #
+      # @example usage
+      #
+      #   render_view(:index)
+      #   render_view(:index, :title => :foo)
       #
       # @api external
       # @see render_custom
@@ -57,12 +91,41 @@ module Innate
         render_custom(action_name, variables) do |action|
           action.layout = nil
           action.method = nil
+          yield(action) if block_given?
+        end
+      end
+
+      # Use the given file as a template and render it in the same scope as
+      # the current action.
+      # The +filename+ may be an absolute path or relative to the process
+      # working directory.
+      #
+      # @example usage
+      #
+      #   path = '/home/manveru/example/app/todo/view/index.xhtml'
+      #   render_file(path)
+      #   render_file(path, :title => :foo)
+      #
+      # Ramaze will emit a warning if you try to render an Action without a
+      # method or view template, but will still try to render it.
+      # The usual {Action#valid?} doesn't apply here, as sometimes you just
+      # cannot have a method associated with a template.
+      #
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_file(filename, variables = {})
+        render_custom(action.path, variables) do |action|
+          action.layout = nil
+          action.method = nil
+          action.view = filename
+          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)
+          raise(ArgumentError, "No Action %p on #{self}" % [action_name])
         end
 
         action.sync_variables(self.action)
@@ -71,11 +134,9 @@ module Innate
 
         yield(action) if block_given?
 
-        if action.valid?
-          action.render
-        else
-          Log.warn("Invalid action: %p" % action)
-        end
+        valid_action = action.view || action.method
+        Log.warn("Empty action: %p" % [action]) unless valid_action
+        action.render
       end
     end
   end

data/lib/innate/log/color_formatter.rb

@@ -1,19 +1,25 @@
 class Logger
   # Extended Formatter that supports ANSI colors.
+  #
+  # The basic mapping of ANSI colors is as follows:
+  #
+  #     | reset | bold | dark | underline | blink | negative
+  # MOD |     0 |    1 |    2 |         4 |     5 |        7
+  #
+  #    | black | red | green | yellow | blue | magenta | cyan | white
+  # FG |    30 |  31 |    32 |     33 |   34 |      35 |   36 |    37
+  # BG |    40 |  41 |    42 |     43 |   44 |      45 |   46 |    47
+  #
+  # The output is done by: "\e[#{mod};#{fg};#{bg}m#{string}\e[0m"
+  # The suffix is to reset the terminal to the original state again.
   class ColorFormatter < Formatter
     LEVEL_COLOR = {
-      'DEBUG'   => :blue,
-      'INFO'    => :white,
-      'WARN'    => :yellow,
-      'ERROR'   => :red,
-      'FATAL'   => :red,
-      'UNKNOWN' => :green,
-    }
-
-    COLOR_CODE = {
-      :reset => 0, :bold => 1, :dark => 2, :underline => 4, :blink => 5,
-      :negative => 7, :black => 30, :red => 31, :green => 32, :yellow => 33,
-      :blue => 34, :magenta => 35, :cyan => 36, :white => 37,
+      'DEBUG'   => "\e[0;34;40m%s\e[0m", # blue on black
+      'INFO'    => "\e[0;37;40m%s\e[0m", # white on black
+      'WARN'    => "\e[0;33;40m%s\e[0m", # yellow on black
+      'ERROR'   => "\e[0;31;40m%s\e[0m", # red on black
+      'FATAL'   => "\e[0;35;40m%s\e[0m", # red on black
+      'UNKNOWN' => "\e[0;32;40m%s\e[0m", # green on black
     }
 
     FORMAT_TIME = "%Y-%m-%d %H:%M:%S"
@@ -33,7 +39,7 @@ class Logger
     end
 
     def colorize(string, severity)
-      "\e[#{COLOR_CODE[LEVEL_COLOR[severity]]}m#{string}\e[0m"
+      LEVEL_COLOR[severity] % string
     end
 
     def self.color?(logdev)

data/lib/innate/node.rb

@@ -244,7 +244,7 @@ module Innate
     # with feedback in your logs.
     #
     # A lot of functionality in here relies on the fact that call is executed
-    # within Innate::STATE.wrap which populates the variables used by Trinity.
+    # within Current#call which populates the variables used by Trinity.
     # So if you use the Node directly as a middleware make sure that you #use
     # Innate::Current as a middleware before it.
     #
@@ -261,11 +261,7 @@ module Innate
       path << '/' if path.empty?
 
       response.reset
-      response = try_resolve(path)
-
-      Current.session.flush(response)
-
-      response.finish
+      try_resolve(path).finish
     end
 
     # Let's try to find some valid action for given +path+.
@@ -364,7 +360,7 @@ module Innate
     def resolve(path)
       name, wish, engine = find_provide(path)
       node = (respond_to?(:ancestors) && respond_to?(:new)) ? self : self.class
-      action = Action.create(:node => node, :wish => wish, :engine => engine)
+      action = Action.create(:node => node, :wish => wish, :engine => engine, :path => path)
 
       if content_type = node.ancestral_trait["#{wish}_content_type"]
         action.options = {:content_type => content_type}
@@ -742,8 +738,6 @@ module Innate
     #
     # Since Innate supports multiple paths to templates the +path+ has to be an
     # Array that may be nested one level.
-    # The +path+ is then translated by {Node#path_glob} and the +wish+ by
-    # {Node#ext_glob}.
     #
     # @example Usage to find available templates
     #
@@ -779,7 +773,6 @@ module Innate
     #
     # @api external
     # @see Node#find_view Node#to_layout Node#find_aliased_view
-    #      Node#path_glob Node#ext_glob
     # @author manveru
     def to_template(path, wish)
       to_view(path, wish) || to_layout(path, wish)
@@ -802,22 +795,27 @@ module Innate
 
     def update_mapping_shared(paths)
       mapping = {}
+      paths.reject!{|path| !File.directory?(path) }
 
       provides.each do |wish_key, engine|
         wish = wish_key[/(.*)_handler/, 1]
-        ext_glob = ext_glob(wish)
+        exts = possible_exts_for(wish)
 
         paths.reverse_each do |path|
-          ::Dir.glob(::File.join(path, "/**/*.#{ext_glob}")) do |file|
-            case file.sub(path, '').gsub('/', '__')
-            when /^(.*)\.(.*)\.(.*)$/
-              action_name, wish_ext, engine_ext = $1, $2, $3
-            when /^(.*)\.(.*)$/
-              action_name, wish_ext, engine_ext = $1, wish, $2
+          Find.find(path) do |file|
+            exts.each do |ext|
+              next unless file =~ ext
+
+              case file.sub(path, '').gsub('/', '__')
+              when /^(.*)\.(.*)\.(.*)$/
+                action_name, wish_ext, engine_ext = $1, $2, $3
+              when /^(.*)\.(.*)$/
+                action_name, wish_ext, engine_ext = $1, wish, $2
+              end
+
+              mapping[wish_ext] ||= {}
+              mapping[wish_ext][action_name] = file
             end
-
-            mapping[wish_ext] ||= {}
-            mapping[wish_ext][action_name] = file
           end
         end
       end
@@ -825,32 +823,37 @@ module Innate
       return mapping
     end
 
+    # Answer with an array of possible paths in order of significance for
+    # template lookup of the given +mappings+.
+    #
+    # @param [#map] An array two Arrays of inner and outer directories.
+    #
+    # @return [Array]
+    # @see update_view_mappings update_layout_mappings update_template_mappings
+    # @author manveru
     def possible_paths_for(mappings)
-      root_mappings.map{|root_mapping|
-        mappings.first.map{|outer_mapping|
-          mappings.last.map{|inner_mapping|
-            File.join(root_mapping, outer_mapping, inner_mapping, '/')
-          }
-        }
-      }.flatten
+      root_mappings.map{|root|
+        mappings.first.map{|inner|
+          mappings.last.map{|outer|
+            ::File.join(root, inner, outer, '/') }}}.flatten
     end
 
-    # Produce a glob that can be processed by Dir::[] matching the extensions
-    # associated with the given +wish+.
+    # Answer with an array of possible extensions in order of significance for
+    # the given +wish+.
     #
     # @param [#to_s] wish the extension (no leading '.')
     #
-    # @return [String] glob matching the valid exts for the given +wish+
+    # @return [Array] list of exts valid for this +wish+
     #
     # @api internal
     # @see Node#to_template View::exts_of Node#provides
     # @author manveru
-    def ext_glob(wish)
+    def possible_exts_for(wish)
       pr = provides
       return unless engine = pr["#{wish}_handler"]
-      engine_exts = View.exts_of(engine).join(',')
-      represented = [*wish].map{|k| "#{k}." }.join(',')
-      "{%s,}{%s}" % [represented, engine_exts]
+      View.exts_of(engine).map{|e_ext|
+        [[*wish].map{|w_ext| /#{w_ext}\.#{e_ext}$/ }, /#{e_ext}$/]
+      }.flatten
     end
 
     # For compatibility with new Kernel#binding behaviour in 1.9
@@ -929,7 +932,7 @@ module Innate
     # @author manveru
     def layout_mappings
       paths = [*ancestral_trait[:layouts]]
-      paths = [mapping] if paths.empty?
+      paths = ['/'] if paths.empty?
 
       [[*options.layouts].flatten, [*paths].flatten]
     end