merb 0.5.3 → 0.9.2

data/lib/merb/core_ext/mash.rb

@@ -1,88 +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 
-  def initialize(constructor = {}) 
-    if constructor.is_a?(Hash) 
-      super() 
-      update(constructor) 
-    else 
-      super(constructor) 
-    end 
-  end 
- 
-  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) 
- 
-  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)) } 
-    self 
-  end 
- 
-  alias_method :merge!, :update 
- 
-  def key?(key) 
-    super(convert_key(key)) 
-  end 
- 
-  alias_method :include?, :key? 
-  alias_method :has_key?, :key? 
-  alias_method :member?, :key? 
- 
-  def fetch(key, *extras) 
-    super(convert_key(key), *extras) 
-  end 
- 
-  def values_at(*indices) 
-    indices.collect {|key| self[convert_key(key)]} 
-  end 
- 
-  def dup 
-    Mash.new(self) 
-  end 
- 
-  def merge(hash) 
-    self.dup.update(hash) 
-  end 
- 
-  def delete(key) 
-    super(convert_key(key)) 
-  end 
- 
-  def stringify_keys!; self end 
-  def symbolize_keys!; self end 
- 
-  # Convert to a Hash with String keys. 
-  def to_hash 
-    Hash.new(default).merge(self) 
-  end 
- 
-  protected 
-    def convert_key(key) 
-      key.kind_of?(Symbol) ? key.to_s : key 
-    end 
- 
-    def convert_value(value) 
-      case value 
-      when Hash 
-        value.to_mash 
-      when Array 
-        value.collect { |e| e.is_a?(Hash) ? e.to_mash : e } 
-      else 
-        value 
-      end 
-    end
-end

data/lib/merb/core_ext/module.rb

@@ -1,67 +0,0 @@
-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.
-    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-    yield(aliased_target, punctuation) if block_given?
-    alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
-    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" \
-        unless attrs.size == passed.size
-  
-      attrs.each_with_index do |att, i|
-        instance_variable_set("@#{att}", passed[i])
-      end
-  
-      after_initialize if respond_to? :after_initialize
-    end
-  end
-
-  
-end

data/lib/merb/core_ext/numeric.rb

@@ -1,72 +0,0 @@
-class Numeric
-  
-  # Converts a number to currency. Optionally, it allows localization of currency.
-  #
-  #   1.5.to_currency #=> "$1.50"
-  # 
-  # You can also localize the symbol that appears before the number, the 
-  # thousands delimiter, the decimal delimiter, and the symbol that appears
-  # after the number:
-  #   1.5.to_currency nil, ",", ".", "$USD" #=> "1.50$USD"
-  #   67_000.5.to_currency nil, ".", ",", "DM" #=> "67.000,50DM"
-  def to_currency(pre_symbol='$', thousands=',', decimal='.', post_symbol=nil)
-    "#{pre_symbol}#{("%.2f" % self ).gsub(".", decimal).gsub(/(\d)(?=(?:\d{3})+(?:$|[\\#{decimal}]))/,"\\1#{thousands}")}#{post_symbol}"
-  end
-
-  # Divides the number by 1,000,000
-  # 
-  #   2.microseconds #=> 2.0e-06
-  def microseconds() Float(self  * (10 ** -6)) end
-  # Divides the number by 1,000
-  #
-  #   2.milliseconds #=> 0.002
-  def milliseconds() Float(self  * (10 ** -3)) end
-  # Returns the same number as is passed in
-  #
-  #   2.seconds #=> 2
-  def seconds() self end
-  # Multiplies the number by 60
-  #
-  #   2.minutes #=> 120
-  def minutes() 60 * seconds end
-  # Multiplies the number by 60 minutes
-  #
-  #   2.hours #=> 7200
-  def hours() 60 * minutes end
-  # Multiples the number by 24 hours
-  #
-  #   2.days #=> 172800
-  def days() 24 * hours end
-  # Multiples the number by 7 days
-  #
-  #   2.weeks #=> 1209600    
-  def weeks() 7 * days end
-  # Multiples the number by 30 days
-  #
-  #   2.months #=> 5184000
-  def months() 30 * days end
-  # Multiplies the number by 365 days
-  #
-  #   2.years #=> 63072000
-  def years() 365 * days end
-  # Multiplies the number by 10 years
-  #
-  #   2.decades #=> 630720000
-  def decades() 10 * years end
-
-  # Each of the time extensions also works in the singular:
-  #
-  #   1.day #=> 86400
-  #   1.hour #=> 3600
-  alias_method :microsecond, :microseconds
-  alias_method :millisecond, :milliseconds
-  alias_method :second, :seconds
-  alias_method :minute, :minutes
-  alias_method :hour, :hours
-  alias_method :day, :days
-  alias_method :week, :weeks
-  alias_method :month, :months
-  alias_method :year, :years
-  alias_method :decade, :decades
-              
-end

data/lib/merb/core_ext/object.rb

@@ -1,183 +0,0 @@
-class Object
-
-  # Yields <tt>value</tt> to the passed block and returns the value.
-  # The object passed in as the value parameter is also passed to the block
-  # as a parameter.
-  #
-  #   returning({}) do |hsh| 
-  #     hsh.merge!((:bar => :baz))
-  #   end #=> {:bar => :baz}
-  def returning(value)
-    yield(value)
-    value
-  end
-  
-  # Extracts the singleton class, so that metaprogramming can be done on it.
-  #
-  # Let's look at two code snippets:
-  #
-  #   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
-  
-  # Runs instance_eval on the metaclass (see Object#meta_class).
-  #
-  #   String.meta_eval do
-  #     define_method :zoo do
-  #       puts "zoo"
-  #     end
-  #   end
-  #
-  #   String.zoo # => "zoo"
-  def meta_eval(&blk) meta_class.instance_eval( &blk ) end
-  
-  # Defines a method on the metaclass (see Object#meta_class).
-  #
-  #   String.meta_def :zoo do
-  #     puts "zoo"
-  #   end
-  #
-  #   String.zoo #=> "zoo"
-  #
-  # If the class inherits from another class, it will only be defined
-  # on the direct class meta_def is called on.
-  #
-  #   class Foo; end
-  #   class Bar < Foo; end
-  #   class Baz < Foo; end
-  #
-  #   Bar.meta_def :q do; "Q"; end
-  #   Foo.q #=> undefined method `r' for Foo:Class
-  #   Bar.q #=> "Q"
-  #   Baz.q #=> undefined method `r' for Baz:Class
-  #
-  # See Object#class_def for a comprehensive example containing meta_def
-  def meta_def(name, &blk) meta_eval { define_method name, &blk } end
-  
-  # Defines a method on new instances of the class.
-  #
-  #   String.class_def :zoo do
-  #     puts "zoo"
-  #   end
-  #
-  #   "HELLO".zoo #=> "zoo"
-  #
-  # In combination with meta_def, you can do some pretty powerful
-  # things:
-  #
-  # require 'merb_object'
-  # class Foo
-  #   def self.var
-  #     @var
-  #   end
-  #   def self.make_var baz
-  #     attr_accessor baz
-  #     meta_def baz do |val|
-  #       @var = val
-  #     end
-  #     class_def :initialize do
-  #       instance_variable_set("@#{baz}", self.class.var)
-  #     end
-  #   end
-  # end
-  #
-  # It might look a bit hairy, but here are some results that
-  # may help:
-  #
-  #   class Bar < Foo
-  #     make_var :foo
-  #     foo "FOO"
-  #   end
-  #
-  #   Bar.new.foo #=> "FOO"
-  #
-  # Essentially, what's happening is that Foo.make_var has the
-  # following effects when some symbol (:foo) is passed in:
-  # * Adds a new :foo accessor (returning @foo)
-  # * Adds a new foo method on the **class**, allowing you to set
-  #   a default value.
-  # * Sets @foo to that default value when new objects are
-  #   initialized.
-  #
-  # In the case of the Bar class, the following occurred:
-  # * make_var :foo created a new :foo accessor
-  # * foo "FOO" set the default value of @foo to "FOO"
-  # * Bar.new created a new Bar object containing the
-  #   instance variable @foo containing the default value
-  #   "FOO"
-  def class_def name, &blk
-    class_eval { define_method name, &blk }
-  end   
-  
-  # Returns true if:
-  # * it's an empty array
-  # * it's an empty string
-  # * !self evaluates to true
-  #
-  #    [].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
-
-  def full_const_get(name)
-    list = name.split("::")
-    obj = Object
-    list.each {|x| obj = obj.const_get(x) }
-    obj
-  end
-
-end

data/lib/merb/core_ext/string.rb

@@ -1,53 +0,0 @@
-require 'strscan'
-
-class String
-  class InvalidPathConversion < Exception; end
-
-  # Escapes any characters in the string that would have special meaning in a 
-  # regular expression.
-  #   $ "\*?{}.".escape_regexp #=> "\\*\\?\\{\\}\\."
-  def escape_regexp
-    Regexp.escape self
-  end
-  
-  # "FooBar".snake_case #=> "foo_bar"
-  def snake_case
-    gsub(/\B[A-Z]/, '_\&').downcase
-  end
-
-  # "foo_bar".camel_case #=> "FooBar"
-  def camel_case
-    split('_').map{|e| e.capitalize}.join
-  end
-  
-  # "merb/core_ext/string" #=> "Merb::CoreExt::String"
-  # 
-  # About 50% faster than string.split('/').map{ |s| s.camel_case }.join('::')
-  def to_const_string
-    new_string = ""
-    input = StringScanner.new(self.downcase)
-    until input.eos?
-      if input.scan(/([a-z][a-zA-Z\d]*)(_|$|\/)/)
-        new_string << input[1].capitalize
-        new_string << "::" if input[2] == '/'
-      else
-        raise InvalidPathConversion, self
-      end
-    end
-    new_string
-  end
-
-  # Concatenates a path
-  #   $ "merb"/"core_ext" #=> "merb/core_ext"
-  def /(o)
-    File.join(self, o.to_s)
-  end
-  
-  # Takes lines of text, removes any indentation, and
-  # adds +indentation+ number of spaces to each line
-  #   $ "  Hello\n Bob\nHow are you?".indent(3) 
-  #   #=> "   Hello\n   Bob\n   How are you?"
-  def indent(indentation)
-    match(/\s*/) && gsub(/^\s{0,#{$&.length}}/, " " * indentation)
-  end
-end