manveru-ramaze 2009.01 → 2009.04

data/lib/ramaze/controller/resolve.rb

@@ -1,278 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze
-  class Controller
-    # TODO:
-    #   * fix caching, see todos below
-    #     FILTER = [ :cached, :default ] unless defined?(FILTER)
-    FILTER = [ :default ] unless defined?(FILTER)
-
-    class << self
-
-      # Resolve an absolute path in the application by passing it to each
-      # element of Ramaze::Controller::FILTER.
-      # If an element does not respond to call it will be sent to self
-      # instead, in either case with path as argument.
-
-      def resolve(path, routed = false)
-        Thread.current[:routed] = routed
-
-        FILTER.each do |filter|
-          answer = if filter.respond_to?(:call)
-                     filter.call(path)
-                   else
-                     send(filter.to_s, path)
-                   end
-          return answer if answer
-        end
-
-        raise_no_filter(path)
-      end
-
-      # Default element of FILTER.
-      # Looks up the path in Cache.resolved and returns it if found.
-
-      def cached(path)
-        if found = Cache.resolved[path]
-          if found.respond_to?(:relaxed_hash)
-            return found.dup
-          else
-            Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
-            Cache.resolved.delete path
-          end
-        end
-
-        nil
-      end
-
-      # Default element of FILTER.
-      # The default handler that tries to find the best match for the given
-      # path in terms of Controller/method/template and given arguments.
-      # If a match is found it will be cached for further use.
-
-      def default(path)
-        mapping     = Global.mapping
-        controllers = Global.controllers
-
-        raise_no_controller(path) if controllers.empty? or mapping.empty?
-
-        # TODO:
-        #   * following code is dangerous (DoS):
-        #     patterns = Cache.patterns[path] ||= pattern_for(path)
-
-        first_controller = nil
-
-        # Look through the possible ways of interpreting the path until we find
-        # one that matches an existing controller action.
-        patterns_for(path) do |controller, method, params|
-          if controller = mapping[controller]
-            first_controller ||= controller
-
-            action = controller.resolve_action(method, *params)
-            next unless action
-
-            template = action.template
-
-            valid_action =
-              if Action.stack.size > 0 || Global.actionless_templates
-                action.method or (params.empty? && template)
-              else
-                action.method
-              end
-
-            if valid_action
-              # TODO:
-              #   * dangerous as well
-              #     Cache.resolved[path] = action
-              return action
-            end
-          end
-        end
-
-        if !Thread.current[:routed] and new_path = Route.resolve(path)
-          Log.dev("Routing from `#{path}' to `#{new_path}'")
-          return resolve(new_path, true)
-        end
-
-        raise_no_action(first_controller, path) if first_controller
-        raise_no_controller(path)
-      end
-
-      # Try to produce an Action from the given path and paremters with the
-      # appropiate template if one exists.
-
-      def resolve_action(path, *parameter)
-        path, parameter = path.to_s, parameter.map{|e| e.to_s}
-        # 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
-
-        method, params = resolve_method(path, *parameter)
-
-        if method or parameter.empty?
-          template ||= resolve_template(path)
-        end
-
-        action =
-          Action.create :path       => path,
-                        :method     => method,
-                        :params     => params,
-                        :template   => template,
-                        :controller => self
-        return false unless action.valid_rest?
-        action
-      end
-
-      # Search the #template_paths for a fitting template for path.
-      # Only the first found possibility for the generated glob is returned.
-
-      def resolve_template(path)
-        path = path.to_s
-        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|
-            File.join(pa, a)
-          }
-        }.flatten.uniq
-
-        glob = "{#{paths.join(',')}}.{#{extension_order.join(',')}}"
-
-        Dir[glob].first
-      end
-
-      # Composes an array with the template-paths to look up in the right order.
-      # Usually this is composed of Global.view_root and the mapping of the
-      # controller.
-
-      def template_paths
-        if paths = view_root
-          paths
-        else
-          view_root(File.join(Global.view_root, Global.mapping.invert[self]))
-        end
-      end
-
-      # Based on methodname and arity, tries to find the right method on
-      # current controller.
-      def resolve_method(name, *params)
-        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 arity < 0 or params.size == arity
-            return method, params
-          end
-        end
-
-        return nil, []
-      end
-
-      # List or create a list of action methods to be cached
-
-      def cached_action_methods
-        Cache.action_methods[self] ||= action_methods
-      end
-
-      # methodnames that may be used for current controller.
-      def action_methods
-        ancs = relevant_ancestors + action_modules
-        ancs.reverse.inject [] do |meths, anc|
-          meths +
-            anc.public_instance_methods(false).map{|im| im.to_s } -
-            anc.private_instance_methods(false).map{|im| im.to_s }
-        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.
-
-      def patterns_for path
-        # Split into fragments, and remove empty ones (which split may have output).
-        # The to_s is vital as sometimes we are passed an array.
-        fragments = path.to_s.split '/'
-        fragments.delete ''
-
-        # Work through all the possible splits of controller and 'the rest' (action
-        # + params) starting with longest possible controller.
-        fragments.length.downto(0) do |ca_split|
-          controller = '/' + fragments[0...ca_split].join('/')
-
-          # Work on the remaining portion, generating all the action/params splits.
-          fragments.length.downto(ca_split) do |ap_split|
-            action = fragments[ca_split...ap_split].join '__'
-            params = fragments[ap_split..-1]
-            if action.empty?
-              yield controller, 'index', params
-            else
-              yield controller, "#{action}__index", params
-              yield controller, action, params
-            end
-          end
-        end
-      end
-
-      # Uses custom defined engines and all available engines and throws it
-      # against the extensions for the template to find the most likely
-      # templating-engine to use ordered by priority and likelyhood.
-      def extension_order
-        t_extensions = Template::ENGINES
-        all_extensions = t_extensions.values.flatten
-
-        if engine = trait[:engine]
-          c_extensions = t_extensions.select{|k,v| k == engine}.map{|k,v| v}.flatten
-          return (c_extensions + all_extensions).uniq
-        end
-
-        all_extensions
-      end
-
-      # Raises Ramaze::Error::NoFilter
-      # TODO:
-      #   * is this called at all for anybody?
-      #     I think everybody has filters.
-
-      def raise_no_filter(path)
-        raise Ramaze::Error::NoFilter, "No Filter found for `#{path}'"
-      end
-
-      # Raises Ramaze::Error::NoController
-
-      def raise_no_controller(path)
-        raise Ramaze::Error::NoController, "No Controller found for `#{path}'"
-      end
-
-      # Raises Ramaze::Error::NoAction
-
-      def raise_no_action(controller, path)
-        STATE[:controller] = controller
-        raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
-      end
-    end
-  end
-end

data/lib/ramaze/current/request.rb

@@ -1,222 +0,0 @@
-#          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
-
-    def domain(path = '/')
-      scheme = env['rack.url_scheme'] || 'http'
-      host = env['HTTP_HOST']
-      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
-  end
-end

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

@@ -1,87 +0,0 @@
-module Ramaze
-  class Session
-    # The purpose of this class is to act as a unifier of the previous
-    # and current flash.
-    #
-    # Flash means pairs of keys and values that are held only over one
-    # request/response cycle. So you can assign a key/value in the current
-    # session and retrieve it in the current and following request.
-    #
-    # Please see the FlashHelper for details on the usage as you won't need
-    # to touch this class at all.
-    class Flash
-      include Enumerable
-
-      def initialize sess
-        @session = sess
-      end
-
-      # iterate over the combined session
-      def each(&block)
-        combined.each(&block)
-      end
-
-      # the current session[:FLASH_PREVIOUS]
-      def previous
-        session[:FLASH_PREVIOUS] || {}
-      end
-
-      # the current session[:FLASH]
-      def current
-        session[:FLASH] ||= {}
-      end
-
-      # combined key/value pairs of previous and current
-      # current keys overshadow the old ones.
-      def combined
-        previous.merge(current)
-      end
-
-      # flash[key] in your Controller
-      def [](key)
-        combined[key]
-      end
-
-      # flash[key] = value in your Controller
-      def []=(key, value)
-        prev = session[:FLASH] || {}
-        prev[key] = value
-        session[:FLASH] = prev
-      end
-
-      # Inspects the combined SessionFlash
-
-      def inspect
-        combined.inspect
-      end
-
-      # Delete a key
-
-      def delete(key)
-        current.delete(key)
-      end
-
-      # check if combined is empty
-
-      def empty?
-        combined.empty?
-      end
-
-      def merge!(hash)
-        current.merge!(hash)
-      end
-
-      def merge(hash)
-        current.merge(hash)
-      end
-
-      private
-
-      # Associated session object
-
-      def session
-        @session
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module Ramaze
-  class Session
-
-    # The Session::Hash acts as the wrapper for a simple Hash
-    #
-    # Its purpose is to notify the underlying cache, in which the sessions
-    # are stored, about updates.
-    class Hash
-
-      # Sets @hash to an empty Hash
-
-      def initialize(session)
-        @session = session
-        @hash = {}
-      end
-
-      # relays all the methods to the @hash and updates the session_cache in
-      # Session.current.sessions if anything changes.
-
-      def method_missing(*args, &block)
-        result = @hash.send(*args, &block)
-        Cache.sessions[@session.session_id] = self
-        result
-      end
-
-      # Calls #inspect on the wrapped @hash
-
-      def inspect
-        @hash.inspect
-      end
-
-      # Use client side session variables
-
-      def client
-        Request.current['session.client'] ||= unmarshal(Request.current.cookies["#{Session::SESSION_KEY}-client"]) || {}
-      end
-
-      private
-
-      # Marshal a session hash into safe cookie data. Include an integrity hash.
-      def marshal(session)
-        data = [ Marshal.dump(session) ].pack('m').chop
-        "#{data}--#{generate_digest(data)}"
-      end
-
-      # Unmarshal cookie data to a hash and verify its integrity.
-      def unmarshal(cookie)
-        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
-      # (64 bytes) or RMD160 (40 bytes), but small relative to the 4096 byte
-      # max cookie size.
-      def generate_digest(data)
-        Digest::SHA512.hexdigest "#{data}#{Session.trait[:secret]}"
-      end
-    end
-  end
-end