store_attribute 0.9.3 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30037caf4b9958aaeb466c389e8e59221c1f165758b98ea8935aeee305772351
-  data.tar.gz: 85326e5621d54adc901f281c9762a313b21053e4e3189fc49bb1fac025d76451
+  metadata.gz: 076f7b987e61b6d32a5ee894f42d9ac85cf226df332400ff133bc492e4a4c184
+  data.tar.gz: 94fcf6d42c30e98888b8a9a7f7af880c1c2e3d0cabf25fc0e63b84e41d6e0f28
 SHA512:
-  metadata.gz: 2c638242092c8e601e17d9d45c603ca2135fa74cc44fa5b57466d37a1f83c43f870570abd27c44e3d7f6d8f2f335c67c16af5c61b1e89bacc4140e4c3a441749
-  data.tar.gz: 668a9a68039681b1e5e1812d762e95b08129b969d1b740e3bb80b1ad5aec1ac3bb8acd69ccff611da65b9718320f85f0ade4d2e89c2242ed87cb23e8deabb197
+  metadata.gz: 6ddff720796fe0c048712b846cdf1bebe54dfdaea59d93d1fbe59557fc263156e53955fb2ee8aef0cea840b7e50f629f193ae2da8a7580108c7c466781341b1f
+  data.tar.gz: 0e6d69b002d492fd4619b4fd4f24eddabbc5e06332c6a597d6b292f7c0cdcb565b4189f63f5bef9e342e40cf20d585d7508b2fc54cc9c0b4dc1f2763ca3bdf7d

data/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## master
 
+## 1.0.2 (2022-07-29)
+
+- Fix possible conflicts with Active Model objects. ([@palkan][])
+
+- Fix passing suffix/prefix to `store_accessor` without types. ([@palkan][])
+
+## 1.0.1 (2022-05-05)
+
+- Fixed suffix/prefix for predicates. ([@Alan-Marx](https://github.com/Alan-Marx))
+
+## 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][])

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,29 @@
+# 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.is_a?(ActiveModel::AttributeSet)
+      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: prefix, suffix: suffix)
 
         typed_keys.each do |key, type|
           store_attribute(store_name, key, type, prefix: prefix, suffix: suffix)
@@ -121,154 +118,96 @@ 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}"
+      def _local_typed_stored_attributes?
+        instance_variable_defined?(:@local_typed_stored_attributes)
+      end
 
-            define_method("#{accessor_key}=") do |value|
-              write_store_attribute(store_name, key, value)
-            end
+      def _local_typed_stored_attributes
+        return @local_typed_stored_attributes if _local_typed_stored_attributes?
 
-            define_method(accessor_key) do
-              read_store_attribute(store_name, key)
+        @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_predicate_method(name, prefix: nil, suffix: nil)
-        _store_accessors_module.module_eval do
-          name = "#{prefix}#{name}#{suffix}"
+      def _define_store_attribute(store_name)
+        attr_name = store_name.to_s
+        was_type = attributes_to_define_after_schema_loads[attr_name]&.first
 
-          define_method("#{name}?") do
-            send(name) == true
-          end
-        end
-      end
+        # For Rails <6.1
+        use_decorator = respond_to?(:decorate_attribute_type) && method(:decorate_attribute_type).parameters.count { |type, _| type == :req } == 2
 
-      def _define_dirty_tracking_methods(store_attribute, keys, prefix: nil, suffix: nil)
-        _store_accessors_module.module_eval do
-          define_method("changes") do
-            changes = super()
-            self.class.local_stored_attributes.each do |accessor, attributes|
-              next unless attribute_changed?(accessor)
+        defaultik = Type::TypedStore::Defaultik.new
 
-              prev_store, new_store = changes[accessor].map(&:dup)
+        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) }
 
-              prev_store&.each do |key, value|
-                if new_store[key] == value
-                  prev_store.except!(key)
-                  new_store&.except!(key)
-                end
-              end
+            define_default_attribute(attr_name, defaultik.proc, type, from_user: true)
 
-              if prev_store.present? || new_store.present?
-                changes[accessor] = prev_store, new_store
-              else
-                changes.delete(accessor)
-              end
-            end
-            changes
+            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)
 
-          keys.flatten.each do |key|
-            key = key.to_s
-            accessor_key = "#{prefix}#{key}#{suffix}"
-
-            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
-
-            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
-
-            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_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
-
-            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 =
+      def _define_predicate_method(name, prefix: nil, suffix: nil)
+        accessor_prefix =
           case prefix
           when String, Symbol
             "#{prefix}_"
           when TrueClass
-            "#{store_name}_"
+            "#{name}_"
+          else
+            ""
           end
-
-        suffix =
+        accessor_suffix =
           case suffix
           when String, Symbol
             "_#{suffix}"
           when TrueClass
-            "_#{store_name}"
+            "_#{name}"
+          else
+            ""
           end
 
-        [prefix, suffix]
+        _store_accessors_module.module_eval do
+          name = "#{accessor_prefix}#{name}#{accessor_suffix}"
+
+          define_method("#{name}?") do
+            send(name) == true
+          end
+        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.3"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: store_attribute
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 1.0.2
 platform: ruby
 authors:
 - palkan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-17 00:00:00.000000000 Z
+date: 2022-07-30 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,14 +99,14 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: ActiveRecord extension which adds typecasting to store accessors