Add Enum DSL Compiler

Author: coreyja

lib/boba.rb

@@ -4,4 +4,5 @@
 module Boba
   require "boba/version"
   require "boba/relations_railtie" if defined?(Rails)
+  require "boba/enums_railtie" if defined?(Rails)
 end

lib/boba/enums_railtie.rb

@@ -0,0 +1,85 @@
+# typed: true
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Boba
+  class EnumsRailtie < Rails::Railtie
+    railtie_name(:boba)
+
+    initializer("boba.add_enum_classes") do
+      ActiveSupport.on_load(:active_record) do
+        module ActiveRecordTypedEnum
+          extend T::Sig
+          extend T::Helpers
+
+          module ClassMethods
+            extend T::Sig
+
+            sig { params(definitions: T::Hash[T.untyped, T.untyped]).returns(T.untyped) }
+            def enum(definitions)
+              # Call the original Rails enum method first
+              result = super
+
+              # Add typed enum methods for each enum
+              definitions.each_key do |name|
+                enum_class_name = name.to_s.camelize
+
+                # Create a simple T::Enum subclass first
+                enum_class = Class.new(T::Enum) { extend T::Sig }
+
+                T.unsafe(self).const_set(enum_class_name, enum_class)
+
+                # Now that the enum is defined in Rails, we can access the values
+                enum_values = T.unsafe(self).defined_enums[name.to_s]
+
+                if enum_values
+                  # Create a local variable to capture the values for the block
+                  values_to_define = enum_values.keys
+
+                  # Populate the enum values inside the enums block
+                  enum_class.class_eval do
+                    enums { values_to_define.each { |key| const_set(key.to_s.camelize, new(key.to_s)) } }
+                  end
+                end
+
+                # Define typed getter method
+                T
+                  .unsafe(self)
+                  .define_method("typed_#{name}") do
+                    value = T.unsafe(self).send(name)
+                    return if value.nil?
+
+                    # Use the model class directly instead of const_get
+                    enum_klass = T.unsafe(self).class.const_get(enum_class_name)
+                    T.unsafe(enum_klass).try_deserialize(value)
+                  end
+
+                # Define typed setter method
+                T
+                  .unsafe(self)
+                  .define_method("typed_#{name}=") do |typed_value|
+                    if typed_value.nil?
+                      T.unsafe(self).send("#{name}=", nil)
+                    else
+                      T.unsafe(self).send("#{name}=", T.unsafe(typed_value).serialize)
+                    end
+                  end
+              end
+
+              result
+            end
+          end
+
+          mixes_in_class_methods(ClassMethods)
+        end
+
+        module ::ActiveRecord
+          class Base
+            include ActiveRecordTypedEnum
+          end
+        end
+      end
+    end
+  end
+end

lib/tapioca/dsl/compilers/active_record_typed_enum.rb

@@ -0,0 +1,69 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module Dsl
+    module Compilers
+      class ActiveRecordTypedEnum < Tapioca::Dsl::Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            ActiveRecord::Base.descendants.select do |klass|
+              klass.respond_to?(:defined_enums) && klass.defined_enums.any? && klass.table_exists?
+            end
+          end
+        end
+
+        sig { override.void }
+        def decorate
+          return unless constant.respond_to?(:defined_enums)
+
+          constant.defined_enums.each do |enum_name, enum_values|
+            # Create the enum class
+            enum_class_name = enum_name.camelize
+
+            root.create_path(constant) do |model|
+              # Create the T::Enum using RBI::TEnum
+              enum_class =
+                RBI::TEnum.new(enum_class_name) do |tenum|
+                  # Try to create a TEnumBlock for the enums do block
+                  enum_block =
+                    RBI::TEnumBlock.new do |block|
+                      enum_values.each_key do |key|
+                        # Add each enum value
+                        block.create_constant(key.to_s.camelize, value: "new")
+                      end
+                    end
+
+                  tenum << enum_block
+                end
+
+              model << enum_class
+
+              column = constant.columns_hash[enum_name]
+              nullability = column.null
+              base_enum_type = "#{constant}::#{enum_class_name}"
+              enum_type = nullability ? "T.nilable(#{base_enum_type})" : base_enum_type
+
+              # Generate typed getter
+              model.create_method("typed_#{enum_name}", return_type: enum_type)
+
+              # Generate typed setter
+              model.create_method(
+                "typed_#{enum_name}=",
+                parameters: [create_param("value", type: enum_type)],
+                return_type: "void",
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end