merb 0.4.2 → 0.5.0

data/lib/merb/controller.rb

@@ -18,7 +18,7 @@ module Merb
   #
   # === Session Store
   #
-  # The session store is set in MERB_ROOT/config/merb.yml :
+  # The session store is set in Merb.root/config/merb.yml :
   #
   #   :session_store: your_store
   #
@@ -83,14 +83,14 @@ module Merb
     
     def set_dispatch_variables(request, response, status, headers)
       if request.params.key?(_session_id_key)
-        if Merb::Server.config[:session_id_cookie_only]
+        if Merb::Config[:session_id_cookie_only]
           # This condition allows for certain controller/action paths to allow
           # a session ID to be passed in a query string. This is needed for
           # Flash Uploads to work since flash will not pass a Session Cookie
           # Recommend running session.regenerate after any controller taking
           # advantage of this in case someone is attempting a session fixation
           # attack
-          if Merb::Server.config[:query_string_whitelist].include?("#{request.controller_name}/#{request.action}")
+          if Merb::Config[:query_string_whitelist].include?("#{request.controller_name}/#{request.action}")
           # FIXME to use routes not controller and action names -----^
             request.cookies[_session_id_key] = request.params[_session_id_key]
           end
@@ -105,7 +105,7 @@ module Merb
     end
     
     def dispatch(action=:index)
-      start = Time.now
+      start = Time.now    
       if self.class.callable_actions[action.to_s]
         params[:action] ||= action
         setup_session
@@ -115,7 +115,7 @@ module Merb
         raise ActionNotFound, "Action '#{action}' was not found in #{self.class}"
       end
       @_benchmarks[:action_time] = Time.now - start
-      MERB_LOGGER.info("Time spent in #{self.class}##{action} action: #{@_benchmarks[:action_time]} seconds")
+      Merb.logger.info("Time spent in #{self.class}##{action} action: #{@_benchmarks[:action_time]} seconds")
     end
       
     # Accessor for @_body. Please use body and never @body directly.

data/lib/merb/core_ext/get_args.rb

@@ -24,6 +24,7 @@ begin
     
     def get_args
       arg_node = deep_array_node(:args)
+      return nil unless arg_node
       args = arg_node.arg_nodes
       default_node = arg_node.deep_array_node(:block)
       return args unless default_node

data/lib/merb/core_ext/hash.rb

@@ -1,139 +1,154 @@
-#require 'hpricot'
+# require 'hpricot'
 
 class Hash
- 	  
   class << self
-      # Converts valid XML into a Ruby Hash structure.
-      # <tt>xml</tt>:: A string representation of valid XML
-      # 
-      # == Typecasting
-      # Typecasting is performed on elements that have a "<tt>type</tt>" attribute of
-      # <tt>integer</tt>:: 
-      # <tt>boolean</tt>:: anything other than "true" evaluates to false
-      # <tt>datetime</tt>:: Returns a Time object.  See +Time+ documentation for valid Time strings
-      # <tt>date</tt>:: Returns a Date object.  See +Date+ documentation for valid Date strings 
-      # 
-      # Keys are automatically converted to +snake_case+
-      #
-      # == Caveats
-      # * Mixed content tags are assumed to be text and any xml tags are kept as a String
-      # * Any attributes other than type on a node containing a text node will be discarded
-      #
-      # == Examples
-      #
-      # === Standard 
-      # <user gender='m'>
-      #   <age type='integer'>35</age>
-      #   <name>Home Simpson</name>
-      #   <dob type='date'>1988-01-01</dob>
-      #   <joined-at type='datetime'>2000-04-28 23:01</joined-at>
-      #   <is-cool type='boolean'>true</is-cool>
-      # </user>
-      #
-      # evaluates to 
-      # 
-      # { "user" => 
-      #         { "gender"    => "m",
-      #           "age"       => 35,
-      #           "name"      => "Home Simpson",
-      #           "dob"       => DateObject( 1998-01-01 ),
-      #           "joined_at" => TimeObject( 2000-04-28 23:01),
-      #           "is_cool"   => true 
-      #         }
-      #     }
-      #
-      # === Mixed Content
-      # <story>
-      #   A Quick <em>brown</em> Fox
-      # </story>
-      #
-      # evaluates to
-      # { "story" => "A Quick <em>brown</em> Fox" }
-      # 
-      # === Attributes other than type on a node containing text
-      # <story is-good='fasle'>
-      #   A Quick <em>brown</em> Fox
-      # </story>
-      #
-      # evaluates to
-      # { "story" => "A Quick <em>brown</em> Fox" }
-      #
-      # <bicep unit='inches' type='integer'>60</bicep>
-      #
-      # evaluates with a typecast to an integer.  But ignores the unit attribute
-      # { "bicep" => 60 }
-      
-      def from_xml( xml )
-        ToHashParser.from_xml(xml)  
-      end
+    # Converts valid XML into a Ruby Hash structure.
+    # <tt>xml</tt>:: A string representation of valid XML
+    # 
+    # == Typecasting
+    # Typecasting is performed on elements that have a "<tt>type</tt>" attribute of
+    # <tt>integer</tt>:: 
+    # <tt>boolean</tt>:: anything other than "true" evaluates to false
+    # <tt>datetime</tt>:: Returns a Time object.  See +Time+ documentation for valid Time strings
+    # <tt>date</tt>:: Returns a Date object.  See +Date+ documentation for valid Date strings 
+    # 
+    # Keys are automatically converted to +snake_case+
+    #
+    # == Caveats
+    # * Mixed content tags are assumed to be text and any xml tags are kept as a String
+    # * Any attributes other than type on a node containing a text node will be discarded
+    #
+    # == Examples
+    #
+    # === Standard 
+    # <user gender='m'>
+    #   <age type='integer'>35</age>
+    #   <name>Home Simpson</name>
+    #   <dob type='date'>1988-01-01</dob>
+    #   <joined-at type='datetime'>2000-04-28 23:01</joined-at>
+    #   <is-cool type='boolean'>true</is-cool>
+    # </user>
+    #
+    # evaluates to 
+    # 
+    # { "user" => 
+    #         { "gender"    => "m",
+    #           "age"       => 35,
+    #           "name"      => "Home Simpson",
+    #           "dob"       => DateObject( 1998-01-01 ),
+    #           "joined_at" => TimeObject( 2000-04-28 23:01),
+    #           "is_cool"   => true 
+    #         }
+    #     }
+    #
+    # === Mixed Content
+    # <story>
+    #   A Quick <em>brown</em> Fox
+    # </story>
+    #
+    # evaluates to
+    # { "story" => "A Quick <em>brown</em> Fox" }
+    # 
+    # === Attributes other than type on a node containing text
+    # <story is-good='fasle'>
+    #   A Quick <em>brown</em> Fox
+    # </story>
+    #
+    # evaluates to
+    # { "story" => "A Quick <em>brown</em> Fox" }
+    #
+    # <bicep unit='inches' type='integer'>60</bicep>
+    #
+    # evaluates with a typecast to an integer.  But ignores the unit attribute
+    # { "bicep" => 60 }
+    def from_xml( xml )
+      ToHashParser.from_xml(xml)
+    end
   end
   
   # convert this hash into a Mash for string or symbol key access
   def to_mash
- 	  hash = Mash.new(self) 
- 	  hash.default = self.default 
- 	  hash
- 	end
- 	
- 	# convert this hash to a query string param
- 	#   {:name => "Bob", :address => {:street => '111 Ruby Ave.', :city => 'Ruby Central', :phones => ['111-111-1111', '222-222-2222']}}
+    hash = Mash.new(self)
+    hash.default = default
+    hash
+  end
+  
+  # Convert this hash to a query string:
+  #   
+  #   { :name => "Bob",
+  #     :address => {
+  #       :street => '111 Ruby Ave.',
+  #       :city => 'Ruby Central',
+  #       :phones => ['111-111-1111', '222-222-2222']
+  #     }
+  #   }.to_params
   #   #=> "name=Bob&address[city]=Ruby Central&address[phones]=111-111-1111222-222-2222&address[street]=111 Ruby Ave."
+  # 
   def to_params
-    result = ''
+    params = ''
     stack = []
-
-    each do |key, value|
-      Hash === value ? stack << [key, value] : result <<  "#{key}=#{value}&"
+    
+    each do |k, v|
+      if v.is_a?(Hash)
+        stack << [k,v]
+      else
+        params << "#{k}=#{v}&"
+      end
     end
-
+    
     stack.each do |parent, hash|
-      hash.each do |key, value|
-        if Hash === value
-          stack << ["#{parent}[#{key}]", value]
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          stack << ["#{parent}[#{k}]", v]
         else
-          result << "#{parent}[#{key}]=#{value}&"
+          params << "#{parent}[#{k}]=#{v}&"
         end
       end
     end
-    result.chop
+    
+    params.chop! # trailing &
+    params
   end
   
-  # lets through the keys in the argument
-  #   $ {:one => 1, :two => 2, :three => 3}.pass(:one)
-  #   #=> {:one=>1}
-  def pass(*allowed) 
-    self.reject { |k,v| ! allowed.include?(k) } 
+  # Returns a new Hash with only the selected keys:
+  #   
+  #   { :one => 1, :two => 2, :three => 3 }.only(:one)
+  #   #=> { :one => 1 }
+  def only(*allowed) 
+    reject { |k,v| !allowed.include?(k) }
   end
-  alias only pass
   
-  # blocks the keys in the arguments
-  #   $ {:one => 1, :two => 2, :three => 3}.block(:one)
-  #   #=> {:two=>2, :three=>3}
-  def block(*rejected) 
-    self.reject { |k,v| rejected.include?(k) } 
+  # Returns a new hash without the selected keys:
+  # 
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #   #=> { :two => 2, :three => 3 }
+  # 
+  def except(*rejected) 
+    reject { |k,v| rejected.include?(k) }
   end
-  alias except block
-
+  
   # Converts the hash into xml attributes
+  # 
   #   { :one => "ONE", "two"=>"TWO" }.to_xml_attributes
   #   #=> 'one="ONE" two="TWO"'
+  # 
   def to_xml_attributes
     map do |k,v|
-      "#{k.to_s.camelize.sub(/^(.{1,1})/){|m| m.downcase}}=\"#{v}\""
-    end.join(" ")
+      %{#{k.to_s.camelize.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"} 
+    end.join(' ')
   end
   
   alias_method :to_html_attributes, :to_xml_attributes
- 
+  
   # Adds the given class symbol or string to the hash in the
   # :class key.  This will add a html class if there are already any existing
   # or create the key and add this as the first class
-  #
-  # Example
+  # 
   #   @hash[:class] #=> nil
   #   @hash.add_html_class!(:selected) #=> @hash[:class] == "selected"
-  #
+  #   
   #   @hash.add_html_class!("class1 class2") #=> @hash[:class] == "selected class1 class2"
+  # 
   def add_html_class!(html_class)
     if self[:class]
       self[:class] = "#{self[:class]} #{html_class}"
@@ -142,40 +157,38 @@ class Hash
     end
   end
   
-  # Destructively convert all keys to symbols recursively.
+  # Destructively convert all keys which respond_to?(:to_sym) to symbols.
+  # Works recursively if given nested hashes.
+  # 
+  #  { 'one' => 1, 'two' => 2 }.symbolize_keys!
+  #  #=> { :one => 1, :two => 2 }
+  # 
   def symbolize_keys!
-    keys.each do |key|
-      unless key.is_a?(Symbol)
-        self[key.to_sym] = self[key]
-        delete(key)
-      end
-      if Hash === (sub = self[key.to_sym])
-        sub.symbolize_keys!
-      end  
+    each do |k,v| 
+      sym = k.respond_to?(:to_sym) ? k.to_sym : k 
+      self[sym] = Hash === v ? v.symbolize_keys! : v 
+      delete(k) unless k == sym
     end
     self
   end
   
-  # Converts every key to an uppercase string (non-recursive.)
-  #   {:name => "Bob", "age" => 12, "nick" => "Bobinator"}.environmentize_keys!
-  #   #=> {"NAME"=>"Bob", "NICK"=>"Bobinator", "AGE"=>12}
+  # Destructively and non-recursively convert each key to an uppercase string.
+  # 
+  #   { :name => "Bob", "age" => 12, "nick" => "Bobinator" }.environmentize_keys!
+  #   #=> { "NAME" => "Bob", "NICK" => "Bobinator", "AGE" => 12 }
+  # 
   def environmentize_keys!
-    self.each do |key, value|
+    keys.each do |key|
       self[key.to_s.upcase] = delete(key)
     end
     self
   end
-    
- def method_missing(m,*a) #:nodoc:
-   m.to_s =~ /=$/ ? self[$`]=a[0] : a==[] ? self[m] : raise(NoMethodError,"#{m}")
- end
   
-  def respond_to?(method, include_private=false)
+  def respond_to?(method, include_private = false)
     return true if keys.include?(method)
     super(method, include_private)
   end
-  
-end  
+end
 
 require 'rexml/parsers/streamparser'
 require 'rexml/parsers/baseparser'
@@ -208,29 +221,25 @@ class REXMLUtilityNode # :nodoc:
       #change repeating groups into an array
       # group by the first key of each element of the array to find repeating groups
       groups = @children.group_by{ |c| c.name }
-
-      hash = {}  
+      
+      hash = {}
       groups.each do |key, values|
         if values.size == 1
-          hash.merge!( values.first ) 
+          hash.merge! values.first
         else
-          hash.merge!( key => values.map{ |element| element.to_hash[key] } )
+          hash.merge! key => values.map { |element| element.to_hash[key] }
         end
       end
-
+      
       # merge the arrays, including attributes
-      hash.merge!( attributes ) unless attributes.empty?
-      return { name => hash }
+      hash.merge! attributes unless attributes.empty?
+      
+      { name => hash }
     end
   end
-
-  def to_s 
-    self.to_html
-  end
-
-
+  
   def typecast_value(value)
-    return value unless attributes["type"] 
+    return value unless attributes["type"]
     
     case attributes["type"]
       when "integer"  then value.to_i
@@ -240,7 +249,7 @@ class REXMLUtilityNode # :nodoc:
       else                 value
     end
   end
-
+  
   def translate_xml_entities(value)
     value.gsub(/&lt;/,   "<").
           gsub(/&gt;/,   ">").
@@ -248,46 +257,50 @@ class REXMLUtilityNode # :nodoc:
           gsub(/&apos;/, "'").
           gsub(/&amp;/,  "&")
   end
-
-   def undasherize_keys(params)
-     params.keys.each do |key, vvalue|
-       params[key.tr("-", "_")] = params.delete(key)
-     end
-     params 
+  
+  def undasherize_keys(params)
+    params.keys.each do |key, vvalue|
+      params[key.tr("-", "_")] = params.delete(key)
+    end
+    params
   end
-
+  
   def inner_html
     @children.join
   end
-
-  def to_html 
+  
+  def to_html
     "<#{name}#{attributes.to_xml_attributes}>#{inner_html}</#{name}>"
   end
+  
+  def to_s 
+    to_html
+  end
 end
 
 class ToHashParser # :nodoc:
-	def self.from_xml(xml)
-		stack = []
-		parser = REXML::Parsers::BaseParser.new(xml)
-		
-		while true
-			event = parser.pull
-			case event[0]
-			when :end_document
-				break
-			when :end_doctype, :start_doctype
-				# do nothing
-			when :start_element
-			  stack.push REXMLUtilityNode.new(event[1], event[2])
-			when :end_element
-			  if stack.size > 1
-			    temp = stack.pop
-			    stack.last.add_node(temp)
-			  end
-			when :text
-			  stack.last.add_node(event[1]) unless event[1].strip.length == 0
-			end
-		end
-		stack.pop.to_hash
-	end	
+  def self.from_xml(xml)
+    stack = []
+    parser = REXML::Parsers::BaseParser.new(xml)
+    
+    while true
+      event = parser.pull
+      case event[0]
+      when :end_document
+        break
+      when :end_doctype, :start_doctype
+        # do nothing
+      when :start_element
+        stack.push REXMLUtilityNode.new(event[1], event[2])
+      when :end_element
+        if stack.size > 1
+          temp = stack.pop
+          stack.last.add_node(temp)
+        end
+      when :text, :cdata
+        stack.last.add_node(event[1]) unless event[1].strip.length == 0
+      end
+    end
+    stack.pop.to_hash
+  end
 end