manveru-ramaze 2008.10 → 2008.12

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){
@@ -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

data/lib/ramaze/current/session/hash.rb

@@ -9,8 +9,8 @@ module Ramaze
 
       # Sets @hash to an empty Hash
 
-      def initialize sess
-        @session = sess
+      def initialize(session)
+        @session = session
         @hash = {}
       end
 
@@ -18,11 +18,8 @@ module Ramaze
       # Session.current.sessions if anything changes.
 
       def method_missing(*args, &block)
-        old = @hash.dup
         result = @hash.send(*args, &block)
-        unless old == @hash
-          Cache.sessions[@session.session_id] = self
-        end
+        Cache.sessions[@session.session_id] = self
         result
       end
 
@@ -48,11 +45,10 @@ module Ramaze
 
       # Unmarshal cookie data to a hash and verify its integrity.
       def unmarshal(cookie)
-        if cookie
-          data, digest = cookie.split('--')
-          return nil unless digest == generate_digest(data)
-          Marshal.load(data.unpack('m').first)
-        end
+        return unless cookie
+        data, digest = cookie.split('--')
+        return nil unless digest == generate_digest(data)
+        Marshal.load(data.unpack('m').first)
       end
 
       # Generate the inline SHA512 message digest. Larger (128 bytes) than SHA256

data/lib/ramaze/current/session.rb

@@ -96,7 +96,7 @@ module Ramaze
     def initialize(sess_or_request = Current.request)
       return unless Global.sessions
 
-      if sess_or_request.is_a?(Request)
+      if sess_or_request.respond_to?(:cookies)
         request = sess_or_request
         @session_id = request.cookies[SESSION_KEY] || Session.random_key
       else
@@ -125,10 +125,8 @@ module Ramaze
     # existing already, the session itself is an instance of SessionHash
 
     def current
-      unless @current
-        @current = ( sessions[session_id] ||= Session::Hash.new(self) )
-      end
-      @current
+      return @current if @current
+      @current = ( sessions[session_id] ||= Session::Hash.new(self) )
     end
 
     # shortcut to Cache.sessions

data/lib/ramaze/dispatcher/action.rb

@@ -35,6 +35,8 @@ module Ramaze
           ex
         end
 
+        # Logs the request via Log#info unless it's boring.
+
         def log(path)
           case path
           when *Global.boring

data/lib/ramaze/dispatcher/file.rb

@@ -79,6 +79,10 @@ module Ramaze
 
         private
 
+        # Shortcut for Ramaze::Dispatcher::File#expand_path(path).
+        # Returns the absolute path of passed argument e.g.
+        # "/Users/rikur/ramaze_tests/public/foo.txt"
+
         def expand(path)
           ::File.expand_path(path)
         end

data/lib/ramaze/helper/aspect.rb

@@ -76,7 +76,7 @@ module Ramaze
   class Action
 
     # overwrites the default Action hook and runs the neccesary blocks in its
-    # scope. before actions are run starting from Ramaze::Controller down the
+    # scope before actions are run, starting from Ramaze::Controller down the
     # ancestor chain.
     def before_process
       common_aspect(:before)
@@ -84,7 +84,7 @@ module Ramaze
 
 
     # overwrites the default Action hook and runs the neccesary blocks in its
-    # scope. before actions are run starting from Ramaze::Controller down the
+    # scope after actions are run, starting from Ramaze::Controller down the
     # ancestor chain.
     def after_process
       common_aspect(:after)

data/lib/ramaze/helper/form.rb

@@ -219,16 +219,19 @@ module Ramaze
 
   # Form for instances of the model class
   class InstanceForm < Form
-    # <input type='text' name='name' value='value' />
+    # returns <input type='text' name='name' value='value' />
     def field_input(name, value)
       "<input type='text' name='#{name}' value='#{value}'/>"
     end
 
+    # returns <textarea name='name'>#{value}</textarea>
+
     def field_textarea(name, value)
       "<textarea name='#{name}'>#{value}</textarea>"
     end
 
-    # <input type="text" name="name" value="value" />
+    # returns <input type="text" name="name" value="value" />
+
     def field_integer(name, value)
       field_input(name, value)
     end

data/lib/ramaze/helper/formatting.rb

@@ -111,6 +111,10 @@ module Ramaze
     end
     alias autolink auto_link
 
+    # takes a string and optional argument for outputting compliance HTML
+    # instead of XHTML.
+    # e.g nl2br "a\nb\n\c" #=> 'a<br />b<br />c'
+
     def nl2br(string, xhtml = true)
       br = xhtml ? '<br />' : '<br>'
       string.gsub(/\n/, br)

data/lib/ramaze/helper/gravatar.rb

@@ -1,12 +1,29 @@
 module Ramaze
   module Helper
     module Gravatar
+
+      # fetches a gravatar from http//www.gravatar.com based on 'email'
+      # and 'size'. Falls back to 'fallback_path' if no gravatar is found.
+      # default 'fallback_path' is "/images/gravatar_default.jpg".
+      # example:
+      #
+      # class GravatarController < Ramaze::Controller
+      #    helper :gravatar
+      #
+      #    def index
+      #      @gravatar_thumbnail_src = gravatar(session[:email] || 'riku@helloit.fi')
+      #    end
+      # end
+      #
+      #  /view/gravatar/index.html:
+      #  <img src="#{@gravatar_thumbnail_src}" />
+
       def gravatar(email, size = 32, fallback_path = "/images/gravatar_default.jpg")
         emailhash = Digest::MD5.hexdigest(email)
 
         fallback = Request.current.domain
         fallback.path = fallback_path
-        default = h(fallback.to_s)
+        default = Rack::Utils.escape(fallback.to_s)
 
         return "http://www.gravatar.com/avatar.php?gravatar_id=#{emailhash}&default=#{default}&size=#{size}"
       end

data/lib/ramaze/helper/maruku.rb

@@ -1,3 +1,5 @@
+require 'maruku'
+
 module Ramaze
   module Helper::Maruku
     def maruku(text)

data/lib/ramaze/helper/redirect.rb

@@ -59,7 +59,7 @@ module Ramaze
     def raw_redirect(target, opts = {})
       target = target.to_s
       header = {'Location' => target}
-      status = opts[:status] || STATUS_CODE["Moved Temporarily"]
+      status = opts[:status] || 302 # Found
       body = %{You are being redirected, please follow <a href="#{target}">this link to: #{target}</a>!}
 
       Log.info("Redirect to '#{target}'")
@@ -72,10 +72,28 @@ module Ramaze
       request[:redirected]
     end
 
-    # redirect to the location the browser says it's coming from.
+    # Redirect to the location the browser says it's coming from.
+    # If the current address is the same as the referrer or no referrer exists
+    # yet, we will redirect to +fallback+.
+    #
+    # NOTE:
+    #   * In some cases this may result in a double redirect, given that the
+    #     request query parameters may change order. We don't have a nice way
+    #     of handling that yet, but it should be very, very rare
+
+    def redirect_referer(fallback = R(:/))
+      if referer = request.referer and url = request.url
+        referer_uri = URI(referer)
+        request_uri = URI(url)
 
-    def redirect_referer
-      redirect request.referer
+        if referer_uri == request_uri
+          redirect fallback
+        else
+          redirect referer
+        end
+      else
+        redirect fallback
+      end
     end
     alias redirect_referrer redirect_referer
   end

data/lib/ramaze/helper.rb

@@ -45,7 +45,7 @@ module Ramaze
             if require_helper(name)
               redo
             else
-              raise LoadError, "#{name} not found"
+              raise LoadError, "helper #{name} not found"
             end
           end
         end
@@ -53,6 +53,8 @@ module Ramaze
 
       private
 
+      # returns the Ramaze::Helper::Name Module Constant if exists.
+
       def find_helper(name)
         name = name.to_s.camel_case
         ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
@@ -61,16 +63,21 @@ module Ramaze
         end
       end
 
+      # Loads helper from /lib/ramaze/helper/name.(so, bundle, rb)
+      # raises LoadError if helper not found.
+
       def require_helper(name)
         paths = (PATH + [Global.root, "#{BASEDIR}/ramaze"]).join(',')
         glob = "{#{paths}}/helper/#{name}.{so,bundle,rb}"
         files = Dir[glob]
         ignore = Helper.trait[:ignore]
         files.reject!{|f| ignore.any?{|i| f =~ i }}
-        raise LoadError, "#{name} not found" unless file = files.first
+        raise LoadError, "file for #{name} not found" unless file = files.first
         require(file)
       end
 
+      # injects the helper via include and extend, takes Constant as argument.
+
       def use_helper(mod)
         include mod
         extend mod

data/lib/ramaze/reloader/watch_inotify.rb

@@ -0,0 +1,73 @@
+module Ramaze
+  class Reloader
+    class WatchInotify
+      POLL_INTERVAL = 2 # seconds
+
+      def initialize
+        @watcher = RInotify.new
+        @changed = []
+        @mutex = Mutex.new
+        @watcher_thread = start_watcher
+      end
+
+      def call(cooldown)
+        yield if @changed.any?
+      end
+
+      # TODO: define a finalizer to cleanup? -- reloader never calls #close
+
+      def start_watcher
+        Thread.new do
+          loop do
+            watcher_cycle
+            sleep POLL_INTERVAL
+          end
+        end
+      end
+
+      def watcher_cycle
+        return unless @watcher.wait_for_events(0)
+        changed_descriptors = []
+
+        @watcher.each_event do |event|
+          changed_descriptors << event.watch_descriptor
+        end
+
+        @mutex.synchronize do
+          changed_descriptors.each do |descriptor|
+            @changed << @watcher.watch_descriptors[descriptor]
+          end
+        end
+      end
+
+      def watch(file)
+        return false if @watcher.watch_descriptors.has_value?(file)
+        return false unless File.exist?(file)
+
+        @mutex.synchronize{ @watcher.add_watch(file, RInotify::MODIFY) }
+
+        true
+      end
+
+      def remove_watch(file)
+        @mutex.synchronize{ @watcher.rm_watch(file) }
+        true
+      end
+
+      def close
+        @watcher_thread.terminate
+        @watcher.close
+        true
+      end
+
+      def changed_files
+        @mutex.synchronize do
+          @tmp = @changed
+          @changed = []
+        end
+        @tmp.uniq!
+        @tmp
+      end
+    end
+  end
+end

data/lib/ramaze/reloader/watch_stat.rb

@@ -0,0 +1,62 @@
+module Ramaze
+  class Reloader
+    class WatchStat
+      def initialize
+        # @files[file_path] = stat
+        @files = {}
+        @last = Time.now
+      end
+
+      def call(cooldown)
+        if cooldown and Time.now > @last + cooldown
+          yield
+          @last = Time.now
+        end
+      end
+
+      # start watching a file for changes
+      # true if succeeded, false if failure
+      def watch(file)
+        return true if watching?(file) # if already watching
+        if stat = safe_stat(file)
+          @files[file] = stat
+        end
+      end
+
+      def watching?(file)
+        @files.has_key?(file)
+      end
+
+      # stop watching a file for changes
+      def remove_watch(file)
+        @files.delete(file)
+      end
+
+      # no need for cleanup
+      def close
+      end
+
+      # return files changed since last call
+      def changed_files
+        changed = []
+
+        @files.each do |file, stat|
+          if new_stat = safe_stat(file)
+            if new_stat.mtime > stat.mtime
+              changed << file
+              @files[file] = new_stat
+            end
+          end
+        end
+
+        changed
+      end
+
+      def safe_stat(file)
+        File.stat(file)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+    end
+  end
+end