innate 2009.04.12 → 2009.05

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/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

@@ -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,11 +91,42 @@ 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 = {})
-        action = resolve(action_name.to_s)
+        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
@@ -69,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/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/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

data/lib/innate/options/dsl.rb

@@ -78,7 +78,8 @@ module Innate
     #                        :doc, :value keys will be ignored
     def option(doc, key, value, other = {}, &block)
       trigger = block || other[:trigger]
-      convert = {:doc => doc.to_s, :value => value, :trigger => trigger}
+      convert = {:doc => doc.to_s, :value => value}
+      convert[:trigger] = trigger if trigger
       @hash[key.to_sym] = other.merge(convert)
     end
     alias o option
@@ -115,7 +116,9 @@ module Innate
     # @param [Array] keys
     # @param [Object] value
     def set_value(keys, value)
-      get(*keys)[:value] = value
+      got = get(*keys)
+      return got[:value] = value if got
+      raise(IndexError, "There is no option available for %p" % [keys])
     end
 
     # Retrieve only the :value from the value hash if found via +keys+.

data/lib/innate/request.rb

@@ -56,7 +56,7 @@ module Innate
   # * values_at
 
   class Request < Rack::Request
-    # Currently handled request from Innate::STATE[:request]
+    # Currently handled request from Thread.current[:request]
     # Call it from anywhere via Innate::Request.current
     def self.current
       Current.request

data/lib/innate/response.rb

@@ -1,9 +1,4 @@
 module Innate
-
-  # In order to reset the body contents we also need to reset the length set by
-  # Response#write - until I can submit a patch to Rack and the next release we
-  # just do this.
-
   class Response < Rack::Response
     include Optioned
 
@@ -12,8 +7,6 @@ module Innate
         :headers, {'Content-Type' => 'text/html'}
     end
 
-    attr_accessor :length
-
     def reset
       self.status = 200
       self.header.delete('Content-Type')
@@ -24,6 +17,7 @@ module Innate
 
     def finish
       options.headers.each{|key, value| self[key] ||= value }
+      Current.session.flush(self)
       super
     end
   end

data/lib/innate/route.rb

@@ -5,6 +5,10 @@ module Innate
   #
   # This middleware should wrap Innate::DynaMap.
   #
+  # Please note that Rack::File is put before Route and Rewrite, that means
+  # that you cannot apply routes to static files unless you add your own route
+  # middleware before.
+  #
   # String routers are the simplest way to route in Innate. One path is
   # translated into another:
   #

data/lib/innate/session.rb

@@ -9,12 +9,12 @@ module Innate
   # You may store anything in here that you may also store in the corresponding
   # store, usually it's best to keep it to things that are safe to Marshal.
   #
-  # The default time of expiration is *
-  #
+  # The default time of expiration is:
   #   Time.at(2147483647) # => Tue Jan 19 12:14:07 +0900 2038
   #
   # Hopefully we all have 64bit systems by then.
-
+  #
+  # The Session instance is compatible with the specification of rack.session.
   class Session
     include Optioned
 
@@ -40,13 +40,17 @@ module Innate
       @flash = Flash.new(self)
     end
 
-    def []=(key, value)
+    # Rack interface
+
+    def store(key, value)
       cache_sid[key] = value
     end
+    alias []= store
 
-    def [](key)
+    def fetch(key, value = nil)
       cache_sid[key]
     end
+    alias [] fetch
 
     def delete(key)
       cache_sid.delete(key)
@@ -57,9 +61,7 @@ module Innate
       @cache_sid = nil
     end
 
-    def cache_sid
-      @cache_sid ||= cache[sid] || {}
-    end
+    # Additional interface
 
     def flush(response = @response)
       return if !@cache_sid or @cache_sid.empty?
@@ -70,6 +72,12 @@ module Innate
       set_cookie(response)
     end
 
+    private
+
+    def cache_sid
+      @cache_sid ||= cache[sid] || {}
+    end
+
     def sid
       @sid ||= cookie || generate_sid
     end
@@ -78,12 +86,6 @@ module Innate
       @request.cookies[options.key]
     end
 
-    def inspect
-      cache.inspect
-    end
-
-    private
-
     def cache
       Innate::Cache.session
     end