Support defining multiple stores with the same store_attribute

Author: AlphonseSantoro

lib/active_record/typed_store/dsl.rb

@@ -9,36 +9,12 @@ class DSL
     def initialize(store_name, options)
       @coder = options.fetch(:coder) { default_coder(store_name) }
       @store_name = store_name
-      @prefix =
-        case options[:prefix]
-        when String, Symbol
-          "#{options[:prefix]}_"
-        when true
-          "#{store_name}_"
-        when false, nil
-          ""
-        else
-          raise ArgumentError, "Unexpected type for prefix option. Expected string, symbol, or boolean"
-        end
-      @suffix =
-        case options[:suffix]
-        when String, Symbol
-          "_#{options[:suffix]}"
-        when true
-          "_#{store_name}"
-        when false, nil
-          ""
-        else
-          raise ArgumentError, "Unexpected type for suffix option. Expected string, symbol, or boolean"
-        end
-      @accessors = if options[:accessors] == false
-        {}
-      elsif options[:accessors].is_a?(Array)
-        options[:accessors].each_with_object({}) do |accessor_name, hash|
-          hash[accessor_name] = accessor_key_for(accessor_name)
-        end
-      end
       @fields = {}
+    end
+
+    def store_accessors(options)
+      set_affixes(options)
+      @accessors = options[:accessors]
       yield self
     end
 
@@ -53,8 +29,10 @@ def default_coder(attribute_name)
     end
 
     def accessors
-      @accessors || @fields.values.select(&:accessor).each_with_object({}) do |field, hash|
-        hash[field.name] = accessor_key_for(field.name)
+      @fields.values.select(&:accessor).each_with_object({}) do |field, hash|
+        next if @accessors.is_a?(Array) && !@accessors.include?(field.name)
+
+        hash[field.name] = accessor_key_for(field.name) if field.accessor
       end
     end
 
@@ -63,13 +41,39 @@ def accessors
     NO_DEFAULT_GIVEN = Object.new
     [:string, :text, :integer, :float, :time, :datetime, :date, :boolean, :decimal, :any].each do |type|
       define_method(type) do |name, **options|
+        options[:accessor] = false if @accessors == false
         @fields[name] = Field.new(name, type, options)
       end
     end
     alias_method :date_time, :datetime
 
     private
 
+    def set_affixes(options)
+      @prefix =
+        case options[:prefix]
+        when String, Symbol
+          "#{options[:prefix]}_"
+        when true
+          "#{@store_name}_"
+        when false, nil
+          ""
+        else
+          raise ArgumentError, "Unexpected type for prefix option. Expected string, symbol, or boolean"
+        end
+      @suffix =
+        case options[:suffix]
+        when String, Symbol
+          "_#{options[:suffix]}"
+        when true
+          "_#{@store_name}"
+        when false, nil
+          ""
+        else
+          raise ArgumentError, "Unexpected type for suffix option. Expected string, symbol, or boolean"
+        end
+    end
+
     def accessor_key_for(name)
       "#{@prefix}#{name}#{@suffix}"
     end

lib/active_record/typed_store/extension.rb

@@ -12,15 +12,34 @@ def typed_store(store_attribute, options={}, &block)
       unless self < Behavior
         include Behavior
         class_attribute :typed_stores, :store_accessors, instance_accessor: false
+
+        def inherited(sub_class)
+          super(sub_class)
+
+          if self.respond_to? :typed_stores
+            # Copy the store to the sub class to avoid mutation of the store in parent class
+            sub_class.typed_stores = self.typed_stores.map do |store_attribute, store|
+              new_store = store.dup
+              new_store.instance_variable_set(:'@fields', store.fields.dup)
+              [store_attribute, new_store]
+            end.to_h
+          end
+        end
       end
 
+      self.typed_stores ||= {}
       store_options = options.slice(:prefix, :suffix)
-      dsl = DSL.new(store_attribute, options, &block)
-      self.typed_stores = (self.typed_stores || {}).merge(store_attribute => dsl)
+      dsl = self.typed_stores[store_attribute] || DSL.new(store_attribute, options)
+      dsl.store_accessors(options, &block)
+      self.typed_stores[store_attribute] = dsl
       self.store_accessors = typed_stores.each_value.flat_map { |d| d.accessors.values }.map { |a| -a.to_s }.to_set
 
       typed_klass = TypedHash.create(dsl.fields.values)
-      const_set("#{store_attribute}_hash".camelize, typed_klass)
+      const_name = "#{store_attribute}_hash".camelize
+      if const_defined?(const_name) && const_get(const_name).to_s == "#{self}/#{store_attribute}_hash".camelize
+        remove_const(const_name)
+      end
+      const_set(const_name, typed_klass)
 
       if ActiveRecord.version >= Gem::Version.new('6.1.0.alpha')
         attribute(store_attribute) do |subtype|

spec/active_record/typed_store_spec.rb

@@ -500,6 +500,41 @@
 
 end
 
+shared_examples 'an inherited model' do
+  let(:model) { described_class.new }
+
+  it 'can be serialized' do
+    model.update(new_attribute: "foobar")
+    expect(model.reload.new_attribute).to be == "foobar"
+  end
+
+  it 'is casted' do
+    model.update(new_attribute: 42)
+    expect(model.settings[:new_attribute]).to be == '42'
+  end
+
+  it 'parent classes are not modified' do
+    sub_klass = Class.new(model.class) { typed_store(:settings) { |t| t.boolean :another_new_attribute } }
+    expect(sub_klass.store_accessors).to include 'another_new_attribute'
+    expect(sub_klass.store_accessors).to include 'new_attribute'
+    expect(model.class.store_accessors).not_to include 'another_new_attribute'
+    expect(model.class.store_accessors).to include 'new_attribute'
+    expect(model.class.superclass.store_accessors).not_to include 'another_new_attribute'
+    expect(model.class.superclass.store_accessors).not_to include 'new_attribute'
+  end
+
+  it 'can redefine fields' do
+    expect(model.age).to eq 18
+  end
+
+  it 'merges the previous store' do
+    settings = model.class.typed_stores[:settings]
+    expect(model).to respond_to :new_attribute
+    expect(settings.keys).to include :new_attribute
+    expect(settings.fields[:age].default).to eq 18
+  end
+end
+
 shared_examples 'a store' do |retain_type = true, settings_type = :text|
   let(:model) { described_class.new }
 
@@ -944,15 +979,8 @@
 describe InheritedTypedStoreModel do
   let(:model) { described_class.new }
 
-  it 'can be serialized' do
-    model.update(new_attribute: "foobar")
-    expect(model.reload.new_attribute).to be == "foobar"
-  end
-
-  it 'is casted' do
-    model.update(new_attribute: 42)
-    expect(model.settings[:new_attribute]).to be == '42'
-  end
+  it_should_behave_like 'an inherited model'
+  it_should_behave_like 'a model supporting arrays'
 end
 
 describe DirtyTrackingModel do

spec/support/models.rb

@@ -145,6 +145,7 @@ class InheritedTypedStoreModel < YamlTypedStoreModel
 
   typed_store :settings do |t|
     t.string :new_attribute
+    t.integer :age, default: 18, null: false
   end
 end