store_attribute 0.5.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 191063cf9091064962abf3548153b75656a55665
-  data.tar.gz: cbc5f2bfc1b33f186296fd9b6c0cc1b8d08fb1df
+SHA256:
+  metadata.gz: a6d0060f9544a3e9e005c149cc189dd6647c0c83493bbb577bb67893e2b5a5fd
+  data.tar.gz: 0f9105dc411953cf7b3342117538e068c9ea7897220d573126bf0d4c01640726
 SHA512:
-  metadata.gz: ae7b28363deb33a59141481eba79eecebd530c7810e9b29a79e9b2a618ca4e5dd8fa6e0211d5ae3d167fe29bff286a175aac0094a8b353e8ae59f484e1caadeb
-  data.tar.gz: bd3858caaa4d37e67bc586a18e1607a2d5c88f2385d9760fc59c9b15ad8fb403694f7a354248299928644acd4cec19bfbc4771f091fbdfd8c75348c6930b9ac0
+  metadata.gz: 0521c55632478bc52bfcb03eab0fb9709ec2e63cc59c9eafa1dc3795742c88d7f2caf7019bb3eac3f3232006f49e0c9dc0cec4bcf619154b7f1873ccd7915201
+  data.tar.gz: e6644235407bd7481499dbb4bfc3fb9214ec0805ebf85be79914ddf8179f7b2f9837db1f33760c8af50236608820e0dc976fad74b3f9046e70f5996c86ec251c

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Change log
+
+## master
+
+## 0.8.0
+
+- Add Rails 6.1 compatibility. ([@palkan][])
+
+- Add support for `prefix` and `suffix` options. ([@palkan][])
+
+## 0.7.1
+
+- Fixed bug with `store` called without accessors. ([@ioki-klaus][])
+
+  See [#10](https://github.com/palkan/store_attribute/pull/10).
+
+## 0.7.0 (2020-03-23)
+
+- Added dirty tracking methods. ([@glaszig][])
+
+  [PR #8](https://github.com/palkan/store_attribute/pull/8).
+
+## 0.6.0 (2019-07-24)
+
+- Added default values support. ([@dreikanter][], [@SumLare][])
+
+  See [PR #7](https://github.com/palkan/store_attribute/pull/7).
+
+- Start keeping changelog. ([@palkan][])
+
+[@palkan]: https://github.com/palkan
+[@dreikanter]: https://github.com/dreikanter
+[@SumLare]: https://github.com/SumLare
+[@glaszig]: https://github.com/glaszig
+[@ioki-klaus]: https://github.com/ioki-klaus

data/{MIT-LICENSE → LICENSE.txt}

@@ -1,4 +1,4 @@
-Copyright 2016 palkan
+Copyright 2016-2020 palkan
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,24 +1,24 @@
+[![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](https://cultofmartians.com/tasks/store-attribute-defaults.html#task)
 [![Gem Version](https://badge.fury.io/rb/store_attribute.svg)](https://rubygems.org/gems/store_attribute) [![Build Status](https://travis-ci.org/palkan/store_attribute.svg?branch=master)](https://travis-ci.org/palkan/store_attribute)
 
 ## Store Attribute
 
 ActiveRecord extension which adds typecasting to store accessors.
 
-Compatible with Rails 4.2 and Rails 5.
+Compatible with Rails 4.2 and Rails 5+.
 
-<a href="https://evilmartians.com/">
-<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+Extracted from not merged PR to Rails: [rails/rails#18942](https://github.com/rails/rails/pull/18942).
 
 ### Install
 
 In your Gemfile:
 
 ```ruby
-# for Rails 5
-gem "store_attribute", "~>0.5.0"
+# for Rails 5+ (6 is supported)
+gem "store_attribute", "~> 0.5.0"
 
 # for Rails 4.2
-gem "store_attribute", "~>0.4.0" 
+gem "store_attribute", "~> 0.4.0"
 ```
 
 ### Usage
@@ -26,14 +26,14 @@ gem "store_attribute", "~>0.4.0"
 You can use `store_attribute` method to add additional accessors with a type to an existing store on a model.
 
 ```ruby
-  store_attribute(store_name, name, type, options = {})
+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.
-- `options` A hash of cast type options such as `precision`, `limit`, `scale`.
+- `options` (optional) A hash of cast type options such as `precision`, `limit`, `scale`, `default`.
 
 Type casting occurs every time you write data through accessor or update store itself
 and when object is loaded from database.
@@ -47,30 +47,36 @@ class MegaUser < User
   store_attribute :settings, :ratio, :integer, limit: 1
   store_attribute :settings, :login_at, :datetime
   store_attribute :settings, :active, :boolean
+  store_attribute :settings, :color, :string, default: "red"
+  store_attribute :settings, :data, :datetime, default: -> { Time.now }
 end
 
-u = MegaUser.new(active: false, login_at: '2015-01-01 00:01', ratio: "63.4608")
+u = MegaUser.new(active: false, login_at: "2015-01-01 00:01", ratio: "63.4608")
 
 u.login_at.is_a?(DateTime) # => true
-u.login_at = DateTime.new(2015,1,1,11,0,0)
+u.login_at = DateTime.new(2015, 1, 1, 11, 0, 0)
 u.ratio # => 63
 u.active # => false
+# Default value is set
+u.color # => red
+# A dynamic default can also be provided
+u.data # => Current time
 # And we also have a predicate method
 u.active? # => false
 u.reload
 
 # After loading record from db store contains casted data
-u.settings['login_at'] == DateTime.new(2015,1,1,11,0,0) # => true
+u.settings["login_at"] == DateTime.new(2015, 1, 1, 11, 0, 0) # => true
 
 # If you update store explicitly then the value returned
 # by accessor isn't type casted
-u.settings['ration'] = "3.141592653"
+u.settings["ratio"] = "3.141592653"
 u.ratio # => "3.141592653"
 
 # On the other hand, writing through accessor set correct data within store
 u.ratio = "3.141592653"
 u.ratio # => 3
-u.settings['ratio'] # => 3
+u.settings["ratio"] # => 3
 ```
 
 You can also specify type using usual `store_accessor` method:

data/lib/store_attribute.rb

@@ -1,2 +1,4 @@
-require 'store_attribute/version'
-require 'store_attribute/active_record'
+# frozen_string_literal: true
+
+require "store_attribute/version"
+require "store_attribute/active_record"

data/lib/store_attribute/active_record.rb

@@ -1 +1,3 @@
-require 'store_attribute/active_record/store'
+# frozen_string_literal: true
+
+require "store_attribute/active_record/store"

data/lib/store_attribute/active_record/store.rb

@@ -1,5 +1,7 @@
-require 'active_record/store'
-require 'store_attribute/active_record/type/typed_store'
+# frozen_string_literal: true
+
+require "active_record/store"
+require "store_attribute/active_record/type/typed_store"
 
 module ActiveRecord
   module Store
@@ -23,9 +25,17 @@ module ActiveRecord
       #   end
       def store(store_name, options = {})
         accessors = options.delete(:accessors)
+        typed_accessors =
+          if accessors && accessors.last.is_a?(Hash)
+            accessors.pop
+          else
+            {}
+          end
+
         _orig_store(store_name, options)
-        store_accessor(store_name, *accessors) if accessors
+        store_accessor(store_name, *accessors, **typed_accessors) if accessors
       end
+
       # Adds additional accessors to an existing store on this model.
       #
       # +store_name+ The name of the store.
@@ -34,21 +44,29 @@ module ActiveRecord
       #
       # +typed_keys+ The key-to-type hash of the accesors with type to the store.
       #
+      # +prefix+ Accessor method name prefix
+      #
+      # +suffix+ Accessor method name suffix
+      #
       # Examples:
       #
       #   class SuperUser < User
       #     store_accessor :settings, :privileges, login_at: :datetime
       #   end
-      def store_accessor(store_name, *keys, **typed_keys)
+      def store_accessor(store_name, *keys, prefix: nil, suffix: nil, **typed_keys)
         keys = keys.flatten
         typed_keys = typed_keys.except(keys)
 
-        _define_accessors_methods(store_name, *keys)
+        accessor_prefix, accessor_suffix = _normalize_prefix_suffix(store_name, prefix, suffix)
+
+        _define_accessors_methods(store_name, *keys, prefix: accessor_prefix, suffix: accessor_suffix)
+
+        _define_dirty_tracking_methods(store_name, keys + typed_keys.keys, prefix: accessor_prefix, suffix: accessor_suffix)
 
         _prepare_local_stored_attributes(store_name, *keys)
 
         typed_keys.each do |key, type|
-          store_attribute(store_name, key, type)
+          store_attribute(store_name, key, type, prefix: prefix, suffix: suffix)
         end
       end
 
@@ -65,6 +83,10 @@ module ActiveRecord
       # +type+ A symbol such as +:string+ or +:integer+, or a type object
       # to be used for the accessor.
       #
+      # +prefix+ Accessor method name prefix
+      #
+      # +suffix+ Accessor method name suffix
+      #
       # +options+ A hash of cast type options such as +precision+, +limit+, +scale+.
       #
       # Examples:
@@ -72,13 +94,16 @@ module ActiveRecord
       #   class MegaUser < User
       #     store_attribute :settings, :ratio, :integer, limit: 1
       #     store_attribute :settings, :login_at, :datetime
+      #
+      #     store_attribute :extra, :version, :integer, prefix: :meta
       #   end
       #
-      #   u = MegaUser.new(active: false, login_at: '2015-01-01 00:01', ratio: "63.4608")
+      #   u = MegaUser.new(active: false, login_at: '2015-01-01 00:01', ratio: "63.4608", meta_version: "1")
       #
       #   u.login_at.is_a?(DateTime) # => true
       #   u.login_at = DateTime.new(2015,1,1,11,0,0)
       #   u.ratio # => 63
+      #   u.meta_version #=> 1
       #   u.reload
       #
       #   # After loading record from db store contains casted data
@@ -95,13 +120,24 @@ module ActiveRecord
       #   u.settings['ratio'] # => 3
       #
       # For more examples on using types, see documentation for ActiveRecord::Attributes.
-      def store_attribute(store_name, name, type, **options)
-        _define_accessors_methods(store_name, name)
+      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)
 
-        _define_predicate_method(name) if type == :boolean
+        _define_predicate_method(name, prefix: prefix, suffix: suffix) if type == :boolean
 
-        decorate_attribute_type(store_name, "typed_accessor_for_#{name}") do |subtype|
-          Type::TypedStore.create_from_type(subtype, name, type, **options)
+        # Rails >6.0
+        if 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|
+            Type::TypedStore.create_from_type(_lookup_cast_type(attr_name, was_type, {}), name, type, **options)
+          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)
@@ -115,27 +151,96 @@ module ActiveRecord
         self.local_stored_attributes[store_name] |= keys
       end
 
-      def _define_accessors_methods(store_name, *keys) # :nodoc:
+      def _define_accessors_methods(store_name, *keys, prefix: nil, suffix: nil) # :nodoc:
         _store_accessors_module.module_eval do
           keys.each do |key|
-            define_method("#{key}=") do |value|
+            accessor_key = "#{prefix}#{key}#{suffix}"
+
+            define_method("#{accessor_key}=") do |value|
               write_store_attribute(store_name, key, value)
             end
 
-            define_method(key) do
+            define_method(accessor_key) do
               read_store_attribute(store_name, key)
             end
           end
         end
       end
 
-      def _define_predicate_method(name)
+      def _define_predicate_method(name, prefix: nil, suffix: nil)
         _store_accessors_module.module_eval do
+          name = "#{prefix}#{name}#{suffix}"
+
           define_method("#{name}?") do
             send(name) == true
           end
         end
       end
+
+      def _define_dirty_tracking_methods(store_attribute, keys, prefix: nil, suffix: nil)
+        _store_accessors_module.module_eval do
+          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
+
+            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
+          end
+        end
+      end
+
+      def _normalize_prefix_suffix(store_name, prefix, suffix)
+        prefix =
+          case prefix
+          when String, Symbol
+            "#{prefix}_"
+          when TrueClass
+            "#{store_name}_"
+          end
+
+        suffix =
+          case suffix
+          when String, Symbol
+            "_#{suffix}"
+          when TrueClass
+            "_#{store_name}"
+          end
+
+        [prefix, suffix]
+      end
     end
   end
 end

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

@@ -1,4 +1,6 @@
-require 'active_record/type'
+# frozen_string_literal: true
+
+require "active_record/type"
 
 module ActiveRecord
   module Type # :nodoc:
@@ -13,43 +15,57 @@ module ActiveRecord
 
       def initialize(subtype)
         @accessor_types = {}
+        @defaults = {}
         @store_accessor = subtype.accessor
         super(subtype)
       end
 
-      def add_typed_key(key, type, **options)
-        type = ActiveRecord::Type.lookup(type, options) if type.is_a?(Symbol)
-        @accessor_types[key.to_s] = type
+      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)
+        safe_key = key.to_s
+        @accessor_types[safe_key] = type
+        @defaults[safe_key] = default unless default == UNDEFINED
       end
 
       def deserialize(value)
         hash = super
-        if hash
-          accessor_types.each do |key, type|
-            hash[key] = type.deserialize(hash[key]) if hash.key?(key)
+        return hash unless hash
+        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 serialize(value)
-        if value.is_a?(Hash)
-          typed_casted = {}
-          accessor_types.each do |key, type|
-            k = key_to_cast(value, key)
-            typed_casted[k] = type.serialize(value[k]) unless k.nil?
+        return super(value) unless value.is_a?(Hash)
+        typed_casted = {}
+        accessor_types.each do |str_key, type|
+          key = key_to_cast(value, str_key)
+          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
-          super(value.merge(typed_casted))
-        else
-          super(value)
         end
+        super(value.merge(typed_casted))
       end
 
       def cast(value)
         hash = super
-        if hash
-          accessor_types.each do |key, type|
-            hash[key] = type.cast(hash[key]) if hash.key?(key)
+        return hash unless hash
+        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
@@ -72,6 +88,7 @@ module ActiveRecord
       def key_to_cast(val, key)
         return key if val.key?(key)
         return key.to_sym if val.key?(key.to_sym)
+        return key if defaults.key?(key)
       end
 
       def typed?(key)
@@ -82,7 +99,12 @@ module ActiveRecord
         accessor_types.fetch(key.to_s)
       end
 
-      attr_reader :accessor_types, :store_accessor
+      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
 end