lib/refinements/hashes.rb in refinements-8.0.1 vs lib/refinements/hashes.rb in refinements-8.1.0

@@ -5,13 +5,11 @@
     refine Hash.singleton_class do
       def infinite
         new { |new_hash, missing_key| new_hash[missing_key] = new(&new_hash.default_proc) }
       end
 
-      def with_default value
-        new { |new_hash, missing_key| new_hash[missing_key] = value }
-      end
+      def with_default(value) = new { |new_hash, missing_key| new_hash[missing_key] = value }
     end
 
     refine Hash do
       def deep_merge other
         clazz = self.class
@@ -23,29 +21,19 @@
             other_value
           end
         end
       end
 
-      def deep_merge! other
-        replace deep_merge(other)
-      end
+      def deep_merge!(other) = replace(deep_merge(other))
 
-      def deep_stringify_keys
-        recurse(&:stringify_keys)
-      end
+      def deep_stringify_keys = recurse(&:stringify_keys)
 
-      def deep_stringify_keys!
-        replace deep_stringify_keys
-      end
+      def deep_stringify_keys! = replace(deep_stringify_keys)
 
-      def deep_symbolize_keys
-        recurse(&:symbolize_keys)
-      end
+      def deep_symbolize_keys = recurse(&:symbolize_keys)
 
-      def deep_symbolize_keys!
-        replace deep_symbolize_keys
-      end
+      def deep_symbolize_keys! = replace(deep_symbolize_keys)
 
       # :reek:TooManyStatements
       def flatten_keys prefix: nil, delimiter: "_", cast: :to_sym
         fail StandardError, "Unknown cast: #{cast}." unless %i[to_sym to_s].include? cast
 
@@ -72,24 +60,16 @@
         transform.each do |key, value|
           transform[key] = value.recurse(&block) if value.is_a? self.class
         end
       end
 
-      def stringify_keys
-        reduce({}) { |hash, (key, value)| hash.merge key.to_s => value }
-      end
+      def stringify_keys = reduce({}) { |hash, (key, value)| hash.merge key.to_s => value }
 
-      def stringify_keys!
-        replace stringify_keys
-      end
+      def stringify_keys! = replace(stringify_keys)
 
-      def symbolize_keys
-        reduce({}) { |hash, (key, value)| hash.merge key.to_sym => value }
-      end
+      def symbolize_keys = reduce({}) { |hash, (key, value)| hash.merge key.to_sym => value }
 
-      def symbolize_keys!
-        replace symbolize_keys
-      end
+      def symbolize_keys! = replace(symbolize_keys)
 
       def use &block
         return [] unless block
 
         block.parameters