store_attribute 0.4.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5b686f8993ef12feb2c0a1b36dcf90fbf0a7225b
-  data.tar.gz: 5498a60d8e4ac7ce66e4316b5fe2dfb50856c662
+SHA256:
+  metadata.gz: a6d0060f9544a3e9e005c149cc189dd6647c0c83493bbb577bb67893e2b5a5fd
+  data.tar.gz: 0f9105dc411953cf7b3342117538e068c9ea7897220d573126bf0d4c01640726
 SHA512:
-  metadata.gz: b41a03c88333430a322a2b0147b445284c4335063fcfaccaae53200b8438cad9a22996b1951df936da18fbbde23bd57d06847a49042971346896e181a9729e86
-  data.tar.gz: eb62f09e1f44a05d3d29540ac9b7f4751d226c0b4f37e6c92cc7b1c285c7cf993e16585e3f33edae18d2170f6544ac30f810590d8ac3a0fd23f1df124fed1ec6
+  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,18 +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.
+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).
 
 ### Install
 
 In your Gemfile:
 
 ```ruby
-gem "store_attribute", "~>0.4.0" # version 0.4.x is for Rails 4.2.x and 0.5.x is for Rails 5
+# for Rails 5+ (6 is supported)
+gem "store_attribute", "~> 0.5.0"
+
+# for Rails 4.2
+gem "store_attribute", "~> 0.4.0"
 ```
 
 ### Usage
@@ -20,14 +26,14 @@ gem "store_attribute", "~>0.4.0" # version 0.4.x is for Rails 4.2.x and 0.5.x is
 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.
@@ -41,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.14.1592653"
+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:
@@ -81,4 +93,4 @@ Or through `store`:
 class User < ActiveRecord::Base
   store :settings, accessors: [:color, :homepage, login_at: :datetime], coder: JSON
 end
-```
+```

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,9 +1,12 @@
-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
     module ClassMethods # :nodoc:
+      alias _orig_store store
       # Defines store on this model.
       #
       # +store_name+ The name of the store.
@@ -21,9 +24,18 @@ module ActiveRecord
       #     store :settings, accessors: [:color, :homepage, login_at: :datetime], coder: JSON
       #   end
       def store(store_name, options = {})
-        serialize store_name, IndifferentCoder.new(options[:coder])
-        store_accessor(store_name, *options[:accessors]) if options.key?(:accessors)
+        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, **typed_accessors) if accessors
       end
+
       # Adds additional accessors to an existing store on this model.
       #
       # +store_name+ The name of the store.
@@ -32,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
 
@@ -63,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:
@@ -70,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
@@ -93,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)
@@ -113,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,22 +1,9 @@
-require 'active_record/type'
+# frozen_string_literal: true
+
+require "active_record/type"
 
 module ActiveRecord
   module Type # :nodoc:
-    BASE_TYPES = {
-      boolean: ::ActiveRecord::Type::Boolean,
-      integer: ::ActiveRecord::Type::Integer,
-      string: ::ActiveRecord::Type::String,
-      float: ::ActiveRecord::Type::Float,
-      date: ::ActiveRecord::Type::Date,
-      datetime: ::ActiveRecord::Type::DateTime,
-      decimal: ::ActiveRecord::Type::Decimal
-    }.freeze
-
-    def self.lookup_type(type, options)
-      BASE_TYPES[type.to_sym].try(:new, options) ||
-        ActiveRecord::Base.connection.type_map.lookup(type.to_s, options)
-    end
-
     class TypedStore < DelegateClass(ActiveRecord::Type::Value) # :nodoc:
       # Creates +TypedStore+ type instance and specifies type caster
       # for key.
@@ -28,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 = Type.lookup_type(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 type_cast_from_database(value)
+      def deserialize(value)
         hash = super
-        if hash
-          accessor_types.each do |key, type|
-            hash[key] = type.type_cast_from_database(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 type_cast_for_database(value)
-        if value.is_a?(Hash)
-          typed_casted = {}
-          accessor_types.each do |key, type|
-            k = key_to_cast(value, key)
-            typed_casted[k] = type.type_cast_for_database(value[k]) unless k.nil?
+      def serialize(value)
+        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 type_cast_from_user(value)
+      def cast(value)
         hash = super
-        if hash
-          accessor_types.each do |key, type|
-            hash[key] = type.type_cast_from_user(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
@@ -75,7 +76,7 @@ module ActiveRecord
       end
 
       def write(object, attribute, key, value)
-        value = type_for(key).type_cast_from_user(value) if typed?(key)
+        value = type_for(key).cast(value) if typed?(key)
         store_accessor.write(object, attribute, key, value)
       end
 
@@ -87,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)
@@ -97,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