rails_dictionary 0.3.pre.rc1 → 0.4.0

data/docs/load-order.md

@@ -0,0 +1,118 @@
+# Load & Seed Order
+
+This document explains how the per-type lookup methods
+(`Dictionary.address_city`, `Dictionary.student_school`, ...) come to exist,
+and why earlier versions broke depending on **when** models were loaded and
+**when** `DictType` rows were written. If you hit a `NoMethodError: undefined
+method 'address_city' for class Dictionary`, this is the page to read.
+
+## Background: how lookups are generated
+
+Up to 0.2.x, `Dictionary.address_city` was resolved lazily at call time through
+`method_missing`. Every call re-checked `DictType.all_types`, so it never
+mattered when the data was seeded — the first call always worked.
+
+From 0.3.0 onward the lookups are **real singleton methods**, generated eagerly
+by `Dictionary.reload_dict_methods`, which walks `DictType.all_types` and calls
+`define_singleton_method` for each category. This is faster and introspectable
+(`Dictionary.respond_to?(:address_city)`), but it means the methods only exist
+once generation has actually run for a given model.
+
+Generation is triggered from three places:
+
+1. **Boot** — the Railtie's `config.to_prepare` calls
+   `RailsDictionary.load_dict_methods` after the app initializes.
+2. **Runtime writes** — `DictType` has `after_save`/`after_destroy
+   :delete_all_caches`, which resets the cached type list and calls
+   `RailsDictionary.reload_dict_methods`.
+3. **Model load** (added in 0.4.0) — when a model runs `acts_as_dictionary`,
+   its `included` hook generates its own lookups from current data.
+
+`RailsDictionary.reload_dict_methods` only regenerates methods on models that
+have **registered themselves**. A model registers (appends to
+`RailsDictionary.dictionary_model_names`) the moment its class body runs
+`acts_as_dictionary`. With `config.eager_load = false` (development, test,
+console, runner) that does not happen until the constant is first referenced.
+
+## The two moving parts
+
+Method generation needs **both** of these to be true at the moment it runs:
+
+- the dictionary model (`Dictionary`) is **loaded/registered**, and
+- the `dict_types` table **exists and contains the rows** you expect.
+
+Every historical bug is some ordering where one of those was not yet true when
+the only generation trigger fired, and nothing fired again afterward.
+
+## Scenarios
+
+Each scenario below has an isolated, single-process reproduction under
+`spec/load_order/` (the shared rspec suite can't exercise boot ordering because
+its tables and models already exist). Run them with `bundle exec rake
+load_order`.
+
+### 1. Pre-seeded boot (normal production) — `preseeded_boot.rb`
+
+`dict_types` is migrated and populated **before** the app boots. Seeding via
+`insert`/SQL skips callbacks, so trigger #2 never fires. The methods must come
+from trigger #1 (boot). Works as long as the model is reachable at
+`to_prepare`, which it is under eager loading in production.
+
+### 2. Empty boot, data arrives later — `empty_boot_recovers.rb`
+
+The app boots while `dict_types` does **not exist yet** (e.g. before the first
+migration, or during `db:create`). Generation at boot must not raise — it is
+guarded by `RailsDictionary.dict_table_ready?`. No methods exist yet. Once the
+table is created and a `DictType` is **created** (not bulk-inserted), trigger #2
+regenerates and the lookup appears.
+
+### 3. Slave/lookup model loaded after seeding — `lazy_slave_model_boot.rb`
+
+This is the bug that motivated 0.4.0, and the one a host app's
+seed/fixture file hits. With lazy loading:
+
+- `DictType` gets referenced and seeded first (`DictType.create!(...)`).
+- At that point `Dictionary` has **never been referenced**, so it is not
+  registered. Trigger #2 fires but finds an empty model registry and defines
+  nothing.
+- The host then references `Dictionary` for the first time. Before 0.4.0 the
+  `included` hook only registered the model; it did **not** generate methods,
+  so `Dictionary.address_city` raised. A *second* call could succeed only if
+  some later reload happened to run after registration (e.g. the dev reloader
+  re-running `to_prepare`), which is why the failure looked intermittent.
+
+0.4.0 fixes this with trigger #3: the model generates its own lookups in its
+`included` hook, so load order between `DictType`, `Dictionary`, and seeding no
+longer matters.
+
+### 4. Reverse load order (`Dictionary` before `DictType`)
+
+If the dictionary model loads before the `DictType` constant is defined, trigger
+#3 is **skipped** (guarded by `Object.const_defined?(:DictType)`) rather than
+raising. Generation then happens at the next boot hook or the next `DictType`
+write. The gem's own `spec/init_models.rb` defines `Dictionary` first and
+relies on this.
+
+## Guarantees after 0.4.0
+
+- Boot with a missing/unmigrated DB never raises (`dict_table_ready?`).
+- A model loaded after its data was seeded gets its lookups immediately on load.
+- A model loaded before `DictType` exists defers cleanly and recovers at the
+  next boot hook or `DictType` write.
+- Runtime `DictType.create!`/`destroy` keeps categories in sync via callbacks.
+
+## If you still see a missing lookup
+
+Force a regeneration and inspect state:
+
+```ruby
+RailsDictionary.dictionary_model_names   # is your model registered?
+RailsDictionary.dict_table_ready?        # can the table be queried?
+DictType.all_types                       # are the categories present?
+RailsDictionary.reload_dict_methods      # regenerate now
+Dictionary.respond_to?(:address_city)    # => true
+```
+
+Bulk seeding (`insert_all`, fixtures, raw SQL) bypasses the `after_save`
+callback. If you seed that way after boot, call
+`RailsDictionary.reload_dict_methods` yourself afterward.

data/lib/rails_dictionary/active_record_extension.rb

@@ -0,0 +1,48 @@
+module RailsDictionary
+  module ActiveRecordExtension
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # TODO: move macro define in each module file
+      # See Usage in readme.doc.
+      def acts_as_dict_type
+
+        has_many :dictionaries
+        validates_uniqueness_of :name
+        after_save :delete_all_caches
+        after_destroy :delete_all_caches
+
+        include RailsDictionary::ActsAsDictType
+      end
+
+      def acts_as_dictionary
+
+        belongs_to :dict_type
+        after_save :delete_dicts_cache
+        after_destroy :delete_dicts_cache
+        scope :dict_type_name_eq, ->(name) { joins(:dict_type).where({ "dict_types.name" => name }) }
+
+        include RailsDictionary::ActsAsDictionary
+      end
+
+      # Ex: acts_as_dict_slave :add => :category
+      # :except - remove dict mapping column
+      # :add - add dict mapping column
+      # :locale - add and initialize class attribute default_dict_locale
+      def acts_as_dict_slave(ops={})
+        include RailsDictionary::ActsAsDictSlave
+        class_attribute :default_dict_locale, :instance_writer => false
+        cattr_accessor :dict_mapping_columns, :instance_writer => false
+        self.default_dict_locale = ops[:locale] if ops[:locale]
+        self.dict_mapping_columns = dict_columns(ops)
+        unless dict_mapping_columns.nil?
+          add_dynamic_column_method
+        end
+      end
+
+      alias_method :acts_as_dict_consumer, :acts_as_dict_slave
+    end
+  end
+end

data/lib/rails_dictionary/acts_as_dict_slave.rb

@@ -0,0 +1,85 @@
+module RailsDictionary
+  module ActsAsDictSlave
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # return columns that exist in DictType#tab_and_column
+      def columns_in_dict_type
+        if ActiveRecord::VERSION::STRING < '3.1'
+          DictType.tab_and_column[self.name.underscore.to_sym]
+        elsif ::DictType.table_exists?
+          DictType.tab_and_column[self.name.underscore.to_sym]
+        else
+          []
+        end
+      end
+
+      # columns which map to dictionary
+      def dict_columns(ops={})
+        conf = { except: nil, add: nil}
+        conf.update(ops)
+        cidt = columns_in_dict_type || []
+        cidt.delete(conf[:except])
+        case conf[:add]
+        when String
+          cidt.push(conf[:add])
+        when Array
+          cidt.push(*conf[:add])
+        else nil
+        end
+        cidt.uniq! || cidt
+      end
+
+      # add a belongs_to(Dictionary) association and a named_{column} method
+      def add_dynamic_column_method
+        dict_mapping_columns.each { |e| belongs_to "#{e}_dict".to_sym, class_name: "Dictionary", foreign_key: e.to_sym }
+        dict_mapping_columns.each { |ele| named_dict_value ele.to_sym }
+        dict_mapping_columns.each { |ele| dict_name_equal ele.to_sym }
+      end
+
+      # Generate dynamic instance method named_column to consumer model
+      # def named_city(locale=nil)
+      #   locale = locale.presence || default_dict_locale.presence || :en
+      #   locale = "name_#{locale}"
+      #   self.send(city_dict).try(:send,locale)
+      # end
+      # alias_method :city_name, :named_city
+      def named_dict_value(method_name)
+        belongs_to_name="#{method_name}_dict".to_sym
+        origin_method_name = method_name
+        method_name="named_#{method_name}"
+        define_method(method_name) do | locale=nil |
+          locale = locale.presence || default_dict_locale.presence || :en
+          locale = "name_#{locale}"
+          self.send(belongs_to_name).try(:send,locale)
+        end
+        alias_method "#{origin_method_name}_name".to_sym, method_name.to_sym
+      end
+
+      # Build dynamic method column_name= to the consumer model
+      #
+      # def city_name=(value, options = {})
+      #
+      #
+      # end
+      def dict_name_equal(colname)
+        method_name = "#{colname}_name="
+        belongs_to_name="#{colname}_dict".to_sym
+        define_method(method_name) do |value, options={}|
+          options.merge!(name_en: value)
+          dict_type_id = DictType.revert("#{self.class.table_name.singularize}_#{colname}")
+          options.merge!(dict_type_id: dict_type_id)
+          exist_dictionary = Dictionary.where(options)
+          if exist_dictionary.present?
+            exist_id = exist_dictionary.first.id
+          else
+            exist_id = send("create_#{belongs_to_name}!", options).id
+          end
+          send "#{colname}=", exist_id
+        end
+      end
+
+    end # END class_methods
+
+  end
+end

data/lib/rails_dictionary/acts_as_dict_type.rb

@@ -0,0 +1,53 @@
+module RailsDictionary
+  module ActsAsDictType
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.mattr_accessor :whole_types
+    end
+
+    module ClassMethods
+
+      def all_types
+        whole_types.presence ||
+          self.whole_types = all.map(&:name).map(&:to_sym)
+      end
+
+      # short method to transfer id to name or name to id
+      # TODO: cache it
+      def revert(arg)
+        if arg.is_a?(String)
+          DictType.where(name: arg).first.try(:id)
+        elsif arg.is_a?(Integer)
+          DictType.where(id: arg).first.try(:name)
+        end
+      end
+
+      #
+      # Parse the name value to get which column and model(or table) are listed in DictType
+      #
+      # Programmer DOC:
+      #   There are two chooses to get subclass,one is subclasses the other is descendants,
+      #   I don't know which is better,but descendants contains subclass of subclass,it contains more.
+      #
+      #   Class like +Ckeditor::Asset+ transfer to "ckeditor/asset",but we can not naming method like that,
+      #   So it still not support, the solution may be simple,just make another convention to escape "/"
+      #
+      #   Seems this method did not need to be cached in production.
+      #   Because everyclass was cached before application was run.So after application was run, it never be run again.
+      # TODO:
+      #   To cache this method output need more skills on how to caculate ActiveRecord::Base.descendants
+      #   Temply remove the cache
+      #   And add test for this situation
+      def tab_and_column
+        all_model_class=ActiveRecord::Base.descendants.map(&:name).map(&:underscore)
+        RailsDictionary.extract_to_hash(all_types.map(&:to_s), all_model_class)
+      end
+    end
+
+    def delete_all_caches
+      self.whole_types = nil
+      RailsDictionary.reload_dict_methods
+      return true
+    end
+  end
+end

data/lib/rails_dictionary/acts_as_dictionary.rb

@@ -0,0 +1,118 @@
+require "active_support/concern"
+
+module RailsDictionary
+  module ActsAsDictionary
+    extend ActiveSupport::Concern
+
+    included do
+      RailsDictionary.register_dictionary_model(self)
+      # A model loaded after the Railtie's boot-time hook (the common case
+      # under lazy autoloading) would otherwise have no lookup methods until
+      # the next DictType write or reload. Generate them now from current data
+      # so load order between this model and DictType never matters. Skipped
+      # when DictType isn't defined yet (reverse load order) -- the boot hook
+      # or the next DictType write will generate them then.
+      reload_dict_methods if Object.const_defined?(:DictType) && RailsDictionary.dict_table_ready?
+    end
+
+    class_methods do
+
+      # Define one singleton method per dict type, replacing the old
+      # method_missing dispatch. Called at boot (Railtie) and whenever a
+      # DictType row is written, so runtime-added categories stay available.
+      #
+      #   Dictionary.student_city               # => [<Dictionary>, ...]
+      #   Dictionary.student_city(locale: :zh)  # => [["北京", 2], ...] for select
+      def reload_dict_methods
+        ::DictType.all_types.each { |name| define_dict_method(name) }
+      end
+
+      # List all distinct categories. Useful for admin UIs.
+      def categories
+        ::DictType.all_types
+      end
+
+      # Add an entry to a category. Returns the created record.
+      #   Dictionary.add(:city, "New York")
+      def add(category, name, attrs = {})
+        dict_type_id = ::DictType.revert(category.to_s)
+        create!(attrs.merge(name_en: name, dict_type_id: dict_type_id))
+      end
+
+      # Remove every entry in a category matching the given name.
+      #   Dictionary.remove(:city, "New York")
+      def remove(category, name)
+        dict_type_id = ::DictType.revert(category.to_s)
+        where(name_en: name, dict_type_id: dict_type_id).destroy_all
+      end
+
+      # Form-ready output for options_for_select: [[label, id], ...].
+      #   Dictionary.options_for(:city, locale: :en)
+      def options_for(category, locale: :en)
+        public_send(category.to_s.downcase)
+          .map { |d| [d.send("name_#{locale}"), d.id] }
+          .reject { |pair| pair.first.nil? }
+      end
+
+      # Override this method to get customed sort block
+      def sort_dicts(options)
+        if options.keys.include? :locale or options.keys.include? "locale"
+          locale="name_#{ options[:locale] }"
+          if options[:locale].to_sym == :zh
+            Proc.new { |a,b| a.send(locale).encode('GBK') <=> b.send(locale).encode('GBK') }
+          else
+            Proc.new { |a,b| a.send(locale).downcase <=> b.send(locale).downcase }
+          end
+        else
+          false
+        end
+      end
+
+      def dict_cache_key(name)
+        "Dictionary.#{connection_db_config.database}.#{name}"
+      end
+
+      private
+
+      def define_dict_method(method_id)
+        method_name = method_id.to_s.downcase
+        build_scope_method(method_id)
+        define_singleton_method(method_name) do |options = {}|
+          key = dict_cache_key(method_name)
+          Rails.cache.delete(key) if options[:query]
+          Rails.cache.fetch(key) { dict_type_name_eq(method_name).to_a }
+          listed_attr = Rails.cache.read(key).dup
+          if options.keys.include? :locale or options.keys.include? "locale"
+            RailsDictionary.deprecator.warn(
+              "Passing :locale to Dictionary.#{method_name} is deprecated; " \
+              "use Dictionary.options_for(:#{method_name}, locale: ...) instead."
+            )
+            locale = "name_#{ options[:locale] }"
+            sort_block = sort_dicts(options)
+            listed_attr.sort!(&sort_block) if sort_block
+            listed_attr.map! { |a| [a.send(locale), a.id] }.reject! { |ele| ele.first.nil? }
+          end
+          listed_attr
+        end
+      end
+
+      def build_scope_method(name)
+        scope_method_name = "scoped_#{name}".to_sym
+        unless respond_to? scope_method_name
+          define_singleton_method scope_method_name do
+            # see http://stackoverflow.com/questions/18198963/with-rails-4-model-scoped-is-deprecated-but-model-all-cant-replace-it
+            # for usage of where(nil)
+            dict_type_name_eq(name).where(nil)
+          end
+        end
+      end
+
+    end # End class_method
+
+    def delete_dicts_cache
+      method_name = ::DictType.revert(self.dict_type_id)
+      Rails.cache.delete(self.class.dict_cache_key(method_name))
+      return true
+    end
+  end
+end

data/lib/rails_dictionary/array_core_ext.rb

@@ -0,0 +1,10 @@
+class Array
+  # Deprecated: the Array monkey-patch will be removed in a future major
+  # release. The real logic now lives in RailsDictionary.extract_to_hash.
+  def extract_to_hash(keys_array)
+    RailsDictionary.deprecator.warn(
+      "Array#extract_to_hash is deprecated; use RailsDictionary.extract_to_hash instead."
+    )
+    RailsDictionary.extract_to_hash(self, keys_array)
+  end
+end

data/lib/rails_dictionary/railtie.rb

@@ -0,0 +1,11 @@
+module RailsDictionary
+  class Railtie < Rails::Railtie
+    # Generate the dynamic lookup methods after the app (and its autoloaded
+    # models) are ready. The actual call is guarded in
+    # RailsDictionary.load_dict_methods so a missing/unmigrated database
+    # during boot, asset builds, or db:create never raises.
+    config.to_prepare do
+      RailsDictionary.load_dict_methods
+    end
+  end
+end

data/lib/rails_dictionary/version.rb

@@ -1,3 +1,3 @@
 module RailsDictionary
-  VERSION = "0.3-rc1"
+  VERSION = "0.4.0"
 end

data/lib/rails_dictionary.rb

@@ -1,33 +1,77 @@
-require File.join(File.dirname(__FILE__), "rails_dictionary/models/active_record_extension")
-require File.join(File.dirname(__FILE__), "rails_dictionary/models/acts_as_dictionary")
-require File.join(File.dirname(__FILE__), "rails_dictionary/models/acts_as_dict_consumer")
-
 # rake tasks not autoload in Rails4
-# todo: may add migration(from 0.2 to 0.3) task
-# Dir[File.expand_path('../tasks/**/*.rake',__FILE__)].each { |ext| load ext } if defined?(Rake)
+Dir[File.expand_path('../tasks/**/*.rake',__FILE__)].each { |ext| load ext } if defined?(Rake)
 
 module RailsDictionary
-
-  def self.config
-    Config.instance
+  # Models that called +acts_as_dictionary+. Stored by name so the registry
+  # survives Zeitwerk reloads in development.
+  def self.dictionary_model_names
+    @dictionary_model_names ||= []
   end
 
-  class Config < Struct.new(:dictionary_klass, :defined_sti_klass)
-    include Singleton
+  def self.register_dictionary_model(klass)
+    return if klass.name.nil?
+    dictionary_model_names << klass.name unless dictionary_model_names.include?(klass.name)
   end
 
-  config.dictionary_klass = :Dictionary
-  config.defined_sti_klass = []
+  # Gem-specific deprecator so warnings can be silenced/raised independently
+  # of the host app. Silenced by default: the removal version is not decided
+  # yet, so we don't nag apps. Re-enable with
+  # `RailsDictionary.deprecator.silenced = false`.
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("a future major release", "rails_dictionary").tap do |deprecator|
+      deprecator.silenced = true
+    end
+  end
 
-  def self.dclass
-    @dclass ||= config.dictionary_klass.to_s.constantize
+  # Internal implementation of the (deprecated) Array#extract_to_hash, kept
+  # here so the gem's own callers don't trip the deprecation warning.
+  def self.extract_to_hash(array, keys_array)
+    ret_hash = {}
+    keys_array.each { |ky| ret_hash[ky.to_sym] = [] }
+    array.each do |sf|
+      keys_array.each do |ky|
+        ret_hash[ky.to_sym] << sf.sub("#{ky}_", "") if sf =~ Regexp.new("^#{ky}_")
+      end
+    end
+    ret_hash.reject { |_k, v| v.blank? }
   end
 
-  def self.init_dict_sti_class(klass)
-    unless config.defined_sti_klass.include?(klass) || Module.const_defined?(klass)
-      subklass = klass.sub "#{config.dictionary_klass}::", ''
-      dclass.const_set subklass, Class.new(dclass)
-      config.defined_sti_klass.push(klass)
+  # Regenerate the per-type lookup methods on every registered dictionary
+  # model. Called whenever a DictType row changes.
+  def self.reload_dict_methods
+    dictionary_model_names.each do |name|
+      klass = name.safe_constantize
+      klass&.reload_dict_methods
     end
   end
+
+  # Boot-time entry point (used by the Railtie). Guarded so a missing or
+  # unmigrated database during boot, asset builds, or db:create never raises.
+  def self.load_dict_methods
+    reload_dict_methods if dict_table_ready?
+  end
+
+  # True only when the dict_types table can actually be queried. Used to guard
+  # method generation so a missing/unmigrated database during boot, asset
+  # builds, or db:create never raises.
+  def self.dict_table_ready?
+    ActiveRecord::Base.connection.table_exists?("dict_types")
+  rescue ActiveRecord::NoDatabaseError,
+         ActiveRecord::StatementInvalid,
+         ActiveRecord::ConnectionNotEstablished
+    false
+  end
 end
+
+require File.join(File.dirname(__FILE__), "rails_dictionary/array_core_ext")
+
+ActiveSupport.on_load :active_record do
+  require File.join(File.dirname(__FILE__), "rails_dictionary/active_record_extension")
+  require File.join(File.dirname(__FILE__), "rails_dictionary/acts_as_dict_type")
+  require File.join(File.dirname(__FILE__), "rails_dictionary/acts_as_dictionary")
+  require File.join(File.dirname(__FILE__), "rails_dictionary/acts_as_dict_slave")
+
+  ::ActiveRecord::Base.send :include, RailsDictionary::ActiveRecordExtension
+end
+
+require File.join(File.dirname(__FILE__), "rails_dictionary/railtie") if defined?(Rails::Railtie)

data/lib/tasks/dicts.rake

@@ -2,22 +2,20 @@
 namespace :dicts do
   desc "Generate dictionary and dict_type model"
   task :generate do
-    system "rails g model dictionary name_en name_zh name_fr type"
+    system "rails g model dictionary name_en:string name_zh:string name_fr:string dict_type_id:integer"
+    system "rails g model dict_type name:string"
   end
-
   desc "Generate student model"
-  task :sample_consumer do
+  task :sample_slave do
     system "rails g model student email:string city:integer school:integer"
   end
-
   desc "Generate sample data for rails_dictionary gem"
   task :sample_data => [:environment] do
-    # @dt_stu_city=DictType.create! name: "student_city"
-    # @dt_stu_school=DictType.create! name: "student_school"
-    @dy_shanghai=Dictionary.create! name_en: "shanghai", name_zh: "上海", name_fr: "shanghai", dict_type_id: @dt_stu_city.id
-    @dy_beijing=Dictionary.create! name_en: "beijing", name_zh: "北京", name_fr: "Pékin", dict_type_id: @dt_stu_city.id
-    @stu_beijing=Student.create! email: "beijing@dict.com", city: @dy_beijing.id
-    @stu_shanghai=Student.create! email: "shanghai@dict.com", city: @dy_shanghai.id
+    @dt_stu_city=DictType.create! :name => "student_city"
+    @dt_stu_school=DictType.create! :name => "student_school"
+    @dy_shanghai=Dictionary.create! name_en: "shanghai",name_zh: "上海",name_fr: "shanghai",dict_type_id: @dt_stu_city.id
+    @dy_beijing=Dictionary.create! name_en: "beijing",name_zh: "北京",name_fr: "Pékin",dict_type_id: @dt_stu_city.id
+    @stu_beijing=Student.create! email: "beijing@dict.com",city: @dy_beijing.id
+    @stu_shanghai=Student.create! email: "shanghai@dict.com",city: @dy_shanghai.id
   end
-
 end

data/rails_dictionary.gemspec

@@ -7,17 +7,17 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Raykin Lee"]
   s.email       = ["raykincoldxiao@campus.com"]
+  s.licenses    = ['MIT']
   s.homepage    = "https://github.com/raykin/rails_dictionary"
   s.summary     = %q{dictionary data for web application}
   s.description = %q{Rails plugin for mapping static data of web application to Dictionary class}
 
-  s.rubyforge_project = "rails_dictionary"
 
-  s.add_runtime_dependency 'rails', '> 4.0'
-  s.add_runtime_dependency 'database_cleaner'
+  s.add_runtime_dependency 'rails', '>= 7.1', '< 9'
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 3.3.0'
 end

data/spec/fake_app.rb

@@ -0,0 +1,29 @@
+# database
+ActiveRecord::Base.configurations = {'test' => {:adapter => 'sqlite3', :database => ':memory:'}}
+
+if ActiveRecord::VERSION::MAJOR >= 5
+  ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+else
+  ActiveRecord::Base.establish_connection(:test)
+end
+
+# config
+app = Class.new(Rails::Application)
+app.config.active_support.deprecation = :log
+app.config.eager_load = false
+app.initialize!
+
+#migrations
+class CreateAllTables < ActiveRecord::VERSION::MAJOR >= 5 ? ActiveRecord::Migration[5.0] : ActiveRecord::Migration
+  def self.up
+    create_table(:dict_types) {|t| t.string :name}
+    create_table(:dictionaries) {|t| t.string :name_en; t.string :name_zh ; t.string :name_fr ; t.integer :dict_type_id}
+    create_table(:students) {|t| t.string :email; t.integer :city; t.integer :school}
+  end
+
+  def self.down
+    drop_table :dict_types
+    drop_table :dictionaries
+    drop_table :students
+  end
+end

data/spec/init_models.rb

@@ -0,0 +1,12 @@
+class Dictionary < ActiveRecord::Base
+  acts_as_dictionary
+end
+
+class DictType < ActiveRecord::Base
+  acts_as_dict_type
+end
+
+# TODO: Here is a serious code loading issue. Student can't be load before DictType and Dictionary
+class Student < ActiveRecord::Base
+  acts_as_dict_slave
+end