1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

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