attr_json 0.7.0 → 1.5.0

data/gemfiles/rails_6_0.gemfile

@@ -2,16 +2,17 @@
 
 source "https://rubygems.org"
 
-gem "combustion", git: "https://github.com/pat/combustion.git"
-gem "rails", ">= 6.0.0.beta1", "< 6.1"
-gem "railties"
+gem "combustion", "~> 1.0"
+gem "rails", ">= 6.0.0", "< 6.1"
 gem "pg", "~> 1.0"
-gem "rspec-rails", "~> 3.7"
+gem "rspec-rails", "~> 4.0"
 gem "simple_form", ">= 4.0"
 gem "cocoon", ">= 1.2"
 gem "jquery-rails"
+gem "coffee-rails"
+gem "sprockets-rails"
 gem "capybara", "~> 3.0"
-gem "webdrivers", "~> 3.0"
+gem "webdrivers", "~> 4.0"
 gem "selenium-webdriver"
 gem "byebug"
 

data/gemfiles/rails_6_1.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "combustion", "~> 1.0"
+gem "rails", "~> 6.1.0"
+gem "pg", "~> 1.0"
+gem "rspec-rails", "~> 4.0"
+gem "simple_form", ">= 4.0"
+gem "cocoon", ">= 1.2"
+gem "jquery-rails"
+gem "coffee-rails"
+gem "sprockets-rails"
+gem "capybara", "~> 3.0"
+gem "webdrivers", "~> 4.0"
+gem "selenium-webdriver"
+gem "byebug"
+
+gemspec path: "../"

data/gemfiles/rails_7_0.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "combustion", "~> 1.0"
+gem "rails", "~> 7.0.0"
+gem "pg", "~> 1.0"
+gem "rspec-rails", "~> 4.0"
+gem "simple_form", ">= 4.0"
+gem "cocoon", ">= 1.2"
+gem "jquery-rails"
+gem "coffee-rails"
+gem "sprockets-rails"
+gem "capybara", "~> 3.0"
+gem "webdrivers", "~> 4.0"
+gem "selenium-webdriver"
+gem "byebug"
+
+gemspec path: "../"

data/gemfiles/{rails_edge_6.gemfile → rails_edge.gemfile}

@@ -2,18 +2,18 @@
 
 source "https://rubygems.org"
 
-gem "combustion", git: "https://github.com/pat/combustion.git"
-gem "rails", git: "https://github.com/rails/rails.git", branch: "master"
-gem "railties"
+gem "combustion", "~> 1.0", github: "pat/combustion"
+gem "rails", git: "https://github.com/rails/rails.git", branch: "main"
 gem "pg", "~> 1.0"
-gem "rspec-rails", "~> 3.7"
+gem "rspec-rails", "~> 4.0"
 gem "simple_form", ">= 4.0"
 gem "cocoon", ">= 1.2"
 gem "jquery-rails"
+gem "coffee-rails"
+gem "sprockets-rails"
 gem "capybara", "~> 3.0"
-gem "webdrivers", "~> 3.0"
+gem "webdrivers", "~> 4.0"
 gem "selenium-webdriver"
 gem "byebug"
-gem "coffee-rails"
 
 gemspec path: "../"

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
 
@@ -71,16 +103,27 @@ module AttrJson
       end
 
 
-      # Like `.new`, but translate store keys in hash
+      # The inverse of model#serializable_hash -- re-hydrates a serialized hash to a model.
+      #
+      # Similar to `.new`, but translates things that need to be translated in deserialization,
+      # like store_keys, and properly calling deserialize on the underlying types.
+      #
+      # @example Model.new_from_serializable(hash)
       def new_from_serializable(attributes = {})
-        attributes = attributes.transform_keys do |key|
+        attributes = attributes.collect do |key, value|
           # store keys in arguments get translated to attribute names on initialize.
           if attribute_def = self.attr_json_registry.store_key_lookup("", key.to_s)
-            attribute_def.name.to_s
-          else
-            key
+            key = attribute_def.name.to_s
           end
-        end
+
+          attr_type = self.attr_json_registry.has_attribute?(key) && self.attr_json_registry.type_for_attribute(key)
+          if attr_type
+            value = attr_type.deserialize(value)
+          end
+
+          [key, value]
+        end.to_h
+
         self.new(attributes)
       end
 
@@ -88,6 +131,21 @@ module AttrJson
         @type ||= AttrJson::Type::Model.new(self)
       end
 
+      def to_serialization_coder
+        @serialization_coder ||= AttrJson::SerializationCoderFromType.new(to_type)
+      end
+
+      # like the ActiveModel::Attributes method
+      def attribute_names
+        attr_json_registry.attribute_names
+      end
+
+      # like the ActiveModel::Attributes method, hash with name keys, and ActiveModel::Type values
+      def attribute_types
+        attribute_names.collect { |name| [name.to_s, attr_json_registry.type_for_attribute(name)]}.to_h
+      end
+
+
       # Type can be an instance of an ActiveModel::Type::Value subclass, or a symbol that will
       # be looked up in `ActiveModel::Type.lookup`
       #
@@ -130,27 +188,6 @@ module AttrJson
         end
       end
 
-      # This should kind of be considered 'protected', but the semantics
-      # of how we want to call it don't give us a visibility modifier that works.
-      # Prob means refactoring called for. TODO?
-      def fill_in_defaults(hash)
-        # Only if we need to mutate it to add defaults, we'll dup it first. deep_dup not neccesary
-        # since we're only modifying top-level here.
-        duped = false
-        attr_json_registry.definitions.each do |definition|
-          if definition.has_default? && ! (hash.has_key?(definition.store_key.to_s) || hash.has_key?(definition.store_key.to_sym))
-            unless duped
-              hash = hash.dup
-              duped = true
-            end
-
-            hash[definition.store_key] = definition.provide_default!
-          end
-        end
-
-        hash
-      end
-
       private
 
       # Define an anonymous module and include it, so can still be easily
@@ -166,11 +203,15 @@ module AttrJson
     end
 
     def initialize(attributes = {})
-      if !attributes.respond_to?(:transform_keys)
-        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument."
-      end
+      super
+
+      fill_in_defaults!
+    end
 
-      super(self.class.fill_in_defaults(attributes))
+    # inspired by https://github.com/rails/rails/blob/8015c2c2cf5c8718449677570f372ceb01318a32/activemodel/lib/active_model/attributes.rb
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+      super
     end
 
     def attributes
@@ -208,6 +249,11 @@ module AttrJson
       self.class.attr_json_registry.has_attribute?(str)
     end
 
+    # like the ActiveModel::Attributes method
+    def attribute_names
+      self.class.attribute_names
+    end
+
     # Override from ActiveModel::Serialization to #serialize
     # by type to make sure any values set directly on hash still
     # get properly type-serialized.
@@ -240,12 +286,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)
@@ -257,8 +300,25 @@ module AttrJson
       false
     end
 
+    # like ActiveModel::Attributes at
+    # https://github.com/rails/rails/blob/8015c2c2cf5c8718449677570f372ceb01318a32/activemodel/lib/active_model/attributes.rb#L120
+    #
+    # is not a full deep freeze
+    def freeze
+      attributes.freeze unless frozen?
+      super
+    end
+
     private
 
+    def fill_in_defaults!
+      self.class.attr_json_registry.definitions.each do |definition|
+        if definition.has_default? && !attributes.has_key?(definition.name.to_s)
+          self.send("#{definition.name.to_s}=", definition.provide_default!)
+        end
+      end
+    end
+
     def _attr_json_write(key, value)
       if attribute_def = self.class.attr_json_registry[key.to_sym]
         attributes[key.to_s] = attribute_def.cast(value)

data/lib/attr_json/record/dirty.rb

@@ -270,7 +270,13 @@ module AttrJson
         # find it from currently declared attributes.
         # https://github.com/rails/rails/blob/6aa5cf03ea8232180ffbbae4c130b051f813c670/activemodel/lib/active_model/attribute_methods.rb#L463-L468
         def matched_attribute_method(method_name)
-          matches = self.class.send(:attribute_method_matchers_matching, method_name)
+          if self.class.respond_to?(:attribute_method_patterns_matching, true)
+            # Rails 7.1+
+            matches = self.class.send(:attribute_method_patterns_matching, method_name)
+          else
+            matches = self.class.send(:attribute_method_matchers_matching, method_name)
+          end
+
           matches.detect do |match|
             registry.has_attribute?(match.attr_name)
           end

data/lib/attr_json/record/query_builder.rb

@@ -10,6 +10,20 @@ module AttrJson
       end
 
       def contains_relation
+        contains_relation_impl do |relation, query, params|
+          relation.where(query, params)
+        end
+      end
+
+      def contains_not_relation
+        contains_relation_impl do |relation, query, params|
+          relation.where.not(query, params)
+        end
+      end
+
+      protected
+
+      def contains_relation_impl
         result_relation = relation
 
         group_attributes_by_container.each do |container_attribute, attributes|
@@ -18,14 +32,12 @@ module AttrJson
           attributes.each do |key, value|
             add_to_param_hash!(param_hash, key, value)
           end
-          result_relation = result_relation.where("#{relation.table_name}.#{container_attribute} @> (?)::jsonb", param_hash.to_json)
+          result_relation = yield(result_relation, "#{relation.table_name}.#{container_attribute} @> (?)::jsonb", param_hash.to_json)
         end
 
         result_relation
       end
 
-      protected
-
       def merge_param_hash!(original, new)
         original.deep_merge!(new) do |key, old_val, new_val|
           if old_val.is_a?(Array) && old_val.first.is_a?(Hash) && new_val.is_a?(Array) && new_val.first.is_a?(Hash)

data/lib/attr_json/record/query_scopes.rb

@@ -17,6 +17,8 @@ module AttrJson
     #
     #      some_model.jsonb_contains(a_string: "foo").first
     #
+    #      some_model.not_jsonb_contains(a_string: "bar").first
+    #
     # See more in {file:README} docs.
     module QueryScopes
       extend ActiveSupport::Concern
@@ -29,6 +31,10 @@ module AttrJson
         scope(:jsonb_contains, lambda do |attributes|
           QueryBuilder.new(self, attributes).contains_relation
         end)
+
+        scope(:not_jsonb_contains, lambda do |attributes|
+          QueryBuilder.new(self, attributes).contains_not_relation
+        end)
       end
     end
   end

data/lib/attr_json/record.rb

@@ -47,7 +47,7 @@ module AttrJson
       when false, nil, ActiveModel::Type::Boolean::FALSE_VALUES
         false
       else
-        if value.respond_to?(:to_i) && ( Numeric === value || value !~ /[^0-9]/ )
+        if value.respond_to?(:to_i) && ( Numeric === value || value.to_s !~ /[^0-9]/ )
           !value.to_i.zero?
         elsif value.respond_to?(:zero?)
           !value.zero?
@@ -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
 
@@ -31,15 +32,17 @@ module AttrJson
           # to_hash is actually the 'implicit' conversion, it really is a hash
           # even though it isn't is_a?(Hash), try to_hash first before to_h,
           # the explicit conversion.
-          model.new_from_serializable(v.to_hash)
+          model.new(v.to_hash)
         elsif v.respond_to?(:to_h)
           # TODO Maybe we ought not to do this on #to_h?
-          model.new_from_serializable(v.to_h)
+          model.new(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,12 +53,36 @@ 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
 
       def deserialize(v)
-        cast(v)
+        if v.nil?
+          # important to stay nil instead of empty object, because they
+          # are different things.
+          v
+        elsif v.kind_of? model
+          v
+        elsif v.respond_to?(:to_hash)
+          # to_hash is actually the 'implicit' conversion, it really is a hash
+          # even though it isn't is_a?(Hash), try to_hash first before to_h,
+          # the explicit conversion.
+          model.new_from_serializable(v.to_hash)
+        elsif v.respond_to?(:to_h)
+          # TODO Maybe we ought not to do this on #to_h? especially here in deserialize?
+          model.new_from_serializable(v.to_h)
+        elsif model.attr_json_config.bad_cast == :as_nil
+          # TODO should we have different config value for bad_deserialize vs bad_cast?
+
+          # 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
+          raise BadCast.new("Can not cast from #{v.inspect} to #{self.type}")
+        end
       end
 
       # these guys are definitely mutable, so we need this.

data/lib/attr_json/type/polymorphic_model.rb

@@ -51,6 +51,8 @@ module AttrJson
     #      MyRecord.jsonb_contains(author: { name: "foo", type: "Corporation"})
     #      MyRecord.jsonb_contains(author: Corporation.new(name: "foo"))
     #
+    # Additionally, there is not_jsonb_contains, which creates the same query terms like jsonb_contains, but negated.
+    #
     class PolymorphicModel < ActiveModel::Type::Value
       class TypeError < ::TypeError ; end
 
@@ -112,6 +114,11 @@ module AttrJson
       end
 
       def serialize(v)
+        return nil if v.nil?
+
+        # if it's not already a model cast it to a model if possible (eg it's a hash)
+        v = cast(v)
+
         model_name = v.class.name
         type = type_for_model_name(model_name)
 

data/lib/attr_json/version.rb

@@ -1,3 +1,3 @@
 module AttrJson
-  VERSION = "0.7.0"
+  VERSION = "1.5.0"
 end

data/lib/attr_json.rb

@@ -1,7 +1,6 @@
 require "attr_json/version"
 
 require "active_record"
-require "active_record/connection_adapters/postgresql_adapter"
 
 require 'attr_json/config'
 require 'attr_json/record'