attr_json 0.2.0 → 1.5.0

data/README.md

@@ -1,9 +1,10 @@
 # AttrJson
-[![Build Status](https://travis-ci.org/jrochkind/attr_json.svg?branch=master)](https://travis-ci.org/jrochkind/attr_json)
+[![CI Status](https://github.com/jrochkind/attr_json/workflows/CI/badge.svg?branch=master)](https://github.com/jrochkind/attr_json/actions?query=workflow%3ACI+branch%3Amaster)
+[![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 5.0, 5.1, or 5.2.
+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).
 
@@ -11,8 +12,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.
 
@@ -85,7 +84,7 @@ class OtherModel < ActiveRecord::Base
   include AttrJson::Record
 
   # as a default for the model
-  self.default_json_container_attribute = :some_other_column_name
+  attr_json_config(default_container_attribute: :some_other_column_name)
 
   # now this is going to serialize to column 'some_other_column_name'
   attr_json :my_int, :integer
@@ -116,7 +115,13 @@ model.json_attributes_before_type_cast # => string containing: {"__my_string":"f
 
 You can of course combine `array`, `default`, `store_key`, and `container_attribute`
 params however you like, with whatever types you like: symbols resolvable
-with `ActiveModel::Type.lookup`, or any [ActiveModel::Type::Value](https://apidock.com/rails/ActiveRecord/Attributes/ClassMethods/attribute) subclass, built-in or custom.
+with `ActiveRecord::Type.lookup`, or any [ActiveModel::Type::Value](https://apidock.com/rails/ActiveRecord/Attributes/ClassMethods/attribute) subclass, built-in or custom.
+
+You can register your custom `ActiveModel::Type::Value` in a Rails initializer or early on in your app boot sequence:
+
+```ruby
+ActiveRecord::Type.register(:my_type, MyActiveModelTypeSubclass)
+```
 
 <a name="querying"></a>
 ## Querying
@@ -134,6 +139,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
@@ -221,6 +229,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).
 
 
@@ -279,6 +307,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
@@ -287,7 +386,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).
 
@@ -299,27 +398,29 @@ 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.
 
-    class MyModel < ActiveRecord::Base
-       include AttrJson::Record
-       include AttrJson::Record::Dirty
-
-       attr_json :str, :string
-    end
-
-    model = MyModel.new
-    model.str = "old"
-    model.save
-    model.str = "new"
+```ruby
+class MyModel < ActiveRecord::Base
+   include AttrJson::Record
+   include AttrJson::Record::Dirty
 
-    # All and only "new" style dirty tracking methods (Raisl 5.1+)
-    # are available:
+   attr_json :str, :string
+end
 
-    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
+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
+```
 
 More options are available, including merging changes from 'ordinary'
 ActiveRecord attributes in. See docs on [Dirty Tracking](./doc_src/dirty_tracking.md)
@@ -377,38 +478,60 @@ 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.
+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.
 
-Backwards incompatible changes are possible before 1.0. Once I tag something 1.0, I'm pretty serious about minimizing backwards incompats.
+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!).
 
-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.
+Feedback of any kind of _very welcome_, please feel free to use the issue tracker. It is hard to get a sense of how many people are actually using this, which is helpful both for my own sense of reward and for anyone to get a sense of the size of the userbase -- feel free to say hi and let us know how you are using it!
 
 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.
+* 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]
 
-* seamless compatibility with ransack
+* 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]
+
+* seamless compatibility with ransack [update: not necessarily prioritized]
 
 * Should we give AttrJson::Model a before_serialize hook that you might
   want to use similar to AR before_save?  Should AttrJson::Models
-  raise on trying to serialize an invalid model?
+  raise on trying to serialize an invalid model? [update: eh, hasn't really come up]
 
 * There are limits to what you can do with just jsonb_contains
   queries. We could support operations like `>`, `<`, `<>`
   as [jsonb_accessor](https://github.com/devmynd/jsonb_accessor),
   even accross keypaths. (At present, you could use a
   before_savee to denormalize/renormalize copy your data into
-  ordinary AR columns/associations for searching. Or perhaps a postgres ts_vector for text searching. Needs to be worked out.)
+  ordinary AR columns/associations for searching. Or perhaps a postgres ts_vector for text searching. Needs to be worked out.) [update: interested, but not necessarily prioritized. This one would be interesting for a third-party PR draft!]
 
 * We could/should probably support `jsonb_order` clauses, even
-  accross key paths, like jsonb_accessor.
+  accross key paths, like jsonb_accessor. [update: interested but not necessarily prioritized]
 
 * Could we make these attributes work in ordinary AR where, same
-  as they do in jsonb_contains? Maybe.
+  as they do in jsonb_contains? Maybe. [update: probably not]
+
+## Development
+
+While `attr_json` depends only on `active_record`, we run integration tests in the context of a full Rails app, in order to test working with simple_form and cocoon, among other things.  (Via [combustion](https://github.com/pat/combustion), with app skeleton at [./spec/internal](./spec/internal)).
+
+At present this does mean that all our automated tests are run in a full Rails environment, which is not great (any suggestions or PR's to fix this while still running integration tests under CI with full Rails app).
+
+Tests are in rspec, run tests simply with `./bin/rspec`.
+
+We use [appraisal](https://github.com/thoughtbot/appraisal) to test with multiple rails versions, including on travis. Locally you can run `bundle exec appraisal rspec` to run tests multiple times for each rails version, or eg `bundle exec appraisal rails-5-1 rspec`. If the `Gemfile` _or_ `Appraisal` file changes, you may need to re-run `bundle exec appraisal install` and commit changes. (Try to put dev dependencies in gemspec instead of Gemfile, but sometimes it gets weird.)
+
+* If you've been switching between rails versions and you get integration test failures, try `rm -rf spec/internal/tmp/cache`. Rails 6 does some things in there apparently not compatible with Rails 5, at least in our setup, and vice versa.
+
+There is a `./bin/console` that will give you a console in the context of attr_json and all it's dependencies, including the combustion rails app, and the models defined there.
 
 ## Acknowledements and Prior Art
 
@@ -430,3 +553,5 @@ Except for the jsonb_contains stuff using postgres jsonb contains operator, I do
 * 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

@@ -40,11 +40,34 @@ 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.add_runtime_dependency "activerecord", ">= 5.0.0", "< 5.3"
+  spec.required_ruby_version = '>= 2.4.0'
 
-  spec.add_development_dependency "bundler", "~> 1.14"
+  # 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"
+  end
+
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", ">= 10.0"
-  spec.add_development_dependency "rspec", "~> 3.5"
-  spec.add_development_dependency "database_cleaner", "~> 1.5"
+  spec.add_development_dependency "rspec", "~> 3.7"
   spec.add_development_dependency "yard-activesupport-concern"
+  spec.add_development_dependency "appraisal", "~> 2.2"
+
+  # Working around annoying issue in selenium 3.x with ruby 3.0.
+  # we don't actually use rexml ourselves. selenium 3 is a dependency
+  # of webdrivers, and tries to use rexml without depending on it
+  # as is needed in ruby 3.
+  #
+  # https://github.com/SeleniumHQ/selenium/issues/9001
+  #
+  # if in the future you can remove this dependecy and still have tests pass
+  # under ruby 3.x, you're good.
+  spec.add_development_dependency "rexml"
+
+  # Used only for Capybara.server in our spec_helper.rb.
+  # webrick is no longer included in ruby 3.0, so has to
+  # be expressed as a dependecy, unless we switch
+  # capybara to use alternate webserver.
+  spec.add_development_dependency "webrick", "~> 1.0"
 end

data/doc_src/dirty_tracking.md

@@ -133,7 +133,7 @@ model.attr_json_changes.merged.changes_to_save
 #    and attr_jsons, as applicable for changes.
 ```
 
-This will ordinarily include your json container attributes (eg `attr_jsons`)
+This will ordinarily include your json container attributes (eg `json_attributes`)
 too, as they will show up in ordinary AR dirty tracking since they are just AR
 columns.
 

data/doc_src/forms.md

@@ -17,25 +17,12 @@ You can look at our [stub app used for integration tests](../spec/internal) as a
 Use with form builder just as you would anything else.
 
     f.text_field :some_string
-    f.datetimme_field :some_datetime
+    f.datetime_field :some_datetime
 
 It _will_ work with the weird rails multi-param setting used for date fields.
 
 Don't forget you gotta handle strong params same as you would for any ordinary attribute.
 
-### Arrays of simple attributes
-
-    attr_json :string_array, :string, array: true
-
-The ActionView+ActiveRecord architecture isn't really setup for an array of "primitives", but you can make it work:
-
-    <% f.object.string_array.each do |str| %>
-      <%= f.text_field(:string_array, value: str, multiple: true) %>
-    <% end %>
-
-That will display, submit and update fine, although when you try to handle reporting validation errors, you'll probably only be able to report on the array, not the specific element.
-
-You may want to [use SimpleForm and create a custom input](https://github.com/plataformatec/simple_form#custom-inputs) to handle arrays of primitives in the way you want. Or you may want to consider an array of AttrJson::Model value types instead -- you can have a model with only one attribute! It can be handled more conventionally, see below.
 
 ### Embedded/Nested AttrJson::Model attributes
 
@@ -81,6 +68,37 @@ It should just work as you are expecting! You have to handle strong params as no
 
 Note that the `AttrJsons::NestedAttributes` module also adds convenient rails-style `build_` methods for you.  In the case above, you get a `build_one_event` and `build_many_event` (note singularization, cause that's how Rails does) method, which you can use much like Rails' `build_to_one_association` or `to_many_assocication.build` methods. You can turn off creation of the build methods by passing `define_build_method: false` to `attr_json_accepts_nested_attributes_for`.
 
+### Shortcuts for attr_json_accepts_nested_attributes_for
+
+You can automatically add the 'accepts nested attributes' call when you define your attribute, including with additional arguments like `reject_if`.
+
+```ruby
+class SomeRecord < ApplicationRecord
+  include AttrJson::Record
+  include AttrJson::NestedAttributes
+
+  attr_json :one_event, Event.to_type, accepts_nested_attributes: true
+  attr_json :many_events, Event.to_type, array: true, accepts_nested_attributes: { reject_if: :all_blank }
+end
+```
+
+You can also set defaults for the whole class:
+
+```ruby
+class SomeRecord < ApplicationRecord
+  include AttrJson::Record
+  include AttrJson::NestedAttributes
+
+  attr_json_config(default_accepts_nested_attributes_for: { reject_if: :all_blank })
+
+  attr_json :one_event, Event.to_type, accepts_nested_attributes: false # override default
+  attr_json :many_events, Event.to_type, array: true
+end
+```
+
+If you're doing a lot of rails-style nested attributes form handling, the above probably makes sense. More convenient than having to do it each time, or repeat every param in another
+long call.
+
 ### Nested multi-level/compound embedded models
 
 A model inside a model inside a model?  Some single and some array? No problem, should just work.
@@ -105,6 +123,50 @@ This will use the [ActiveRecord::Base.attribute](http://api.rubyonrails.org/clas
 
 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
+
+    attr_json :string_array, :string, array: true
+
+The ActionView+ActiveRecord architecture isn't really setup for an array of "primitives", but we can kind of make it work:
+
+    <% f.object.string_array.each do |str| %>
+      <%= f.text_field(:string_array, value: str, multiple: true) %>
+    <% end %>
+
+Or with simple_form, perhaps:
+
+    <%= f.input :string_array do %>
+        <% f.object.string_array.each do |str| %>
+            <%= f.text_field(:string_array, value: str, class: "form-control", multiple: true) %>
+        <% end %>
+    <% end %>
+
+That will display, submit and update fine, although when you try to handle reporting validation errors, you'll probably only be able to report on the array, not the specific element.
+
+The bigger problem is that if you use some javascript to allow people to add/remove elements,
+and they remove _all_ elements, Rails params get no input for this attribute, and instead of setting it to empty array, doesn't touch it as in-memory. This is similar to the problem
+with Rails collection checkboxes, and we can use a similar solution, of a hidden input value
+making sure there's always at least one value.
+
+    <%= f.hidden_field "string_array[]", "" %>
+    <%= f.input :string_array do %>
+        <% f.object.string_array.each do |str| %>
+            <%= f.text_field(:string_array, value: str, class: "form-control", multiple: true) %>
+        <% end %>
+    <% end %>
+
+But now we'll get an extra empty string added on to our array on every submit! We need to filter
+out empty strings. `attr_json_accepts_nested_attributes_for` has an `_attributes=` method implementation when it recognizes an array of primitives, that simply filteres out empty strings. So! With `attr_json_accepts_nested_attributes_for :string_array`:
+
+    <%= f.hidden_field "string_array_attributes[]", "" %>
+    <%= f.input :string_array do %>
+        <% f.object.string_array.each do |str| %>
+            <%= f.text_field(:string_array_attributes, value: str, class: "form-control", multiple: true) %>
+        <% end %>
+    <% end %>
+
+This is definitely getting a bit obtuse. You may want to consider an array of AttrJson::Model value types instead -- you can have a model with only one attribute! It can be handled somewhat more conventionally, as above.
+
 ## Cocoon
 
 [Cocoon](https://github.com/nathanvda/cocoon) is one easy way to implement js-powered add- and remove-field functionality for to-many associations nested on a form with Rails.

data/gemfiles/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_RETRY: "1"

data/gemfiles/rails_5_0.gemfile

@@ -0,0 +1,20 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "combustion", "~> 0.9.0"
+gem "rails", "~> 5.0.0"
+gem "pg", "~> 0.18"
+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"
+gem "rails-ujs", require: false
+
+gemspec path: "../"

data/gemfiles/rails_5_1.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "combustion", "~> 0.9.0"
+gem "rails", "~> 5.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_5_2.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "combustion", "~> 0.9.0"
+gem "rails", "~> 5.2.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_6_0.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "combustion", "~> 1.0"
+gem "rails", ">= 6.0.0", "< 6.1"
+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_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.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+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", "~> 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/lib/attr_json/attribute_definition/registry.rb

@@ -23,7 +23,7 @@ module AttrJson
     # All references in code to "definition" are to a AttrJson::AttributeDefinition instance.
     class Registry
       def initialize(hash = {})
-        @name_to_definition = hash
+        @name_to_definition = hash.dup
         @store_key_to_definition = {}
         definitions.each { |d| store_key_index!(d) }
       end
@@ -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