ptomato-ramaze 2009.02

data/lib/ramaze/controller.rb

@@ -0,0 +1,288 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/helper'
+require 'ramaze/template'
+require 'ramaze/action'
+
+require 'ramaze/controller/resolve'
+require 'ramaze/controller/error'
+
+module Ramaze
+
+  # The Controller is responsible for combining and rendering actions.
+
+  class Controller
+    include Helper::Methods
+
+    helper :redirect, :link, :sendfile, :flash, :cgi, :partial
+
+    # Whether or not to map this controller on startup automatically
+
+    trait[:automap] ||= true
+
+    # Place to map the Controller to, this is something like '/' or '/foo'
+
+    trait[:map] ||= nil
+
+    # Caches patterns for the given path.
+
+    trait :pattern_cache => Hash.new{|h,k| h[k] = Controller.pattern_for(k) }
+
+    class << self
+      # When Controller is subclassed the resulting class is placed in
+      # Global.controllers and a new trait :actions_cached is set on it.
+
+      def inherited controller
+        controller.trait :actions_cached => {}
+        Global.controllers << controller
+        if map = controller.mapping
+          Log.dev("mapping #{map} => #{controller}")
+          Global.mapping[map] ||= controller
+        end
+      end
+
+      # called from Ramaze.startup, adds Cache.actions and Cache.patterns, walks
+      # all controllers subclassed so far and adds them to the Global.mapping if
+      # they are not assigned yet.
+
+      def startup options = {}
+        Log.dev("found Controllers: #{Global.controllers.inspect}")
+
+        check_path("Public root: '%s' doesn't exist", Global.public_root)
+        check_path("View root: '%s' doesn't exist", Global.view_root)
+
+        require 'ramaze/controller/main' if Global.mapping.empty?
+
+        Log.debug("mapped Controllers: #{Global.mapping.inspect}")
+      end
+
+      # checks paths for existance and logs a warning if it doesn't exist yet.
+
+      def check_path(message, *paths)
+        paths.each do |path|
+          Log.warn(message % path) unless File.directory?(path)
+        end
+      end
+
+      # 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. 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
+
+      # Map Controller to the given syms or strings.
+      # Replaces old mappings.
+      # If you want to _add_ a mapping, just modify Global.mapping.
+
+      def map(*syms)
+        Global.mapping.delete_if{|k,v| v == self}
+
+        syms.compact.each do |sym|
+          Global.mapping[sym.to_s] = self
+        end
+      end
+
+      # Returns the Controller at a mapped path.
+
+      def at(mapping)
+        Global.mapping[mapping.to_s]
+      end
+
+      # Define a layout for all actions on this controller
+      #
+      # Example:
+      #   class Foo < Ramaze::Controller
+      #     layout :foo
+      #   end
+      #
+      #  This defines the action :foo to be layout of the controller and will
+      #  render the layout after any other action has been rendered, assigns
+      #  @content to the result of the action and then goes on rendering
+      #  the layout-action where @content may or may not be used, returning
+      #  whatever the layout returns.
+
+      def layout(*meth_or_hash)
+        if meth_or_hash.empty?
+          trait[:layout] ||= ( ancestral_trait[:layout] || {:all => nil, :deny => Set.new} ).dup
+        else
+          meth_or_hash = meth_or_hash.first
+          if meth_or_hash.respond_to?(:to_hash)
+            meth_or_hash.each do |layout_name, *actions|
+              actions.flatten.each do |action|
+                layout[action.to_s] = layout_name
+              end
+            end
+          else
+            layout[:all] = meth_or_hash
+          end
+        end
+      end
+
+      # Deny layout for passed names of actions.
+      # Name should be name of the method or template without extension, as
+      # String or Symbol
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     deny_layout :atom
+      #
+      #     def atom
+      #       "I won't have layout"
+      #     end
+      #   end
+
+      def deny_layout(*actions)
+        actions.each do |action|
+          layout[:deny] << action.to_s
+        end
+      end
+
+      # Define a view_root for Controller, returns the current view_root
+      # if no argument is given.
+      # Runs every given path through Controller::check_path
+
+      def view_root *args
+        return @view_root if args.empty?
+
+        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
+      # controller and action to route to.
+      #
+      # Usage:
+      #   class MainController
+      #     template :index, OtherController, :list
+      #     template :foo, :bar
+      #     template :bar, :file => '/absolute/path'
+      #     template :baz, :file => 'relative/path'
+      #     template :abc, :controller => OtherController
+      #     template :xyz, :controller => OtherController, :action => 'list'
+      #
+      #     def index
+      #       'will use template from OtherController#list'
+      #     end
+      #
+      #     def foo
+      #       'will use template from self#bar'
+      #     end
+      #
+      #     def bar
+      #       'will use template from /absolute/path'
+      #     end
+      #
+      #     def baz
+      #       'will use template from relative/path'
+      #     end
+      #
+      #     def abc
+      #       'will use template from OtherController#index'
+      #     end
+      #
+      #     def xyz
+      #       'will use template from OtherController#list'
+      #     end
+      #   end
+
+      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
+          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
+
+      # This is a method to specify the templating engine for your controller.
+      # It basically just is sugar for:
+      #   trait :engine => Haml
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     engine :Haml
+      #   end
+
+      def engine(name)
+        name = Template.const_get(name)
+      rescue NameError => ex
+        Log.warn ex
+        Log.warn "Try to use passed engine directly"
+      ensure
+        trait :engine => name
+      end
+
+      # Return Controller of current Action
+
+      def current
+        action = Action.current
+        action.instance || action.controller
+      end
+
+      # Entering point for Dispatcher, first Controller::resolve(path) and then
+      # renders the resulting Action.
+
+      def handle path
+        action = resolve(path)
+        STATE[:controller] = action.controller
+        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)
+        end
+      end
+    end
+
+    private
+
+    # Simplistic render, rerouting to Controller.handle(*args)
+
+    def render *args
+      self.class.handle(*args)
+    end
+  end
+end

data/lib/ramaze/current/request.rb

@@ -0,0 +1,231 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'rack/request'
+
+module Ramaze
+
+  # The purpose of this class is to act as a simple wrapper for Rack::Request
+  # and provide some convinient methods for our own use.
+
+  class Request < ::Rack::Request
+    class << self
+
+      # get the current request out of STATE[:request]
+      #
+      # You can call this from everywhere with Ramaze::Request.current
+
+      def current() Current.request end
+    end
+
+    # you can access the original @request via this method_missing,
+    # first it tries to match your method with any of the HTTP parameters
+    # then, in case that fails, it will relay to @request
+
+    def method_missing meth, *args
+      key = meth.to_s.upcase
+      return env[key] if env.has_key?(key)
+      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
+      else
+        env['REMOTE_ADDR']
+      end
+    end
+
+    # Request is from a local network?
+    # Checks both IPv4 and IPv6
+
+    ipv4 = %w[ 127.0.0.1/32 192.168.0.0/16 172.16.0.0/12 10.0.0.0/8 169.254.0.0/16 ]
+    ipv6 = %w[ fc00::/7 fe80::/10 fec0::/10 ::1 ]
+    LOCAL = (ipv4 + ipv6).map{|a| IPAddr.new(a)} unless defined?(LOCAL)
+
+    # 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)
+      LOCAL.find{|range| range.include?(addr) }
+    rescue ArgumentError => ex
+      raise ArgumentError, ex unless ex.message == 'invalid address'
+    end
+
+    def [](key, *rest)
+      return params[key.to_s] if rest.empty?
+      [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|
+        next unless value = self[arg]
+        instance.instance_variable_set("@#{arg}", value)
+      end
+    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 = {}
+
+      @rack_params.each do |key, value|
+        if key =~ /^(.*?)(\[.*\])/
+          prim, nested = $~.captures
+          ref = @ramaze_params
+
+          keys = nested.scan(/\[([^\]]+)\]/).flatten
+          keys.unshift prim
+
+          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
+                ref = ref[k] ||= {}
+              end
+            end
+          end
+        else
+          @ramaze_params[key] = value
+        end
+      end
+
+      @ramaze_params
+    end
+
+    # Interesting HTTP variables from env
+
+    def http_vars
+      env.reject{ |k,v|
+        k.to_s !~ /USER|HOST|REQUEST|REMOTE|FORWARD|REFER|PATH|QUERY|VERSION|KEEP|CACHE/
+      }
+    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){
+        { 'params' => params,
+          'cookies' => cookies,
+          'env' => http_vars }.each do |name, hash|
+          pp.breakable
+          pp.text " @#{name}="
+          pp.nest(name.length+3){ pp.pp_hash hash }
+        end
+      }
+    end
+
+    # Answers with a subset of request.params with only the key/value pairs for
+    # which you pass the keys.
+    # Valid keys are objects that respond to :to_s
+    #
+    # Example:
+    #   request.params
+    #   # => {'name' => 'jason', 'age' => '45', 'job' => 'lumberjack'}
+    #   request.subset('name')
+    #   # => {'name' => 'jason'}
+    #   request.subset(:name, :job)
+    #   # => {'name' => 'jason', 'job' => 'lumberjack'}
+
+    def subset(*keys)
+      keys = keys.map{|k| k.to_s }
+      params.reject{|k,v| not keys.include?(k) }
+    end
+
+    # Is this an SSL request?
+    def ssl?
+      env['HTTPS'] == 'on' || env['HTTP_X_FORWARDED_PROTO'] == 'https'
+    end
+
+    # Returns 'https' if this is an SSL request and 'http' otherwise.
+    def protocol
+      ssl? ? 'https' : 'http'
+    end
+
+    def domain(path = '/')
+      host = env['HTTP_HOST']
+      URI("#{protocol}://#{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
+  end
+end