attr_json 1.5.0 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cd2566fed014325bee56f5c062080d3c929a790dbb3b287e92b086c2fa3180f
-  data.tar.gz: ffa8e7b471dce27a2708b12e6a2bf27edb5b20d1345656ca026ecc4b263a01a7
+  metadata.gz: 11d5f5f1403cf8388ab7b5b14494a68ff5bdb11c1cd739ae81f78da5b97dbbbc
+  data.tar.gz: d787c2b06cc01478cd764201a204e85312bc9204f8c54b9bdbe2c5e597ac00b1
 SHA512:
-  metadata.gz: f8db6d4211a2dd9f4b9d8a5482b723597958082617e139157c325e8e3b9dddf15216d21bd56daece5d5b3674acdc8e099a22998ad452473a4bf0834774b7a21f
-  data.tar.gz: 13e2cd5b4b10f67f4ecfc1be8732c6a33a7f7a7fdb561b6d8f4f89ae39c74e4b0b153ae10fdf5d650a239534f5b28cd33750aaff90009eeec8877677e765a935
+  metadata.gz: 8dd9c059292d1fba076323f101f0a3445986db3b41ef6099a4f33a583dd1c8bb1dc58e42fba1f35d74fe87eeb1f3fe4253959377cb98c322fa9e22a99c5d43db
+  data.tar.gz: d145d01c73273d4fd1f089b95287fb67adb3c1f6ed12a5c5317a879f230430b760b3abbdf0c27626a2560e612a6823e239ab849ec557a2b412564e2a6bd5ef1c

data/.github/workflows/ci.yml

@@ -29,27 +29,6 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - gemfile: rails_5_0
-            ruby: 2.4
-
-          - gemfile: rails_5_0
-            ruby: 2.5
-
-          - gemfile: rails_5_1
-            ruby: 2.4
-
-          - gemfile: rails_5_2
-            ruby: 2.4
-
-          - gemfile: rails_5_2
-            ruby: 2.6
-
-          - gemfile: rails_6_0
-            ruby: 2.6
-
-          - gemfile: rails_6_0
-            ruby: 2.7
-
           - gemfile: rails_6_1
             ruby: 2.7
 

data/Appraisals

@@ -1,30 +1,3 @@
-appraise "rails-5-0" do
-  gem 'combustion', '~> 0.9.0'
-
-  gem "rails", "~> 5.0.0"
-
-  # rails 5.1+ includes it by default, but rails 5.0 needs it:
-  gem 'rails-ujs', require: false
-
-  # Rails 5 won't work with pg 1.0 even though it doesn't say so
-  gem "pg",  "~> 0.18"
-end
-
-appraise "rails-5-1" do
-  gem 'combustion', '~> 0.9.0'
-
-  gem "rails", "~> 5.1.0"
-
-  gem "pg", "~> 1.0"
-end
-
-appraise "rails-5-2" do
-  gem 'combustion', '~> 0.9.0'
-
-  gem "rails", "~> 5.2.0"
-  gem "pg", "~> 1.0"
-end
-
 appraise "rails-6-0" do
   gem 'combustion', "~> 1.0"
 

data/CHANGELOG.md

@@ -4,7 +4,44 @@ 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.4.1...HEAD)
+## [Unreleased](https://github.com/jrochkind/attr_json/compare/v3.0.0...HEAD)
+
+
+
+## [3.0.0.rc1](https://github.com/jrochkind/attr_json/compare/v1.5.0...v3.0.0.rc1)
+
+While it has some backwards incompat changes, this is expected not to be a challenging upgrade, please let us know by filing an issue if it's giving you troubles, maybe we can make things easier for you. No changes to data stored in your DB should be needed when upgrading, the persisted data should be compatible between 2.x and 3.x.
+
+### Removed
+
+* `AttrJson::Record::Dirty` has been removed, along with the `#attr_json_changes` method. You should now be able to just use standard ActiveRecord dirty tracking with attr_json attributes. https://github.com/jrochkind/attr_json/pull/163 (AttrJson::Record::Dirty was actually badly broken, as reported by @bemueller at https://github.com/jrochkind/attr_json/issues/148)
+
+* The `rails_attribute` param to `attr_json` or `attr_json_config` no longer exists. We now always create rails attributes for AttrJson::Record attributes. https://github.com/jrochkind/attr_json/pull/117 and https://github.com/jrochkind/attr_json/pull/158
+
+### Changed
+
+* We now create Rails Attribute cover for all attr_json attributes, and we do a better job of keeping the Rails attribute values sync'd with attr_json values.   https://github.com/jrochkind/attr_json/pull/117, https://github.com/jrochkind/attr_json/pull/158, and https://github.com/jrochkind/attr_json/pull/163
+
+* Drop support for Rails earlier than 6.0 and ruby earlier than 2.7. https://github.com/jrochkind/attr_json/pull/155 https://github.com/jrochkind/attr_json/pull/174
+
+* Array types now default to an empty array. If you'd like to turn that off, you can use the somewhat odd `default: AttrJson::AttributeDefinition::NO_DEFAULT_PROVIDED` on attribute definiton. Thanks @g13ydson for suggestion. https://github.com/jrochkind/attr_json/pull/161
+
+* time or datetime types used to truncate all fractional seconds to 0. Now they properly allow precision of `ActiveSupport::JSON::Encoding.time_precision` (normally three decimal places, ie milliseconds). And by default the Type::Value's are set to proper precision for cast too. https://github.com/jrochkind/attr_json/pull/173
+
+* AttrJson::Models are serialized without nil values in the hash, for more compact representations. This is only done for attributes without defaults. This behavior can be disabled/altered when specifying the type. https://github.com/jrochkind/attr_json/pull/175
+
+* config default_accepts_nested_attributes will only apply nested attributes to suitable attribute types (array or nested model), the default won't apply to inapplicable types. https://github.com/jrochkind/attr_json/pull/178
+
+### Added
+
+* ActiveRecord-style "timezone-aware attribute" conversion now works properly, in both AttrJson::Record and (similarly) AttrJson::Model. https://github.com/jrochkind/attr_json/pull/164
+
+### Fixed
+
+* the `AttrJson::Type::Array` type used for our array types was not properly tracking in-place mutation changes. Now it is https://github.com/jrochkind/attr_json/pull/163
+
+* Default nested model validation should allow nils in arrays of models. https://github.com/jrochkind/attr_json/pull/177
+
 
 
 ## [1.5.0](https://github.com/jrochkind/attr_json/compare/v1.4.1...v1.5.0)
@@ -17,6 +54,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * AttrJson::Model has some methods conventional in ActiveModel classes: Klass.attribute_types, Klass.attribute_names, and instance.attribute_names. https://github.com/jrochkind/attr_json/pull/169
 
+
+
 ## [1.4.1](https://github.com/jrochkind/attr_json/compare/v1.4.0...v1.4.1)
 
 ### Fixed

data/README.md

@@ -3,10 +3,9 @@
 [![CI Status](https://github.com/jrochkind/attr_json/workflows/CI%20on%20Future%20Rails%20Versions/badge.svg?branch=master)](https://github.com/jrochkind/attr_json/actions?query=workflow%3A%22CI+on+Future+Rails+Versions%22+branch%3Amaster)
 [![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 6.0.x through 7.0.x. Ruby 2.7+.
 
-ActiveRecord attributes stored serialized in a json column, super smooth. For Rails 5.0 through 7.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).
+Typed and cast like Active Record. Supporting [nested models](#nested), [dirty tracking](#ar_attributes), 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).
 
 *Use your database as a typed object store via ActiveRecord, in the same models right next to ordinary ActiveRecord column-backed attributes and associations. Your json-serialized `attr_json` attributes use as much of the existing ActiveRecord architecture as we can.*
 
@@ -18,7 +17,7 @@ has not yet been tested with MySQL.
 ## Basic Use
 
 ```ruby
-# migration
+# migration, default column used is `json_attributes, but this can be changed
 class CreatMyModels < ActiveRecord::Migration[5.0]
   def change
     create_table :my_models do |t|
@@ -30,6 +29,14 @@ class CreatMyModels < ActiveRecord::Migration[5.0]
   end
 end
 
+# An embedded model, if desired
+class LangAndValue
+  include AttrJson::Model
+
+  attr_json :lang, :string, default: "en"
+  attr_json :value, :string
+end
+
 class MyModel < ActiveRecord::Base
    include AttrJson::Record
 
@@ -39,14 +46,37 @@ class MyModel < ActiveRecord::Base
    attr_json :my_integer, :integer
    attr_json :my_datetime, :datetime
 
-   # You can have an _array_ of those things too.
+   # You can have an _array_ of those things too. It will ordinarily default to empty array.
    attr_json :int_array, :integer, array: true
 
    #and/or defaults
-   attr_json :int_with_default, :integer, default: 100
+   attr_json :str_with_default, :string, default: "default value"
+
+   attr_json :embedded_lang_and_val, LangAndValue.to_type
 end
+
+model = MyModel.create!(
+  my_integer: 101,
+  my_datetime: DateTime.new(2001,2,3,4,5,6),
+  embedded_lang_and_val: LangAndValue.new(value: "a sentance in default language english")
+  )
+```
+
+What will get serialized to your `json_attributes` column will look like:
+
+```json
+{
+  "my_integer":101,
+  "my_datetime":"2001-02-03T04:05:06Z",
+  "str_with_default":"default value",
+  "embedded_lang_and_val": {
+    "lang":"en",
+    "value":"a sentance in default language english"
+  }
+}
 ```
 
+
 These attributes have type-casting behavior very much like ordinary ActiveRecord values.
 
 ```ruby
@@ -57,6 +87,8 @@ model.int_array = "12"
 model.int_array # => [12]
 model.my_datetime = "2016-01-01 17:45"
 model.my_datetime # => a Time object representing that, just like AR would cast
+model.embedded_lang_and_val = { value: "val"}
+model.embedded_lang_and_val #=> #<LangAndVal:0x000000010c9a7ad8 @attributes={"value"=>"val"...>
 ```
 
 You can use ordinary ActiveRecord validation methods with `attr_json` attributes.
@@ -64,14 +96,9 @@ You can use ordinary ActiveRecord validation methods with `attr_json` attributes
 All the `attr_json` attributes are serialized to json as keys in a hash, in a database jsonb/json column. By default, in a column `json_attributes`.
 If you look at `model.json_attributes`, you'll see values already cast to their ruby representations.
 
-But one way to see something like what it's really like in the db is to
-save the record and then use the standard Rails `*_before_type_cast` method.
+To see JSON representations, we can use Rails [\*\_before_type_cast](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/BeforeTypeCast.html) methods,  [\*\-in_database](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Dirty.html#method-i-attribute_in_database) and [\*\_for_database] methods (Rails 7.0+ only).
 
-```ruby
-model.save!
-model.json_attributes_before_type_cast
-# => string containing: {"my_integer":12,"int_array":[12],"my_datetime":"2016-01-01T17:45:00.000Z"}
-```
+These methods can all be called on the container `json_attributes` json hash attribute (generally showing serialized JSON to string), or any individual attribute (generally showing in-memory JSON-able object). [This is a bit confusing and possibly not entirely consistent, needs more investigation.]
 
 ## Specifying db column to use
 
@@ -229,6 +256,8 @@ m.attr_jsons_before_type_cast
 
 You can nest AttrJson::Model objects inside each other, as deeply as you like.
 
+For use with Rails forms, you may want to use `attr_json_accepts_nested_attributes_for` (like Rails `accepts_nested_attributes_for`, see doc page on [Use with Forms and Form Builders](https://github.com/jrochkind/attr_json/blob/master/doc_src/forms.md).
+
 ### Model-type defaults
 
 If you want to set a default for an AttrJson::Model type, you should use a proc argument for
@@ -386,44 +415,29 @@ 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`.  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).
 
-<a name="dirty"></a>
-## Dirty tracking
+<a name="ar_attributes"></a>
+## ActiveRecord Attributes and Dirty tracking
 
-Full change-tracking, ActiveRecord::Attributes::Dirty-style, is available in
-Rails 5.1+ on `attr_json`s on your ActiveRecord classes that include
-`AttrJson::Record`, by including `AttrJson::Record::Dirty`.
-Change-tracking methods are available off the `attr_json_changes` method.
+We endeavor to make record-level `attr_json` attributes available as standard ActiveRecord attributes, supporting that full API.
 
-```ruby
-class MyModel < ActiveRecord::Base
-   include AttrJson::Record
-   include AttrJson::Record::Dirty
+Standard [Rails dirty tracking](https://api.rubyonrails.org/classes/ActiveModel/Dirty.html) should work properly with AttrJson::Record attributes! We have a test suite demonstrating.
 
-   attr_json :str, :string
-end
+We actually keep the "canonical" copy of data inside the "container attribute" hash in the ActiveRecord model. This is because this is what will actually get saved when you save. So we have two copies, that we do our best to keep in sync.
 
-model = MyModel.new
-model.str = "old"
-model.save
-model.str = "new"
-
-# All and only "new" style dirty tracking methods (Raisl 5.1+)
-# are available:
-
-model.attr_json_changes.saved_changes
-model.attr_json_changes.changes_to_save
-model.attr_json_changes.saved_change_to_str?
-model.attr_json_changes.saved_change_to_str
-model.attr_json_changes.will_save_change_to_str?
-# etc
+They get out of sync if you are doing unusual things like using the ActiveRecord attribute API directly (like calling `write_attribute` with an attr_json attribute). Even if this happens, mostly you won't notice. But one thing it will effect is dirty tracking.
+
+If you ever need to sync the ActiveRecord attribute values from the AttrJson "canonical" copies, you can call `active_record_model.attr_json_sync_to_rails_attributes`. If you wanted to be 100% sure of dirty tracking, I suppose you could always call this method first. Sorry, this is the best we could do!
+
+Note that ActiveRecord DirtyTracking will give you ruby objects, for instance for nested models, you might get:
+
+```ruby
+record_obj.attribute_change_to_be_saved(:nested_model)
+# => [#<object>, #<object>]
 ```
 
-More options are available, including merging changes from 'ordinary'
-ActiveRecord attributes in. See docs on [Dirty Tracking](./doc_src/dirty_tracking.md)
+If you want to see JSON instead, you could call #as_json on the values. The Rails [\*\_before_type_cast](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/BeforeTypeCast.html) and [\*\-in_database](https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Dirty.html#method-i-attribute_in_database) methods may also be useful.
 
 <a name="why"></a>
 ## Do you want this?
@@ -478,9 +492,7 @@ to prevent overwriting other updates from processes.
 
 ## State of Code, and To Be Done
 
-This code is solid and stable and is being used in production by at least a handful of people, including the primary maintainer, jrochkind.
-
-The project is currently getting very little maintainance -- and is still working reliably through Rails releases. It is tested on edge rails and ruby (and has needed very few if any changes with subsequent releases), and I endeavor to keep it working as Rails keeps releasing.
+This code is solid and stable and is being used in production. If you don't see a lot of activity, it might be because it's stable, rather than abandoned. Check to see if it's passing/supported on recent Rails? We test on "edge" unreleased rails to try to stay ahead of compatibility, and has worked through multiple major Rails verisons with few if any changes needed.
 
 In order to keep the low-maintenace scenario sustainable, I am *very* cautious accepting new features, especially if they increase code complexity at all. Even if you have a working PR, I may be reluctant to accept it. I'm prioritizing sustainability and stability over new features, and so far this is working out well. However, discussion is always welcome! Especially when paired with code (failing tests for the bugfix or feature you want are super helpful on their own!).
 
@@ -494,13 +506,9 @@ This is still mostly a single-maintainer operation, so has all the sustainabilit
 
 ### Possible future features:
 
-* Make AttrJson::Model lean more heavily on ActiveModel::Attributes API that did not fully exist in first version of attr_json [hope for a future attr_json 2.0 release]
-
-* Make AttrJson::Record insist on creating rails cover attributes (no longer optional)  and integrating more fully into rails, including rails dirty tricking, eliminating need for custom dirty tracking implementation. Overall decrease in lines of code. Can use jsonb_accessor as guide for some aspects. [hope for inclusion in future attr_json 2.0 release]
-
-* 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. [update: this is hard, probably not coming soon]
+* Make AttrJson::Model lean more heavily on ActiveModel::Attributes API that did not fully exist in first version of attr_json (perhaps not, see https://github.com/jrochkind/attr_json/issues/18)
 
-* seamless compatibility with ransack [update: not necessarily prioritized]
+* 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. [update: this is hard, probably not coming soon. See https://github.com/jrochkind/attr_json/issues/143]
 
 * Should we give AttrJson::Model a before_serialize hook that you might
   want to use similar to AR before_save?  Should AttrJson::Models

data/attr_json.gemspec

@@ -11,8 +11,8 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{ActiveRecord attributes stored serialized in a json column, super smooth.}
   spec.description   = %q{ActiveRecord attributes stored serialized in a json column, super smooth.
-For Rails 5.0, 5.1, or 5.2. Typed and cast like Active Record. Supporting nested models,
-dirty tracking, some querying (with postgres jsonb contains), and working smoothy with form builders.
+Typed and cast like Active Record. Supporting nested models, dirty tracking, some querying
+(with postgres jsonb contains), and working smoothy with form builders.
 
 Use your database as a typed object store via ActiveRecord, in the same models right next to
 ordinary ActiveRecord column-backed attributes and associations. Your json-serialized attr_json
@@ -40,12 +40,12 @@ attributes use as much of the existing ActiveRecord architecture as we can.}
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.required_ruby_version = '>= 2.4.0'
+  spec.required_ruby_version = '>= 2.6.0'
 
   # 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"] || ENV['CI']
-    spec.add_runtime_dependency "activerecord", ">= 5.0.0", "< 7.1"
+    spec.add_runtime_dependency "activerecord", ">= 6.0.0", "< 7.1"
   end
 
   spec.add_development_dependency "bundler"

data/doc_src/forms.md

@@ -31,7 +31,7 @@ With ordinary rails associations handled in the ordinary Rails way, you use [acc
 You can handle a single or array AttrJson::Model attr_json similarly, but you have to:
 
 * include AttrJson::NestedAttributes in your model, and then
-* use our own similar `attr_json_accepts_nested_attributes_for` instead.  It _always_ has `allow_destroy`, and some of the other `accepts_nested_attributes_for` options also don't apply, see method for full options.
+* use our own similar `attr_json_accepts_nested_attributes_for` instead.  It _always_ has `allow_destroy`, and some of the other `accepts_nested_attributes_for` options also don't apply, see method for full options -- we expect you will usually want to use this with the `reject_if: :all_blank` option to ignore hashes with no non-nil values.
 
 ```ruby
 class Event
@@ -47,7 +47,7 @@ class MyRecord < ActiveRecord::Base
   attr_json :one_event, Event.to_type
   attr_json :many_events, Event.to_type, array: true
 
-  attr_json_accepts_nested_attributes_for :one_event, :many_events
+  attr_json_accepts_nested_attributes_for :one_event, :many_events, reject_if: :all_blank
 end
 
 # In a form template...
@@ -109,19 +109,8 @@ Remember to add `include AttrJson::NestedAttributes` to all your AttrJson::Model
 
 One of the nice parts about [simple_form](https://github.com/plataformatec/simple_form) is how you can just give it `f.input`, and it figures out the right input for you.
 
-AttrJson by default, on an ActiveRecord::Base, doesn't register it's `attr_jsons` in the right way for simple_form to reflect and figure out their types. However, you can ask it to with `rails_attribute: true`.
+AttrJson by default registers  `attr_jsons` as Rails attributes, and provides other appropriate implementations in AttrJson::Model classes, such that simple_form should just work. There are limited CI tests in this project to confirm simple_form stays working.
 
-```ruby
-class SomeRecord < ActiveRecord::Base
-  include AttrJson::Record
-
-  attr_json :my_date, :date, rails_attribute: true
-end
-```
-
-This will use the [ActiveRecord::Base.attribute](http://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html) method to register the attribute and type, and SimpleForm will now be able to automatically look up attribute type just as you expect. (Q: Should we make this default on?)
-
-You don't need to do this in your nested AttrJson::Model classes, SimpleForm will already be able to reflect on their attribute types just fine as is.
 
 ### Arrays of simple attributes
 

data/lib/attr_json/attribute_definition.rb

@@ -34,23 +34,14 @@
 
       @default = if options.has_key?(:default)
         options[:default]
+      elsif options[:array] == true
+        -> { [] }
       else
         NO_DEFAULT_PROVIDED
       end
 
-      if type.is_a? Symbol
-        # ActiveModel::Type.lookup may make more sense, but ActiveModel::Type::Date
-        # seems to have a bug with multi-param assignment. Mostly they return
-        # the same types, but ActiveRecord::Type::Date works with multi-param assignment.
-        #
-        # We pass `adapter: nil` to avoid triggering a db connection.
-        # See: https://github.com/jrochkind/attr_json/issues/41
-        # This is at the "cost" of not using any adapter-specific types... which
-        # maybe preferable anyway?
-        type = ActiveRecord::Type.lookup(type, adapter: nil)
-      elsif ! type.is_a? ActiveModel::Type::Value
-        raise ArgumentError, "Second argument (#{type}) must be a symbol or instance of an ActiveModel::Type::Value subclass"
-      end
+      type = self.class.lookup_type(type)
+
       @type = (options[:array] == true ? AttrJson::Type::Array.new(type) : type)
     end
 
@@ -102,5 +93,50 @@
     def array_type?
       type.is_a? AttrJson::Type::Array
     end
+
+    # Used for figuring out appropriate behavior for nested attribute implementation among
+    # other places. true if type is a nested model, either straight or polymorphic
+    def single_model_type?
+      self.class.single_model_type?(type)
+    end
+
+    def self.single_model_type?(arg_type)
+      arg_type.is_a?(AttrJson::Type::Model) || arg_type.is_a?(AttrJson::Type::PolymorphicModel)
+    end
+
+    # Used for figuring out appropriate behavior in nested attribute implementation among
+    # other places. true if type is an array of things that are not nested models.
+    def array_of_primitive_type?
+      array_type? && !self.class.single_model_type?(type.base_type)
+    end
+
+    # Can look up a symbol to a type, or leave a type alone, or raise if it's neither.
+    # Extracted into a method, so it can be called from AttrJson::Model#attr_json, for
+    # some timezone aware shenanigans.
+    def self.lookup_type(type)
+      if type.is_a? Symbol
+        # ActiveModel::Type.lookup may make more sense, but ActiveModel::Type::Date
+        # seems to have a bug with multi-param assignment. Mostly they return
+        # the same types, but ActiveRecord::Type::Date works with multi-param assignment.
+        #
+        # We pass `adapter: nil` to avoid triggering a db connection.
+        # See: https://github.com/jrochkind/attr_json/issues/41
+        # This is at the "cost" of not using any adapter-specific types... which
+        # maybe preferable anyway?
+        #
+        # AND we add precision for datetime/time types... since we're using Rails json
+        # serializing, we're kind of stuck with this precision in current implementation.
+        lookup_kwargs = { adapter: nil }
+        if type == :datetime || type == :time
+          lookup_kwargs = { precision: ActiveSupport::JSON::Encoding.time_precision }
+        end
+
+        type = ActiveRecord::Type.lookup(type, **lookup_kwargs)
+      elsif !(type.is_a?(ActiveModel::Type::Value) || type.is_a?(ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter))
+        raise ArgumentError, "Second argument (#{type}) must be a symbol or instance of an ActiveModel::Type::Value subclass"
+      end
+      type
+    end
+
   end
 end

data/lib/attr_json/config.rb

@@ -5,18 +5,17 @@ module AttrJson
   class Config
     RECORD_ALLOWED_KEYS = %i{
       default_container_attribute
-      default_rails_attribute
       default_accepts_nested_attributes
     }
 
     MODEL_ALLOWED_KEYS = %i{
       unknown_key
       bad_cast
+      time_zone_aware_attributes
     }
 
     DEFAULTS = {
       default_container_attribute: "json_attributes",
-      default_rails_attribute: false,
       unknown_key: :raise
     }