attr_json 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1033d8a923d5935a8b18e10612883d6756279089
-  data.tar.gz: 8c8b5faf3c24cc27d1d6e382b44c3a63b180826a
+  metadata.gz: 9a4f8e06e4c2ae8894433a2271d782e0aa023d3c
+  data.tar.gz: 4b4e44c1af5d89affd2f2aadde14610eda05aadd
 SHA512:
-  metadata.gz: 57dec15a2438c7d5fa8b2460afc3c3fcedef01aad80a78bf9bb1511b9be68bb6b7166acb7dc9b1aa25d5614c8cd7eb688fc55433ed9bce1fdb8eab8d1061e22d
-  data.tar.gz: 76f0397e93f14b3ca5ff38c01bf4da3b6d4ea11080414d60e7da2126ecffc78926e087245fe82cc8d30a5d8bc6ffa41d2092b096ed8bcb2ad91149960610a85d
+  metadata.gz: 1de9b6472284debc8aa8e60e26d7a8ba2463543b8515248470584ddf06b493d90c9fc4e4e221f244e00421a07703564e3ff3a3d7d6e35bead76adedaeeaabd3a
+  data.tar.gz: cb0567d3031ececf33c64895130cd78bd2295e382547fc3cb4f0ad17072602e6fa71ad24645564abc1ff3ed354a07655140cea7a57cc477e3887470c9e546be2

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.
+ActiveRecord attributes stored serialized in a json column, super smooth. For Rails 5.0, 5.1, or 5.2. 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).
 
@@ -85,7 +85,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
@@ -410,6 +410,16 @@ Except for the jsonb_contains stuff using postgres jsonb contains operator, I do
 * Could we make these attributes work in ordinary AR where, same
   as they do in jsonb_contains? Maybe.
 
+## 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`.
+
+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
 
 * The excellent work [Sean Griffin](https://twitter.com/sgrif) did on ActiveModel::Type

data/attr_json.gemspec

@@ -40,6 +40,8 @@ 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.add_runtime_dependency "activerecord", ">= 5.0.0", "< 5.3"
 
   spec.add_development_dependency "bundler", "~> 1.14"

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,7 +17,7 @@ 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.
 

data/lib/attr_json.rb

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

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

data/lib/attr_json/config.rb

@@ -0,0 +1,45 @@
+module AttrJson
+  # Intentionally non-mutable, to avoid problems with subclass inheritance
+  # and rails class_attribute. Instead, you set to new Config object
+  # changed with {#merge}.
+  class Config
+    RECORD_ALLOWED_KEYS = %i{default_container_attribute}
+    MODEL_ALLOWED_KEYS = %i{unknown_key}
+    DEFAULTS = {
+      default_container_attribute: "json_attributes",
+      unknown_key: :raise
+    }
+
+    (MODEL_ALLOWED_KEYS + RECORD_ALLOWED_KEYS).each do |key|
+      define_method(key) do
+        attributes[key]
+      end
+    end
+
+    attr_reader :mode
+
+    def initialize(options = {})
+      @mode = options.delete(:mode)
+      unless mode == :record || mode == :model
+        raise ArgumentError, "required :mode argument must be :record or :model"
+      end
+      valid_keys = mode == :record ? RECORD_ALLOWED_KEYS : MODEL_ALLOWED_KEYS
+      options.assert_valid_keys(valid_keys)
+
+      options.reverse_merge!(DEFAULTS.slice(*valid_keys))
+
+      @attributes = options
+    end
+
+    # Returns a new Config object, with changes merged in.
+    def merge(changes = {})
+      self.class.new(attributes.merge(changes).merge(mode: mode))
+    end
+
+    protected
+
+    def attributes
+      @attributes
+    end
+  end
+end

data/lib/attr_json/model.rb

@@ -21,12 +21,18 @@ module AttrJson
   # @note Includes ActiveModel::Model whether you like it or not. TODO, should it?
   #
   # You can control what happens if you set an unknown key (one that you didn't
-  # register with `attr_json`) with the class attribute `attr_json_unknown_key`.
+  # register with `attr_json`) with the config attribute `attr_json_config(unknown_key:)`.
   # * :raise (default) raise ActiveModel::UnknownAttributeError
   # * :strip Ignore the unknown key and do not include it, without raising.
   # * :allow Allow the unknown key and it's value to be in the serialized hash,
   #     and written to the database. May be useful for legacy data or columns
   #     that other software touches, to let unknown keys just flow through.
+  #
+  #        class Something
+  #          include AttrJson::Model
+  #          attr_json_config(unknown_key: :ignore)
+  #          #...
+  #        end
   module Model
     extend ActiveSupport::Concern
 
@@ -41,13 +47,30 @@ module AttrJson
 
       class_attribute :attr_json_registry, instance_accessor: false
       self.attr_json_registry = ::AttrJson::AttributeDefinition::Registry.new
-
-      # :raise, :strip, :allow. :raise is default. Is there some way to enforce this.
-      class_attribute :attr_json_unknown_key
-      self.attr_json_unknown_key ||= :raise
     end
 
     class_methods do
+      def attr_json_config(new_values = {})
+        if new_values.present?
+          # get one without new values, then merge new values into it, and
+          # set it locally for this class.
+          @attr_json_config = attr_json_config.merge(new_values)
+        else
+          if instance_variable_defined?("@attr_json_config")
+            # we have a custom one for this class, return it.
+            @attr_json_config
+          elsif superclass.respond_to?(:attr_json_config)
+            # return superclass without setting it locally, so changes in superclass
+            # will continue effecting us.
+            superclass.attr_json_config
+          else
+            # no superclass, no nothing, set it to blank one.
+            @attr_json_config = Config.new(mode: :model)
+          end
+        end
+      end
+
+
       # Like `.new`, but translate store keys in hash
       def new_from_serializable(attributes = {})
         attributes = attributes.transform_keys do |key|
@@ -247,7 +270,7 @@ module AttrJson
 
 
     def _attr_json_write_unknown_attribute(key, value)
-      case attr_json_unknown_key
+      case self.class.attr_json_config.unknown_key
       when :strip
         # drop it, no-op
       when :allow

data/lib/attr_json/record.rb

@@ -17,8 +17,6 @@ module AttrJson
   module Record
     extend ActiveSupport::Concern
 
-    DEFAULT_CONTAINER_ATTRIBUTE = :json_attributes
-
     included do
       unless self < ActiveRecord::Base
         raise TypeError, "AttrJson::Record can only be used with an ActiveRecord::Base model. #{self} does not appear to be one. Are you looking for ::AttrJson::Model?"
@@ -26,12 +24,45 @@ module AttrJson
 
       class_attribute :attr_json_registry, instance_accessor: false
       self.attr_json_registry = AttrJson::AttributeDefinition::Registry.new
-
-      class_attribute :default_json_container_attribute, instance_acessor: false
-      self.default_json_container_attribute ||= DEFAULT_CONTAINER_ATTRIBUTE
     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
+      # rails class_attribute's are used.
+      #
+      # @example access config
+      #   SomeClass.attr_json_config
+      #
+      # @example set config variables
+      #    class SomeClass < ActiveRecordBase
+      #       include JsonAttribute::Record
+      #
+      #       attr_json_config(default_container_attribute: "some_column")
+      #    end
+      # TODO make Model match please.
+      def attr_json_config(new_values = {})
+        if new_values.present?
+          # get one without new values, then merge new values into it, and
+          # set it locally for this class.
+          @attr_json_config = attr_json_config.merge(new_values)
+        else
+          if instance_variable_defined?("@attr_json_config")
+            # we have a custom one for this class, return it.
+            @attr_json_config
+          elsif superclass.respond_to?(:attr_json_config)
+            # return superclass without setting it locally, so changes in superclass
+            # will continue effecting us.
+            superclass.attr_json_config
+          else
+            # no superclass, no nothing, set it to blank one.
+            @attr_json_config = Config.new(mode: :record)
+          end
+        end
+      end
+
+
+
       # Type can be a symbol that will be looked up in `ActiveModel::Type.lookup`,
       # or an ActiveModel:::Type::Value).
       #
@@ -47,9 +78,9 @@ module AttrJson
       # @option options [String,Symbol] :store_key (nil) Serialize to JSON using
       #   given store_key, rather than name as would be usual.
       #
-      # @option options [Symbol,String] :container_attribute (self.default_json_container_attribute) The real
+      # @option options [Symbol,String] :container_attribute (attr_json_config.default_container_attribute, normally `json_attributes`) The real
       #   json(b) ActiveRecord attribute/column to serialize as a key in. Defaults to
-      #  `self.default_json_container_attribute`, which defaults to `:attr_jsons`
+      #  `attr_json_config.default_container_attribute`, which defaults to `:json_attributes`
       #
       # @option options [Boolean] :validate (true) Create an ActiveRecord::Validations::AssociatedValidator so
       #   validation errors on the attributes post up to self.
@@ -62,7 +93,7 @@ module AttrJson
         options = {
           rails_attribute: false,
           validate: true,
-          container_attribute: self.default_json_container_attribute
+          container_attribute: self.attr_json_config.default_container_attribute
         }.merge!(options)
         options.assert_valid_keys(AttributeDefinition::VALID_OPTIONS + [:validate, :rails_attribute])
         container_attribute = options[:container_attribute]
@@ -74,9 +105,15 @@ module AttrJson
         # only if it hasn't already been done. WARNING we are using internal
         # Rails API here, but only way to do this lazily, which I thought was
         # worth it. On the other hand, I think .attribute is idempotent, maybe we don't need it...
+        #
+        # We set default to empty hash, because that 'tricks' AR into knowing any
+        # application of defaults is a change that needs to be saved.
         unless attributes_to_define_after_schema_loads[container_attribute.to_s] &&
-               attributes_to_define_after_schema_loads[container_attribute.to_s].first.is_a?(AttrJson::Type::ContainerAttribute)
-            attribute container_attribute.to_sym, AttrJson::Type::ContainerAttribute.new(self, container_attribute)
+               attributes_to_define_after_schema_loads[container_attribute.to_s].first.is_a?(AttrJson::Type::ContainerAttribute) &&
+               attributes_to_define_after_schema_loads[container_attribute.to_s].first.model == self
+           # If this is already defined, but was for superclass, we need to define it again for
+           # this class.
+           attribute container_attribute.to_sym, AttrJson::Type::ContainerAttribute.new(self, container_attribute), default: -> { {} }
         end
 
         self.attr_json_registry = attr_json_registry.with(

data/lib/attr_json/record/dirty.rb

@@ -137,20 +137,20 @@ module AttrJson
         end
 
         def saved_changes
-          saved_changes = model.saved_changes
-          return {} if saved_changes == {}
+          original_saved_changes = model.saved_changes
+          return {} if original_saved_changes.blank?
 
           json_attr_changes = registry.definitions.collect do |definition|
-            if container_change = saved_changes[definition.container_attribute]
-              old_v = container_change[0][definition.store_key]
-              new_v = container_change[1][definition.store_key]
+            if container_change = original_saved_changes[definition.container_attribute]
+              old_v = container_change.dig(0, definition.store_key)
+              new_v = container_change.dig(1, definition.store_key)
               if old_v != new_v
                 [ definition.name.to_s, formatted_before_after(old_v, new_v, definition) ]
               end
             end
           end.compact.to_h
 
-          prepared_changes(json_attr_changes, saved_changes)
+          prepared_changes(json_attr_changes, original_saved_changes)
         end
 
         def saved_changes?
@@ -198,21 +198,21 @@ module AttrJson
         end
 
         def changes_to_save
-          changes_to_save = model.changes_to_save
+          original_changes_to_save = model.changes_to_save
 
-          return {} if changes_to_save == {}
+          return {} if original_changes_to_save.blank?
 
           json_attr_changes = registry.definitions.collect do |definition|
-            if container_change = changes_to_save[definition.container_attribute]
-              old_v = container_change[0][definition.store_key]
-              new_v = container_change[1][definition.store_key]
+            if container_change = original_changes_to_save[definition.container_attribute]
+              old_v = container_change.dig(0, definition.store_key)
+              new_v = container_change.dig(1, definition.store_key)
               if old_v != new_v
                 [ definition.name.to_s, formatted_before_after(old_v, new_v, definition) ]
               end
             end
           end.compact.to_h
 
-          prepared_changes(json_attr_changes, changes_to_save)
+          prepared_changes(json_attr_changes, original_changes_to_save)
         end
 
         def has_changes_to_save?

data/lib/attr_json/type/container_attribute.rb

@@ -38,19 +38,30 @@ module AttrJson
           [key, attr_def ? attr_def.serialize(value) : value]
         end.to_h)
       end
-      def deserialize(v)
-        h = super || {}
+
+      # optional with_defaults arg is our own, not part of ActiveModel::Type API,
+      # used by {#changed_in_place?} so we can consider default application to
+      # be a change.
+      def deserialize(v, with_defaults: true)
+        h = super(v) || {}
         model.attr_json_registry.definitions.each do |attr_def|
           next unless container_attribute.to_s == attr_def.container_attribute.to_s
 
           if h.has_key?(attr_def.store_key)
             h[attr_def.store_key] = attr_def.deserialize(h[attr_def.store_key])
-          elsif attr_def.has_default?
+          elsif with_defaults && attr_def.has_default?
             h[attr_def.store_key] = attr_def.provide_default!
           end
         end
         h
       end
+
+      # Just like superclass, but we tell deserialize to NOT apply defaults,
+      # so we can consider default-application to be a change.
+      def changed_in_place?(raw_old_value, new_value)
+        deserialize(raw_old_value, with_defaults: false) != new_value
+      end
+
     end
   end
 end

data/lib/attr_json/version.rb

@@ -1,3 +1,3 @@
 module AttrJson
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attr_json
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jonathan Rochkind
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-05-04 00:00:00.000000000 Z
+date: 2018-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -133,6 +133,7 @@ files:
 - lib/attr_json.rb
 - lib/attr_json/attribute_definition.rb
 - lib/attr_json/attribute_definition/registry.rb
+- lib/attr_json/config.rb
 - lib/attr_json/model.rb
 - lib/attr_json/model/cocoon_compat.rb
 - lib/attr_json/nested_attributes.rb
@@ -163,7 +164,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="