merb 0.3.4 → 0.3.7

data/lib/merb/core_ext/merb_enumerable.rb

@@ -1,7 +1,49 @@
 module Enumerable
+   
+  # Abstract the common pattern of injecting a hash into a block to accumulate
+  # and return the injected hash.
+  #
+  # Both of these are equivalent 
+  #   [1,2,3].inject({}){|m,i| m[i] = i; m }
+  #   [1,2,3].injecting({}){|m,i| m[i] = i }
+  #   =>  {1=>1, 2=>2, 3=>3}
+  #
+  # The main difference is with injecting you do not have to end the block
+  # with ;m to return the accumulated hash m. In this sense it is very much 
+  # like Object#returning
   def injecting(s)
     inject(s) do |k, i|
       yield(k, i); k
     end
   end
-end
+
+  # Look for any of an array of things inside another array (or any Enumerable).
+  #
+  #   ['louie', 'bert'].include_any?('louie', 'chicken')
+  #   => true
+  def include_any?(*args)
+    args.any? {|arg| self.include?(arg) }
+  end
+
+ 
+  #
+  # Returns a hash, which keys are evaluated result from the
+  # block, and values are arrays of elements in <i>enum</i>
+  # corresponding to the key.
+  #     
+  # (1..6).group_by {|i| i%3}   #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
+  #
+  # This is included in Ruby 1.9
+  # http://www.ruby-doc.org/core-1.9/classes/Enumerable.html#M002672
+  #
+  # Implementation from Ruby on Rails: 
+  # trunk/activesupport/lib/active_support/core_ext/enumerable.rb 
+  # [rev 5334]
+  #
+  def group_by
+    inject({}) do |groups, element|
+      (groups[yield(element)] ||= []) << element
+      groups
+    end
+  end if RUBY_VERSION < '1.9'  
+end

data/lib/merb/core_ext/merb_hash.rb

@@ -1,76 +1,73 @@
+require 'hpricot'
+
 class Hash
 
   class << self
-    def from_xml(xml)
-      # TODO: Refactor this into something much cleaner that doesn't rely on XmlSimple
-      undasherize_keys(typecast_xml_value(XmlSimple.xml_in(xml,
-        'forcearray'   => false,
-        'forcecontent' => true,
-        'keeproot'     => true,
-        'contentkey'   => '__content__')
-      ))            
-    end
-
-    private
-      def typecast_xml_value(value)
-        case value.class.to_s
-          when "Hash"
-            if value.has_key?("__content__")
-              content = translate_xml_entities(value["__content__"])
-              case value["type"]
-                when "integer"  then content.to_i
-                when "boolean"  then content.strip == "true"
-                when "datetime" then ::Time.parse(content).utc
-                when "date"     then ::Date.parse(content)
-                else                 content
-              end
-            else
-              (value.blank? || value['type'] || value['nil'] == 'true') ? nil : value.inject({}) do |h,(k,v)|
-                h[k] = typecast_xml_value(v)
-                h
-              end
-            end
-          when "Array"
-            value.map! { |i| typecast_xml_value(i) }
-            case value.length
-              when 0 then nil
-              when 1 then value.first
-              else value
-            end
-          when "String"
-            value
-          else
-            raise "can't typecast #{value.inspect}"
-        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
-    
-      def translate_xml_entities(value)
-        value.gsub(/&lt;/,   "<").
-              gsub(/&gt;/,   ">").
-              gsub(/&quot;/, '"').
-              gsub(/&apos;/, "'").
-              gsub(/&amp;/,  "&")
-      end
-    
-      def undasherize_keys(params)
-        case params.class.to_s
-        when "Hash"
-          params.inject({}) do |h,(k,v)|
-            h[k.to_s.tr("-", "_")] = undasherize_keys(v)
-            h
-          end
-        when "Array"
-          params.map { |v| undasherize_keys(v) }
-        else
-          params
-        end
-     end
   end
   
-    
-  def with_indifferent_access
-    MerbHash.new(self)
-  end
   def to_params
     result = ''
     stack = []
@@ -94,88 +91,169 @@ class Hash
   # lets through the keys in the argument
   # >> {:one => 1, :two => 2, :three => 3}.pass(:one)
   # => {:one=>1}
-  def pass(*keys) 
-    self.reject { |k,v| ! keys.include?(k) } 
+  def pass(*allowed) 
+    self.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(*keys) 
-    self.reject { |k,v| keys.include?(k) } 
+  def block(*rejected) 
+    self.reject { |k,v| rejected.include?(k) } 
   end
   alias except block
-end  
 
-# like HashWithIndifferentAccess from ActiveSupport.
-class MerbHash < Hash
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash)
-      super()
-      update(constructor)
-    else
-      super(constructor)
+
+  # Destructively convert all keys to symbols recursively.
+  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  
     end
+    self
   end
- 
-  def default(key)
-    self[key.to_s] if key.is_a?(Symbol)
-  end  
-
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-  alias_method :u, :regular_update
   
-  def []=(key, value)
-    regular_writer(convert_key(key), convert_value(value))
-  end
-
-  def update(other_hash)
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+  def environmentize_keys!
+    self.each do |key, value|
+      self[key.to_s.upcase] = delete(key)
+    end
     self
   end
+    
+ def method_missing(m,*a)
+   m.to_s =~ /=$/ ? self[$`]=a[0] : a==[] ? self[m] : raise(NoMethodError,"#{m}")
+ end
+  
+  def respond_to?(method, include_private=false)
+    return true if keys.include?(method)
+    super(method, include_private)
+  end
   
-  alias_method :merge!, :update
+end  
+
+require 'rexml/parsers/streamparser'
+require 'rexml/parsers/baseparser'
+require 'rexml/light/node'
 
-  def key?(key)
-    super(convert_key(key))
+# This is a slighly modified version of the XMLUtilityNode from
+# http://merb.devjavu.com/projects/merb/ticket/95 (has.sox@gmail.com)
+# It's mainly just adding vowels, as I ht cd wth n vwls :)
+# This represents the hard part of the work, all I did was change the underlying
+# parser
+class REXMLUtilityNode # :nodoc:
+  attr_accessor :name, :attributes, :children
+  
+  def initialize(name, attributes = {})
+    @name       = name.tr("-", "_")
+    @attributes = undasherize_keys(attributes)
+    @children   = []
+    @text       = false
   end
+  
+  def add_node(node)
+    @text = true if node.is_a? String
+    @children << node
+  end
+  
+  def to_hash
+    if @text
+      return { name => typecast_value( translate_xml_entities( inner_html ) ) }
+    else
+      #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 }
 
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
+      hash = {}  
+      groups.each do |key, values|
+        if values.size == 1
+          hash.merge!( values.first ) 
+        else
+          hash.merge!( key => values.map{ |element| element.to_hash[key] } )
+        end
+      end
 
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
+      # merge the arrays, including attributes
+      hash.merge!( attributes ) unless attributes.empty?
+      return { name => hash }
+    end
   end
 
-  def values_at(*indices)
-    indices.collect {|key| self[convert_key(key)]}
+  def to_s 
+    self.to_html
   end
 
-  def dup
-    MerbHash.new(self)
+
+  def typecast_value(value)
+    return value unless attributes["type"] 
+    
+    case attributes["type"]
+      when "integer"  then value.to_i
+      when "boolean"  then value.strip == "true"
+      when "datetime" then ::Time.parse(value).utc
+      when "date"     then ::Date.parse(value)
+      else                 value
+    end
   end
-  
-  def merge(hash)
-    self.dup.update(hash)
+
+  def translate_xml_entities(value)
+    value.gsub(/&lt;/,   "<").
+          gsub(/&gt;/,   ">").
+          gsub(/&quot;/, '"').
+          gsub(/&apos;/, "'").
+          gsub(/&amp;/,  "&")
   end
 
-  def delete(key)
-    super(convert_key(key))
+   def undasherize_keys(params)
+     params.keys.each do |key, vvalue|
+       params[key.tr("-", "_")] = params.delete(key)
+     end
+     params 
   end
 
-  # allow merbhash.key to work the same as merbhash[key]
-  def method_missing(m,*a)
-    m.to_s =~ /=$/?self[$`]=a[0]:a==[]?self[m]:raise(NoMethodError,"#{m}")
+  def inner_html
+    @children.join
   end
-  
-  protected
-    def convert_key(key)
-      key.kind_of?(Symbol) ? key.to_s : key
-    end
-    def convert_value(value)
-      value.is_a?(Hash) ? value.with_indifferent_access : value
-    end
+
+  def to_html 
+    "<#{name}#{attributes_to_xml}>#{inner_html}</#{name}>"
+  end
+
+  def attributes_to_xml
+    attributes.keys.map do |key| 
+      "#{key}='#{attributes[key]}'"
+    end.join
+  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	
 end

data/lib/merb/core_ext/merb_kernel.rb

@@ -14,6 +14,8 @@ module Kernel
     end
   end
   
+  # does a basic require, and prints the message passed as an optional
+  # second parameter if an error occurs.
   def rescue_require(sym, message = nil)
     require sym
   rescue LoadError, RuntimeError

data/lib/merb/core_ext/merb_module.rb

@@ -1,5 +1,26 @@
 class Module
   
+  # alias_method_chain :foo, :bar produces the following pattern:
+  # 
+  #   alias_method :foo_without_bar, :foo
+  #   alias_method :foo, :foo_with_bar
+  #
+  # You will then need to write the foo_with_bar method, which will
+  # be able to reference foo_without_bar:
+  #
+  # def foo_with_bar
+  #   foo_without_bar.map {|x| x + 1 }
+  # end
+  # 
+  # Method punctuation (foo? and foo!) will be retained:
+  #
+  # alias_method_chain :foo?, :bar will produce:
+  #   foo_without_bar?
+  #   foo_with_bar?
+  #
+  # alias_method_chain :foo!, :bar will produce:
+  #   foo_without_bar!
+  #   foo_with_bar!
   def alias_method_chain(target, feature)
     # Strip out punctuation on predicates or bang methods since
     # e.g. target?_without_feature is not a valid method name.
@@ -9,6 +30,26 @@ class Module
     alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
   end
   
+  # defines a series of instance variables to be initialized when
+  # the class is initialized.
+  #
+  # For instance, you could create the class Foo:
+  #
+  #   class Foo
+  #     attr_initialize :bar, :baz
+  #     attr_accessor   :bar, :baz
+  #   end
+  #
+  # and initialize an instance of the class as follows:
+  #
+  #   Foo.new(1, 2)
+  #
+  # which will create a new Foo object with #bar equal to 1 and #baz
+  # equal to 2.
+  #
+  # Passing a different number of arguments to <tt>new</tt> than you
+  # passed to attr_initialize will result in an ArgumentError being 
+  # thrown. 
   def attr_initialize(*attrs)
     define_method(:initialize) do |*passed|
       raise ArgumentError, "Wrong number of arguments" \