attr_json 0.5.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80130e194fdf715bf967ea25fc6fff1d7e043f53479c1e539d9b9e2122233404
-  data.tar.gz: df2d7d442df1dfec49becd935321a0fbdc8aebec5892e34d84d415c4f5a87471
+  metadata.gz: b6bbeb0707de928eae27b0bceafa5691486a2784d3065c71f91757e825bbaa94
+  data.tar.gz: 64b4d70c31b1b9499ee74f764940b283d45231ec6f4809cec35459e7d6ed9288
 SHA512:
-  metadata.gz: 1e2712bca13ff4fa2b874b5f141070cd5f8e5ab306c6ff9f5e41a7129c4a7b740f6ce0a79a7f9cdf759195cb1c7d144bd0d8ea7ef6d46682487f8d75a47a1c25
-  data.tar.gz: 1c86d1e8cea7a9413960fa357507fd5ba25e55c6f27820fb091bd8f4921c3aa7aa3274c90bd30f93b8cdde521d177d6a3cebe9154757038f2b30ba5cebbf970e
+  metadata.gz: 91aab7ce45bf723d4c76d9b2756ad65650bef1b223b2214bc9091118a8e4a04cb347fbac2438e7aaab4ed302f92c26f88b23f602e626b494f1aa5251f81473d7
+  data.tar.gz: 7862793a46004520e65cbb8b98a4857ec5441d6f0456dd8e368c4af7be8fafaefd8f0ef780f38f7361ea45b1117dbee4fe384492e44f5044aa295ee56488a99b

data/.travis.yml

@@ -1,21 +1,64 @@
 #
-dist: trusty
 sudo: false
 addons:
   postgresql: '9.4'
   chrome: stable
 language: ruby
 cache: bundler
-rvm:
-  - 2.4
-  - 2.5.1
-gemfile:
-  - gemfiles/rails_5_0.gemfile
-  - gemfiles/rails_5_1.gemfile
-  - gemfiles/rails_5_2.gemfile
-  - gemfiles/rails_edge_6.gemfile
+
+# rvm:
+#   - 2.4.5
+#   - 2.5.3
+#   - 2.6.5
+#   - 2.7.0
+# gemfile:
+#   - gemfiles/rails_5_0.gemfile
+#   - gemfiles/rails_5_1.gemfile
+#   - gemfiles/rails_5_2.gemfile
+#   - gemfiles/rails_6_0.gemfile
+#   - gemfiles/rails_edge.gemfile
+
 before_install:
-  - gem install bundler -v 1.14.6
+  - gem install bundler -v "~> 2.0"
+
 matrix:
+  include:
+    - rvm: 2.4.5
+      gemfile: gemfiles/rails_5_0.gemfile
+
+    - rvm: 2.4.5
+      gemfile: gemfiles/rails_5_1.gemfile
+
+    - rvm: 2.4.5
+      gemfile: gemfiles/rails_5_2.gemfile
+
+    - rvm: 2.5.3
+      gemfile: gemfiles/rails_5_0.gemfile
+
+    - rvm: 2.5.3
+      gemfile: gemfiles/rails_5_1.gemfile
+
+    - rvm: 2.5.3
+      gemfile: gemfiles/rails_5_2.gemfile
+
+    - rvm: 2.5.3
+      gemfile: gemfiles/rails_6_0.gemfile
+
+    - rvm: 2.6.5
+      gemfile: gemfiles/rails_5_2.gemfile
+
+    - rvm: 2.6.5
+      gemfile: gemfiles/rails_6_0.gemfile
+
+    - rvm: 2.7.0
+      gemfile: gemfiles/rails_6_0.gemfile
+
+    - rvm: 2.7.0
+      gemfile: gemfiles/rails_edge.gemfile
+
   allow_failures:
-  - gemfile: gemfiles/rails_edge_6.gemfile
+  - gemfile: gemfiles/rails_edge.gemfile
+  fast_finish: true
+
+
+

data/Appraisals

@@ -25,10 +25,17 @@ appraise "rails-5-2" do
   gem "pg", "~> 1.0"
 end
 
+appraise "rails-6-0" do
+  gem 'combustion', "~> 1.0"
+
+  gem "rails", ">= 6.0.0.beta1", "< 6.1"
+  gem "pg", "~> 1.0"
+end
+
 appraise "rails-edge-6" do
   # Edge rails needs unreleased combustion
   # https://github.com/pat/combustion/issues/92
-  gem 'combustion', git: "https://github.com/pat/combustion.git"
+  gem 'combustion', "~> 1.0"
 
   gem "rails", git: "https://github.com/rails/rails.git", branch: "master"
   gem "pg", "~> 1.0"

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+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.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)
+
+### Added
+
+* not_jsonb_contains query method, like `jsonb_contains` but negated. https://github.com/jrochkind/attr_json/pull/85

data/Gemfile

@@ -10,7 +10,7 @@ gemspec
 # We also have these development dependencies here in the Gemfile instead of the
 # gemspec so appraisal can override them from our Appraisal file.
 
-gem 'combustion', '~> 0.9.0'
+gem 'combustion', '~> 1.1'
 
 # all of rails is NOT a dependency, just activerecord.
 # But we use it for integration testing with combustion. Hmm, a bit annoying
@@ -24,13 +24,13 @@ gem 'rails'
 gem 'railties'
 
 gem "pg"
-gem "rspec-rails", "~> 3.7"
+gem "rspec-rails", "~> 4.0"
 gem "simple_form", ">= 4.0"
 gem 'cocoon', ">= 1.2"
 gem 'jquery-rails'
 
 gem 'capybara', "~> 3.0"
-gem "chromedriver-helper"
+gem 'webdrivers', '~> 4.0'
 gem "selenium-webdriver"
 
 gem "byebug"

data/README.md

@@ -3,7 +3,7 @@
 [![Gem Version](https://badge.fury.io/rb/attr_json.svg)](https://badge.fury.io/rb/attr_json)
 
 
-ActiveRecord attributes stored serialized in a json column, super smooth. For Rails 5.0, 5.1, or 5.2. Ruby 2.4+.
+ActiveRecord attributes stored serialized in a json column, super smooth. For Rails 5.0, 5.1, 5.2, or 6.0. Ruby 2.4+.
 
 Typed and cast like Active Record. Supporting [nested models](#nested), [dirty tracking](#dirty), some [querying](#querying) (with postgres [jsonb](https://www.postgresql.org/docs/9.5/static/datatype-json.html) contains), and [working smoothy with form builders](#forms).
 
@@ -11,8 +11,6 @@ Typed and cast like Active Record. Supporting [nested models](#nested), [dirty t
 
 [Why might you want or not want this?](#why)
 
-AttrJson is pre-1.0. The functionality that is documented here _is_ already implemented (these docs are real, not vaporware) and seems pretty solid. It may still have backwards-incompat changes before 1.0 release. Review and feedback is very welcome.
-
 Developed for postgres, but most features should work with MySQL json columns too, although
 has not yet been tested with MySQL.
 
@@ -140,6 +138,9 @@ MyModel.jsonb_contains(my_string: "foo", my_integer: 100).first
 # Implemented with scopes, this is an ordinary relation, you can
 # combine it with whatever, just like ordinary `where`.
 
+MyModel.not_jsonb_contains(my:string: "foo", my_integer: 100).to_sql
+# SELECT "products".* FROM "products" WHERE NOT (products.json_attributes @> ('{"my_string":"foo","my_integer":100}')::jsonb)
+
 # typecasts much like ActiveRecord on query too:
 MyModel.jsonb_contains(my_string: "foo", my_integer: "100")
 # no problem
@@ -227,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).
 
 
@@ -285,6 +306,77 @@ 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
+
+Arbitrary JSON data (hashes, arrays, primitives of any depth) can be stored within attributes by using the rails built in `ActiveModel::Type::Value` as the attribute type. This is basically a "no-op" value type -- JSON alone will be used to serialize/deserialize whatever values you put there, because of the json type on the container field.
+
+```ruby
+class MyModel < ActiveRecord::Base
+  include AttrJson::Record
+
+  attr_json :arbitrary_hash, ActiveModel::Type::Value.new
+end
+
+```
+
 
 <a name="forms"></a>
 ## Forms and Form Builders
@@ -293,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).
 
@@ -383,16 +475,16 @@ to prevent overwriting other updates from processes.
 
 ## State of Code, and To Be Done
 
-This is a pre-1.0 work in progress. But the functionality that is here seems pretty solid.
+The functionality that is here seems pretty solid, and is being used by jrochkind in a production app.
 
-Backwards incompatible changes are possible before 1.0. Once I tag something 1.0, I'm pretty serious about minimizing backwards incompats.
-
-I do not yet use this myself in production, and may not for a while. I generally am reluctant to release something as 1.0 with implied suitable for production when I'm not yet using it in production myself, but may with enough feedback. A couple others are already using in production.
+We are committed to [semantic versioning](https://semver.org/) and will endeavor to release no backwards breaking changes without a major version. We are also serious about minimizing backwards incompat releases altogether (ie minimiing major version releases).
 
 Feedback of any kind of _very welcome_, please feel free to use the issue tracker.
 
 Except for the jsonb_contains stuff using postgres jsonb contains operator, I don't believe any postgres-specific features are used. It ought to work with MySQL, testing and feedback welcome. (Or a PR to test on MySQL?).  My own interest is postgres.
 
+This is still mostly a single-maintainer operation, so has all the sustainability risks of that. Although there are other people using and contributing to it, check out the Github Issues and Pull Request tabs yourself to get a sense.
+
 ### Possible future features:
 
 * partial updates for json hashes would be really nice: Using postgres jsonb merge operators to only overwrite what changed. In my initial attempts, AR doesn't make it easy to customize this.
@@ -450,3 +542,5 @@ There is a `./bin/console` that will give you a console in the context of attr_j
 * Didn't actually notice existing [json_attributes](https://github.com/joel/json_attributes)
   until I was well on my way here. I think it's not updated for Rails5 or type-aware,
   haven't looked at it too much.
+
+* [store_model](https://github.com/DmitryTsepelev/store_model) was created after `attr_json`, and has some overlapping functionality.

data/attr_json.gemspec

@@ -45,10 +45,10 @@ attributes use as much of the existing ActiveRecord architecture as we can.}
   # Only to get CI to work on versions of Rails other than we release with,
   # should never release a gem with RAILS_GEM set!
   unless ENV['APPRAISAL_INITIALIZED'] || ENV["TRAVIS"]
-    spec.add_runtime_dependency "activerecord", ">= 5.0.0", "< 5.3"
+    spec.add_runtime_dependency "activerecord", ">= 5.0.0", "< 6.1"
   end
 
-  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", ">= 10.0"
   spec.add_development_dependency "rspec", "~> 3.7"
   spec.add_development_dependency "database_cleaner", "~> 1.5"

data/gemfiles/rails_5_0.gemfile

@@ -6,12 +6,12 @@ gem "combustion", "~> 0.9.0"
 gem "rails", "~> 5.0.0"
 gem "railties"
 gem "pg", "~> 0.18"
-gem "rspec-rails", "~> 3.7"
+gem "rspec-rails", "~> 4.0"
 gem "simple_form", ">= 4.0"
 gem "cocoon", ">= 1.2"
 gem "jquery-rails"
 gem "capybara", "~> 3.0"
-gem "chromedriver-helper"
+gem "webdrivers", "~> 4.0"
 gem "selenium-webdriver"
 gem "byebug"
 gem "rails-ujs", require: false

data/gemfiles/rails_5_1.gemfile

@@ -6,12 +6,12 @@ gem "combustion", "~> 0.9.0"
 gem "rails", "~> 5.1.0"
 gem "railties"
 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 "capybara", "~> 3.0"
-gem "chromedriver-helper"
+gem "webdrivers", "~> 4.0"
 gem "selenium-webdriver"
 gem "byebug"
 

data/gemfiles/rails_5_2.gemfile

@@ -6,12 +6,12 @@ gem "combustion", "~> 0.9.0"
 gem "rails", "~> 5.2.0"
 gem "railties"
 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 "capybara", "~> 3.0"
-gem "chromedriver-helper"
+gem "webdrivers", "~> 4.0"
 gem "selenium-webdriver"
 gem "byebug"
 

data/gemfiles/rails_6_0.gemfile

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

data/gemfiles/rails_edge.gemfile

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

data/gemfiles/rails_edge_6.gemfile

@@ -2,16 +2,16 @@
 
 source "https://rubygems.org"
 
-gem "combustion", git: "https://github.com/pat/combustion.git"
+gem "combustion", "~> 1.0"
 gem "rails", git: "https://github.com/rails/rails.git", branch: "master"
 gem "railties"
 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 "capybara", "~> 3.0"
-gem "chromedriver-helper"
+gem "webdrivers", "~> 4.0"
 gem "selenium-webdriver"
 gem "byebug"
 gem "coffee-rails"

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'

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/attribute_definition/registry.rb

@@ -54,6 +54,11 @@ module AttrJson
         @name_to_definition.values
       end
 
+      # Returns all registered attributes as an array of symbols
+      def attribute_names
+        @name_to_definition.keys
+      end
+
       def container_attributes
         @store_key_to_definition.keys.collect(&:to_s)
       end

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

@@ -26,6 +26,37 @@ module AttrJson
       self.attr_json_registry = AttrJson::AttributeDefinition::Registry.new
     end
 
+    protected
+
+    # adapted from ActiveRecord query_attribute method
+    # https://github.com/rails/rails/blob/v5.2.3/activerecord/lib/active_record/attribute_methods/query.rb#L12
+    #
+    # Sadly we could not re-use Rails code here, becuase the built-in method assumes attribute
+    # can be obtained with `self[attr_name]`, which you can not with attr_json (is that bad?), as
+    # well as `self.class.columns_hash[attr_name]` which you definitely can not (which is probably not bad),
+    # and has no way to use the value-translation semantics independently of that. May be a problem if
+    # ActiveRecord changes it's query method semantics in the future, will have to be sync'd here.
+    #
+    # Used to implement query methods on attr_json attributes, like `attr_json :foo, :string`, method `#foo?`
+    def self.attr_json_query_method(record, attribute)
+      value = record.send(attribute)
+
+      case value
+      when true
+        true
+      when false, nil, ActiveModel::Type::Boolean::FALSE_VALUES
+        false
+      else
+        if value.respond_to?(:to_i) && ( Numeric === value || value.to_s !~ /[^0-9]/ )
+          !value.to_i.zero?
+        elsif value.respond_to?(:zero?)
+          !value.zero?
+        else
+          !value.blank?
+        end
+      end
+    end
+
     class_methods do
       # Access or set class-wide json_attribute_config. Inherited by sub-classes,
       # but setting on sub-classes is unique to subclass. Similar to how
@@ -88,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
@@ -129,34 +161,46 @@ 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
+          # For getter and setter, we used to use read_store_attribute/write_store_attribute
+          # copied from Rails store_accessor implementation.
+          # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
+          #
+          # But in fact just getting/setting in the hash provided to us by ActiveRecord json type
+          # container works BETTER for dirty tracking. We had a test that only passed doing it
+          # this simple way.
+
           define_method("#{name}=") do |value|
+            super(value) if defined?(super)
             attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
-            # write_store_attribute copied from Rails store_accessor implementation.
-            # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
-
-            # special handling for nil, sorry, because if name key was previously
-            # not present, write_store_attribute by default will decide there was
-            # no change and refuse to make the change. TODO messy.
-            if value.nil? && !public_send(attribute_def.container_attribute).has_key?(attribute_def.store_key)
-               public_send :"#{attribute_def.container_attribute}_will_change!"
-               public_send(attribute_def.container_attribute)[attribute_def.store_key] = nil
-            else
-              # use of `write_store_attribute` is copied from Rails store_accessor implementation.
-              # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
-              write_store_attribute(attribute_def.container_attribute, attribute_def.store_key, attribute_def.cast(value))
-            end
+            public_send(attribute_def.container_attribute)[attribute_def.store_key] = attribute_def.cast(value)
           end
 
           define_method("#{name}") do
             attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
+            public_send(attribute_def.container_attribute)[attribute_def.store_key]
+          end
 
-            # use of `read_store_attribute` is copied from Rails store_accessor implementation.
-            # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
-            read_store_attribute(attribute_def.container_attribute, attribute_def.store_key)
+          define_method("#{name}?") do
+            # implementation of `query_store_attribute` is based on Rails `query_attribute` implementation
+            AttrJson::Record.attr_json_query_method(self, name)
           end
         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/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/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
 

data/lib/attr_json/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attr_json
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jonathan Rochkind
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-01-02 00:00:00.000000000 Z
+date: 2020-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: 5.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,21 +29,21 @@ dependencies:
         version: 5.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.3'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -133,6 +133,7 @@ files:
 - ".travis.yml"
 - ".yardopts"
 - Appraisals
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -149,6 +150,8 @@ files:
 - gemfiles/rails_5_0.gemfile
 - gemfiles/rails_5_1.gemfile
 - gemfiles/rails_5_2.gemfile
+- gemfiles/rails_6_0.gemfile
+- gemfiles/rails_edge.gemfile
 - gemfiles/rails_edge_6.gemfile
 - lib/attr_json.rb
 - lib/attr_json/attribute_definition.rb
@@ -164,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
@@ -176,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
@@ -191,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: []