ramaze 2008.06 → 2008.11

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

@@ -0,0 +1,82 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.     
+
+# Pretty DSL to express Sequel relations
+#
+# Usage:
+#   SequelRelation.relations do
+#     the User do
+#       has_many Article
+#       has_one Avatar
+#     end
+#
+#     the Article do
+#       belongs_to User
+#     end
+#
+#     the Avatar do
+#       belongs_to User
+#     end
+#   end
+
+module SequelRelation
+  def self.relations(&block)
+    rema = RelationshipManager.new(&block)
+    rema.finalize
+  end
+
+  class RelationshipManager
+    TODO = {}
+
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    def finalize
+      TODO.keys.each do |model|
+        model.create_table unless model.table_exists?
+      end
+
+      TODO.each do |model, instructions|
+        instructions.each do |args|
+          model.send(*args)
+        end
+      end
+
+      return # remove this line for debugging
+
+      pp TODO
+
+      TODO.keys.each do |model|
+        puts "the #{model}"
+        assoc = model.send(:association_reflections)
+        assoc.each do |key, reflection|
+          puts "  #{reflection[:type]} => #{key}"
+        end
+      end
+    end
+
+    def the(left_model, &block)
+      @left = left_model
+      TODO[@left] = []
+      instance_eval(&block)
+    end
+
+    def belongs_to(model)
+      todo :belongs_to, model.to_s.downcase.to_sym
+    end
+
+    def has_many(model)
+      todo :create_join, model
+      todo :many_to_many, model.to_s.downcase.pluralize.to_sym
+    end
+
+    def has_one(model)
+      todo :belongs_to, model.to_s.downcase.to_sym
+    end
+
+    def todo(method, *args)
+      TODO[@left] << [method, *args]
+    end
+  end
+end

data/lib/ramaze/controller.rb

@@ -85,7 +85,7 @@ module Ramaze
       def map(*syms)
         Global.mapping.delete_if{|k,v| v == self}
 
-        syms.each do |sym|
+        syms.compact.each do |sym|
           Global.mapping[sym.to_s] = self
         end
       end
@@ -150,17 +150,10 @@ module Ramaze
       # Runs every given path through Controller::check_path
 
       def view_root *args
-        if args.empty?
-          @view_root
-        else
-          check_path("#{self}.view_root: '%s' doesn't exist", *args)
-          @view_root = args.flatten
-        end
-      end
+        return @view_root if args.empty?
 
-      def template_root(*args)
-        Ramaze.deprecated("Controller::template_root", "Controller::view_root")
-        view_root(*args)
+        check_path("#{self}.view_root: '%s' doesn't exist", *args)
+        @view_root = args.flatten
       end
 
       # This is used for template rerouting, takes action, optionally a
@@ -202,30 +195,36 @@ module Ramaze
 
       def template(this, *argv)
         case argv.first
-          when Hash
-            options, *ignored = argv
-            controller = options[:controller] || options['controller']
-            action = options[:action] || options['action']
-            file = options[:file] || options['file']
-            info = {}
-            if file
-              file = file.to_s
-              unless Pathname(file).absolute?
-                root = [view_root || Global.view_root].flatten.first
-                file = File.join(root, file)
-              end
-              info[:file] = file
-            else
-              controller ||= self
-              action = (action || 'index').to_s
-              info[:controller] = controller
-              info[:action] = action
+        when Hash
+          options, *ignored = argv
+          controller = options[:controller] || options['controller']
+          action = options[:action] || options['action']
+          file = options[:file] || options['file']
+          info = {}
+          if file
+            file = file.to_s
+            unless Pathname(file).absolute?
+              root = [view_root || Global.view_root].flatten.first
+              file = File.join(root, file)
             end
-            trait "#{this}_template" => info
+            info[:file] = file
           else
-            controller, action, *ignored = argv
-            controller, action = self, controller unless action
-            trait "#{this}_template" => {:controller => controller, :action => action}
+            controller ||= self
+            action = (action || 'index').to_s
+            info[:controller] = controller
+            info[:action] = action
+          end
+          trait "#{this}_template" => info
+        else
+          # Only explicitly set the controller to use, if it was explicitly given.
+          # This helps ensure that template mappings still work in subclasses
+          # of this controller.
+          first, second, *ignored = argv
+          if second
+            trait "#{this}_template" => {:controller => first, :action => second}
+          else
+            trait "#{this}_template" => {:action => first}
+          end
         end
       end
 
@@ -259,7 +258,7 @@ module Ramaze
 
       def handle path
         action = resolve(path)
-        Thread.current[:controller] = action.controller
+        STATE[:controller] = action.controller
         action.render
       end
 

data/lib/ramaze/controller/resolve.rb

@@ -104,10 +104,13 @@ module Ramaze
 
       def resolve_action(path, *parameter)
         path, parameter = path.to_s, parameter.map{|e| e.to_s}
-        if info = trait["#{path}_template"]
+        # Use ancestral_trait so if template is set in superclass, it is still found.
+        if info = ancestral_trait["#{path}_template"]
           template = info[:file]
           unless template
             controller, action = info.values_at :controller, :action
+            # Controller may not have been explicitly set, in which case use self.
+            controller ||= self
             template = controller.resolve_template(action)
           end
         end
@@ -154,15 +157,25 @@ module Ramaze
         end
       end
 
-      # Based on methodname and arity, tries to find the right method on current controller.
+      # Based on methodname and arity, tries to find the right method on
+      # current controller.
       def resolve_method(name, *params)
-        if method = [ name, name.gsub('__','/') ].find{|n|
-          cached_action_methods.include?(n) }
+        cam = cached_action_methods
+
+        if cam.include?(name)
+          method = name
+        else
+          name = name.gsub(/__/, '/')
+          method = name if cam.include?(name)
+        end
+
+        if method
           arity = instance_method(method).arity
-          if params.size == arity or arity < 0
+          if arity < 0 or params.size == arity
             return method, params
           end
         end
+
         return nil, []
       end
 
@@ -174,8 +187,7 @@ module Ramaze
 
       # methodnames that may be used for current controller.
       def action_methods
-        ancs = relevant_ancestors + Helper::LOOKUP.to_a
-
+        ancs = relevant_ancestors + action_modules
         ancs.reverse.inject [] do |meths, anc|
           meths +
             anc.public_instance_methods(false).map{|im| im.to_s } -
@@ -183,6 +195,14 @@ module Ramaze
         end
       end
 
+      # Array of all modules (so including Ramaze helpers) that are included in
+      # this controller and where the module is also in the Helper::LOOKUP set.
+      # Hence this is the included modules whose public methods may be exposed
+      # as actions of this controller.
+      def action_modules
+        Helper::LOOKUP.find_all {|mod| self.include?(mod)}
+      end
+
       # Iterator that yields potential ways in which a given path could be mapped
       # to controller, action and params. It produces them in strict order, with
       # longest controller path favoured, then longest action path.
@@ -230,7 +250,7 @@ module Ramaze
       # Raises Ramaze::Error::NoFilter
       # TODO:
       #   * is this called at all for anybody?
-      #     I think everybody does have filters.
+      #     I think everybody has filters.
 
       def raise_no_filter(path)
         raise Ramaze::Error::NoFilter, "No Filter found for `#{path}'"
@@ -245,7 +265,7 @@ module Ramaze
       # Raises Ramaze::Error::NoAction
 
       def raise_no_action(controller, path)
-        Thread.current[:controller] = controller
+        STATE[:controller] = controller
         raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
       end
     end

data/lib/ramaze/current.rb

@@ -3,6 +3,54 @@ require 'ramaze/current/response'
 require 'ramaze/current/session'
 
 module Ramaze
+  class Current
+    include Trinity
+    extend Trinity
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      setup(env)
+      before_call
+      record
+
+      @app.call(env)
+      finish
+    ensure
+      after_call
+    end
+
+    def record
+      return unless filter = Global.record
+      request = Current.request
+      Record << request if filter.call(request)
+    end
+
+    def setup(env)
+      self.request = Request.new(env)
+      self.response = Response.new
+      self.session = Session.new
+    end
+
+    def finish
+      session.finish if session
+      response.finish
+    end
+
+    def self.call(env)
+    end
+
+    def before_call
+    end
+
+    def after_call
+    end
+  end
+end
+__END__
+
   module Current
     class << self
       include Trinity
@@ -35,35 +83,27 @@ module Ramaze
       end
 
       def before(&block)
-        @before = block if block
-        @before
+        @before = block_given? ? block : @before
       end
 
       def before_call
-        if before
-          begin
-            before.call
-          rescue Object => e
-            Ramaze::Log.error e
-            raise
-          end
-        end
+        return unless before
+        before.call
+      rescue Object => e
+        Ramaze::Log.error e
+        raise e
       end
 
       def after(&block)
-        @after = block if block
-        @after
+        @after = block_given? ? block : @after
       end
 
       def after_call
-        if after
-          begin
-            after.call
-          rescue Object => e
-            Ramaze::Log.error e
-            raise
-          end
-        end
+        return unless after
+        after.call
+      rescue Object => e
+        Ramaze::Log.error e
+        raise e
       end
     end
   end

data/lib/ramaze/current/request.rb

@@ -11,7 +11,7 @@ module Ramaze
   class Request < ::Rack::Request
     class << self
 
-      # get the current request out of Thread.current[:request]
+      # get the current request out of STATE[:request]
       #
       # You can call this from everywhere with Ramaze::Request.current
 
@@ -33,7 +33,11 @@ module Ramaze
     end
 
     def ip
-      env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR']
+      if addr = env['HTTP_X_FORWARDED_FOR']
+        addr.split(',').last.strip
+      else
+        env['REMOTE_ADDR']
+      end
     end
 
     # Request is from a local network?
@@ -48,7 +52,6 @@ module Ramaze
     # ++
 
     def local_net?(address = ip)
-      address = address.to_s.split(',').first
       addr = IPAddr.new(address)
       LOCAL.find{|range| range.include?(addr) }
     rescue ArgumentError => ex
@@ -56,10 +59,8 @@ module Ramaze
     end
 
     def [](key, *rest)
-      value = params[key.to_s]
-      return value if rest.empty?
-      keys = rest.flatten.map{|k| k.to_s}
-      Array[value, *params.values_at(*keys)]
+      return params[key.to_s] if rest.empty?
+      [key, *rest].map{|k| params[k.to_s] }
     end
 
     def to_ivs(*args)

data/lib/ramaze/current/response.rb

@@ -15,13 +15,25 @@ module Ramaze
     end
 
     # Build/replace this responses data
-    def build(body = body, status = status, header = header)
+    def build(new_body = body, status = status, header = header)
       header.each do |key, value|
         self[key] = value
       end
 
-      self.body, self.status = body, status
-      self
+      self.body, self.status = new_body, status
+    end
+
+    def body=(obj)
+      if obj.respond_to?(:stat)
+        @length = obj.stat.size
+        @body = obj
+      elsif obj.respond_to?(:size)
+        @body = []
+        @length = 0
+        write(obj)
+      else
+        raise(ArgumentError, "Invalid body: %p" % obj)
+      end
     end
   end
 end

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

@@ -67,6 +67,14 @@ module Ramaze
         combined.empty?
       end
 
+      def merge!(hash)
+        current.merge!(hash)
+      end
+
+      def merge(hash)
+        current.merge(hash)
+      end
+
       private
 
       # Associated session object