activerecord-materialized 0.1.1 → 0.2.0

data/lib/activerecord/materialized/view_incremental_class_methods.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -6,48 +5,76 @@ module ActiveRecord
     # Incremental-maintenance DSL mixed into a {View}: `refresh_mode`, `incremental_keys`,
     # `incremental_from`, and the per-write maintenance entry points.
     module ViewIncrementalClassMethods
-      extend T::Sig
-      extend T::Helpers
+      # The maintenance modes a view may declare (validated fail-fast by refresh_mode).
+      REFRESH_MODES = %i[incremental full].freeze
 
-      sig { params(base: T.class_of(View)).void }
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       # The incremental-maintenance DSL methods available on a {View} subclass.
       module ClassMethods
-        extend T::Sig
-
-        sig { returns(T.class_of(View)) }
         def view_class
-          T.cast(self, T.class_of(View))
+          self
         end
 
-        sig { params(mode: RefreshMode).void }
+        # Sets whether maintenance is incremental (default) or a full recompute on every change.
+        #
+        # @param mode [Symbol] +:incremental+ (default) or +:full+
+        # @return [void]
         def refresh_mode(mode)
-          T.unsafe(self).instance_variable_set(:@refresh_mode, mode.to_sym)
+          mode = mode.to_sym
+          unless REFRESH_MODES.include?(mode)
+            raise ArgumentError, "unknown refresh mode #{mode.inspect}; expected one of #{REFRESH_MODES.inspect}"
+          end
+
+          instance_variable_set(:@refresh_mode, mode)
         end
 
-        sig { params(block: T.proc.returns(::ActiveRecord::Relation)).void }
+        # Overrides the source relation used for incremental maintenance (defaults to +materialized_from+).
+        #
+        # @yieldreturn [ActiveRecord::Relation] the relation to maintain incrementally
+        # @return [void]
         def incremental_from(&block)
-          @incremental_source_definition = T.let(block, T.nilable(SourceDefinition))
+          @incremental_source_definition = block
         end
 
-        sig { params(columns: T.any(Symbol, String)).void }
+        # Declares the explicit GROUP BY key columns used to scope incremental maintenance.
+        #
+        # @param columns [Array<Symbol>] the key columns identifying a partition
+        # @return [void]
         def incremental_keys(*columns)
-          @incremental_key_columns = T.let(columns.map(&:to_s), T.nilable(T::Array[String]))
+          @incremental_key_columns = columns.map(&:to_s)
+        end
+
+        # Maps a write on `table` to the partition key(s) it affects — for a view
+        # whose GROUP BY key lives on a joined/parent table, so the written row's own
+        # payload can't supply it. The block receives the {WriteChange} and returns
+        # the key value(s): a scalar (or array of scalars) for a single-column key, a
+        # tuple (or array of tuples) for a composite key; returning nothing falls back
+        # to a full recompute. Trades a small lookup per write for avoiding one.
+        #
+        # @param table [Symbol, String] the dependency table the resolver applies to
+        # @yieldparam change [WriteChange] the committed write on +table+
+        # @yieldreturn [Object, Array, nil] the affected partition key(s), or +nil+ to force a full recompute
+        # @return [void]
+        def partition_key_for(table, &block)
+          partition_key_resolvers[table.to_s] = block
+        end
+
+        def partition_key_resolver_for(table_name)
+          partition_key_resolvers[table_name]
+        end
+
+        def partition_key_resolvers
+          @partition_key_resolvers ||= {}
         end
 
-        sig { returns(RefreshMode) }
         def resolved_refresh_mode
-          mode = T.let(
-            T.unsafe(self).instance_variable_get(:@refresh_mode),
-            T.nilable(RefreshMode)
-          )
+          mode = instance_variable_get(:@refresh_mode)
           mode || :incremental
         end
 
-        sig { returns(ViewDefinition) }
         def view_definition
           ViewDefinition.new(
             view_class.resolved_source,
@@ -55,73 +82,45 @@ module ActiveRecord
           )
         end
 
-        sig { returns(T::Array[String]) }
         def maintenance_key_columns
           return incremental_key_columns if incremental_key_columns.any?
 
           view_definition.group_key_columns
         end
 
-        sig { returns(T::Boolean) }
         def incrementally_maintainable?
           resolved_refresh_mode != :full && view_definition.incrementally_maintainable?
         end
 
-        sig { returns(AggregateAnalysis) }
         def aggregate_analysis
           AggregateAnalysis.new(view_class.resolved_source)
         end
 
         # A warm view with all-distributive aggregates uses summary-delta IVM;
-        # otherwise writes drive scoped recompute.
-        sig { returns(T::Boolean) }
+        # otherwise writes drive scoped recompute. Restricted to callback-backed
+        # views: their in-app writes arrive exactly once, so applying signed deltas
+        # is safe. Externally fed views recompute their partitions instead, so
+        # at-least-once or duplicate delivery converges rather than double-counting.
         def delta_maintaining?
-          resolved_refresh_mode != :full && view_class.materialized? && aggregate_analysis.delta_maintainable?
+          resolved_refresh_mode != :full &&
+            view_class.resolved_change_source == ChangeSource::CALLBACKS &&
+            view_class.materialized? &&
+            aggregate_analysis.delta_maintainable?
         end
 
-        sig { returns(T::Boolean) }
         def incremental_source_override?
           !@incremental_source_definition.nil?
         end
 
-        sig { params(change: WriteChange).void }
         def record_write_change!(change)
-          return record_summary_delta!(change) if delta_maintaining?
-          return unless incrementally_maintainable?
-
-          delta = MaintenanceDeltaBuilder.new(change, maintenance_key_columns).build
-          record_write_delta!(delta)
-
-          # On a cold view the written partitions are no longer current; drop them
-          # from the fresh set until re-maintained.
-          return if view_class.materialized? || delta.full_partition?
-
-          PartitionState.new(view_class).mark_stale!(delta.key_tuples)
-        end
-
-        sig { params(change: WriteChange).void }
-        def record_summary_delta!(change)
-          summary = SummaryDeltaBuilder.new(change, aggregate_analysis, maintenance_key_columns).build
-          MaintenanceStore.new(view_class).merge!(summary) unless summary.empty?
+          WriteMaintenance.new(view_class).record!(change)
         end
 
-        sig { params(delta: MaintenanceDelta).void }
-        def record_write_delta!(delta)
-          return unless incrementally_maintainable?
-
-          MaintenanceStore.new(view_class).merge!(delta)
-        end
-
-        sig { returns(T::Array[String]) }
         def incremental_key_columns
-          columns = T.let(
-            T.unsafe(self).instance_variable_get(:@incremental_key_columns),
-            T.nilable(T::Array[String])
-          )
+          columns = instance_variable_get(:@incremental_key_columns)
           columns.nil? ? [] : columns
         end
 
-        sig { returns(::ActiveRecord::Relation) }
         def resolved_incremental_source
           unless incremental_source_override?
             Kernel.raise ArgumentError,
@@ -135,8 +134,6 @@ module ActiveRecord
           )
         end
       end
-
-      mixes_in_class_methods ClassMethods
     end
   end
 end

data/lib/activerecord/materialized/view_loader.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # Eager-loads the view classes under {Configuration#view_load_paths} so their +depends_on+ commit
+    # callbacks are installed even under Zeitwerk's lazy loading (development/test). Invoked by the
+    # Railtie on boot and on each code reload (via +config.to_prepare+); idempotent.
+    #
+    # Without this, a view whose constant nothing has referenced yet is dormant — its +after_*_commit+
+    # hooks are never installed — so writes to its dependencies silently don't schedule maintenance
+    # until something first touches the class. In production (+config.eager_load = true+) every view
+    # already loads at boot, so this is a no-op there.
+    #
+    # @api private
+    class ViewLoader
+      class << self
+        # Load the configured view directories through Zeitwerk. A no-op outside Rails or when
+        # {Configuration#view_load_paths} is empty.
+        #
+        # @return [void]
+        def load!
+          return unless rails_application?
+
+          autoloader = ::Rails.autoloaders.main
+          ActiveRecord::Materialized.configuration.view_load_paths.each do |path|
+            absolute = ::Rails.root.join(path).to_s
+            eager_load_dir(autoloader, absolute) if File.directory?(absolute)
+          end
+        end
+
+        private
+
+        def rails_application?
+          defined?(::Rails) && ::Rails.respond_to?(:application) && ::Rails.application
+        end
+
+        # Eager-load one directory through Zeitwerk so the view constants under it load and install
+        # their callbacks. +eager_load_dir+ is Rails' own mechanism — idempotent and reload-safe — but
+        # it raises for a directory this autoloader does not manage (an engine path, a non-autoloaded
+        # location), which is not ours to load, so that is ignored.
+        def eager_load_dir(autoloader, absolute)
+          autoloader.eager_load_dir(absolute)
+        rescue ::Zeitwerk::Error
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/materialized/view_query_access_class_methods.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -9,79 +8,107 @@ module ActiveRecord
     # Read and refresh API mixed into a {View}: `rebuild!`, `refresh!`, `refresh_if_stale!`,
     # `materialized?`, `stale?`, `dirty?`, and the routed query methods.
     module ViewQueryAccessClassMethods
-      extend T::Sig
-      extend T::Helpers
-
-      sig { params(base: T.class_of(View)).void }
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       # The read and refresh methods available on a {View} subclass.
       module ClassMethods
-        extend T::Sig
-
-        sig { returns(T.class_of(View)) }
         def view_class
-          T.cast(self, T.class_of(View))
+          self
         end
 
-        sig { returns(T::Boolean) }
+        # Whether the view needs refreshing — dirty, never refreshed, or past its +max_staleness+.
+        #
+        # @return [Boolean]
         def stale?
           view_class.metadata.stale?
         end
 
-        sig { returns(T::Boolean) }
+        # Whether dependency writes have marked the view dirty since its last refresh.
+        #
+        # @return [Boolean]
         def dirty?
           view_class.metadata.dirty?
         end
 
-        sig { returns(T::Boolean) }
+        # Whether the view has been fully materialized; cold views are served read-through.
+        #
+        # @return [Boolean]
         def warm?
           view_class.metadata.warm?
         end
 
         # Reads are served from the cache only once warmed and the table exists;
         # otherwise they fall through to the cold-read path.
-        sig { returns(T::Boolean) }
+        #
+        # @return [Boolean]
         def materialized?
           view_class.table_exists? && view_class.metadata.warm?
         end
 
-        sig { returns(T.nilable(Timestamp)) }
+        # When the view was last refreshed, or +nil+ if it never has been.
+        #
+        # @return [Time, nil]
         def last_refreshed_at
           view_class.metadata.last_refreshed_at
         end
 
-        sig { returns(T::Boolean) }
+        # The oldest applied CDC source watermark across the view's partitions — its most-behind
+        # partition — or +nil+ if no watermarked change has been ingested (see {SourceWatermark}).
+        # Subtract from your source clock (same unit as the +source_ts+ you pass {Materialized.ingest_change})
+        # to get the view's freshness/lag.
+        #
+        # @return [Integer, nil]
+        def source_watermark
+          SourceWatermark.new(view_class).oldest
+        end
+
+        # Whether a refresh is currently in progress for the view.
+        #
+        # @return [Boolean]
         def refreshing?
           view_class.metadata.refreshing?
         end
 
-        sig { void }
         def mark_dependencies_changed!
           view_class.metadata.mark_dirty!
         end
 
-        sig { returns(T::Boolean) }
         def table_exists?
           view_class.connection.data_source_exists?(view_class.table_name)
         end
 
         # Incremental maintenance only — never scans all base data.
-        sig { returns(RefreshResult) }
+        #
+        # @return [RefreshResult]
         def refresh!
           Refresher.new(view_class).refresh!
         end
 
-        sig { returns(T.nilable(RefreshResult)) }
+        # Refreshes the view only when it is materialized and stale; otherwise a no-op.
+        #
+        # @return [RefreshResult, nil] the refresh result, or +nil+ when no refresh was needed
         def refresh_if_stale!
           refresh! if materialized? && stale?
         end
 
+        # Verify this view's contents against its source and repair any drift with
+        # scoped maintenance (never a full rebuild). See {Reconciler}.
+        #
+        # @param mode [Symbol] drift-check depth: +:row_count+, +:checksum+, or +:full+
+        # @param sample [Numeric, nil] verify a random subset (Integer count / Float fraction)
+        # @return [ReconcileResult]
+        def reconcile!(mode: :checksum, sample: nil)
+          Reconciler.new(view_class, mode: mode, sample: sample).reconcile!
+        end
+
         # The only path that scans all base data; `confirm:` guards against
         # firing a full materialization by accident.
-        sig { params(confirm: T::Boolean).returns(RefreshResult) }
+        #
+        # @param confirm [Boolean] must be +true+ to run the full materialization
+        # @raise [ArgumentError] unless +confirm+ is true
+        # @return [RefreshResult]
         def rebuild!(confirm: false)
           unless confirm
             Kernel.raise ArgumentError,
@@ -91,70 +118,86 @@ module ActiveRecord
           Refresher.new(view_class).rebuild!
         end
 
-        sig { params(args: T.untyped).returns(T.untyped) }
         def all(*args)
-          read_scope.all(*args)
+          read_router.scope.all(*args)
         end
 
-        sig { params(args: T.untyped).returns(T.untyped) }
         def where(*args)
-          partition_scope(args).where(*args)
+          read_router.partition_scope(args).where(*args)
         end
 
-        sig { params(args: T.untyped).returns(T.untyped) }
         def find(*args)
-          read_scope.find(*args)
+          read_router.scope.find(*args)
         end
 
-        sig { params(args: T.untyped).returns(T.untyped) }
         def find_by(*args)
-          partition_scope(args).find_by(*args)
+          read_router.partition_scope(args).find_by(*args)
         end
 
-        sig { params(args: T.untyped).returns(T.untyped) }
         def count(*args)
-          read_scope.count(*args)
+          read_router.scope.count(*args)
         end
 
-        private
-
-        sig { returns(T.untyped) }
-        def read_scope
-          materialized? ? cache_scope : cold_scope
+        # Order-dependent finders (+first+, +last+, +second+, …) fall back to an implicit
+        # +ORDER BY <primary key>+ when the relation carries no order. A cold view reads through to
+        # the source as a derived table with no +id+ column, so that implicit order references a
+        # column that does not exist and the query blows up. Order by the GROUP BY key(s) instead —
+        # they exist on both the cold derived table and the warm cache — and the trailing +nil+ tells
+        # ActiveRecord's +_order_columns+ to use only these columns and NOT append the primary key.
+        # A non-grouped view has no such key, so it keeps the default primary-key behavior.
+        #
+        # The keys are unqualified (a dotted GROUP BY like +"items.category"+ maps to the projected
+        # +category+ on the cache/derived table), matching how {ViewDefinition} and {CacheTableSchema}
+        # resolve them — a qualified name would reference a column neither table has, on warm and cold.
+        #
+        # @return [Array, Object] the group-by key columns (plus a trailing nil), or the default
+        def implicit_order_column
+          keys = maintenance_key_columns.map { |key| key.rpartition(".").last }
+          keys.any? ? [*keys, nil] : super
         end
 
-        # Per-partition fast path for keyed reads: serve fresh partitions from the
-        # cache, otherwise read through and enqueue maintenance (populate-on-read).
-        sig { params(args: T::Array[T.untyped]).returns(T.untyped) }
-        def partition_scope(args)
-          return cache_scope if materialized?
+        # +ids+ and batch iteration (+find_each+/+find_in_batches+/+in_batches+) are defined in terms
+        # of the primary key: +ids+ plucks it, and batching cursors on it and requires the cursor to be
+        # a unique column. A cold view's read-through derived table has no +id+ (and no index to make a
+        # group-key cursor unique), so none of these can be served correctly — a warm, materialized
+        # cache table is required. Refuse with a clear, actionable error rather than emitting the
+        # cryptic "no such column: id" the underlying query would raise.
+        def ids(*args)
+          require_materialized!(:ids)
+          super
+        end
 
-          keys = PartitionState.keys_from(view_class, args)
-          return cold_scope if keys.nil?
-          return cache_scope if PartitionState.new(view_class).all_fresh?(keys)
+        def find_each(*args, **opts, &block)
+          require_materialized!(:find_each)
+          super
+        end
 
-          enqueue_partition_maintenance(keys)
-          cold_scope
+        def find_in_batches(*args, **opts, &block)
+          require_materialized!(:find_in_batches)
+          super
         end
 
-        sig { returns(T.untyped) }
-        def cache_scope
-          T.unsafe(view_class).unscoped
+        def in_batches(*args, **opts, &block)
+          require_materialized!(:in_batches)
+          super
         end
 
-        sig { returns(T.untyped) }
-        def cold_scope
-          ColdRead.new(view_class).scope
+        private
+
+        # These methods need the materialized cache table (a stable primary key / unique cursor);
+        # a cold read-through has none, so refuse with guidance instead of a misleading SQL error.
+        def require_materialized!(method_name)
+          return if materialized?
+
+          Kernel.raise NotMaterializedError,
+                       "#{view_class.name}.#{method_name} requires a materialized view; " \
+                       "run #{view_class.name}.rebuild!(confirm: true) first"
         end
 
-        sig { params(keys: T::Array[T.untyped]).void }
-        def enqueue_partition_maintenance(keys)
-          MaintenanceStore.new(view_class).merge!(MaintenanceDelta.scoped(keys))
-          RefreshScheduler.schedule(view_class)
+        def read_router
+          ReadRouter.new(view_class)
         end
       end
-
-      mixes_in_class_methods ClassMethods
     end
   end
 end

data/lib/activerecord/materialized/view_refresh_policy_class_methods.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -6,73 +5,104 @@ module ActiveRecord
     # Refresh-policy DSL mixed into a {View}: `refresh_on_change`, `refresh_debounce`, `cold_read`,
     # `warm_up`, `max_staleness`, plus `warm_up!`.
     module ViewRefreshPolicyClassMethods
-      extend T::Sig
-      extend T::Helpers
-
-      sig { params(base: T.class_of(View)).void }
       def self.included(base)
         base.extend(ClassMethods)
       end
 
       # The refresh-policy DSL methods available on a {View} subclass.
       module ClassMethods
-        extend T::Sig
-
-        sig { returns(T.class_of(View)) }
         def view_class
-          T.cast(self, T.class_of(View))
+          self
         end
 
-        sig { params(strategy: Symbol).void }
+        # Sets the strategy used to refresh the view when a dependency changes.
+        #
+        # @param strategy [Symbol] one of +:async+ (default), +:immediate+, or +:manual+
+        # @raise [ArgumentError] if +strategy+ is not a known refresh strategy
+        # @return [void]
         def refresh_on_change(strategy = :async)
-          @refresh_strategy = T.let(strategy.to_sym, T.nilable(Symbol))
+          strategy = strategy.to_sym
+          unless RefreshScheduler::STRATEGIES.include?(strategy)
+            raise ArgumentError,
+                  "unknown refresh strategy #{strategy.inspect}; expected one of #{RefreshScheduler::STRATEGIES.inspect}"
+          end
+
+          @refresh_strategy = strategy
         end
 
-        sig { params(seconds: DebounceInterval).void }
+        # Sets how long successive async refreshes are coalesced before one runs.
+        #
+        # @param seconds [Numeric, ActiveSupport::Duration] the debounce interval
+        # @return [void]
         def refresh_debounce(seconds)
-          @refresh_debounce = T.let(seconds, T.nilable(DebounceInterval))
+          unless seconds.is_a?(Numeric) || seconds.is_a?(::ActiveSupport::Duration)
+            raise ArgumentError, "refresh_debounce expects seconds (a number or Duration), got #{seconds.inspect}"
+          end
+
+          @refresh_debounce = seconds
         end
 
-        sig { params(strategy: Symbol).void }
+        # Sets how reads are served before the view has been materialized.
+        #
+        # @param strategy [Symbol] one of +:read_through+ (default), +:serve_stale+, or +:raise+
+        # @return [void]
         def cold_read(strategy)
-          @cold_read_strategy = T.let(strategy.to_sym, T.nilable(Symbol))
+          @cold_read_strategy = strategy.to_sym
         end
 
-        sig { returns(Symbol) }
         def resolved_cold_read_strategy
-          T.let(@cold_read_strategy, T.nilable(Symbol)) ||
+          @cold_read_strategy ||
             ActiveRecord::Materialized.configuration.default_cold_read_strategy
         end
 
+        # Selects where this view's changes come from: +:callbacks+ (the default
+        # built-in tracker installs commit callbacks on +depends_on+ models) or
+        # +:none+ (install no callbacks; feed changes through the public
+        # ingestion API from an external adapter — e.g. a CDC stream).
+        #
+        # Setting +:callbacks+ (re)installs callbacks for any dependencies already
+        # declared, so it works regardless of whether it precedes or follows
+        # +depends_on+ — important when the global default is +:none+.
+        #
+        # @param source [Symbol] +:callbacks+ or +:none+
+        # @return [void]
+        def change_source(source)
+          @change_source = ChangeSource.cast(source)
+          DependencyRegistry.install_callbacks_for(view_class) if @change_source == ChangeSource::CALLBACKS
+        end
+
+        def resolved_change_source
+          @change_source ||
+            ActiveRecord::Materialized.configuration.default_change_source
+        end
+
         # Queries warm_up! runs to materialize a cold view's hot partitions, e.g.:
         #   warm_up { [where(region: "us"), order(revenue: :desc).limit(50)] }
-        sig { params(block: T.proc.returns(T.untyped)).void }
+        #
+        # @yieldreturn [Array<ActiveRecord::Relation>] the relations whose partitions to warm
+        # @return [void]
         def warm_up(&block)
-          @warm_up_definition = T.let(block, T.nilable(Proc))
+          @warm_up_definition = block
         end
 
-        sig { returns(T::Array[::ActiveRecord::Relation]) }
         def resolved_warm_up_queries
-          block = T.let(@warm_up_definition, T.nilable(Proc))
+          block = @warm_up_definition
           return [] if block.nil?
 
-          Kernel.Array(T.unsafe(view_class).instance_eval(&block))
+          Kernel.Array(view_class.instance_eval(&block))
         end
 
         # Running each warm_up query enqueues scoped maintenance for the
         # partitions it touches; refresh! then applies it.
-        sig { returns(T.nilable(RefreshResult)) }
         def warm_up!
           resolved_warm_up_queries.each(&:to_a)
           view_class.refresh!
         end
 
-        sig { returns(Symbol) }
         def resolved_refresh_strategy
           @refresh_strategy || ActiveRecord::Materialized.configuration.default_refresh_strategy
         end
 
-        sig { returns(T.any(Integer, Float)) }
         def resolved_refresh_debounce
           interval = if @refresh_debounce.nil?
                        ActiveRecord::Materialized.configuration.default_refresh_debounce
@@ -82,28 +112,31 @@ module ActiveRecord
           interval.respond_to?(:to_f) ? interval.to_f : interval.to_i
         end
 
-        sig do
-          params(
-            duration: T.nilable(StalenessDuration),
-            block: T.nilable(T.proc.returns(StalenessDuration))
-          ).void
-        end
+        # Sets the maximum staleness window before the view is treated as stale — a static
+        # duration, or a block evaluated in the view's context for a dynamic window.
+        #
+        # @param duration [Integer, ActiveSupport::Duration, nil] a static staleness window (seconds)
+        # @yieldreturn [Integer, ActiveSupport::Duration] a dynamically computed staleness window
+        # @return [void]
         def max_staleness(duration = nil, &block)
-          @max_staleness_setting = T.let(duration || block, T.nilable(T.any(StalenessDuration, Proc)))
+          setting = duration || block
+          unless setting.nil? || [Integer, ::ActiveSupport::Duration, Proc].any? { |type| setting.is_a?(type) }
+            raise ArgumentError,
+                  "max_staleness expects an Integer (seconds), a Duration, or a block, got #{duration.inspect}"
+          end
+
+          @max_staleness_setting = setting
         end
 
-        sig { returns(T.nilable(StalenessDuration)) }
         def resolved_max_staleness
           setting = @max_staleness_setting
           default = ActiveRecord::Materialized.configuration.default_max_staleness
-          return T.cast(default, T.nilable(StalenessDuration)) if setting.nil?
-          return T.unsafe(view_class).instance_eval(&setting) if setting.is_a?(Proc)
+          return default if setting.nil?
+          return view_class.instance_eval(&setting) if setting.is_a?(Proc)
 
           setting
         end
       end
-
-      mixes_in_class_methods ClassMethods
     end
   end
 end