merb-core 0.9.2

data/lib/merb-core/dispatch/router/cached_proc.rb

@@ -0,0 +1,52 @@
+module Merb
+  
+  class Router
+    # Cache procs for future reference in eval statement
+    class CachedProc
+      @@index = 0
+      @@list = []
+      
+      attr_accessor :cache, :index
+
+      # ==== Parameters
+      # cache<Proc>:: The block of code to cache.
+      def initialize(cache)
+        @cache, @index = cache, CachedProc.register(self)
+      end
+      
+      # ==== Returns
+      # String:: The CachedProc object in a format embeddable within a string.
+      def to_s
+        "CachedProc[#{@index}].cache"
+      end
+      
+      class << self
+
+        # ==== Parameters
+        # cached_code<CachedProc>:: The cached code to register.
+        #
+        # ==== Returns
+        # Fixnum:: The index of the newly registered CachedProc.
+        def register(cached_code)
+          CachedProc[@@index] = cached_code
+          @@index += 1
+          @@index - 1
+        end
+
+        # Sets the cached code for a specific index.
+        #
+        # ==== Parameters
+        # index<Fixnum>:: The index of the cached code to set.
+        # code<CachedProc>:: The cached code to set.
+        def []=(index, code) @@list[index] = code end
+
+        # ==== Parameters
+        # index<Fixnum>:: The index of the cached code to retrieve.
+        #
+        # ==== Returns
+        # CachedProc:: The cached code at index.
+        def [](index) @@list[index] end
+      end
+    end # CachedProc
+  end
+end

data/lib/merb-core/dispatch/router/route.rb

@@ -0,0 +1,212 @@
+require 'merb-core/controller/mixins/responder'
+module Merb
+  
+  class Router
+
+    class Route
+      attr_reader :conditions, :conditional_block
+      attr_reader :params, :behavior, :segments, :index, :symbol
+
+      # ==== Parameters
+      # conditions<Hash>:: Conditions for the route.
+      # params<Hash>:: Parameters for the route.
+      # behavior<Merb::Router::Behavior>::
+      #   The associated behavior. Defaults to nil.
+      # &conditional_block::
+      #		A block with the conditions to be met for the route to take effect.
+      def initialize(conditions, params, behavior = nil, &conditional_block)
+        @conditions, @params, @behavior = conditions, params, behavior
+        @conditional_block = conditional_block
+        if @behavior && (path = @behavior.merged_original_conditions[:path])
+          @segments = segments_from_path(path)
+        end
+      end
+
+      # ==== Returns
+      # Boolean:: True if fixation is allowed.
+      def allow_fixation? 
+        @fixation
+      end 
+         
+      # ==== Parameters
+      # enabled<Boolean>:: True enables fixation on the route.
+      def fixatable(enable=true) 
+        @fixation = enable 
+        self
+      end
+
+      # ==== Returns
+      # String:: The route as a string, e.g. "admin/:controller/:id".
+      def to_s
+        segments.inject('') do |str,seg|
+          str << (seg.is_a?(Symbol) ? ":#{seg}" : seg)
+        end
+      end
+      
+      # Registers the route in the Router.routes array.
+      def register
+        @index = Router.routes.size
+        Router.routes << self
+        self
+      end
+      
+      # ==== Returns
+      # Array:: All the symbols in the segments array.
+      def symbol_segments
+        segments.select{ |s| s.is_a?(Symbol) }
+      end
+      
+      # Turn a path into string and symbol segments so it can be reconstructed,
+      # as in the case of a named route.
+      #
+      # ==== Parameters
+      # path<String>:: The path to split into segments.
+      #
+      # ==== Returns
+      # Array:: The Symbol and String segments for the path.
+      def segments_from_path(path)
+        # Remove leading ^ and trailing $ from each segment (left-overs from regexp joining)
+        strip = proc { |str| str.gsub(/^\^/, '').gsub(/\$$/, '') }
+        segments = []
+        while match = (path.match(SEGMENT_REGEXP))
+          segments << strip[match.pre_match] unless match.pre_match.empty?
+          segments << match[2].intern
+          path = strip[match.post_match]
+        end
+        segments << strip[path] unless path.empty?
+        segments
+      end
+      
+      # Names this route in Router.
+      #
+      # ==== Parameters
+      # symbol<Symbol>:: The name of the route.
+      #
+      # ==== Raises
+      # ArgumentError:: symbol is not a Symbol.
+      def name(symbol = nil)
+        raise ArgumentError unless (@symbol = symbol).is_a?(Symbol)
+        Router.named_routes[@symbol] = self
+      end
+
+      # ==== Returns
+      # Boolean::
+      #   True if this route is a regexp, i.e. its behavior or one of the
+      #   behaviors ancestors is a regexp.
+      def regexp?
+        behavior.regexp? || behavior.send(:ancestors).any? { |a| a.regexp? }
+      end
+      
+      # ==== Parameters
+      # params<Hash>:: Optional parameters for the route.
+      # fallback<Hash>:: Optional parameters for the fallback route.
+      #
+      # ==== Returns
+      # String::
+      #   The URL corresponding to the params, using the stored route segments
+      #   for reconstruction of the URL.
+      def generate(params = {}, fallback = {})
+        raise "Cannot generate regexp Routes" if regexp?
+        query_params = params.dup if params.is_a? Hash
+        url = @segments.map do |segment|
+          value =
+            if segment.is_a? Symbol
+              if params.is_a? Hash
+                params[segment] || fallback[segment]
+                query_params.delete segment
+              else
+                if segment == :id && params.respond_to?(:to_param) 
+                  params.to_param
+                elsif segment == :id && params.is_a?(Fixnum)
+                  params
+                elsif params.respond_to?(segment)
+                  params.send(segment)
+                else
+                  fallback[segment]
+                end
+              end
+            elsif segment.respond_to? :to_s
+              segment
+            else
+              raise "Segment type '#{segment.class}' can't be converted to a string"
+            end
+          (value.respond_to?(:to_param) ? value.to_param : value).to_s
+        end.join
+        if query_params && !query_params.empty?
+          url += "?" + Merb::Request.params_to_query_string(query_params)
+        end
+        url
+      end
+
+      # ==== Params
+      # params_as_string<String>::
+      #   The params hash as a string, e.g. ":foo => 'bar'".
+      #
+      # ==== Returns
+      # Array:: All the conditions as eval'able strings.
+      def if_conditions(params_as_string)
+        cond = []
+        condition_string = proc do |key, value, regexp_string|
+          max = Behavior.count_parens_up_to(value.source, value.source.size)
+          captures = max == 0 ? "" : (1..max).to_a.map{ |n| "#{key}#{n}" }.join(", ") + " = " +
+                                     (1..max).to_a.map{ |n| "$#{n}"}.join(", ")
+          " (#{value.inspect} =~ #{regexp_string}) #{" && (" + captures + ")" unless captures.empty?}"
+        end
+        @conditions.each_pair do |key, value|
+          
+          # Note: =~ is slightly faster than .match
+          cond << case key
+          when :path then condition_string[key, value, "cached_path"]
+          when :method then condition_string[key, value, "cached_method"]
+          else condition_string[key, value, "request.#{key}.to_s"]
+          end
+        end
+        if @conditional_block
+          str = "  # #{@conditional_block.inspect.scan(/@([^>]+)/).flatten.first}\n"
+          str << "    (block_result = #{CachedProc.new(@conditional_block)}.call(request, params.merge({#{params_as_string}})))" if @conditional_block
+          cond << str
+        end
+        cond
+      end
+
+      # Compiles the route to a form used by Merb::Router.
+      #
+      # ==== Parameters
+      # first<Boolean>::
+      #   True if this is the first route in set of routes. Defaults to false.
+      #
+      # ==== Returns
+      # String:: The code corresponding to the route in a form suited for eval.
+      def compile(first = false)
+        code = ""
+        default_params = { :action => "index" }
+        get_value = proc do |key|
+          if default_params.has_key?(key) && params[key][0] != ?"
+            "#{params[key]} || \"#{default_params[key]}\""
+          else
+            "#{params[key]}"
+          end
+        end
+        params_as_string = params.keys.map { |k| "#{k.inspect} => #{get_value[k]}" }.join(', ')
+        code << "  els" unless first
+        code << "if  # #{@behavior.merged_original_conditions.inspect}  \n"
+        code << if_conditions(params_as_string).join(" && ") << "\n"
+        code << "    # then\n"
+        if @conditional_block
+          code << "    [#{@index.inspect}, block_result]\n"
+        else
+          code << "    [#{@index.inspect}, {#{params_as_string}}]\n"
+        end
+      end
+
+      # Prints a trace of the behavior for this route.
+      def behavior_trace
+        if @behavior
+          puts @behavior.send(:ancestors).reverse.map{|a| a.inspect}.join("\n"); puts @behavior.inspect; puts
+        else
+          puts "No behavior to trace #{self}"
+        end
+      end
+    end # Route
+  end
+end

data/lib/merb-core/dispatch/session.rb

@@ -0,0 +1,28 @@
+module Merb
+  
+  module SessionMixin
+
+    # ==== Returns
+    # String:: A random 32 character string for use as a unique session ID.
+    def rand_uuid
+      values = [
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x0010000),
+        rand(0x1000000),
+        rand(0x1000000),
+      ]
+      "%04x%04x%04x%04x%04x%06x%06x" % values
+    end
+
+    # Marks this session as needing a new cookie.
+    def needs_new_cookie!
+      @_new_cookie = true
+    end
+    
+    module_function :rand_uuid, :needs_new_cookie!
+  end
+
+end

data/lib/merb-core/dispatch/session/cookie.rb

@@ -0,0 +1,166 @@
+require 'base64'        # to convert Marshal.dump to ASCII
+require 'openssl'       # to generate the HMAC message digest
+# Most of this code is taken from bitsweat's implementation in rails
+module Merb
+
+  module SessionMixin #:nodoc:
+
+    # Adds a before and after dispatch hook for setting up the cookie session
+    # store.
+    #
+    # ==== Parameters
+    # base<Class>:: The class to which the SessionMixin is mixed into.
+    def setup_session
+      request.session = Merb::CookieSession.new(cookies[_session_id_key], _session_secret_key)
+      @original_session = request.session.read_cookie
+    end
+
+    # Finalizes the session by storing the session in a cookie, if the session
+    # has changed.
+    def finalize_session
+      new_session = request.session.read_cookie
+      
+      if @original_session != new_session
+        set_cookie(_session_id_key, new_session, Time.now + _session_expiry) 
+      end
+    end
+
+    # ==== Returns
+    # String:: The session store type, i.e. "cookie".
+    def session_store_type
+      "cookie"
+    end
+  end
+  
+  # If you have more than 4K of session data or don't want your data to be
+  # visible to the user, pick another session store.
+  #
+  # CookieOverflow is raised if you attempt to store more than 4K of data.
+  # TamperedWithCookie is raised if the data integrity check fails.
+  #
+  # A message digest is included with the cookie to ensure data integrity:
+  # a user cannot alter session data without knowing the secret key included
+  # in the hash. 
+  # 
+  # To use Cookie Sessions, set in config/merb.yml
+  #  :session_secret_key - your secret digest key
+  #  :session_store: cookie
+  class CookieSession
+    # TODO (maybe):
+    # include request ip address
+    # AES encrypt marshaled data
+    
+    # Raised when storing more than 4K of session data.
+    class CookieOverflow < StandardError; end
+    
+    # Raised when the cookie fails its integrity check.
+    class TamperedWithCookie < StandardError; end
+    
+    # Cookies can typically store 4096 bytes.
+    MAX = 4096
+    DIGEST = OpenSSL::Digest::Digest.new('SHA1') # or MD5, RIPEMD160, SHA256?
+    
+    attr_reader :data
+
+    # ==== Parameters
+    # cookie<String>:: The cookie.
+    # secret<String>:: A session secret.
+    #
+    # ==== Raises
+    # ArgumentError:: Nil or blank secret.
+    def initialize(cookie, secret)
+      if secret.nil? or secret.blank?
+        raise ArgumentError, 'A secret is required to generate an integrity hash for cookie session data.'
+      end
+      @secret = secret
+      @data = unmarshal(cookie) || Hash.new
+    end
+    
+    # ==== Returns
+    # String:: Cookie value.
+    #
+    # ==== Raises
+    # CookieOverflow:: Session contains too much information.
+    def read_cookie
+      unless @data.nil? or @data.empty? 
+        updated = marshal(@data)
+        raise CookieOverflow if updated.size > MAX
+        updated
+      end
+    end
+    
+    # ==== Parameters
+    # k<~to_s>:: The key of the session parameter to set.
+    # v<~to_s>:: The value of the session parameter to set.
+    def []=(k, v) 
+      @data[k] = v
+    end
+
+    # ==== Parameters
+    # k<~to_s>:: The key of the session parameter to retrieve.
+    #
+    # ==== Returns
+    # String:: The value of the session parameter.
+    def [](k) 
+      @data[k] 
+    end
+
+    # Yields the session data to an each block.
+    #
+    # ==== Parameter
+    # &b:: The block to pass to each.
+    def each(&b) 
+      @data.each(&b) 
+    end
+
+    # Deletes the session by emptying stored data.
+    def delete  
+      @data = {} 
+    end
+    
+    private
+
+    # Attempts to redirect any messages to the data object.
+    def method_missing(name, *args, &block)
+      @data.send(name, *args, &block)
+    end
+    
+    # Generate the HMAC keyed message digest. Uses SHA1.
+    def generate_digest(data)
+      OpenSSL::HMAC.hexdigest(DIGEST, @secret, data)
+    end
+    
+    # Marshal a session hash into safe cookie data. Include an integrity hash.
+    #
+    # ==== Parameters
+    # session<Hash>:: The session to store in the cookie.
+    #
+    # ==== Returns
+    # String:: The cookie to be stored.
+    def marshal(session)
+      data = Base64.encode64(Marshal.dump(session)).chop
+      Merb::Request.escape "#{data}--#{generate_digest(data)}"
+    end
+    
+    # Unmarshal cookie data to a hash and verify its integrity.
+    #
+    # ==== Parameters
+    # cookie<~to_s>:: The cookie to unmarshal.
+    #
+    # ==== Raises
+    # TamperedWithCookie:: The digests don't match.
+    #
+    # ==== Returns
+    # Hash:: The stored session data.
+    def unmarshal(cookie)
+      if cookie
+        data, digest = Merb::Request.unescape(cookie).split('--')
+        return {} if data.blank?
+        unless digest == generate_digest(data)
+          raise TamperedWithCookie, "Maybe the site's session_secret_key has changed?"
+        end
+        Marshal.load(Base64.decode64(data))
+      end
+    end
+  end
+end