attr_json 0.2.0 → 1.5.0

data/lib/attr_json/attribute_definition.rb

@@ -12,7 +12,9 @@
     attr_reader :name, :type, :original_args, :container_attribute
 
     # @param name [Symbol,String]
-    # @param type [Symbol,ActiveModel::Type::Value]
+    # @param type [Symbol,ActiveModel::Type::Value] Symbol is looked up in
+    #   ActiveRecord::Type.lookup, but with `adapter: nil` for no custom
+    #   adapter-specific lookup.
     #
     # @option options store_key [Symbol,String]
     # @option options container_attribute [Symbol,ActiveModel::Type::Value]
@@ -40,7 +42,12 @@
         # 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.
-        type = ActiveRecord::Type.lookup(type)
+        #
+        # 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
@@ -71,6 +78,12 @@
       @default != NO_DEFAULT_PROVIDED
     end
 
+    # Can be value or proc!
+    def default_argument
+      return nil unless has_default?
+      @default
+    end
+
     def provide_default!
       unless has_default?
         raise ArgumentError.new("This #{self.class.name} does not have a default defined!")

data/lib/attr_json/config.rb

@@ -0,0 +1,55 @@
+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
+      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
+    }
+
+    (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

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

@@ -16,7 +16,11 @@ module AttrJson
 
       def assign_nested_attributes(attributes)
         if attr_def.array_type?
-          assign_nested_attributes_for_model_array(attributes)
+          if attr_def.type.base_type_primitive?
+            assign_nested_attributes_for_primitive_array(attributes)
+          else
+            assign_nested_attributes_for_model_array(attributes)
+          end
         else
           assign_nested_attributes_for_single_model(attributes)
         end
@@ -38,6 +42,27 @@ module AttrJson
         end
       end
 
+
+      # Implementation for an `#{attribute_name}_attributes=` method, when the attr_json
+      # attribute in question is recognized as an array of primitive values (not nested models)
+      #
+      # Really just exists to filter out blank/empty strings with reject_if.
+      #
+      # It will insist on filtering out empty strings and nils from arrays (ignores reject_if argument),
+      # since that's the only reason to use it. It will respect limit argument.
+      #
+      # Filtering out empty strings can be convenient for using a hidden field in a form to
+      # make sure an empty array gets set if all individual fields are removed from form using
+      # cocoon-like javascript.
+      def assign_nested_attributes_for_primitive_array(attributes_array)
+        options = nested_attributes_options[attr_name]
+        check_record_limit!(options[:limit], attributes_array)
+
+        attributes_array = attributes_array.reject { |value| value.blank? }
+
+        model_send("#{attr_name}=", attributes_array)
+      end
+
       # Copied with signficant modifications from:
       # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/nested_attributes.rb#L407
       def assign_nested_attributes_for_single_model(attributes)

data/lib/attr_json/nested_attributes.rb

@@ -29,6 +29,11 @@ module AttrJson
       # * _allow_destroy_, no such option. Effectively always true, doesn't make sense to try to gate this with our implementation.
       # * _update_only_, no such option. Not really relevant to this architecture where you're embedded models have no independent existence.
       #
+      # If called on an array of 'primitive' (not AttrJson::Model) objects, it will do a kind of weird
+      # thing where it creates an `#{attribute_name}_attributes=` method that does nothing
+      # but filter out empty strings and nil values. This can be convenient in hackily form
+      # handling array of primitives, see guide doc on forms.
+      #
       # @overload attr_json_accepts_nested_attributes_for(define_build_method: true, reject_if: nil, limit: nil)
       #   @param define_build_method [Boolean] Default true, provide `build_attribute_name`
       #     method that works like you expect. [Cocoon](https://github.com/nathanvda/cocoon),
@@ -74,7 +79,8 @@ module AttrJson
             end
           end
 
-          if options[:define_build_method]
+          # No build method for our wacky array of primitive type.
+          if options[:define_build_method] && !(attr_def.array_type? && attr_def.type.base_type_primitive?)
             _attr_jsons_module.module_eval do
               build_method_name = "build_#{attr_name.to_s.singularize}"
               if method_defined?(build_method_name)

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

data/lib/attr_json/record/query_builder.rb

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

data/lib/attr_json/record/query_scopes.rb

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