store_attribute 0.9.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5de07480a22b55413fe34512b0d36a6572da92390c998dcc1ad7838866667e5c
-  data.tar.gz: 78d3d38f95d1f614f6d9233f0a0bfa52b67a65853f741fedbb8ff510e38e6988
+  metadata.gz: f7594a9e113dc4e6f0872b45d64904354d8e88020111046c443416d3b9b90192
+  data.tar.gz: 5dd045f4f13862a9df72ecb20746a03fcea120308f500faa6e773c6bd47c2996
 SHA512:
-  metadata.gz: 3831baa1c5de7d7dee01dfe5ee0be5a1478b95a2e110c37e1c9ebd405c1246e300cc4eadbbf0b3e83742c8ea258db7399ddd0dc3df10c8797e7b911428bbd3e9
-  data.tar.gz: 774eb359b1ba5e02022f7e931089990f0d169116cbd8f9c725bc7f8bfa8189dce9c649ca3b7b3face0eccbca13b73dbb2a1028ab6f282dfe797b65adffab627c
+  metadata.gz: 59d6d8f7dffbfe818e728012ccb3a1394f6a3c83a6b0a9b6b753576c28941a1a32d3fb00abc91cc8a32d8e8329d33e50358e0fe3aaa4157b3d573c7637265fd2
+  data.tar.gz: 559c01f0dc9dc5c193c46c55af999aaab586ba1d924546cf9eb226f7e88777147c5c3eea2650cef976870200bd43ce5fe019ddb08459de5abc5ebfd37f48e23a

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## master
 
+## 1.0.0 (2022-03-17)
+
+- **Ruby 2.6+ and Rails 6+** is required.
+
+- Refactored internal implementation to use Rails Store implementation as much as possible. ([@palkan][])
+
+Use existing Attributes API and Store API instead of duplicating and monkey-patching. Dirty-tracking, accessors and prefixes/suffixes are now handled by Rails. We only provide type coercions for stores.
+
+## 0.9.3 (2021-11-17)
+
+- Fix keeping empty store hashes in the changes. ([@markedmondson][])
+
+See [PR#22](https://github.com/palkan/store_attribute/pull/22).
+
+## 0.9.2 (2021-10-13)
+
+- Fix bug with store mutation during changes calculation. ([@palkan][])
+
 ## 0.9.1
 
 - Fix bug with dirty nullable stores. ([@palkan][])

data/README.md

@@ -6,15 +6,16 @@
 
 ActiveRecord extension which adds typecasting to store accessors.
 
-Compatible with Rails 4.2 and Rails 5+.
-
-Extracted from not merged PR to Rails: [rails/rails#18942](https://github.com/rails/rails/pull/18942).
+Originally extracted from not merged PR to Rails: [rails/rails#18942](https://github.com/rails/rails/pull/18942).
 
 ### Install
 
 In your Gemfile:
 
 ```ruby
+# for Rails 6+ (7 is supported)
+gem "store_attribute", "~> 1.0"
+
 # for Rails 5+ (6 is supported)
 gem "store_attribute", "~> 0.8.0"
 
@@ -31,6 +32,7 @@ store_attribute(store_name, name, type, options)
 ```
 
 Where:
+
 - `store_name` The name of the store.
 - `name` The name of the accessor to the store.
 - `type` A symbol such as `:string` or `:integer`, or a type object to be used for the accessor.
@@ -98,3 +100,48 @@ class User < ActiveRecord::Base
   store :settings, accessors: [:color, :homepage, login_at: :datetime], coder: JSON
 end
 ```
+
+### Using defaults
+
+With `store_attribute`, you can provide default values for the store attribute. This functionality follows Rails behaviour for `attribute ..., default: ...` (and is backed by Attribute API).
+
+You must remember two things when using defaults:
+
+- A default value is only populated if no value for the **store** attribute was set, i.e., only when creating a new record.
+- Default values persist as soon as you save the record.
+
+The examples below demonstrate these caveats:
+
+```ruby
+# Database schema
+create_table("users") do |t|
+  t.string :name
+  t.jsonb :extra
+end
+
+class RawUser < ActiveRecord::Base
+  self.table_name = "users"
+end
+
+class User < ActiveRecord::Base
+  attribute :name, :string, default: "Joe"
+  store_attribute :extra, :expired_at, :date, default: -> { 2.days.from_now }
+end
+
+Date.current #=> 2022-03-17
+
+user = User.new
+user.name #=> "john"
+user.expired_at #=> 2022-03-19
+user.save!
+
+raw_user = RawUser.find(user.id)
+user.name #=> "john"
+user.expired_at #=> 2022-03-19
+
+another_raw_user = RawUser.create!
+another_user = User.find(another_raw_user.id)
+
+user.name #=> nil
+user.expired_at #=> nil
+```

data/lib/store_attribute/active_record/mutation_tracker.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module StoreAttribute
+  # Upgrade mutation tracker to return partial changes for typed stores
+  module MutationTracker
+    def change_to_attribute(attr_name)
+      return super unless attributes[attr_name].type.is_a?(ActiveRecord::Type::TypedStore)
+
+      orig_changes = super
+
+      return unless orig_changes
+
+      prev_store, new_store = orig_changes.map(&:dup)
+
+      prev_store&.each do |key, value|
+        if new_store[key] == value
+          prev_store.except!(key)
+          new_store&.except!(key)
+        end
+      end
+
+      [prev_store, new_store]
+    end
+  end
+end
+
+require "active_model/attribute_mutation_tracker"
+ActiveModel::AttributeMutationTracker.prepend(StoreAttribute::MutationTracker)

data/lib/store_attribute/active_record/store.rb

@@ -2,11 +2,14 @@
 
 require "active_record/store"
 require "store_attribute/active_record/type/typed_store"
+require "store_attribute/active_record/mutation_tracker"
 
 module ActiveRecord
   module Store
     module ClassMethods # :nodoc:
-      alias_method :_orig_store, :store
+      alias_method :_orig_store_without_types, :store
+      alias_method :_orig_store_accessor_without_types, :store_accessor
+
       # Defines store on this model.
       #
       # +store_name+ The name of the store.
@@ -32,7 +35,7 @@ module ActiveRecord
             {}
           end
 
-        _orig_store(store_name, options)
+        _orig_store_without_types(store_name, options)
         store_accessor(store_name, *accessors, **typed_accessors) if accessors
       end
 
@@ -57,13 +60,7 @@ module ActiveRecord
         keys = keys.flatten
         typed_keys = typed_keys.except(keys)
 
-        accessor_prefix, accessor_suffix = _normalize_prefix_suffix(store_name, prefix, suffix)
-
-        _define_accessors_methods(store_name, *keys, prefix: accessor_prefix, suffix: accessor_suffix)
-
-        _prepare_local_stored_attributes(store_name, *keys)
-
-        _define_dirty_tracking_methods(store_name, keys + typed_keys.keys, prefix: accessor_prefix, suffix: accessor_suffix)
+        _orig_store_accessor_without_types(store_name, *(keys - typed_keys.keys), prefix: nil, suffix: nil)
 
         typed_keys.each do |key, type|
           store_attribute(store_name, key, type, prefix: prefix, suffix: suffix)
@@ -121,149 +118,77 @@ module ActiveRecord
       #
       # For more examples on using types, see documentation for ActiveRecord::Attributes.
       def store_attribute(store_name, name, type, prefix: nil, suffix: nil, **options)
-        prefix, suffix = _normalize_prefix_suffix(store_name, prefix, suffix)
-
-        _define_accessors_methods(store_name, name, prefix: prefix, suffix: suffix)
-
+        _orig_store_accessor_without_types(store_name, name.to_s, prefix: prefix, suffix: suffix)
         _define_predicate_method(name, prefix: prefix, suffix: suffix) if type == :boolean
 
-        # Rails >6.0
-        if !respond_to?(:decorate_attribute_type) || method(:decorate_attribute_type).parameters.count { |type, _| type == :req } == 1
-          attr_name = store_name.to_s
-          was_type = attributes_to_define_after_schema_loads[attr_name]&.first
-          attribute(attr_name) do |subtype|
-            if defined?(_lookup_cast_type)
-              Type::TypedStore.create_from_type(_lookup_cast_type(attr_name, was_type, {}), name, type, **options)
-            else
-              Type::TypedStore.create_from_type(subtype, name, type, **options)
-            end
-          end
-        else
-          decorate_attribute_type(store_name, "typed_accessor_for_#{name}") do |subtype|
-            Type::TypedStore.create_from_type(subtype, name, type, **options)
-          end
-        end
-
-        _prepare_local_stored_attributes(store_name, name)
-
-        _define_dirty_tracking_methods(store_name, [name], prefix: prefix, suffix: suffix)
+        _define_store_attribute(store_name) if !_local_typed_stored_attributes? || _local_typed_stored_attributes[store_name].empty?
+        _store_local_stored_attribute(store_name, name, type, **options)
       end
 
-      def _prepare_local_stored_attributes(store_name, *keys) # :nodoc:
-        # assign new store attribute and create new hash to ensure that each class in the hierarchy
-        # has its own hash of stored attributes.
-        self.local_stored_attributes ||= {}
-        self.local_stored_attributes[store_name] ||= []
-        self.local_stored_attributes[store_name] |= keys
+      def _store_local_stored_attribute(store_name, key, cast_type, default: Type::TypedStore::UNDEFINED, **options) # :nodoc:
+        cast_type = ActiveRecord::Type.lookup(cast_type, **options) if cast_type.is_a?(Symbol)
+        _local_typed_stored_attributes[store_name][key] = [cast_type, default]
       end
 
-      def _define_accessors_methods(store_name, *keys, prefix: nil, suffix: nil) # :nodoc:
-        _store_accessors_module.module_eval do
-          keys.each do |key|
-            accessor_key = "#{prefix}#{key}#{suffix}"
-
-            define_method("#{accessor_key}=") do |value|
-              write_store_attribute(store_name, key, value)
-            end
-
-            define_method(accessor_key) do
-              read_store_attribute(store_name, key)
-            end
-          end
-        end
+      def _local_typed_stored_attributes?
+        instance_variable_defined?(:@local_typed_stored_attributes)
       end
 
-      def _define_predicate_method(name, prefix: nil, suffix: nil)
-        _store_accessors_module.module_eval do
-          name = "#{prefix}#{name}#{suffix}"
+      def _local_typed_stored_attributes
+        return @local_typed_stored_attributes if _local_typed_stored_attributes?
 
-          define_method("#{name}?") do
-            send(name) == true
+        @local_typed_stored_attributes =
+          if superclass.respond_to?(:_local_typed_stored_attributes)
+            superclass._local_typed_stored_attributes.dup.tap do |h|
+              h.transform_values!(&:dup)
+            end
+          else
+            Hash.new { |h, k| h[k] = {}.with_indifferent_access }.with_indifferent_access
           end
-        end
       end
 
-      def _define_dirty_tracking_methods(store_attribute, keys, prefix: nil, suffix: nil)
-        _store_accessors_module.module_eval do
-          define_method("changes") do
-            return @changes if defined?(@changes)
-            changes = super()
-            self.class.local_stored_attributes.each do |accessor, attributes|
-              next unless attribute_changed?(accessor)
-
-              prev_store, new_store = changes[accessor]
-
-              prev_store&.each do |key, value|
-                if new_store[key] == value
-                  prev_store.except!(key)
-                  new_store&.except!(key)
-                end
-              end
-            end
-            @changes = changes
-          end
+      def _define_store_attribute(store_name)
+        attr_name = store_name.to_s
+        was_type = attributes_to_define_after_schema_loads[attr_name]&.first
 
-          keys.flatten.each do |key|
-            key = key.to_s
-            accessor_key = "#{prefix}#{key}#{suffix}"
+        # For Rails <6.1
+        use_decorator = respond_to?(:decorate_attribute_type) && method(:decorate_attribute_type).parameters.count { |type, _| type == :req } == 2
 
-            define_method("#{accessor_key}_changed?") do
-              return false unless attribute_changed?(store_attribute)
-              prev_store, new_store = changes[store_attribute]
-              prev_store&.dig(key) != new_store&.dig(key)
-            end
+        defaultik = Type::TypedStore::Defaultik.new
 
-            define_method("#{accessor_key}_change") do
-              return unless attribute_changed?(store_attribute)
-              prev_store, new_store = changes[store_attribute]
-              [prev_store&.dig(key), new_store&.dig(key)]
-            end
+        if use_decorator
+          decorate_attribute_type(attr_name, "typed_accessor_for_#{attr_name}") do |subtype|
+            subtypes = _local_typed_stored_attributes[attr_name]
+            type = Type::TypedStore.create_from_type(subtype)
+            defaultik.type = type
+            subtypes.each { |name, (cast_type, default)| type.add_typed_key(name, cast_type, default: default) }
 
-            define_method("#{accessor_key}_was") do
-              return unless attribute_changed?(store_attribute)
-              prev_store, _new_store = changes[store_attribute]
-              prev_store&.dig(key)
-            end
+            define_default_attribute(attr_name, defaultik.proc, type, from_user: true)
 
-            define_method("saved_change_to_#{accessor_key}?") do
-              return false unless saved_change_to_attribute?(store_attribute)
-              prev_store, new_store = saved_change_to_attribute(store_attribute)
-              prev_store&.dig(key) != new_store&.dig(key)
-            end
+            type
+          end
+        else
+          attribute(attr_name, default: defaultik.proc) do |subtype|
+            subtypes = _local_typed_stored_attributes[attr_name]
+            subtype = _lookup_cast_type(attr_name, was_type, {}) if defined?(_lookup_cast_type)
 
-            define_method("saved_change_to_#{accessor_key}") do
-              return unless saved_change_to_attribute?(store_attribute)
-              prev_store, new_store = saved_change_to_attribute(store_attribute)
-              [prev_store&.dig(key), new_store&.dig(key)]
-            end
+            type = Type::TypedStore.create_from_type(subtype)
+            defaultik.type = type
+            subtypes.each { |name, (cast_type, default)| type.add_typed_key(name, cast_type, default: default) }
 
-            define_method("#{accessor_key}_before_last_save") do
-              return unless saved_change_to_attribute?(store_attribute)
-              prev_store, _new_store = saved_change_to_attribute(store_attribute)
-              prev_store&.dig(key)
-            end
+            type
           end
         end
       end
 
-      def _normalize_prefix_suffix(store_name, prefix, suffix)
-        prefix =
-          case prefix
-          when String, Symbol
-            "#{prefix}_"
-          when TrueClass
-            "#{store_name}_"
-          end
+      def _define_predicate_method(name, prefix: nil, suffix: nil)
+        _store_accessors_module.module_eval do
+          name = "#{prefix}#{name}#{suffix}"
 
-        suffix =
-          case suffix
-          when String, Symbol
-            "_#{suffix}"
-          when TrueClass
-            "_#{store_name}"
+          define_method("#{name}?") do
+            send(name) == true
           end
-
-        [prefix, suffix]
+        end
       end
     end
   end

data/lib/store_attribute/active_record/type/typed_store.rb

@@ -5,12 +5,24 @@ require "active_record/type"
 module ActiveRecord
   module Type # :nodoc:
     class TypedStore < DelegateClass(ActiveRecord::Type::Value) # :nodoc:
+      class Defaultik
+        attr_accessor :type
+
+        def proc
+          @proc ||= Kernel.proc do
+            raise ArgumentError, "Has no type attached" unless type
+
+            type.build_defaults
+          end
+        end
+      end
+
       # Creates +TypedStore+ type instance and specifies type caster
       # for key.
-      def self.create_from_type(basetype, key, type, **options)
-        typed_store = new(basetype)
-        typed_store.add_typed_key(key, type, **options)
-        typed_store
+      def self.create_from_type(basetype, **options)
+        return basetype.dup if basetype.is_a?(self)
+
+        new(basetype)
       end
 
       def initialize(subtype)
@@ -21,7 +33,6 @@ module ActiveRecord
       end
 
       UNDEFINED = Object.new
-      private_constant :UNDEFINED
 
       def add_typed_key(key, type, default: UNDEFINED, **options)
         type = ActiveRecord::Type.lookup(type, **options) if type.is_a?(Symbol)
@@ -36,15 +47,13 @@ module ActiveRecord
         accessor_types.each do |key, type|
           if hash.key?(key)
             hash[key] = type.deserialize(hash[key])
-          elsif defaults.key?(key)
-            hash[key] = get_default(key)
           end
         end
         hash
       end
 
       def changed_in_place?(raw_old_value, new_value)
-        raw_old_value != serialize(new_value)
+        deserialize(raw_old_value) != new_value
       end
 
       def serialize(value)
@@ -55,8 +64,6 @@ module ActiveRecord
           next unless key
           if value.key?(key)
             typed_casted[key] = type.serialize(value[key])
-          elsif defaults.key?(str_key)
-            typed_casted[key] = type.serialize(get_default(str_key))
           end
         end
         super(value.merge(typed_casted))
@@ -68,8 +75,6 @@ module ActiveRecord
         accessor_types.each do |key, type|
           if hash.key?(key)
             hash[key] = type.cast(hash[key])
-          elsif defaults.key?(key)
-            hash[key] = get_default(key)
           end
         end
         hash
@@ -86,6 +91,19 @@ module ActiveRecord
 
       delegate :read, :prepare, to: :store_accessor
 
+      def build_defaults
+        defaults.transform_values do |val|
+          val.is_a?(Proc) ? val.call : val
+        end.with_indifferent_access
+      end
+
+      def dup
+        self.class.new(__getobj__).tap do |dtype|
+          dtype.accessor_types.merge!(accessor_types)
+          dtype.defaults.merge!(defaults)
+        end
+      end
+
       protected
 
       # We cannot rely on string keys 'cause user input can contain symbol keys
@@ -103,11 +121,6 @@ module ActiveRecord
         accessor_types.fetch(key.to_s)
       end
 
-      def get_default(key)
-        value = defaults.fetch(key)
-        value.is_a?(Proc) ? value.call : value
-      end
-
       attr_reader :accessor_types, :defaults, :store_accessor
     end
   end

data/lib/store_attribute/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StoreAttribute # :nodoc:
-  VERSION = "0.9.1"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: store_attribute
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 1.0.0
 platform: ruby
 authors:
 - palkan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-27 00:00:00.000000000 Z
+date: 2022-03-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -78,6 +78,7 @@ files:
 - README.md
 - lib/store_attribute.rb
 - lib/store_attribute/active_record.rb
+- lib/store_attribute/active_record/mutation_tracker.rb
 - lib/store_attribute/active_record/store.rb
 - lib/store_attribute/active_record/type/typed_store.rb
 - lib/store_attribute/version.rb
@@ -98,7 +99,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="