ramaze 2008.11 → 2009.01

data/lib/proto/public/dispatch.fcgi

@@ -4,8 +4,8 @@ require 'rubygems'
 require 'ramaze'
 
 # FCGI doesn't like you writing to stdout
-Ramaze::Log.loggers = [ Ramaze::Logger::Informer.new( File.join(__DIR__, '..', 'ramaze.fcgi.log') ) ]
+Ramaze::Log.loggers = [ Ramaze::Logger::Informer.new( __DIR__("../ramaze.fcgi.log") ) ]
 Ramaze::Global.adapter = :fcgi
 
-$0 = File.join(__DIR__, '..', 'start.rb')
+$0 = __DIR__("../start.rb")
 require $0

data/lib/proto/spec/main.rb

@@ -1,12 +1,12 @@
 require 'ramaze'
 require 'ramaze/spec/helper'
 
-require __DIR__/'../start'
+require __DIR__('../start')
 
 describe MainController do
   behaves_like 'http', 'xpath'
-  ramaze :view_root => __DIR__/'../view',
-         :public_root => __DIR__/'../public'
+  ramaze :view_root => __DIR__('../view'),
+         :public_root => __DIR__('../public')
 
   it 'should show start page' do
     got = get('/')

data/lib/proto/start.rb

@@ -1,6 +1,10 @@
 require 'rubygems'
 require 'ramaze'
 
+# Add directory start.rb is in to the load path, so you can run the app from
+# any other working path
+$LOAD_PATH.unshift(__DIR__)
+
 # Initialize controllers and models
 require 'controller/init'
 require 'model/init'

data/lib/ramaze.rb

@@ -79,6 +79,8 @@ module Ramaze
     # each class in trait[:essentials] by calling ::startup on them.
 
     def startup options = {}
+      options = options.to_hash
+
       force = options.delete(:force)
       force ||= !trait[:started]
 
@@ -97,10 +99,14 @@ module Ramaze
       end
     end
 
+    # A shortcut for setting Ramaze.trait[:started] = true.
+
     def skip_start
       trait[:started] = true
     end
 
+    # Forces the startup of Ramaze regardless if trait[:started] is set.
+
     def start!(options = {})
       trait[:started] = false
       startup(options)

data/lib/ramaze/action.rb

@@ -110,17 +110,21 @@ module Ramaze
     end
 
     # Try to figure out a sane name for current action.
+
     def name
       File.basename((self[:method] || self[:template]).to_s).split('.').first
     end
 
     # combined path to current action, from path and params
+
     def extended_path
       (path == "index" && !params.empty? ? params : Array[path, *params]).join('/')
     end
 
+    # same as Ramaze::Action#extended_path, with mapping of the current controller prepended.
+
     def full_path
-      self.controller.mapping/extended_path
+      File.join(self.controller.mapping, extended_path)
     end
 
     # Hook for AspectHelper
@@ -133,6 +137,8 @@ module Ramaze
     def after_process
     end
 
+    # Returns true if current request is valid REST request.
+
     def valid_rest?
       return true unless rest = controller.trait[:REST]
       meth = Request.current.request_method

data/lib/ramaze/action/render.rb

@@ -49,8 +49,8 @@ module Ramaze
     # true.
 
     def cached_render
-      if Global.file_cache
-        cached_render_file
+      if cache_root = Global.file_cache
+        cached_render_file(cache_root)
       else
         cached_render_memory
       end
@@ -59,12 +59,13 @@ module Ramaze
     # Uses files in the Global.public_root to provide a static ressource on
     # next request and returns the rendered action
 
-    def cached_render_file
+    def cached_render_file(cache_root)
       rendered = uncached_render
 
-      global_epath = Global.public_root/self.controller.mapping/extended_path
+      cr = cache_root.respond_to?(:to_str) ? cache_root.to_str : Global.public_root
+      global_epath = File.join(cr, self.controller.mapping, extended_path)
       FileUtils.mkdir_p(File.dirname(global_epath))
-      File.open(global_epath, 'w+') {|fp| fp.print(rendered) }
+      File.open(global_epath, 'w+'){|fp| fp.print(rendered) }
 
       rendered
     end

data/lib/ramaze/cache.rb

@@ -6,6 +6,7 @@ require 'ramaze/cache/memory'
 module Ramaze
   autoload :YAMLStoreCache, "ramaze/cache/yaml_store.rb"
   autoload :MemcachedCache, "ramaze/cache/memcached.rb"
+  autoload :FileCache, "ramaze/cache/file.rb"
 
   # This is the wrapper of all caches, providing mechanism
   # for switching caching from one adapter to another.

data/lib/ramaze/cache/file.rb

@@ -0,0 +1,71 @@
+module Ramaze
+  # Persist cache contents to the filesystem.
+  # By default this will create a `/cache` directory in your APPDIR
+  #
+  # Usage for sessions only:
+  #
+  #     Ramaze::Global::cache_alternative[:sessions] = Ramaze::FileCache
+  #
+  # Usage for everything:
+  #
+  #     Ramaze::Global::cache = Ramaze::FileCache
+
+  class FileCache
+    attr_accessor :root, :subdir
+    attr_reader :host, :pid
+
+    def initialize(root = Ramaze::Global.root, subdir = 'cache')
+      @root, @subdir = root, subdir
+      @host = Socket.gethostname
+      @pid = $$
+
+      FileUtils.mkdir_p(dir)
+    end
+
+    def dir(*further)
+      File.join(root, subdir, *further)
+    end
+
+    def [](key)
+      Marshal.load(File.read(dir(key.to_s, 'data')))
+    rescue
+      nil
+    end
+
+    def []=(key, value)
+      key = key.to_s
+      tmp_name = dir(key, "data.#{host}.#{pid}")
+      key_name = dir(key, 'data')
+      dir_name = dir(key)
+
+      data = Marshal.dump(value)
+
+      FileUtils.rm_rf(dir_name)
+      FileUtils.mkdir_p(dir_name)
+
+      File.open(tmp_name, 'w'){|fd| fd.write(data) }
+
+      FileUtils.mv(tmp_name, key_name)
+
+      return value
+    end
+
+    def values_at(*keys)
+      keys.map{|key| self[key] }
+    end
+
+    def delete(*keys)
+      keys.map do |key|
+        FileUtils.rm_rf(dir(key.to_s))
+      end
+    end
+
+    def clear
+      Dir[dir('*')].each{|entry| FileUtils.rm_rf(entry) }
+    end
+
+    def to_sym
+      name.split('::').last.to_sym
+    end
+  end
+end

data/lib/ramaze/contrib.rb

@@ -49,7 +49,7 @@ module Ramaze
           const.startup if const.respond_to?(:startup)
           Log.dev "Loaded contrib: #{const}"
         rescue NameError
-          files = Dir["{contrib,#{BASEDIR/:ramaze/:contrib}}/#{name}.{so,bundle,rb}"]
+          files = Dir["{contrib,#{BASEDIR}/ramaze/contrib}/#{name}.{so,bundle,rb}"]
           raise LoadError, "#{mod_name} not found" unless files.any?
           require(files.first) ? retry : raise
         end

data/lib/ramaze/contrib/email.rb

@@ -67,6 +67,8 @@ Message-Id: #{id}
         send_smtp( email, recipient, subject )
       end
 
+      # the raw mail sending method used by Ramaze::EmailHelper
+
       def send_smtp( email, recipient, subject )
         options = trait.values_at(:smtp_server, :smtp_port, :smtp_helo_domain,
                                   :smtp_username, :smtp_password, :smtp_auth_type)

data/lib/ramaze/contrib/facebook.rb

@@ -1,4 +1,4 @@
-require __DIR__/:facebook/:facebook
+require __DIR__('facebook/facebook')
 
 module Ramaze
   module Helper::Facebook
@@ -20,4 +20,4 @@ module Ramaze
     end
     alias fb facebook
   end
-end
+end

data/lib/ramaze/contrib/file_cache.rb

@@ -1,65 +1,3 @@
-#
-# drop-in replacement for Ramaze's built-in MemoryCache built on the
-# filesystem.  # to use with sessions do
-#
-#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::FileCache
-#
-# to use with everything do
-#
-#   Ramaze::Global::cache = Ramaze::FileCache
-#
+Ramaze::Log.warn("ramaze/contrib/file_cache is now ramaze/cache/file")
 
-module Ramaze::FileCache
-  require "fileutils"
-  require "socket"
-
-  Host = Socket.gethostname
-  Pid = Process.pid
-  Fu = FileUtils
-  Root = File.join Ramaze::APPDIR, "cache"
-
-  Fu.mkdir_p(Root) rescue nil
-
-  def self.[] key
-    path = File.join Root, key, "data"
-    Marshal.load(IO.read(path))
-  rescue
-    nil
-  end
-
-  def self.[]= key, value
-    tmp = File.join Root, key, "data.#{ Host }.#{ Pid }"
-    dirname = File.join Root, key
-    path = File.join Root, key, "data"
-    data = Marshal.dump value
-    Fu.rm_rf dirname rescue nil
-    Fu.mkdir_p dirname rescue nil
-    open(tmp, 'w'){|fd| fd.write data}
-    Fu.mv tmp, path
-  rescue
-    nil
-  end
-
-  def self.values_at *keys
-    keys.map{|key| self[key]}
-  end
-
-  def self.delete *keys
-    keys.map do |key|
-      dirname = File.join Root, key
-      Fu.rm_rf dirname rescue next
-    end
-  end
-
-  def self.clear
-    Dir["#{ Root }/*"].each{|entry| Fu.rm_rf entry}
-  end
-
-  def self.new
-    self
-  end
-
-  def self.to_sym
-    name.split(%r/::/).last.to_sym
-  end
-end
+require 'ramaze/cache/file'

data/lib/ramaze/contrib/sequel/image.rb

@@ -31,7 +31,7 @@
 #       #     Creates a square thumbnail of the image cropping the longest edge
 #       #     to match the shortest edge, resizes to +size+.
 #
-#       :agorithm => :thumbnail,
+#       :algorithm => :thumbnail,
 #
 #
 #       # Key specifies the filename and accessors, value are arguments to the

data/lib/ramaze/controller.rb

@@ -67,13 +67,17 @@ module Ramaze
 
       # if trait[:automap] is set and controller is not in Global.mapping yet
       # this will build a new default mapping-point, MainController is put
-      # at '/' by default.
+      # at '/' by default. For other Class names, String#snake_case is called,
+      # e.g. FooBarController is mapped at '/foo_bar'.
 
       def mapping
         global_mapping = Global.mapping.invert[self]
+
         return global_mapping if global_mapping
+
         if ancestral_trait[:automap] && self.to_s !~ /#<Class:/
           name = self.to_s.gsub('Controller', '').gsub('::', '/').clone
+          return if name.empty?
           name == 'Main' ? '/' : "/#{name.snake_case}"
         end
       end
@@ -262,6 +266,10 @@ module Ramaze
         action.render
       end
 
+      # By default, returns all ancestors of current Controller that have
+      # Ramaze::Controller as their ancestor. Optional argument parent
+      # can be used return ancestors that have parent as an ancestor.
+
       def relevant_ancestors(parent = Ramaze::Controller)
         ancestors.select do |anc|
           anc.ancestors.include?(parent)

data/lib/ramaze/controller/resolve.rb

@@ -16,7 +16,7 @@ module Ramaze
       # instead, in either case with path as argument.
 
       def resolve(path, routed = false)
-        @routed = routed
+        Thread.current[:routed] = routed
 
         FILTER.each do |filter|
           answer = if filter.respond_to?(:call)
@@ -90,7 +90,7 @@ module Ramaze
           end
         end
 
-        if !@routed and new_path = Route.resolve(path)
+        if !Thread.current[:routed] and new_path = Route.resolve(path)
           Log.dev("Routing from `#{path}' to `#{new_path}'")
           return resolve(new_path, true)
         end
@@ -136,10 +136,15 @@ module Ramaze
 
       def resolve_template(path)
         path = path.to_s
-        path_converted = path.split('__').inject{|s,v| s/v}
+        path_converted = path.split('__').inject{|s,v| File.join(s, v) }
         possible_paths = [path, path_converted].compact
 
-        paths = template_paths.map{|pa| possible_paths.map{|a| pa/a } }.flatten.uniq
+        paths = template_paths.map{|pa|
+          possible_paths.map{|a|
+            File.join(pa, a)
+          }
+        }.flatten.uniq
+
         glob = "{#{paths.join(',')}}.{#{extension_order.join(',')}}"
 
         Dir[glob].first
@@ -153,7 +158,7 @@ module Ramaze
         if paths = view_root
           paths
         else
-          view_root(Global.view_root / Global.mapping.invert[self])
+          view_root(File.join(Global.view_root, Global.mapping.invert[self]))
         end
       end
 

data/lib/ramaze/current/request.rb

@@ -28,10 +28,14 @@ module Ramaze
       super
     end
 
+    # the full request URI provided by Rack::Request e.g. http://localhost:7000/controller/action?foo=bar.xhtml
+
     def request_uri
       env['REQUEST_URI'] || path_info
     end
 
+    # the IP address(s) making the request provided by Rack::Request. You shouldn't trust it
+
     def ip
       if addr = env['HTTP_X_FORWARDED_FOR']
         addr.split(',').last.strip
@@ -47,9 +51,8 @@ module Ramaze
     ipv6 = %w[ fc00::/7 fe80::/10 fec0::/10 ::1 ]
     LOCAL = (ipv4 + ipv6).map{|a| IPAddr.new(a)} unless defined?(LOCAL)
 
-    # --
-    # Mongrel somehow puts together multiple IPs when proxy is involved.
-    # ++
+    # returns true if the IP address making the request is from local network.
+    # Optional argument address can be used to check any IP address.
 
     def local_net?(address = ip)
       addr = IPAddr.new(address)
@@ -63,6 +66,15 @@ module Ramaze
       [key, *rest].map{|k| params[k.to_s] }
     end
 
+    # Sets any arguments passed as @instance_variables for the current action.
+    #
+    # Usage:
+    #   request.params # => {'name' => 'manveru', 'q' => 'google', 'lang' => 'de'}
+    #   to_ivs(:name, :q)
+    #   @q    # => 'google'
+    #   @name # => 'manveru'
+    #   @lang # => nil
+
     def to_ivs(*args)
       instance = Action.current.instance
       args.each do |arg|
@@ -71,81 +83,77 @@ module Ramaze
       end
     end
 
-    unless method_defined?(:rack_params)
-      alias rack_params params
-
-      # Wrapping Request#params to support a one-level hash notation.
-      # It doesn't support anything really fancy, so be conservative in its use.
-      #
-      # See if following provides something useful for us:
-      # http://redhanded.hobix.com/2006/01/25.html
-      #
-      # Example Usage:
-      #
-      #  # Template:
-      #
-      #  <form action="/paste">
-      #    <input type="text" name="paste[name]" />
-      #    <input type="text" name="paste[syntax]" />
-      #    <input type="submit" />
-      #  </form>
-      #
-      #  # In your Controller:
-      #
-      #  def paste
-      #    name, syntax = request['paste'].values_at('name', 'syntax')
-      #    paste = Paste.create_with(:name => name, :syntax => syntax)
-      #    redirect '/'
-      #  end
-      #
-      #  # Or, easier:
-      #
-      #  def paste
-      #    paste = Paste.create_with(request['paste'])
-      #    redirect '/'
-      #  end
-
-      def params
-        return {} if put?
-        return @ramaze_params if @ramaze_params
-
-        begin
-          @rack_params ||= rack_params
-        rescue EOFError => ex
-          @rack_params = {}
-          Log.error(ex)
-        end
+    # Wrapping Request#params to support a one-level hash notation.
+    # It doesn't support anything really fancy, so be conservative in its use.
+    #
+    # See if following provides something useful for us:
+    # http://redhanded.hobix.com/2006/01/25.html
+    #
+    # Example Usage:
+    #
+    #  # Template:
+    #
+    #  <form action="/paste">
+    #    <input type="text" name="paste[name]" />
+    #    <input type="text" name="paste[syntax]" />
+    #    <input type="submit" />
+    #  </form>
+    #
+    #  # In your Controller:
+    #
+    #  def paste
+    #    name, syntax = request['paste'].values_at('name', 'syntax')
+    #    paste = Paste.create_with(:name => name, :syntax => syntax)
+    #    redirect '/'
+    #  end
+    #
+    #  # Or, easier:
+    #
+    #  def paste
+    #    paste = Paste.create_with(request['paste'])
+    #    redirect '/'
+    #  end
+
+    def params
+      return {} if put?
+      return @ramaze_params if @ramaze_params
+
+      begin
+        @rack_params ||= super
+      rescue EOFError => ex
+        @rack_params = {}
+        Log.error(ex)
+      end
 
-        @ramaze_params = {}
+      @ramaze_params = {}
 
-        @rack_params.each do |key, value|
-          if key =~ /^(.*?)(\[.*\])/
-            prim, nested = $~.captures
-            ref = @ramaze_params
+      @rack_params.each do |key, value|
+        if key =~ /^(.*?)(\[.*\])/
+          prim, nested = $~.captures
+          ref = @ramaze_params
 
-            keys = nested.scan(/\[([^\]]+)\]/).flatten
-            keys.unshift prim
+          keys = nested.scan(/\[([^\]]+)\]/).flatten
+          keys.unshift prim
 
-            keys.each_with_index do |k, i|
-              if i + 1 >= keys.size
-                ref[k] = value
+          keys.each_with_index do |k, i|
+            if i + 1 >= keys.size
+              ref[k] = value
+            else
+              # in case the value is a string we cannot let it be ref next
+              # time, so throw it away
+              if ref[k].is_a?(String)
+                ref = ref[k] = {}
               else
-                # in case the value is a string we cannot let it be ref next
-                # time, so throw it away
-                if ref[k].is_a?(String)
-                  ref = ref[k] = {}
-                else
-                  ref = ref[k] ||= {}
-                end
+                ref = ref[k] ||= {}
               end
             end
-          else
-            @ramaze_params[key] = value
           end
+        else
+          @ramaze_params[key] = value
         end
-
-        @ramaze_params
       end
+
+      @ramaze_params
     end
 
     # Interesting HTTP variables from env
@@ -156,12 +164,18 @@ module Ramaze
       }
     end
 
+    # Returns a string presentation of the request, useful for debugging
+    # parameters of the action.
+
     def to_s
       p, c, e = params.inspect, cookies.inspect, http_vars.inspect
       %{#<Ramaze::Request params=#{p} cookies=#{c} env=#{e}>}
     end
     alias inspect to_s
 
+    # Pretty prints current action with parameters, cookies and
+    # enviroment variables.
+
     def pretty_print pp
       p, c, e = params, cookies, http_vars
       pp.object_group(self){
@@ -182,9 +196,9 @@ module Ramaze
     # Example:
     #   request.params
     #   # => {'name' => 'jason', 'age' => '45', 'job' => 'lumberjack'}
-    #   request.sub('name')
+    #   request.subset('name')
     #   # => {'name' => 'jason'}
-    #   request.sub(:name, :job)
+    #   request.subset(:name, :job)
     #   # => {'name' => 'jason', 'job' => 'lumberjack'}
 
     def subset(*keys)
@@ -198,6 +212,9 @@ module Ramaze
       URI("#{scheme}://#{host}#{path}")
     end
 
+    # Returns and array of locales from env['HTTP_ACCEPT_LANGUAGE].
+    # e.g. ["fi", "en", "ja", "fr", "de", "es", "it", "nl", "sv"]
+
     def locales
       env['HTTP_ACCEPT_LANGUAGE'].to_s.split(/(?:,|;q=[\d.,]+)/)
     end