module Inflector
  def methodize(word)
    camelize(underscore(word), false)
  end
end

module JavaScript
  class Literal < String
    def to_json_with_literal
      to_json_without_literal[1..-2]
    end
    alias_method_chain :to_json, :literal
  end
end

class String
  def methodize
    Inflector.methodize(self)
  end
  alias_method :methodcase, :methodize
  
  def to_jsl
    JavaScript::Literal.new(self)
  end
end

class Hash
  def methodize_keys
    inject({}) do |options, (key, value)|
      options[key.to_s.methodize] = value
      options
    end
  end
  
  def methodize_keys!
    keys.each do |key|
      unless key.class.to_s == "String"
        self[key.to_s.methodize] = self[key]
        delete(key)
      end
    end
    self
  end
  
  def recursively(&block)
    inject({}) do |hash, (key, value)|
      if value.is_a?(self.class)
        hash[key] = value.recursively(&block)
      else
        hash[key] = value
      end
      yield hash
    end
  end

  def recursively!(&block)
    replace(recursively(&block))
  end
  
  def rec_merge!(other)
    other.each do |key, value|
      myval = self[key]
      if value.is_a?(Hash) && myval.is_a?(Hash)
        myval.rec_merge!(value)
      else
        self[key] = value
      end
    end
    self
  end
end

class Array
  def recursively(&block)
    map do |item|
      if item.is_a?(self.class)
        item.recursively(&block)
      else
        yield item
      end
    end
  end

  def recursively!(&block)
    replace(recursively(&block))
  end
end