remove the ability to pass a class name for a sqlite extension

Author: flavorjones

lib/sqlite3/database.rb

@@ -73,20 +73,6 @@ module SQLite3
   # Note that the constructor will implicitly call #enable_load_extension if the +extensions:+
   # keyword argument is present.
   #
-  # Finally, it's also possible to load an extension by passing the _name_ of a constant that
-  # implements the +_ExtensionSpecifier+ interface:
-  #
-  #   db = SQLite3::Database.new(":memory:", extensions: ["SQLean::Crypto"])
-  #
-  # Handling the name of a constant like this is what enables injection of an extension in a Rails
-  # application's `config/database.yml` file, like this:
-  #
-  #   development:
-  #     adapter: sqlite3
-  #     database: storage/development.sqlite3
-  #     extensions:
-  #       - SQLean::Crypto
-  #
   class Database
     attr_reader :collations
 
@@ -183,7 +169,7 @@ def initialize file, options = {}, zvfs = nil
       @readonly = mode & Constants::Open::READONLY != 0
       @default_transaction_mode = options[:default_transaction_mode] || :deferred
 
-      marshal_extensions(options[:extensions])
+      initialize_extensions(options[:extensions])
 
       ForkSafety.track(self)
 
@@ -738,26 +724,14 @@ def load_extension(extension_specifier)
       load_extension_internal(extension_specifier)
     end
 
-    def marshal_extensions(extensions) # :nodoc:
+    def initialize_extensions(extensions) # :nodoc:
       return if extensions.nil?
       raise TypeError, "extensions must be an Array" unless extensions.is_a?(Array)
       return if extensions.empty?
 
       enable_load_extension(true)
 
       extensions.each do |extension|
-        # marshall the extension into an object if it's the name of a constant that responds to
-        # `#to_path`
-        if extension.is_a?(String)
-          begin
-            extension_spec = Object.const_get(extension)
-            if extension_spec.respond_to?(:to_path)
-              extension = extension_spec
-            end
-          rescue NameError
-          end
-        end
-
         load_extension(extension)
       end
     end

test/test_database.rb

@@ -671,8 +671,8 @@ def test_load_extension_error_with_nonexistent_path
       skip("extensions are not enabled") unless db.respond_to?(:load_extension)
       db.enable_load_extension(true)
 
-      assert_raises(SQLite3::Exception) { db.load_extension("/path/to/extension") }
-      assert_raises(SQLite3::Exception) { db.load_extension(Pathname.new("foo")) }
+      assert_raises(SQLite3::Exception) { db.load_extension("/nonexistent/path") }
+      assert_raises(SQLite3::Exception) { db.load_extension(Pathname.new("nonexistent")) }
     end
 
     def test_load_extension_error_with_invalid_argument
@@ -697,81 +697,76 @@ def test_load_extension_with_an_extension_descriptor
       assert_equal(["/path/to/extension"], db.load_extension_internal_path)
     end
 
-    def test_marshal_extensions_with_extensions_calls_enable_load_extension
+    def test_initialize_extensions_with_extensions_calls_enable_load_extension
       mock_database_load_extension_internal(db)
       class << db
-        attr_reader :enable_load_extension_called
+        attr_accessor :enable_load_extension_called
 
         def enable_load_extension(...)
           @enable_load_extension_called = true
         end
       end
 
-      db.marshal_extensions(nil)
+      db.initialize_extensions(nil)
       refute(db.enable_load_extension_called)
 
-      db.marshal_extensions([])
+      db.initialize_extensions([])
       refute(db.enable_load_extension_called)
 
-      db.marshal_extensions([FakeExtensionSpecifier])
+      db.initialize_extensions(["/path/to/extension"])
       assert(db.enable_load_extension_called)
-    end
 
-    def test_marshal_extensions_object_is_an_extension_specifier
-      mock_database_load_extension_internal(db)
+      db.enable_load_extension_called = false # reset
 
-      db.marshal_extensions([Pathname.new("/path/to/extension")])
-      assert_equal(["/path/to/extension"], db.load_extension_internal_path)
+      db.initialize_extensions([FakeExtensionSpecifier])
+      assert(db.enable_load_extension_called)
+    end
 
-      db.load_extension_internal_path.clear # reset
+    def test_initialize_extensions_object_is_an_extension_specifier
+      mock_database_load_extension_internal(db)
 
-      db.marshal_extensions([FakeExtensionSpecifier])
+      db.initialize_extensions([Pathname.new("/path/to/extension")])
       assert_equal(["/path/to/extension"], db.load_extension_internal_path)
 
       db.load_extension_internal_path.clear # reset
 
-      db.marshal_extensions(["SQLite3::FakeExtensionSpecifier"])
+      db.initialize_extensions([FakeExtensionSpecifier])
       assert_equal(["/path/to/extension"], db.load_extension_internal_path)
-
-      db.load_extension_internal_path.clear # reset
-
-      db.marshal_extensions(["CannotBeResolved"])
-      assert_equal(["CannotBeResolved"], db.load_extension_internal_path)
     end
 
-    def test_marshal_extensions_object_not_an_extension_specifier
+    def test_initialize_extensions_object_not_an_extension_specifier
       mock_database_load_extension_internal(db)
 
-      db.marshal_extensions(["CannotBeResolved"])
-      assert_equal(["CannotBeResolved"], db.load_extension_internal_path)
+      db.initialize_extensions(["/path/to/extension"])
+      assert_equal(["/path/to/extension"], db.load_extension_internal_path)
 
-      assert_raises(TypeError) { db.marshal_extensions([Class.new]) }
+      assert_raises(TypeError) { db.initialize_extensions([Class.new]) }
 
-      assert_raises(TypeError) { db.marshal_extensions(FakeExtensionSpecifier) }
+      assert_raises(TypeError) { db.initialize_extensions(FakeExtensionSpecifier) }
     end
 
-    def test_initialize_with_extensions_calls_marshal_extensions
-      # ephemeral class to capture arguments passed to marshal_extensions
+    def test_initialize_with_extensions_calls_initialize_extensions
+      # ephemeral class to capture arguments passed to initialize_extensions
       klass = Class.new(SQLite3::Database) do
-        attr :marshal_extensions_called, :marshal_extensions_arg
+        attr :initialize_extensions_called, :initialize_extensions_arg
 
-        def marshal_extensions(extensions)
-          @marshal_extensions_called = true
-          @marshal_extensions_arg = extensions
+        def initialize_extensions(extensions)
+          @initialize_extensions_called = true
+          @initialize_extensions_arg = extensions
         end
       end
 
       db = klass.new(":memory:")
-      assert(db.marshal_extensions_called)
-      assert_nil(db.marshal_extensions_arg)
+      assert(db.initialize_extensions_called)
+      assert_nil(db.initialize_extensions_arg)
 
       db = klass.new(":memory:", extensions: [])
-      assert(db.marshal_extensions_called)
-      assert_empty(db.marshal_extensions_arg)
+      assert(db.initialize_extensions_called)
+      assert_empty(db.initialize_extensions_arg)
 
-      db = klass.new(":memory:", extensions: ["path/to/ext1", "path/to/ext2", "ClassName"])
-      assert(db.marshal_extensions_called)
-      assert_equal(["path/to/ext1", "path/to/ext2", "ClassName"], db.marshal_extensions_arg)
+      db = klass.new(":memory:", extensions: ["path/to/ext1", "path/to/ext2", FakeExtensionSpecifier])
+      assert(db.initialize_extensions_called)
+      assert_equal(["path/to/ext1", "path/to/ext2", FakeExtensionSpecifier], db.initialize_extensions_arg)
     end
 
     def test_raw_float_infinity