Reimplement DatabaseAdapter as a class hierarchy

Same features, less verbose implementation. Introducing new adapter type
should be easier now.

Co-authored-by: Piotr Jurewicz <[email protected]>

Author: fidel

ruby_event_store-active_record/lib/ruby_event_store/active_record/generators/database_adapter.rb

@@ -6,102 +6,57 @@ module ActiveRecord
     InvalidDataTypeForAdapter = Class.new(StandardError)
 
     class DatabaseAdapter
-      BIG_NUM = 169_614_201_293_062_129
-
       NOT_SET = Object.new.freeze
-      private_constant :NOT_SET
 
-      class PostgreSQL
+      class PostgreSQL < self
         SUPPORTED_DATA_TYPES = %w[binary json jsonb].freeze
-        private_constant :SUPPORTED_DATA_TYPES
 
         def initialize(data_type = NOT_SET)
-          if !data_type.eql?(NOT_SET) && !supported_data_types.include?(data_type)
-            raise InvalidDataTypeForAdapter,
-                  "PostgreSQL doesn't support #{data_type.inspect}. Supported types are: #{supported_data_types.join(", ")}."
-          end
-
-          @data_type = data_type
-        end
-
-        attr_reader :data_type
-
-        def supported_data_types
-          SUPPORTED_DATA_TYPES
-        end
-
-        def eql?(other)
-          other.instance_of?(PostgreSQL)
-        end
-
-        alias == eql?
-
-        def hash
-          PostgreSQL.hash ^ BIG_NUM
+          super("postgresql", data_type)
         end
       end
 
-      class MySQL2
+      class MySQL2 < self
         SUPPORTED_DATA_TYPES = %w[binary json].freeze
-        private_constant :SUPPORTED_DATA_TYPES
 
         def initialize(data_type = NOT_SET)
-          if !data_type.eql?(NOT_SET) && !supported_data_types.include?(data_type)
-            raise InvalidDataTypeForAdapter,
-                  "MySQL2 doesn't support #{data_type.inspect}. Supported types are: #{supported_data_types.join(", ")}."
-          end
-
-          @data_type = data_type
-        end
-
-        attr_reader :data_type
-
-        def supported_data_types
-          SUPPORTED_DATA_TYPES
-        end
-
-        def eql?(other)
-          other.instance_of?(MySQL2)
-        end
-
-        alias == eql?
-
-        def hash
-          MySQL2.hash ^ BIG_NUM
+          super("mysql2", data_type)
         end
       end
 
-      class SQLite
+      class SQLite < self
         SUPPORTED_DATA_TYPES = %w[binary].freeze
-        private_constant :SUPPORTED_DATA_TYPES
 
         def initialize(data_type = NOT_SET)
-          if !data_type.eql?(NOT_SET) && !supported_data_types.include?(data_type)
-            raise InvalidDataTypeForAdapter,
-                  "SQLite doesn't support #{data_type.inspect}. Supported types are: #{supported_data_types.join}."
-          end
-
-          @data_type = data_type
+          super("sqlite", data_type)
         end
+      end
 
-        attr_reader :data_type
+      def initialize(adapter_name, data_type)
+        validate_data_type!(data_type)
 
-        def supported_data_types
-          SUPPORTED_DATA_TYPES
-        end
+        @adapter_name = adapter_name
+        @data_type = data_type
+      end
 
-        def eql?(other)
-          other.instance_of?(SQLite)
-        end
+      attr_reader :adapter_name, :data_type
 
-        alias == eql?
+      def supported_data_types
+        self.class::SUPPORTED_DATA_TYPES
+      end
 
-        def hash
-          SQLite.hash ^ BIG_NUM
-        end
+      def eql?(other)
+        other.is_a?(DatabaseAdapter) && adapter_name.eql?(other.adapter_name)
       end
 
-      def self.new(adapter_name, data_type = NOT_SET)
+      alias == eql?
+
+      def hash
+        DatabaseAdapter.hash ^ adapter_name.hash
+      end
+
+      def self.from_string(adapter_name, data_type = NOT_SET)
+        raise NoMethodError unless eql?(DatabaseAdapter)
         case adapter_name.to_s.downcase
         when "postgresql", "postgis"
           PostgreSQL.new(data_type)
@@ -113,6 +68,19 @@ def self.new(adapter_name, data_type = NOT_SET)
           raise UnsupportedAdapter, "Unsupported adapter: #{adapter_name.inspect}"
         end
       end
+
+      private
+
+      def validate_data_type!(data_type)
+        if !data_type.eql?(NOT_SET) && !supported_data_types.include?(data_type)
+          raise InvalidDataTypeForAdapter,
+                "#{class_name} doesn't support #{data_type.inspect}. Supported types are: #{supported_data_types.join(", ")}."
+        end
+      end
+
+      def class_name
+        self.class.name.split("::").last
+      end
     end
   end
 end

ruby_event_store-active_record/lib/ruby_event_store/active_record/generators/foreign_key_on_event_id_migration_generator.rb

@@ -4,7 +4,7 @@ module RubyEventStore
   module ActiveRecord
     class ForeignKeyOnEventIdMigrationGenerator
       def call(database_adapter_name, migration_path)
-        database_adapter = DatabaseAdapter.new(database_adapter_name)
+        database_adapter = DatabaseAdapter.from_string(database_adapter_name)
         each_migration(database_adapter) do |migration_name|
           path = build_path(migration_path, migration_name)
           write_to_file(path, migration_code(database_adapter, migration_name))

ruby_event_store-active_record/lib/ruby_event_store/active_record/generators/rails_foreign_key_on_event_id_migration_generator.rb

@@ -19,7 +19,7 @@ class Error < Thor::Error
         def initialize(*args)
           super
 
-          @database_adapter = DatabaseAdapter.new(adapter_name)
+          @database_adapter = DatabaseAdapter.from_string(adapter_name)
         rescue UnsupportedAdapter => e
           raise Error, e.message
         end

ruby_event_store-active_record/lib/ruby_event_store/active_record/generators/rails_migration_generator.rb

@@ -25,12 +25,12 @@ class Error < Thor::Error
       def initialize(*args)
         super
 
-        @database_adapter = DatabaseAdapter.new(adapter_name, data_type)
+        @database_adapter = DatabaseAdapter.from_string(adapter_name, data_type)
       rescue UnsupportedAdapter => e
         raise Error, e.message
       rescue InvalidDataTypeForAdapter
         raise Error,
-              "Invalid value for --data-type option. Supported for options are: #{DatabaseAdapter.new(adapter_name).supported_data_types.join(", ")}."
+              "Invalid value for --data-type option. Supported for options are: #{DatabaseAdapter.from_string(adapter_name).supported_data_types.join(", ")}."
       end
 
       def create_migration

ruby_event_store-active_record/lib/ruby_event_store/active_record/tasks/migration_tasks.rake

@@ -6,7 +6,7 @@ task "db:migrations:copy" do
     ENV["DATA_TYPE"] || raise("Specify data type (binary, json, jsonb): rake db:migrations:copy DATA_TYPE=json")
   ::ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"])
   database_adapter =
-    RubyEventStore::ActiveRecord::DatabaseAdapter.new(::ActiveRecord::Base.connection.adapter_name, data_type)
+    RubyEventStore::ActiveRecord::DatabaseAdapter.from_string(::ActiveRecord::Base.connection.adapter_name, data_type)
 
   path =
     RubyEventStore::ActiveRecord::MigrationGenerator.new.call(database_adapter, ENV["MIGRATION_PATH"] || "db/migrate")

ruby_event_store-active_record/spec/database_adapter_spec.rb

@@ -5,57 +5,49 @@
 module RubyEventStore
   module ActiveRecord
     ::RSpec.describe DatabaseAdapter do
-      specify "equality" do
-        expect(DatabaseAdapter.new("postgresql")).to eql(DatabaseAdapter::PostgreSQL.new)
-        expect(DatabaseAdapter.new("mysql2")).to eql(DatabaseAdapter::MySQL2.new)
-        expect(DatabaseAdapter.new("sqlite")).to eql(DatabaseAdapter::SQLite.new)
-
-        expect(DatabaseAdapter.new("postgresql")).to eq(DatabaseAdapter::PostgreSQL.new)
-        expect(DatabaseAdapter.new("mysql2")).to eq(DatabaseAdapter::MySQL2.new)
-        expect(DatabaseAdapter.new("sqlite")).to eq(DatabaseAdapter::SQLite.new)
-      end
-
-      specify "does not equal different type" do
-        expect(DatabaseAdapter.new("postgresql")).not_to eql("postgresql")
-        expect(DatabaseAdapter.new("mysql2")).not_to eql("mysql2")
-        expect(DatabaseAdapter.new("sqlite")).not_to eql("sqlite")
-      end
-
-      specify "hash" do
-        expect(DatabaseAdapter::PostgreSQL.new.hash).to eql(DatabaseAdapter::PostgreSQL.hash ^ DatabaseAdapter::BIG_NUM)
-        expect(DatabaseAdapter::MySQL2.new.hash).to eql(DatabaseAdapter::MySQL2.hash ^ DatabaseAdapter::BIG_NUM)
-        expect(DatabaseAdapter::SQLite.new.hash).to eql(DatabaseAdapter::SQLite.hash ^ DatabaseAdapter::BIG_NUM)
-
-        expect(DatabaseAdapter::PostgreSQL.new.hash).to eql(DatabaseAdapter::PostgreSQL.new.hash)
-        expect(DatabaseAdapter::MySQL2.new.hash).to eql(DatabaseAdapter::MySQL2.new.hash)
-        expect(DatabaseAdapter::SQLite.new.hash).to eql(DatabaseAdapter::SQLite.new.hash)
+      specify "from_string" do
+        expect(DatabaseAdapter.from_string("PostgreSQL")).to eql(DatabaseAdapter::PostgreSQL.new)
+        expect(DatabaseAdapter.from_string("PostGIS")).to eql(DatabaseAdapter::PostgreSQL.new)
+        expect(DatabaseAdapter.from_string("MySQL2")).to eql(DatabaseAdapter::MySQL2.new)
+        expect(DatabaseAdapter.from_string("SQLite")).to eql(DatabaseAdapter::SQLite.new)
       end
 
-      specify "different adapters does not compare" do
-        expect(DatabaseAdapter.new("postgresql")).not_to eql(DatabaseAdapter.new("mysql2"))
+      specify "equality" do
+        expect(DatabaseAdapter::PostgreSQL.new).not_to eql(DatabaseAdapter::MySQL2.new)
+        expect(DatabaseAdapter::PostgreSQL.new).not_to eql("postgresql")
       end
 
-      specify "postgis is postgresql flavor" do
-        expect(DatabaseAdapter.new("postgis")).to eq(DatabaseAdapter.new("postgresql"))
+      specify "adapter_name" do
+        expect(DatabaseAdapter::PostgreSQL.new.adapter_name).to eql("postgresql")
+        expect(DatabaseAdapter::MySQL2.new.adapter_name).to eql("mysql2")
+        expect(DatabaseAdapter::SQLite.new.adapter_name).to eql("sqlite")
       end
 
-      specify "raises exception on unsupported adapter" do
-        expect { DatabaseAdapter.new("foo") }.to raise_error(UnsupportedAdapter, "Unsupported adapter: \"foo\"")
+      specify "raise on unknown adapter" do
+        expect { DatabaseAdapter.from_string("kakadudu") }.to raise_error(
+          UnsupportedAdapter,
+          "Unsupported adapter: \"kakadudu\""
+        )
+        expect { DatabaseAdapter.from_string(nil) }.to raise_error(UnsupportedAdapter, "Unsupported adapter: nil")
+        expect { DatabaseAdapter.from_string(123) }.to raise_error(UnsupportedAdapter, "Unsupported adapter: 123")
       end
 
-      specify "case insensitive adapter name" do
-        expect(DatabaseAdapter.new("PostgreSQL")).to eq(DatabaseAdapter.new("postgresql"))
+      specify "unsupported data type passed to #from_string" do
+        expect { DatabaseAdapter.from_string("postgresql", "foo") }.to raise_error(InvalidDataTypeForAdapter)
+        expect { DatabaseAdapter.from_string("mysql2", "foo") }.to raise_error(InvalidDataTypeForAdapter)
+        expect { DatabaseAdapter.from_string("sqlite", "foo") }.to raise_error(InvalidDataTypeForAdapter)
       end
 
-      specify "junk adapter name" do
-        expect { DatabaseAdapter.new(nil) }.to raise_error(UnsupportedAdapter, "Unsupported adapter: nil")
-        expect { DatabaseAdapter.new(123) }.to raise_error(UnsupportedAdapter, "Unsupported adapter: 123")
+      specify "hash" do
+        expect(DatabaseAdapter::PostgreSQL.new.hash).to eql(DatabaseAdapter.hash ^ "postgresql".hash)
+        expect(DatabaseAdapter::MySQL2.new.hash).to eql(DatabaseAdapter.hash ^ "mysql2".hash)
+        expect(DatabaseAdapter::SQLite.new.hash).to eql(DatabaseAdapter.hash ^ "sqlite".hash)
       end
 
-      specify "unsupported data type" do
-        expect { DatabaseAdapter.new("postgresql", "foo") }.to raise_error(InvalidDataTypeForAdapter)
-        expect { DatabaseAdapter.new("mysql2", "foo") }.to raise_error(InvalidDataTypeForAdapter)
-        expect { DatabaseAdapter.new("sqlite", "foo") }.to raise_error(InvalidDataTypeForAdapter)
+      specify "child classes don't implement #from_string" do
+        expect { DatabaseAdapter::PostgreSQL.from_string("postgresql") }.to raise_error(NoMethodError)
+        expect { DatabaseAdapter::MySQL2.from_string("mysql2") }.to raise_error(NoMethodError)
+        expect { DatabaseAdapter::SQLite.from_string("sqlite") }.to raise_error(NoMethodError)
       end
 
       context "data type verification" do
@@ -85,8 +77,8 @@ module ActiveRecord
         end
 
         specify "PostgreSQL doesn't support bla" do
-          expect { DatabaseAdapter::PostgreSQL.new("bla") }.to raise_error InvalidDataTypeForAdapter,
-                      "PostgreSQL doesn't support \"bla\". Supported types are: binary, json, jsonb."
+          expect { DatabaseAdapter::PostgreSQL.new("kakadudu") }.to raise_error InvalidDataTypeForAdapter,
+                      "PostgreSQL doesn't support \"kakadudu\". Supported types are: binary, json, jsonb."
         end
 
         specify "sqlite supports binary" do

ruby_event_store-active_record/spec/migration_generator_spec.rb

@@ -125,7 +125,7 @@ module ActiveRecord
       private
 
       def migration_generator(dir, data_type = "binary", database_adapter = "sqlite")
-        ActiveRecord::MigrationGenerator.new.call(DatabaseAdapter.new(database_adapter, data_type), dir)
+        ActiveRecord::MigrationGenerator.new.call(DatabaseAdapter.from_string(database_adapter, data_type), dir)
       end
 
       def migration_exists?(dir)

ruby_event_store-active_record/spec/template_directory_spec.rb

@@ -6,16 +6,16 @@ module RubyEventStore
   module ActiveRecord
     ::RSpec.describe TemplateDirectory do
       specify "returns template directory for postgresql adapter" do
-        expect(TemplateDirectory.for_adapter(DatabaseAdapter.new("PostgreSQL"))).to eq("postgres/")
-        expect(TemplateDirectory.for_adapter(DatabaseAdapter.new("PostGIS"))).to eq("postgres/")
+        expect(TemplateDirectory.for_adapter(DatabaseAdapter.from_string("PostgreSQL"))).to eq("postgres/")
+        expect(TemplateDirectory.for_adapter(DatabaseAdapter.from_string("PostGIS"))).to eq("postgres/")
       end
 
       specify "returns template directory for mysql2 adapter" do
-        expect(TemplateDirectory.for_adapter(DatabaseAdapter.new("MySQL2"))).to eq("mysql/")
+        expect(TemplateDirectory.for_adapter(DatabaseAdapter.from_string("MySQL2"))).to eq("mysql/")
       end
 
       specify "returns template directory for sqlite adapter" do
-        expect(TemplateDirectory.for_adapter(DatabaseAdapter.new("sqlite"))).to eq(nil)
+        expect(TemplateDirectory.for_adapter(DatabaseAdapter.from_string("sqlite"))).to eq(nil)
       end
     end
   end