merb-core 0.9.2 → 0.9.3

data/lib/merb-core/controller/mixins/responder.rb

@@ -1,5 +1,6 @@
 require 'enumerator'
 require 'merb-core/controller/mime'
+require "merb-core/vendor/facets/dictionary"
 module Merb
   # The ResponderMixin adds methods that help you manage what
   # formats your controllers have available, determine what format(s)
@@ -96,7 +97,7 @@ module Merb
   # and none of the provides methods can be used.
   module ResponderMixin
     
-    TYPES = {}
+    TYPES = Dictionary.new
 
     class ContentTypeAlreadySet < StandardError; end
     
@@ -294,7 +295,12 @@ module Merb
       specifics = accepts & _provided_formats
       return specifics.first unless specifics.length == 0
       return _provided_formats.first if accepts.include? :all
-      raise Merb::ControllerExceptions::NotAcceptable
+      message  = "A format (%s) that isn't provided (%s) has been requested. "
+      message += "Make sure the action provides the format, and be "
+      message += "careful of before filters which won't recognize "
+      message += "formats provided within actions."
+      raise Merb::ControllerExceptions::NotAcceptable,
+        (message % [accepts.join(', '), _provided_formats.join(', ')])
     end
 
     # Returns the output format for this request, based on the 

data/lib/merb-core/controller/template.rb

@@ -67,7 +67,7 @@ module Merb::Template
     #   The module to put the compiled method into. Defaults to
     #   Merb::InlineTemplates
     #
-    # ==== Note
+    # ==== Notes
     # Even though this method supports inlining into any module, the method
     # must be available to instances of AbstractController that will use it.
     #---

data/lib/merb-core/core_ext.rb

@@ -1,6 +1,7 @@
 corelib = File.join(File.dirname(__FILE__), "core_ext")
 
 require "#{corelib}/string"
+require corelib/:time
 require corelib/:class
 require corelib/:hash
 require corelib/:kernel

data/lib/merb-core/core_ext/class.rb

@@ -4,8 +4,11 @@
 # example, an array without those additions being shared with either their
 # parent, siblings, or children, which is unlike the regular class-level
 # attributes that are shared across the entire hierarchy.
-class Class # :nodoc:
-
+class Class
+  # Defines class-level and instance-level attribute reader.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of attributes to define reader for.
   def cattr_reader(*syms)
     syms.flatten.each do |sym|
       next if sym.is_a?(Hash)
@@ -25,6 +28,13 @@ class Class # :nodoc:
     end
   end
 
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of attributes to define writer for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level attribute writer is defined.
   def cattr_writer(*syms)
     options = syms.last.is_a?(Hash) ? syms.pop : {}
     syms.flatten.each do |sym|
@@ -47,11 +57,23 @@ class Class # :nodoc:
     end
   end
 
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of attributes to define accessor for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level attribute writer is defined.
   def cattr_accessor(*syms)
     cattr_reader(*syms)
     cattr_writer(*syms)
   end
 
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of attributes to define inheritable reader for.
   def class_inheritable_reader(*syms)
     syms.each do |sym|
       next if sym.is_a?(Hash)
@@ -68,6 +90,14 @@ class Class # :nodoc:
     end
   end
 
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of attributes to define inheritable writer for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level inheritable attribute writer is defined.
   def class_inheritable_writer(*syms)
     options = syms.last.is_a?(Hash) ? syms.pop : {}
     syms.each do |sym|
@@ -87,6 +117,15 @@ class Class # :nodoc:
     end
   end
 
+  # Defines class-level inheritable array writer. Arrays are available to subclasses,
+  # each subclass has a copy of parent's array. Difference between other inheritable
+  # attributes is that array is recreated every time it is written.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of array attribute names to define inheritable writer for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level inheritable array attribute writer is defined.
   def class_inheritable_array_writer(*syms)
     options = syms.last.is_a?(Hash) ? syms.pop : {}
     syms.each do |sym|
@@ -106,6 +145,15 @@ class Class # :nodoc:
     end
   end
 
+  # Defines class-level inheritable hash writer. Hashs are available to subclasses,
+  # each subclass has a copy of parent's hash. Difference between other inheritable
+  # attributes is that hash is recreated every time it is written.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of hash attribute names to define inheritable writer for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level inheritable hash attribute writer is defined.
   def class_inheritable_hash_writer(*syms)
     options = syms.last.is_a?(Hash) ? syms.pop : {}
     syms.each do |sym|
@@ -125,25 +173,62 @@ class Class # :nodoc:
     end
   end
 
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of attributes to define inheritable accessor for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level inheritable attribute writer is defined.
   def class_inheritable_accessor(*syms)
     class_inheritable_reader(*syms)
     class_inheritable_writer(*syms)
   end
 
+  # Defines class-level inheritable array accessor. Arrays are available to subclasses,
+  # each subclass has a copy of parent's array. Difference between other inheritable
+  # attributes is that array is recreated every time it is written.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of array attribute names to define inheritable accessor for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level inheritable array attribute writer is defined.
   def class_inheritable_array(*syms)
     class_inheritable_reader(*syms)
     class_inheritable_array_writer(*syms)
   end
 
+  # Defines class-level inheritable hash accessor. Hashs are available to subclasses,
+  # each subclass has a copy of parent's hash. Difference between other inheritable
+  # attributes is that hash is recreated every time it is written.
+  #
+  # ==== Parameters
+  # *syms<Array>:: Array of hash attribute names to define inheritable accessor for.
+  #
+  # ==== Options
+  # :instance_writer<Boolean>:: if true, instance-level inheritable hash attribute writer is defined.
   def class_inheritable_hash(*syms)
     class_inheritable_reader(*syms)
     class_inheritable_hash_writer(*syms)
   end
 
+  # ==== Returns
+  # <Hash>:: inheritable attributes hash or it's default value, new frozen Hash.
   def inheritable_attributes
     @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
   end
 
+  # Sets the attribute which copy is available to subclasses.
+  #
+  # ==== Parameters
+  # key<~to_s, String, Symbol>:: inheritable attribute name
+  # value<Anything but Array or Hash>:: value of inheritable attribute
+  #
+  # ==== Notes
+  # If inheritable attributes storage has it's default value,
+  # a new frozen hash, it is set to new Hash that is not frozen.
   def write_inheritable_attribute(key, value)
     if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
       @inheritable_attributes = {}
@@ -151,31 +236,53 @@ class Class # :nodoc:
     inheritable_attributes[key] = value
   end
 
+  # Sets the array attribute which copy is available to subclasses.
+  #
+  # ==== Parameters
+  # key<~to_s, String, Symbol>:: inheritable attribute name
+  # value<Array>:: value of inheritable attribute
+  #
+  # ==== Notes
+  # Inheritable array is re-created on each write.
   def write_inheritable_array(key, elements)
     write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
     write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
   end
 
+  # Sets the hash attribute which copy is available to subclasses.
+  #
+  # ==== Parameters
+  # key<~to_s, String, Symbol>:: inheritable attribute name
+  # value<Hash>:: value of inheritable attribute
+  #
+  # ==== Notes
+  # Inheritable hash is re-created on each write.
   def write_inheritable_hash(key, hash)
     write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
     write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
   end
 
+  # Reads value of inheritable attributes.
+  #
+  # ==== Returns
+  # Inheritable attribute value. Subclasses store copies of values.
   def read_inheritable_attribute(key)
     inheritable_attributes[key]
   end
 
+  # Resets inheritable attributes to either EMPTY_INHERITABLE_ATTRIBUTES
+  # if it is defined or it's default value, new frozen Hash.
   def reset_inheritable_attributes
     @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
   end
-  
+
   private
     # Prevent this constant from being created multiple times
     EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
 
     def inherited_with_inheritable_attributes(child)
       inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
-      
+
       if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
         new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
       else
@@ -183,10 +290,10 @@ class Class # :nodoc:
           memo.update(key => (value.dup rescue value))
         end
       end
-      
+
       child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
     end
 
     alias inherited_without_inheritable_attributes inherited
     alias inherited inherited_with_inheritable_attributes
-end
+end

data/lib/merb-core/core_ext/hash.rb

@@ -14,13 +14,13 @@ class Hash
     #
     # ===== Typecasting
     # Typecasting is performed on elements that have a +type+ attribute:
-    # integer:: 
+    # integer::
     # boolean:: Anything other than "true" evaluates to false.
     # datetime::
     #   Returns a Time object. See Time documentation for valid Time strings.
     # date::
     #   Returns a Date object. See Date documentation for valid Date strings.
-    # 
+    #
     # Keys are automatically converted to +snake_case+
     #
     # ==== Examples
@@ -34,15 +34,15 @@ class Hash
     #     <is-cool type='boolean'>true</is-cool>
     #   </user>
     #
-    # evaluates to 
-    # 
-    #   { "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 
+    #       "is_cool"   => true
     #     }
     #   }
     #
@@ -54,7 +54,7 @@ class Hash
     # evaluates to
     #
     #   { "story" => "A Quick <em>brown</em> Fox" }
-    # 
+    #
     # ====== Attributes other than type on a node containing text
     #   <story is-good='false'>
     #     A Quick <em>brown</em> Fox
@@ -73,15 +73,19 @@ class Hash
       ToHashParser.from_xml(xml)
     end
   end
-  
+
   # ==== Returns
   # Mash:: This hash as a Mash for string or symbol key access.
+  #
+  # This class has semantics of ActiveSupport's HashWithIndifferentAccess
+  # and we only have it so that people can write
+  # params[:key] instead of params['key'].
   def to_mash
     hash = Mash.new(self)
     hash.default = default
     hash
   end
-  
+
   # ==== Returns
   # String:: This hash as a query string
   #
@@ -97,7 +101,7 @@ class Hash
   def to_params
     params = ''
     stack = []
-    
+
     each do |k, v|
       if v.is_a?(Hash)
         stack << [k,v]
@@ -105,7 +109,7 @@ class Hash
         params << "#{k}=#{v}&"
       end
     end
-    
+
     stack.each do |parent, hash|
       hash.each do |k, v|
         if v.is_a?(Hash)
@@ -115,11 +119,11 @@ class Hash
         end
       end
     end
-    
+
     params.chop! # trailing &
     params
   end
-  
+
   # ==== Parameters
   # *allowed:: The hash keys to include.
   #
@@ -129,10 +133,10 @@ class Hash
   # ==== Examples
   #   { :one => 1, :two => 2, :three => 3 }.only(:one)
   #     #=> { :one => 1 }
-  def only(*allowed) 
+  def only(*allowed)
     reject { |k,v| !allowed.include?(k) }
   end
-  
+
   # ==== Parameters
   # *rejected:: The hash keys to exclude.
   #
@@ -142,10 +146,10 @@ class Hash
   # ==== Examples
   #   { :one => 1, :two => 2, :three => 3 }.except(:one)
   #     #=> { :two => 2, :three => 3 }
-  def except(*rejected) 
+  def except(*rejected)
     reject { |k,v| rejected.include?(k) }
   end
-  
+
   # ==== Returns
   # String:: The hash as attributes for an XML tag.
   #
@@ -154,12 +158,12 @@ class Hash
   #     #=> 'one="1" two="TWO"'
   def to_xml_attributes
     map do |k,v|
-      %{#{k.to_s.camel_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"} 
+      %{#{k.to_s.camel_case.sub(/^(.{1,1})/) { |m| m.downcase }}="#{v}"}
     end.join(' ')
   end
-  
+
   alias_method :to_html_attributes, :to_xml_attributes
-  
+
   # ==== Parameters
   # html_class<~to_s>::
   #   The HTML class to add to the :class key. The html_class will be
@@ -178,7 +182,7 @@ class Hash
       self[:class] = html_class.to_s
     end
   end
-  
+
   # Converts all keys into string values. This is used during reloading to
   # prevent problems when classes are no longer declared.
   #
@@ -188,7 +192,7 @@ class Hash
   def protect_keys!
     keys.each {|key| self[key.to_s] = delete(key) }
   end
-  
+
   # Attempts to convert all string keys into Class keys. We run this after
   # reloading to convert protected hashes back into usable hashes.
   #
@@ -197,11 +201,11 @@ class Hash
   #   hash = { "One" => 1, "Two" => 2 }.unproctect_keys!
   #   hash # => { One => 1, Two => 2 }
   def unprotect_keys!
-    keys.each do |key| 
+    keys.each do |key|
       (self[Object.full_const_get(key)] = delete(key)) rescue nil
     end
   end
-  
+
   # Destructively and non-recursively convert each key to an uppercase string,
   # deleting nil values along the way.
   #
@@ -218,7 +222,7 @@ class Hash
       self[key.to_s.upcase] = val
     end
     self
-  end  
+  end
 end
 
 require 'rexml/parsers/streamparser'
@@ -233,7 +237,7 @@ require 'rexml/light/node'
 class REXMLUtilityNode # :nodoc:
   attr_accessor :name, :attributes, :children, :type
   cattr_accessor :typecasts, :available_typecasts
-  
+
   self.typecasts = {}
   self.typecasts["integer"]       = lambda{|v| v.nil? ? nil : v.to_i}
   self.typecasts["boolean"]       = lambda{|v| v.nil? ? nil : (v.strip != "false")}
@@ -247,14 +251,14 @@ class REXMLUtilityNode # :nodoc:
   self.typecasts["string"]        = lambda{|v| v.to_s}
   self.typecasts["yaml"]          = lambda{|v| v.nil? ? nil : YAML.load(v)}
   self.typecasts["base64Binary"]  = lambda{|v| Base64.decode64(v)}
-  
+
   self.available_typecasts = self.typecasts.keys
 
   def initialize(name, attributes = {})
     @name         = name.tr("-", "_")
     # leave the type alone if we don't know what it is
     @type         = self.class.available_typecasts.include?(attributes["type"]) ? attributes.delete("type") : attributes["type"]
-    
+
     @nil_element  = attributes.delete("nil") == "true"
     @attributes   = undasherize_keys(attributes)
     @children     = []
@@ -268,7 +272,7 @@ class REXMLUtilityNode # :nodoc:
 
   def to_hash
     if @type == "file"
-      f = StringIO.new(::Base64.decode64(@children.first || ""))  
+      f = StringIO.new(::Base64.decode64(@children.first || ""))
       class << f
         attr_accessor :original_filename, :content_type
       end
@@ -276,13 +280,13 @@ class REXMLUtilityNode # :nodoc:
       f.content_type = attributes['content_type'] || 'application/octet-stream'
       return {name => f}
     end
-    
+
     if @text
       return { name => typecast_value( translate_xml_entities( inner_html ) ) }
     else
       #change repeating groups into an array
       groups = @children.inject({}) { |s,e| (s[e.name] ||= []) << e; s }
-      
+
       out = nil
       if @type == "array"
         out = []
@@ -294,7 +298,7 @@ class REXMLUtilityNode # :nodoc:
           end
         end
         out = out.flatten
-        
+
       else # If Hash
         out = {}
         groups.each do |k,v|
@@ -322,11 +326,11 @@ class REXMLUtilityNode # :nodoc:
   #
   # ==== Parameters
   # value<String>:: The value that is being typecast.
-  # 
+  #
   # ==== :type options
-  # "integer":: 
+  # "integer"::
   #   converts +value+ to an integer with #to_i
-  # "boolean":: 
+  # "boolean"::
   #   checks whether +value+, after removing spaces, is the literal
   #   "true"
   # "datetime"::
@@ -338,7 +342,7 @@ class REXMLUtilityNode # :nodoc:
   # Integer, true, false, Time, Date, Object::
   #   The result of typecasting +value+.
   #
-  # ==== Note
+  # ==== Notes
   # If +self+ does not have a "type" key, or if it's not one of the
   # options specified above, the raw +value+ will be returned.
   def typecast_value(value)
@@ -388,7 +392,7 @@ class REXMLUtilityNode # :nodoc:
 
   # ==== Alias
   # #to_html
-  def to_s 
+  def to_s
     to_html
   end
 end
@@ -398,7 +402,7 @@ class ToHashParser # :nodoc:
   def self.from_xml(xml)
     stack = []
     parser = REXML::Parsers::BaseParser.new(xml)
-    
+
     while true
       event = parser.pull
       case event[0]
@@ -419,4 +423,4 @@ class ToHashParser # :nodoc:
     end
     stack.pop.to_hash
   end
-end
+end