class String
  
  # reloads controller classes on each request if
  # :allow_reloading is set to true in the config
  # file or command line options.
  def import
    if Merb::Server.config[:allow_reloading] 
      Object.send(:remove_const, self.camel_case.intern) rescue nil
      load(self.snake_case  + '.rb')
    else  
      require(self.snake_case)
    end
  end
  
  # "FooBar".snake_case #=> "foo_bar"
  def snake_case
    return self unless self =~ %r/[A-Z]/
    self.reverse.scan(%r/[A-Z]+|[^A-Z]*[A-Z]+?/).reverse.map{|word| word.reverse.downcase}.join '_'
  end

  # "foo_bar".camel_case #=> "FooBar"
  def camel_case
    return self if self =~ %r/[A-Z]/ and self !~ %r/_/
    words = self.strip.split %r/\s*_+\s*/
    words.map!{|w| w.downcase.sub(%r/^./){|c| c.upcase}}
    words.join
  end

  # Concatenates a path
  def /(o)
    File.join(self, o.to_s)
  end
  
end


module Enumerable
  def injecting(s)
    inject(s) do |k, i|
      yield(k, i); k
    end
  end
end

class Numeric
  def to_currency( pre_symbol='$', thousands=',', decimal='.',
post_symbol=nil )
    "#{pre_symbol}#{
      ( "%.2f" % self ).gsub(
        /(\d)(?=(?:\d{3})+(?:$|\.))/,
        "\\1#{thousands}"
      )
    }#{post_symbol}"
  end
end

class Symbol
  
  # faster Symbol#to_s to speed up routing.
  def to_s
    @str_rep ||= id2name.freeze
  end
  
  # ["foo", "bar"].map &:reverse #=> ['oof', 'rab']
  def to_proc
     Proc.new{|*args| args.shift.__send__(self, *args)}
   end
end  

class Object
  def returning(value)
    yield(value)
    value
  end
end

class Hash
  def with_indifferent_access
    MerbHash.new(self)
  end
end  

# like HashWithIndifferentAccess from ActiveSupport.
class MerbHash < Hash
  def initialize(constructor = {})
    if constructor.is_a?(Hash)
      super()
      update(constructor)
    else
      super(constructor)
    end
  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)) }
    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
    MerbHash.new(self)
  end
  
  def merge(hash)
    self.dup.update(hash)
  end

  def delete(key)
    super(convert_key(key))
  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}")
  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
end