attr_json 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be1175039b6fbd78d5a9c1bcaae7c4ce003d29f403ef1e86d71d3c226e659a0b
-  data.tar.gz: 588710deb7c2b6076ba1cf1094f9b4ab67fb7bd74cecfc8c560de5b0ef50eafb
+  metadata.gz: b6bbeb0707de928eae27b0bceafa5691486a2784d3065c71f91757e825bbaa94
+  data.tar.gz: 64b4d70c31b1b9499ee74f764940b283d45231ec6f4809cec35459e7d6ed9288
 SHA512:
-  metadata.gz: d71520892d16915465eab7c9e373f5e5ecabb8efee7a295da6532fbedd0c9817890da7e689e31f1bf1c7b3c1cad73f071f3563d7eb6d5637516de40174fce627
-  data.tar.gz: ea225c01754abfa5dec0e8749fd91ff68e1a329b54e684a27fee14655de7eb4eddf832538a961b14bbf83e222e0b90bfe554a8fdac001ca95aefb456353ed763
+  metadata.gz: 91aab7ce45bf723d4c76d9b2756ad65650bef1b223b2214bc9091118a8e4a04cb347fbac2438e7aaab4ed302f92c26f88b23f602e626b494f1aa5251f81473d7
+  data.tar.gz: 7862793a46004520e65cbb8b98a4857ec5441d6f0456dd8e368c4af7be8fafaefd8f0ef780f38f7361ea45b1117dbee4fe384492e44f5044aa295ee56488a99b

data/CHANGELOG.md

@@ -4,7 +4,26 @@ Notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased](https://github.com/jrochkind/attr_json/compare/v1.1.0...HEAD)
+## [Unreleased](https://github.com/jrochkind/attr_json/compare/v1.2.0...HEAD)
+
+
+
+## [1.2.0](https://github.com/jrochkind/attr_json/compare/v1.1.0...v1.2.0)
+
+### Added
+
+* attr_json_config(bad_cast: :as_nil) to avoid raising on data that can't be cast to a
+  AttrJson::Model, instead just casting to nil. https://github.com/jrochkind/attr_json/pull/95
+
+* Documented and tested support for using ActiveRecord serialize to map one AttrJson::Model
+to an entire column on it's own. https://github.com/jrochkind/attr_json/pull/89 and
+https://github.com/jrochkind/attr_json/pull/93
+
+* Better synchronization with ActiveRecord attributes when using rails_attribute:true, and a configurable true default_rails_attribute.  Thanks @volkanunsal . https://github.com/jrochkind/attr_json/pull/94
+
+### Changed
+
+* AttrJson::Model#== now requires same class for equality. And doesn't raise on certain arguments. https://github.com/jrochkind/attr_json/pull/90 Thanks @caiofilipemr for related bug report.
 
 ## [1.1.0](https://github.com/jrochkind/attr_json/compare/v1.0.0...v1.1.0)
 

data/README.md

@@ -228,6 +228,26 @@ m.attr_jsons_before_type_cast
 
 You can nest AttrJson::Model objects inside each other, as deeply as you like.
 
+### Model-type defaults
+
+If you want to set a default for an AttrJson::Model type, you should use a proc argument for
+the default, to avoid accidentally re-using a shared global default value, similar to issues
+people have with ruby Hash default.
+
+```ruby
+  attr_json :lang_and_value, LangAndValue.to_type, default: -> { LangAndValue.new(lang: "en", value: "default") }
+```
+
+You can also use a Hash value that will be cast to your model, no need for proc argument
+in this case.
+
+```ruby
+  attr_json :lang_and_value, LangAndValue.to_type, default: { lang: "en", value: "default" }
+```
+
+
+### Polymorphic model types
+
 There is some support for "polymorphic" attributes that can hetereogenously contain instances of different AttrJson::Model classes, see comment docs at [AttrJson::Type::PolymorphicModel](./lib/attr_json/type/polymorphic_model.rb).
 
 
@@ -286,6 +306,63 @@ always mean 'contains' -- the previous query needs a `my_labels.hello`
 which is a hash that includes the key/value, `lang: en`, it can have
 other key/values in it too.  String values will need to match exactly.
 
+## Single AttrJson::Model serialized to an entire json column
+
+The main use case of the gem is set up to let you combine multiple primitives and nested models
+under different keys combined in a single json or jsonb column.
+
+But you may also want to have one AttrJson::Model class that serializes to map one model class, as
+a hash, to an entire json column on it's own.
+
+`AttrJson::Model` can supply a simple coder for the [ActiveRecord serialization](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html)
+feature  to easily do that.
+
+```ruby
+class MyModel
+  include AttrJson::Model
+
+  attr_json :some_string, :string
+  attr_json :some_int, :int
+end
+
+class MyTable < ApplicationRecord
+  serialize :some_json_column, MyModel.to_serialization_coder
+end
+
+MyTable.create(some_json_column: MyModel.new(some_string: "string"))
+
+# will cast from hash for you
+MyTable.create(some_json_column: { some_int: 12 })
+
+# etc
+```
+
+To avoid errors raised at inconvenient times, we recommend you set these settings to make 'bad'
+data turn into `nil`, consistent with most ActiveRecord types:
+
+```ruby
+class MyModel
+  include AttrJson::Model
+
+  attr_json_config(bad_cast: :as_nil, unknown_key: :strip)
+  # ...
+end
+```
+
+And/or define a setter method to cast, and raise early on data problems:
+
+```ruby
+class MyTable < ApplicationRecord
+  serialize :some_json_column, MyModel.to_serialization_coder
+
+  def some_json_column=(val)
+    super(   )
+  end
+end
+```
+
+Serializing a model to an entire json column is a relatively recent feature, please let us know how it's working for you.
+
 <a name="arbitrary-json-data"></a>
 ## Storing Arbitrary JSON data
 
@@ -308,7 +385,7 @@ Use with Rails form builders is supported pretty painlessly. Including with [sim
 
 If you have nested AttrJson::Models you'd like to use in your forms much like Rails associated records: Where you would use Rails `accepts_nested_attributes_for`, instead `include AttrJson::NestedAttributes` and use `attr_json_accepts_nested_attributes_for`. Multiple levels of nesting are supported.
 
-To get simple_form to properly detect your attribute types, define your attributes with `rails_attribute: true`.
+To get simple_form to properly detect your attribute types, define your attributes with `rails_attribute: true`.  You can default rails_attribute to true with `attr_json_config(default_rails_attribute: true)`
 
 For more info, see doc page on [Use with Forms and Form Builders](doc_src/forms.md).
 

data/lib/attr_json/attribute_definition.rb

@@ -78,6 +78,12 @@
       @default != NO_DEFAULT_PROVIDED
     end
 
+    # Can be value or proc!
+    def default_argument
+      return nil unless has_default?
+      @default
+    end
+
     def provide_default!
       unless has_default?
         raise ArgumentError.new("This #{self.class.name} does not have a default defined!")

data/lib/attr_json/config.rb

@@ -3,10 +3,20 @@ module AttrJson
   # and rails class_attribute. Instead, you set to new Config object
   # changed with {#merge}.
   class Config
-    RECORD_ALLOWED_KEYS = %i{default_container_attribute default_accepts_nested_attributes}
-    MODEL_ALLOWED_KEYS = %i{unknown_key}
+    RECORD_ALLOWED_KEYS = %i{
+      default_container_attribute
+      default_rails_attribute
+      default_accepts_nested_attributes
+    }
+
+    MODEL_ALLOWED_KEYS = %i{
+      unknown_key
+      bad_cast
+    }
+
     DEFAULTS = {
       default_container_attribute: "json_attributes",
+      default_rails_attribute: false,
       unknown_key: :raise
     }
 

data/lib/attr_json/model.rb

@@ -7,6 +7,8 @@ require 'attr_json/attribute_definition/registry'
 require 'attr_json/type/model'
 require 'attr_json/model/cocoon_compat'
 
+require 'attr_json/serialization_coder_from_type'
+
 module AttrJson
 
   # Meant for use in a plain class, turns it into an ActiveModel::Model
@@ -30,9 +32,39 @@ module AttrJson
   #
   #        class Something
   #          include AttrJson::Model
-  #          attr_json_config(unknown_key: :ignore)
+  #          attr_json_config(unknown_key: :allow)
+  #          #...
+  #        end
+  #
+  # Similarly, trying to set a Model-valued attribute with an object that
+  # can't be cast to a Hash or Model at all will normally raise a
+  # AttrJson::Type::Model::BadCast error, but you can set config `bad_cast: :as_nil`
+  # to make it cast to nil, more like typical ActiveRecord cast.
+  #
+  #        class Something
+  #          include AttrJson::Model
+  #          attr_json_config(bad_cast: :as_nil)
   #          #...
   #        end
+  #
+  # ## ActiveRecord `serialize`
+  #
+  # If you want to map a single AttrJson::Model to a json/jsonb column, you
+  # can use ActiveRecord `serialize` feature.
+  #
+  # https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html
+  #
+  # We provide a simple shim to give you the right API for a "coder" for AR serialize:
+  #
+  # class ValueModel
+  #   include AttrJson::Model
+  #   attr_json :some_string, :string
+  # end
+  #
+  # class SomeModel < ApplicationRecord
+  #   serialize :some_json_column, ValueModel.to_serialize_coder
+  # end
+  #
   module Model
     extend ActiveSupport::Concern
 
@@ -88,6 +120,10 @@ module AttrJson
         @type ||= AttrJson::Type::Model.new(self)
       end
 
+      def to_serialization_coder
+        @serialization_coder ||= AttrJson::SerializationCoderFromType.new(to_type)
+      end
+
       # Type can be an instance of an ActiveModel::Type::Value subclass, or a symbol that will
       # be looked up in `ActiveModel::Type.lookup`
       #
@@ -240,12 +276,9 @@ module AttrJson
     end
 
     # Two AttrJson::Model objects are equal if they are the same class
-    # or one is a subclass of the other, AND their #attributes are equal.
-    # TODO: Should we allow subclasses to be equal, or should they have to be the
-    # exact same class?
+    # AND their #attributes are equal.
     def ==(other_object)
-      (other_object.is_a?(self.class) || self.is_a?(other_object.class)) &&
-      other_object.attributes == self.attributes
+      other_object.class == self.class && other_object.attributes == self.attributes
     end
 
     # ActiveRecord objects [have a](https://github.com/rails/rails/blob/v5.1.5/activerecord/lib/active_record/nested_attributes.rb#L367-L374)

data/lib/attr_json/record.rb

@@ -119,10 +119,11 @@ module AttrJson
       # @option options [Boolean] :rails_attribute (false) Create an actual ActiveRecord
       #    `attribute` for name param. A Rails attribute isn't needed for our functionality,
       #    but registering thusly will let the type be picked up by simple_form and
-      #    other tools that may look for it via Rails attribute APIs.
+      #    other tools that may look for it via Rails attribute APIs. Default can be changed
+      #    with `attr_json_config(default_rails_attribute: true)`
       def attr_json(name, type, **options)
         options = {
-          rails_attribute: false,
+          rails_attribute: self.attr_json_config.default_rails_attribute,
           validate: true,
           container_attribute: self.attr_json_config.default_container_attribute,
           accepts_nested_attributes: self.attr_json_config.default_accepts_nested_attributes
@@ -160,7 +161,21 @@ module AttrJson
         # We don't actually use this for anything, we provide our own covers. But registering
         # it with usual system will let simple_form and maybe others find it.
         if options[:rails_attribute]
-          self.attribute name.to_sym, self.attr_json_registry.fetch(name).type
+          attr_json_definition = attr_json_registry[name]
+
+          attribute_args = attr_json_definition.has_default? ? { default: attr_json_definition.default_argument } : {}
+          self.attribute name.to_sym, attr_json_definition.type, **attribute_args
+
+          # Ensure that rails attributes tracker knows about value we just fetched
+          # for this particular attribute. Yes, we are registering an after_find for each
+          # attr_json registered with rails_attribute:true, using the `name` from above under closure. .
+          after_find do
+            value = public_send(name)
+            if value && has_attribute?(name.to_sym)
+              write_attribute(name.to_sym, value)
+              self.send(:clear_attribute_changes, [name.to_sym])
+            end
+          end
         end
 
         _attr_jsons_module.module_eval do
@@ -173,6 +188,7 @@ module AttrJson
           # this simple way.
 
           define_method("#{name}=") do |value|
+            super(value) if defined?(super)
             attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
             public_send(attribute_def.container_attribute)[attribute_def.store_key] = attribute_def.cast(value)
           end

data/lib/attr_json/serialization_coder_from_type.rb

@@ -0,0 +1,40 @@
+module AttrJson
+
+  # A little wrapper to provide an object that provides #dump and #load method for use
+  # as a coder second-argument for [ActiveRecord Serialization](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html),
+  # that simply delegates to #serialize and #deserialize from a ActiveModel::Type object.
+  #
+  # Created to be used with an AttrJson::Model type (AttrJson::Type::Model), but hypothetically
+  # could be a shim from anything with serialize/deserialize to dump/load instead.
+  #
+  #    class ValueModel
+  #      include AttrJson::Model
+  #      attr_json :some_string, :string
+  #    end
+  #
+  #    class SomeModel < ApplicationRecord
+  #      serialize :some_json_column, ValueModel.to_serialize_coder
+  #    end
+  #
+  # Note when used with an AttrJson::Model, it will dump/load from a HASH, not a
+  # string. It assumes it's writing to a Json(b) column that wants/provides hashes,
+  # not strings.
+  class SerializationCoderFromType
+    attr_reader :type
+    def initialize(type)
+      @type = type
+    end
+
+    # Dump and load methods to support ActiveRecord Serialization
+    # too.
+    def dump(value)
+      type.serialize(value)
+    end
+
+    # Dump and load methods to support ActiveRecord Serialization
+    # too. https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Serialization/ClassMethods.html
+    def load(value)
+      type.deserialize(value)
+    end
+  end
+end

data/lib/attr_json/type/model.rb

@@ -7,6 +7,7 @@ module AttrJson
     # You create one with AttrJson::Model::Type.new(attr_json_model_class),
     # but normally that's only done in AttrJson::Model.to_type, there isn't
     # an anticipated need to create from any other place.
+    #
     class Model < ::ActiveModel::Type::Value
       class BadCast < ArgumentError ; end
 
@@ -35,11 +36,13 @@ module AttrJson
         elsif v.respond_to?(:to_h)
           # TODO Maybe we ought not to do this on #to_h?
           model.new_from_serializable(v.to_h)
+        elsif model.attr_json_config.bad_cast == :as_nil
+          # This was originally default behavior, to be like existing ActiveRecord
+          # which kind of silently does this for non-castable basic values. That
+          # ended up being confusing in the basic case, so now we raise by default,
+          # but this is still configurable.
+          nil
         else
-          # Bad input. Originally we were trying to return nil, to be like
-          # existing ActiveRecord which kind of silently does a basic value
-          # with null input. But that ended up making things confusing, let's
-          # just raise.
           raise BadCast.new("Can not cast from #{v.inspect} to #{self.type}")
         end
       end
@@ -50,7 +53,7 @@ module AttrJson
         elsif v.kind_of?(model)
           v.serializable_hash
         else
-          cast(v).serializable_hash
+          (cast_v = cast(v)) && cast_v.serializable_hash
         end
       end
 

data/lib/attr_json/version.rb

@@ -1,3 +1,3 @@
 module AttrJson
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attr_json
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jonathan Rochkind
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-06-02 00:00:00.000000000 Z
+date: 2020-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -167,6 +167,7 @@ files:
 - lib/attr_json/record/dirty.rb
 - lib/attr_json/record/query_builder.rb
 - lib/attr_json/record/query_scopes.rb
+- lib/attr_json/serialization_coder_from_type.rb
 - lib/attr_json/type/array.rb
 - lib/attr_json/type/container_attribute.rb
 - lib/attr_json/type/model.rb
@@ -179,7 +180,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/jrochkind/attr_json
   source_code_uri: https://github.com/jrochkind/attr_json
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -194,9 +195,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: ActiveRecord attributes stored serialized in a json column, super smooth.
 test_files: []