lib/active_object/hash.rb in active_object-1.0.1 vs lib/active_object/hash.rb in active_object-1.0.2

@@ -1,8 +1,8 @@
 class Hash
 
-  unless method_defined?(:assert_valid_keys)
+  unless defined?(Rails)
     def assert_valid_keys(*valid_keys)
       valid_keys.flatten!
       each_key do |k|
         unless valid_keys.include?(k)
           raise ArgumentError,
@@ -10,29 +10,29 @@
         end
       end
     end
   end
 
-  unless method_defined?(:compact)
+  unless defined?(Rails)
     def compact
       select { |k,v| !v.nil? }
     end
   end
 
-  unless method_defined?(:compact!)
+  unless defined?(Rails)
     def compact!
       reject! { |k,v| v.nil? }
     end
   end
 
-  unless method_defined?(:deep_merge)
+  unless defined?(Rails)
     def deep_merge(other_hash, &block)
       dup.deep_merge!(other_hash, &block)
     end
   end
 
-  unless method_defined?(:deep_merge!)
+  unless defined?(Rails)
     def deep_merge!(other_hash, &block)
       other_hash.each_pair do |current_key, other_value|
         this_value = self[current_key]
 
         self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
@@ -43,17 +43,17 @@
       end
       self
     end
   end
 
-  unless method_defined?(:except)
+  unless defined?(Rails)
     def except(*keys)
       dup.except!(*keys)
     end
   end
 
-  unless method_defined?(:except!)
+  unless defined?(Rails)
     def except!(*keys)
       keys.each { |k| delete(k) }
       self
     end
   end
@@ -68,17 +68,17 @@
         self[k] = nil
       end
     end
   end
 
-  unless method_defined?(:only)
+  unless defined?(Rails)
     def only(*keys)
       dup.only!(*keys)
     end
   end
 
-  unless method_defined?(:only!)
+  unless defined?(Rails)
     def only!(*args)
       hash = {}
       args.each {|k| hash[k] = self[k] if self.has_key?(k) }
       hash
     end
@@ -92,29 +92,29 @@
     keys = Hash[*args.flatten]
     keys.each { |k, v| self[v] = delete(k) if self[k] }
     self
   end
 
-  unless method_defined?(:reverse_merge)
+  unless defined?(Rails)
     def reverse_merge(other_hash)
       other_hash.merge(self)
     end
   end
 
-  unless method_defined?(:reverse_merge!)
+  unless defined?(Rails)
     def reverse_merge!(other_hash)
       merge!(other_hash) { |k,l,r| l }
     end
   end
 
-  unless method_defined?(:slice)
+  unless defined?(Rails)
     def slice(*keys)
       keys.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
     end
   end
 
-  unless method_defined?(:slice!)
+  unless defined?(Rails)
     def slice!(*keys)
       omit = slice(*self.keys - keys)
       hash = slice(*keys)
 
       hash.default      = default
@@ -123,17 +123,17 @@
       replace(hash)
       omit
     end
   end
 
-  unless method_defined?(:stringify_keys)
+  unless defined?(Rails)
     def stringify_keys
       dup.stringify_keys!
     end
   end
 
-  unless method_defined?(:stringify_keys!)
+  unless defined?(Rails)
     def stringify_keys!
       inject({}) do |options,(k,v)|
         options[k.to_s] = v
         options
       end
@@ -146,17 +146,17 @@
 
   def strip!
     reject! { |k,v| v.blank? }
   end
 
-  unless method_defined?(:symbolize_keys)
+  unless defined?(Rails)
     def symbolize_keys
       dup.symbolize_keys!
     end
   end
 
-  unless method_defined?(:symbolize_keys!)
+  unless defined?(Rails)
     def symbolize_keys!
       inject({}) do |options, (k,v)|
         options[(k.to_sym rescue k) || k] = v
         options
       end
@@ -172,30 +172,30 @@
       options[(k.to_s.gsub(" ", "_").underscore.to_sym rescue k) || k] = v
       options
     end
   end
 
-  unless method_defined?(:transform_keys)
+  unless defined?(Rails)
     def transform_keys(&block)
       dup.transform_keys!(&block)
     end
   end
 
-  unless method_defined?(:transform_keys!)
+  unless defined?(Rails)
     def transform_keys!(&block)
       return(enum_for(:transform_keys!)) unless block_given?
       keys.each { |k| self[yield(k)] = delete(k) }
       self
     end
   end
 
-  unless method_defined?(:transform_values)
+  unless defined?(Rails)
     def transform_values(&block)
       dup.transform_values!(&block)
     end
   end
 
-  unless method_defined?(:transform_values!)
+  unless defined?(Rails)
     def transform_values!(&block)
       return(enum_for(:transform_values!)) unless block_given?
       each { |k,v| self[k] = yield(v) }
     end
   end
\ No newline at end of file