ActiveSupport compatibility: fix underscore and try

- Make String#underscore AS-compatible (converts :: to /)
- String#snakecase remains pure case conversion without :: handling
- Make Kernel#try AS-compatible (add block form and try!)
- Facets' Tee form retained when try called with no args and no block
- Verified all other AS overlaps (blank?, present?, symbolize_keys,
  deep_merge, reverse_merge, squish, remove, etc.) are already compatible

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: trans

HISTORY.md

@@ -33,6 +33,10 @@ Changes:
   * Rewrite `Kernel#callstack`, `#require_all`, `#load_all` to use `caller_locations`
     instead of parsing caller strings with regex.
   * Switch CI from Travis to GitHub Actions.
+  * Make `String#underscore` ActiveSupport-compatible (converts `::` to `/`).
+    Use `String#snakecase` for pure case conversion without namespace handling.
+  * Make `Kernel#try` ActiveSupport-compatible (supports block form and `try!`).
+    Facets' Tee/Functor form retained as extra feature.
 
 * Bug Fixes
 

lib/core/facets/kernel/try.rb

@@ -3,38 +3,36 @@
 module Kernel
 
   # Invokes the method identified by the symbol +method+, passing it any
-  # arguments  and/or the block specified, just like the regular Ruby
-  # <tt>Object#send</tt> does.
+  # arguments and/or the block specified.
   #
-  # *Unlike* that method however, a +NoMethodError+ exception will *not*
-  # be raised and +nil+ will be returned instead, if the receiving object
-  # is a +nil+ object or NilClass.
+  # Unlike regular send, a +NoMethodError+ exception will *not* be raised
+  # if the receiving object is +nil+ (see NilClass#try below).
   #
-  # For example, without try
+  # Compatible with ActiveSupport's #try, plus an additional Tee/Functor
+  # form when called with no arguments and no block.
   #
-  #   @example = Struct.new(:name).new("bob")
-  #
-  #   @example && @example.name
-  #
-  # or:
-  #
-  #   @example ? @example.name : nil
-  #
-  # But with try
-  #
-  #   @example.try(:name)  #=> "bob"
-  #
-  # or
-  #
-  #   @example.try.name    #=> "bob"
-  #
-  # It also accepts arguments and a block, for the method it is trying:
-  #
-  #   @people.try(:collect){ |p| p.name }
+  #   @example.try(:name)              #=> "bob"
+  #   @example.try { |o| o.name }     #=> "bob"  (ActiveSupport block form)
+  #   @example.try.name               #=> "bob"  (Facets Tee form)
   #
   def try(method=nil, *args, &block)
     if method
       __send__(method, *args, &block)
+    elsif block_given?
+      yield self
+    else
+      self
+    end
+  end
+
+  # Like #try, but raises NoMethodError if the method doesn't exist
+  # (unless receiver is nil). Compatible with ActiveSupport's #try!.
+  #
+  def try!(method=nil, *args, &block)
+    if method
+      public_send(method, *args, &block)
+    elsif block_given?
+      yield self
     else
       self
     end
@@ -46,13 +44,25 @@ def try(method=nil, *args, &block)
 class NilClass
 
   # See Kernel#try.
-  def try(method=nil, *args)
+  def try(method=nil, *args, &block)
     if method
       nil
+    elsif block_given?
+      nil
     else
-      Functor.new{ nil }
+      Tee.new { nil }
     end
   end
 
-end
+  # See Kernel#try!.
+  def try!(method=nil, *args, &block)
+    if method
+      nil
+    elsif block_given?
+      nil
+    else
+      Tee.new { nil }
+    end
+  end
 
+end

lib/core/facets/string/snakecase.rb

@@ -9,11 +9,11 @@ class String
   #   "Snake Case".snakecase        #=> "snake_case"
   #   "Snake  -  Case".snakecase    #=> "snake_case"
   #
-  # Note, this method no longer converts `::` to `/`, in that case
-  # use the {#pathize} method instead.
+  # Note, unlike #underscore this does not convert `::` to `/`.
+  # Use {#pathize} for that, or use {#underscore} for ActiveSupport
+  # compatible behavior.
 
   def snakecase
-    #gsub(/::/, '/').
     gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
     gsub(/([a-z\d])([A-Z])/,'\1_\2').
     tr('-', '_').
@@ -22,10 +22,17 @@ def snakecase
     downcase
   end
 
+  # Like #snakecase but also converts '::' to '/' for
+  # namespace-to-path conversion. This is compatible with
+  # ActiveSupport's #underscore.
   #
-  alias_method :underscore, :snakecase
+  #   "SnakeCase".underscore        #=> "snake_case"
+  #   "Foo::Bar".underscore         #=> "foo/bar"
+  #
+  def underscore
+    gsub(/::/, '/').snakecase
+  end
 
   # TODO: Add *separators to #snakecase, like camelcase.
 
 end
-