merb-core 0.9.3 → 0.9.4

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

@@ -1,299 +0,0 @@
-# Allows attributes to be shared within an inheritance hierarchy, but where
-# each descendant gets a copy of their parents' attributes, instead of just a
-# pointer to the same. This means that the child can add elements to, for
-# 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
-  # 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)
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
-
-        def #{sym}
-          @@#{sym}
-        end
-      EOS
-    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|
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-
-        #{"
-
-        def #{sym}=(obj)
-          @@#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    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)
-      class_eval <<-EOS, __FILE__, __LINE__
-
-        def self.#{sym}
-          read_inheritable_attribute(:#{sym})
-        end
-
-        def #{sym}
-          self.class.#{sym}
-        end
-      EOS
-    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|
-      class_eval <<-EOS, __FILE__, __LINE__
-
-        def self.#{sym}=(obj)
-          write_inheritable_attribute(:#{sym}, obj)
-        end
-
-        #{"
-
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    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|
-      class_eval <<-EOS, __FILE__, __LINE__
-
-        def self.#{sym}=(obj)
-          write_inheritable_array(:#{sym}, obj)
-        end
-
-        #{"
-
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    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|
-      class_eval <<-EOS, __FILE__, __LINE__
-
-        def self.#{sym}=(obj)
-          write_inheritable_hash(:#{sym}, obj)
-        end
-
-        #{"
-
-        def #{sym}=(obj)
-          self.class.#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-    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 = {}
-    end
-    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
-        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
-          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

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

@@ -1,426 +0,0 @@
-require 'base64'
-
-class Hash
-  class << self
-    # Converts valid XML into a Ruby Hash structure.
-    #
-    # ==== Paramters
-    # xml<String>:: A string representation of valid XML.
-    #
-    # ==== Notes
-    # * Mixed content is treated as text and any tags in it are left unparsed
-    # * Any attributes other than type on a node containing a text node will be
-    #   discarded
-    #
-    # ===== Typecasting
-    # Typecasting is performed on elements that have a +type+ attribute:
-    # 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
-    #
-    # ===== 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='false'>
-    #     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 unit attribute is ignored.
-    #
-    #    { "bicep" => 60 }
-    def from_xml( xml )
-      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
-  #
-  # ==== Examples
-  #   { :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
-    params = ''
-    stack = []
-
-    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 |k, v|
-        if v.is_a?(Hash)
-          stack << ["#{parent}[#{k}]", v]
-        else
-          params << "#{parent}[#{k}]=#{v}&"
-        end
-      end
-    end
-
-    params.chop! # trailing &
-    params
-  end
-
-  # ==== Parameters
-  # *allowed:: The hash keys to include.
-  #
-  # ==== Returns
-  # Hash:: A new hash with only the selected keys.
-  #
-  # ==== Examples
-  #   { :one => 1, :two => 2, :three => 3 }.only(:one)
-  #     #=> { :one => 1 }
-  def only(*allowed)
-    reject { |k,v| !allowed.include?(k) }
-  end
-
-  # ==== Parameters
-  # *rejected:: The hash keys to exclude.
-  #
-  # ==== Returns
-  # Hash:: A new hash without the selected keys.
-  #
-  # ==== Examples
-  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
-  #     #=> { :two => 2, :three => 3 }
-  def except(*rejected)
-    reject { |k,v| rejected.include?(k) }
-  end
-
-  # ==== Returns
-  # String:: The hash as attributes for an XML tag.
-  #
-  # ==== Examples
-  #   { :one => 1, "two"=>"TWO" }.to_xml_attributes
-  #     #=> 'one="1" two="TWO"'
-  def to_xml_attributes
-    map do |k,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
-  #   concatenated to any existing classes.
-  #
-  # ==== Examples
-  #   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}"
-    else
-      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.
-  #
-  # === Examples
-  #   hash = { One => 1, Two => 2 }.proctect_keys!
-  #   hash # => { "One" => 1, "Two" => 2 }
-  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.
-  #
-  # === Examples
-  #   # Provided that classes One and Two are declared in this scope:
-  #   hash = { "One" => 1, "Two" => 2 }.unproctect_keys!
-  #   hash # => { One => 1, Two => 2 }
-  def unprotect_keys!
-    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.
-  #
-  # ==== Returns
-  # Hash:: The newly environmentized hash.
-  #
-  # ==== Examples
-  #   { :name => "Bob", :contact => { :email => "bob@bob.com" } }.environmentize_keys!
-  #     #=> { "NAME" => "Bob", "CONTACT" => { :email => "bob@bob.com" } }
-  def environmentize_keys!
-    keys.each do |key|
-      val = delete(key)
-      next if val.nil?
-      self[key.to_s.upcase] = val
-    end
-    self
-  end
-end
-
-require 'rexml/parsers/streamparser'
-require 'rexml/parsers/baseparser'
-require 'rexml/light/node'
-
-# 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, :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")}
-  self.typecasts["datetime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
-  self.typecasts["date"]          = lambda{|v| v.nil? ? nil : Date.parse(v)}
-  self.typecasts["dateTime"]      = lambda{|v| v.nil? ? nil : Time.parse(v).utc}
-  self.typecasts["decimal"]       = lambda{|v| BigDecimal(v)}
-  self.typecasts["double"]        = lambda{|v| v.nil? ? nil : v.to_f}
-  self.typecasts["float"]         = lambda{|v| v.nil? ? nil : v.to_f}
-  self.typecasts["symbol"]        = lambda{|v| v.to_sym}
-  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     = []
-    @text         = false
-  end
-
-  def add_node(node)
-    @text = true if node.is_a? String
-    @children << node
-  end
-
-  def to_hash
-    if @type == "file"
-      f = StringIO.new(::Base64.decode64(@children.first || ""))
-      class << f
-        attr_accessor :original_filename, :content_type
-      end
-      f.original_filename = attributes['name'] || 'untitled'
-      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 = []
-        groups.each do |k, v|
-          if v.size == 1
-            out << v.first.to_hash.entries.first.last
-          else
-            out << v.map{|e| e.to_hash[k]}
-          end
-        end
-        out = out.flatten
-
-      else # If Hash
-        out = {}
-        groups.each do |k,v|
-          if v.size == 1
-            out.merge!(v.first)
-          else
-            out.merge!( k => v.map{|e| e.to_hash[k]})
-          end
-        end
-        out.merge! attributes unless attributes.empty?
-        out = out.empty? ? nil : out
-      end
-
-      if @type && out.nil?
-        { name => typecast_value(out) }
-      else
-        { name => out }
-      end
-    end
-  end
-
-  # Typecasts a value based upon its type. For instance, if
-  # +node+ has #type == "integer",
-  # {{[node.typecast_value("12") #=> 12]}}
-  #
-  # ==== Parameters
-  # value<String>:: The value that is being typecast.
-  #
-  # ==== :type options
-  # "integer"::
-  #   converts +value+ to an integer with #to_i
-  # "boolean"::
-  #   checks whether +value+, after removing spaces, is the literal
-  #   "true"
-  # "datetime"::
-  #   Parses +value+ using Time.parse, and returns a UTC Time
-  # "date"::
-  #   Parses +value+ using Date.parse
-  #
-  # ==== Returns
-  # Integer, true, false, Time, Date, Object::
-  #   The result of typecasting +value+.
-  #
-  # ==== 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)
-    return value unless @type
-    proc = self.class.typecasts[@type]
-    proc.nil? ? value : proc.call(value)
-  end
-
-  # Convert basic XML entities into their literal values.
-  #
-  # ==== Parameters
-  # value<~gsub>::
-  #   An XML fragment.
-  #
-  # ==== Returns
-  # ~gsub::
-  #   The XML fragment after converting entities.
-  def translate_xml_entities(value)
-    value.gsub(/&lt;/,   "<").
-          gsub(/&gt;/,   ">").
-          gsub(/&quot;/, '"').
-          gsub(/&apos;/, "'").
-          gsub(/&amp;/,  "&")
-  end
-
-  # Take keys of the form foo-bar and convert them to foo_bar
-  def undasherize_keys(params)
-    params.keys.each do |key, value|
-      params[key.tr("-", "_")] = params.delete(key)
-    end
-    params
-  end
-
-  # Get the inner_html of the REXML node.
-  def inner_html
-    @children.join
-  end
-
-  # Converts the node into a readable HTML node.
-  #
-  # ==== Returns
-  # String:: The HTML node in text form.
-  def to_html
-    attributes.merge!(:type => @type ) if @type
-    "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>"
-  end
-
-  # ==== Alias
-  # #to_html
-  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, :cdata
-        stack.last.add_node(event[1]) unless event[1].strip.length == 0
-      end
-    end
-    stack.pop.to_hash
-  end
-end