merb-core 0.9.3 → 0.9.4

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

@@ -1,154 +0,0 @@
-# This class has dubious semantics and we only have it so that people can write
-# params[:key] instead of params['key'].
-class Mash < Hash
-
-  # ==== Parameters
-  # constructor<Object>::
-  #   The default value for the mash. Defaults to an empty hash.
-  #
-  # ==== Alternatives
-  # If constructor is a Hash, a new mash will be created based on the keys of
-  # the hash and no default value will be set.
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash) 
-      super() 
-      update(constructor) 
-    else 
-      super(constructor) 
-    end 
-  end
-
-  # ==== Parameters
-  # key<Object>:: The default value for the mash. Defaults to nil.
-  #
-  # ==== Alternatives
-  # If key is a Symbol and it is a key in the mash, then the default value will
-  # be set to the value matching the key.
-  def default(key = nil) 
-    if key.is_a?(Symbol) && include?(key = key.to_s) 
-      self[key] 
-    else 
-      super 
-    end 
-  end 
- 
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) 
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  # ==== Parameters
-  # key<Object>:: The key to set. This will be run through convert_key.
-  # value<Object>::
-  #   The value to set the key to.  This will be run through convert_value.
-  def []=(key, value) 
-    regular_writer(convert_key(key), convert_value(value)) 
-  end
-
-  # ==== Parameters
-  # other_hash<Hash>::
-  # A hash to update values in the mash with. The keys and the values will be
-  # converted to Mash format.
-  #
-  # ==== Returns
-  # Mash:: The updated mash.
-  def update(other_hash) 
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } 
-    self 
-  end 
- 
-  alias_method :merge!, :update
-
-  # ==== Parameters
-  # key<Object>:: The key to check for. This will be run through convert_key.
-  #
-  # ==== Returns
-  # Boolean:: True if the key exists in the mash.
-  def key?(key) 
-    super(convert_key(key)) 
-  end 
-
-  # def include? def has_key? def member?
-  alias_method :include?, :key? 
-  alias_method :has_key?, :key? 
-  alias_method :member?, :key?
-
-  # ==== Parameters
-  # key<Object>:: The key to fetch. This will be run through convert_key.
-  # extras:: Default value.
-  #
-  # ==== Returns
-  # Object:: The value at key or the default value.
-  def fetch(key, *extras) 
-    super(convert_key(key), *extras) 
-  end
-
-  # ==== Parameters
-  # indices<Array>::
-  #   The keys to retrieve values for. These will be run through +convert_key+.
-  def values_at(*indices) 
-    indices.collect {|key| self[convert_key(key)]} 
-  end
-
-  # ==== Returns
-  # Mash:: A duplicate of this mash.
-  def dup 
-    Mash.new(self) 
-  end
-
-  # ==== Parameters
-  # hash<Hash>:: The hash to merge with the mash.
-  #
-  # ==== Returns
-  # Mash:: A new mash with the hash values merged in.
-  def merge(hash) 
-    self.dup.update(hash) 
-  end
-
-  # ==== Parameters
-  # key<Object>::
-  #   The key to delete from the mash. This will be run through convert_key.
-  def delete(key) 
-    super(convert_key(key)) 
-  end
-
-  # Used to provide the same interface as Hash.
-  #
-  # ==== Returns
-  # Mash:: This mash unchanged.
-  def stringify_keys!; self end
- 
-  # ==== Returns
-  # Hash:: The mash as a Hash with string keys.
-  def to_hash 
-    Hash.new(default).merge(self) 
-  end 
- 
-  protected
-  # ==== Parameters
-  # key<Object>:: The key to convert.
-  #
-  # ==== Returns
-  # Object::
-  #   The converted key. If the key was a symbol, it will be converted to a
-  #   string.
-  def convert_key(key) 
-    key.kind_of?(Symbol) ? key.to_s : key 
-  end
-
-  # ==== Parameters
-  # value<Object>:: The value to convert.
-  #
-  # ==== Returns
-  # Object::
-  #   The converted value. A Hash or an Array of hashes, will be converted to
-  #   their Mash equivalents.
-  def convert_value(value) 
-    case value 
-    when Hash 
-      value.to_mash 
-    when Array 
-      value.collect { |e| convert_value(e) } 
-    else 
-      value 
-    end 
-  end
-end

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

@@ -1,147 +0,0 @@
-class Object
-  # Extracts the singleton class, so that metaprogramming can be done on it.
-  #
-  # ==== Returns
-  # Class:: The meta class.
-  #
-  # ==== Examples
-  #   class MyString < String; end
-  #
-  #   MyString.instance_eval do
-  #     define_method :foo do
-  #       puts self
-  #     end
-  #   end
-  #
-  #   MyString.meta_class.instance_eval do
-  #     define_method :bar do
-  #       puts self
-  #     end
-  #   end
-  #
-  #   def String.add_meta_var(var)
-  #     self.meta_class.instance_eval do
-  #       define_method var do
-  #         puts "HELLO"
-  #       end
-  #     end
-  #   end
-  #
-  #   MyString.new("Hello").foo #=> "Hello"
-  #   MyString.new("Hello").bar
-  #     #=> NoMethodError: undefined method `bar' for "Hello":MyString
-  #   MyString.foo
-  #     #=> NoMethodError: undefined method `foo' for MyString:Class
-  #   MyString.bar
-  #     #=> MyString
-  #   String.bar
-  #     #=> NoMethodError: undefined method `bar' for String:Class
-  #
-  #   MyString.add_meta_var(:x)
-  #   MyString.x #=> HELLO
-  #
-  # As you can see, using #meta_class allows you to execute code (and here,
-  # define a method) on the metaclass itself. It also allows you to define
-  # class methods that can be run on subclasses, and then be able to execute
-  # code on the metaclass of the subclass (here MyString).
-  #
-  # In this case, we were able to define a class method (add_meta_var) on
-  # String that was executable by the MyString subclass. It was then able to
-  # define a method on the subclass by adding it to the MyString metaclass.
-  #
-  # For more information, you can check out _why's excellent article at:
-  # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
-  def meta_class() class << self; self end end
-
-  # ==== Returns
-  # Boolean::
-  #   True if the empty? is true or if the object responds to strip (e.g. a
-  #   String) and strip.empty? is true, or if !self is true.
-  #
-  # ==== Examples
-  #    [].blank?         #=>  true
-  #    [1].blank?        #=>  false
-  #    [nil].blank?      #=>  false
-  #    nil.blank?        #=>  true
-  #    true.blank?       #=>  false
-  #    false.blank?      #=>  true
-  #    "".blank?         #=>  true
-  #    "     ".blank?    #=>  true
-  #    " hey ho ".blank? #=>  false
-  def blank?
-    if respond_to?(:empty?) && respond_to?(:strip)
-      empty? or strip.empty?
-    elsif respond_to?(:empty?)
-      empty?
-    else
-      !self
-    end
-  end
-
-  # ==== Parameters
-  # name<String>:: The name of the constant to get, e.g. "Merb::Router".
-  #
-  # ==== Returns
-  # Object:: The constant corresponding to the name.
-  def full_const_get(name)
-    list = name.split("::")
-    obj = Object
-    list.each {|x| obj = obj.const_get(x) }
-    obj
-  end
-
-  # Defines module from a string name (e.g. Foo::Bar::Baz)
-  # If method already exists, no exception raised.
-  #
-  # ==== Parameters
-  # name<String>:: The name of the full module name to make
-  #
-  # ==== Returns
-  # nil
-  def make_module(str)
-    mod = str.split("::")
-    start = mod.map {|x| "module #{x}"}.join("; ")
-    ender = (["end"] * mod.size).join("; ")
-    self.class_eval <<-HERE
-      #{start}
-      #{ender}
-    HERE
-  end
-
-  # ==== Parameters
-  # duck<Symbol, Class, Array>:: The thing to compare the object to.
-  #
-  # ==== Notes
-  # The behavior of the method depends on the type of duck as follows:
-  # Symbol:: Check whether the object respond_to?(duck).
-  # Class:: Check whether the object is_a?(duck).
-  # Array::
-  #   Check whether the object quacks_like? at least one of the options in the
-  #   array.
-  #
-  # ==== Returns
-  # Boolean:: True if the object quacks like duck.
-  def quacks_like?(duck)
-    case duck
-    when Symbol
-      self.respond_to?(duck)
-    when Class
-      self.is_a?(duck)
-    when Array
-      duck.any? {|d| self.quacks_like?(d) }
-    else
-      false
-    end
-  end
-  
-  # ==== Parameters
-  # arrayish<Array>:: Container to check, to see if it includes the object.
-  # more<Objects>:: additional args, will be flattened into arrayish
-  #
-  # ==== Returns
-  # Boolean: True if the object is included in arrayish (+ more)
-  def in?(arrayish,*more)
-    arrayish = more.unshift(arrayish) unless more.empty?
-    arrayish.include?(self)
-  end
-end

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

@@ -1,14 +0,0 @@
-module ObjectSpace
-  
-  class << self
-
-    # ==== Returns
-    # Array[Class]:: All the classes in the object space.
-    def classes
-      klasses = []
-      ObjectSpace.each_object(Class) {|o| klasses << o}
-      klasses
-    end
-  end
-  
-end

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

@@ -1,28 +0,0 @@
-# this is a temporary workaround until rubygems Does the Right thing here
-require 'rubygems'
-module Gem
-  class SourceIndex
-    
-    # Overwrite this so that a gem of the same name and version won't push one
-    # from the gems directory out entirely.
-    #
-    # ==== Parameters
-    # gem_spec<Gem::Specification>:: The specification of the gem to add.
-    def add_spec(gem_spec)
-      @gems[gem_spec.full_name] = gem_spec unless @gems[gem_spec.full_name].is_a?(Gem::Specification) && @gems[gem_spec.full_name].installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems")
-    end
-  end
-
-  class Specification
-
-    # Overwrite this so that gems in the gems directory get preferred over gems
-    # from any other location. If there are two gems of different versions in
-    # the gems directory, the later one will load as usual.
-    #
-    # ==== Returns
-    # Array[Array]:: The object used for sorting gem specs.
-    def sort_obj
-      [@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1]
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-module Merb
-  # Simple set implementation
-  # on top of Hash with mergins support.
-  #
-  # In particular this is used to store
-  # a set of callable actions of controller.
-  class SimpleSet < Hash
-
-    # ==== Parameters
-    # arr<Array>:: Initial set values.
-    #
-    # ==== Returns
-    # Array:: The array the Set was initialized with
-    def initialize(arr = [])
-      arr.each {|x| self[x] = true}
-    end
-
-    # ==== Parameters
-    # value<Object>:: Value to add to set.
-    #
-    # ==== Returns
-    # true
-    def <<(value)
-      self[value] = true
-    end
-
-    # ==== Parameters
-    # arr<Array>:: Values to merge with set.
-    #
-    # ==== Returns
-    # SimpleSet:: The set after the Array was merged in.
-    def merge(arr)
-      super(arr.inject({}) {|s,x| s[x] = true; s })
-    end
-
-    # ==== Returns
-    # String:: A human readable version of the set.
-    def inspect
-      "#<SimpleSet: {#{keys.map {|x| x.inspect}.join(", ")}}>"
-    end
-
-    # def to_a
-    alias_method :to_a, :keys
-
-  end # SimpleSet
-end # Merb

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

@@ -1,89 +0,0 @@
-require "pathname"
-
-class String
-
-  # ==== Returns
-  # String:: The string with all regexp special characters escaped.
-  #
-  # ==== Examples
-  #   "*?{}.".escape_regexp #=> "\\*\\?\\{\\}\\."
-  def escape_regexp
-    Regexp.escape self
-  end
-
-  # ==== Returns
-  # String:: The string with all regexp special characters unescaped.
-  #
-  # ==== Examples
-  #   "\\*\\?\\{\\}\\.".unescape_regexp #=> "*?{}."
-  def unescape_regexp
-    self.gsub(/\\([\.\?\|\(\)\[\]\{\}\^\$\*\+\-])/, '\1')
-  end
-
-  # ==== Returns
-  # String:: The string converted to snake case.
-  #
-  # ==== Examples
-  #   "FooBar".snake_case #=> "foo_bar"
-  #   "HeadlineCNNNews".snake_case #=> "headline_cnn_news"
-  #   "CNN".snake_case #=> "cnn"
-  def snake_case
-    return self.downcase if self =~ /^[A-Z]+$/
-    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
-      return $+.downcase
-  end
-
-  # ==== Returns
-  # String:: The string converted to camel case.
-  #
-  # ==== Examples
-  #   "foo_bar".camel_case #=> "FooBar"
-  def camel_case
-    return self if self !~ /_/ && self =~ /[A-Z]+.*/
-    split('_').map{|e| e.capitalize}.join
-  end
-
-  # ==== Returns
-  # String:: The path string converted to a constant name.
-  #
-  # ==== Examples
-  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
-  def to_const_string
-    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-  end
-
-  # ==== Returns
-  # String::
-  #   The path that is associated with the constantized string, assuming a
-  #   conventional structure.
-  #
-  # ==== Examples
-  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
-  def to_const_path
-    snake_case.gsub(/::/, "/")
-  end
-
-  # ==== Parameters
-  # o<String>:: The path component to join with the string.
-  #
-  # ==== Returns
-  # String:: The original path concatenated with o.
-  #
-  # ==== Examples
-  #   "merb"/"core_ext" #=> "merb/core_ext"
-  def /(o)
-    File.join(self, o.to_s)
-  end
-
-  # ==== Parameters ====
-  # other<String>:: Base path to calculate against
-  #
-  # ==== Returns ====
-  # String:: Relative path from between the two
-  #
-  # ==== Example ====
-  # "/opt/local/lib".relative_path_from("/opt/local/lib/ruby/site_ruby") # => "../.."
-  def relative_path_from(other)
-    Pathname.new(self).relative_path_from(Pathname.new(other)).to_s
-  end
-end