attr_json 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dadc04fb081fee0b326eaff03f569f15d745948119959e2a8eb5d91b690dec38
-  data.tar.gz: fb6a28e048e03822432e63a7205d0242d218ddace88dd0566624517c3a5454b5
+  metadata.gz: eb4f8078039ec81cc25e7a95318ff5e42cb5bf85a955b40326f60f9022af16a2
+  data.tar.gz: 635f08ce5fa34ce45dfdd5256ae0e81fdcc2d455f4525bad5f71f5b0c4391c6b
 SHA512:
-  metadata.gz: 6048863f54826dc166200400a93cdfdb91055ddba960d6d2b8587077eafda5e3058e49d030f60c3eb05f74ba2ea99512c087c403f8eb0a18e4dd45c4f7929bee
-  data.tar.gz: afafb7cf57637cce5f99c3afacd38bc802aca8c5e60b9c0cd1adebc08a482b064ce5a7398c44507b612f94691fd8362bba9cb00d13f8d14603524e235e93b617
+  metadata.gz: 22c35f674c7b5f3a4e91f348d20439df3e8fe175ca5d3c8938720a5e71739df2474cdddd5fdab5f0527f8751ed0fb6dee11ba7f75889c143daca92bd84afc86b
+  data.tar.gz: 636628f0083dd61c869de5b9eb65a0c11988560e26d5dcd8e822759788bdac4bdb3c6f0359e2257867ac91a61721fda32df54a36f51a001450ef883289be433a

data/.github/workflows/ci.yml

@@ -18,7 +18,10 @@ jobs:
   tests:
     services:
       db:
-        image: postgres:9.4
+        # used to be 9.4, should work on 9.4, only moved to 10.0
+        # because of rails 7.1 bug (rails intends to support 9 too!)
+        # https://github.com/jrochkind/attr_json/issues/211
+        image: postgres:10.0
         env:
           POSTGRES_USER: postgres
           POSTGRES_PASSWORD: postgres
@@ -49,7 +52,7 @@ jobs:
 
           - gemfile: rails_7_0
             ruby: 3.2
-            
+
           - gemfile: rails_7_1
             ruby: '3.0'
 

data/CHANGELOG.md

@@ -4,7 +4,7 @@ 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/v2.2.0...HEAD)
+## [Unreleased](https://github.com/jrochkind/attr_json/compare/v2.3.0...HEAD)
 
 ### Fixed
 
@@ -22,6 +22,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 *
 
+### Changed
+
+*
+
+*
+
+*
+
+## [2.3.0]((https://github.com/jrochkind/attr_json/compare/v2.2.0...v2.3.0))
+
+
+### Changed
+
+* Avoid private ActiveRecord API when lazily registering container attributes. (Compat with Rails post 7.1) https://github.com/jrochkind/attr_json/pull/214
+
+* Freeze more strings to reduce String allocations https://github.com/jrochkind/attr_json/pull/216
+
 ## [2.2.0](https://github.com/jrochkind/attr_json/compare/v2.1.0...v2.2.0)
 
 ### Added

data/lib/attr_json/attribute_definition/registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/attribute_definition'
 
 module AttrJson
@@ -25,7 +27,10 @@ module AttrJson
       def initialize(hash = {})
         @name_to_definition = hash.dup
         @store_key_to_definition = {}
-        definitions.each { |d| store_key_index!(d) }
+
+        @name_to_definition.values.each { |d| store_key_index!(d) }
+
+        @container_attributes_registered = Hash.new { Set.new }
       end
 
       def fetch(key, *args, &block)
@@ -46,12 +51,13 @@ module AttrJson
 
       # Can return nil if none found.
       def store_key_lookup(container_attribute, store_key)
-        @store_key_to_definition[container_attribute.to_s] &&
-          @store_key_to_definition[container_attribute.to_s][store_key.to_s]
+        @store_key_to_definition[AttrJson.efficient_to_s(container_attribute)] &&
+          @store_key_to_definition[AttrJson.efficient_to_s(container_attribute)][AttrJson.efficient_to_s(store_key)]
       end
 
       def definitions
-        @name_to_definition.values
+        # Since we are immutable, we can cache this to avoid allocation in a hot spot
+        @stored_definitions ||= @name_to_definition.values
       end
 
       # Returns all registered attributes as an array of symbols
@@ -60,7 +66,7 @@ module AttrJson
       end
 
       def container_attributes
-        @store_key_to_definition.keys.collect(&:to_s)
+        @store_key_to_definition.keys.collect { |s| AttrJson.efficient_to_s(s) }
       end
 
       # This is how you register additional definitions, as a non-mutating
@@ -73,6 +79,32 @@ module AttrJson
         end
       end
 
+
+      # We need to lazily set the container type only the FIRST time
+      #
+      # While also avoiding this triggering ActiveRecord to actually go to DB,
+      # we don't want DB connection forced on boot, that's a problem for many apps,
+      # including that may not have a DB connection in initial development.
+      # (#type_for_attribute forces DB connection)
+      #
+      # AND we need to call container attriubte on SUB-CLASS AGAIN, iff sub-class
+      # has any of it's own new registrations, to make sure we get the right type in
+      # sub-class!
+      #
+      # So we just keep track of whether we've registered ourselves, so we can
+      # first time we need to.
+      #
+      # While current implementation is simple, this has ended up a bit fragile,
+      # a different API that doesn't require us to do this implicitly lazily
+      # might be preferred! But this is what we got for now.
+      def register_container_attribute(attribute_name:, model:)
+        @container_attributes_registered[attribute_name.to_sym] << model
+      end
+
+      def container_attribute_registered?(attribute_name:, model:)
+         @container_attributes_registered[attribute_name.to_sym].include?(model)
+      end
+
       protected
 
       def add!(definition)
@@ -81,17 +113,19 @@ module AttrJson
         end
         @name_to_definition[definition.name.to_sym] = definition
         store_key_index!(definition)
+
+        @stored_definitions = nil
       end
 
       def store_key_index!(definition)
-        container_hash = (@store_key_to_definition[definition.container_attribute.to_s] ||= {})
+        container_hash = (@store_key_to_definition[AttrJson.efficient_to_s(definition.container_attribute)] ||= {})
 
-        if container_hash.has_key?(definition.store_key.to_s)
-          existing = container_hash[definition.store_key.to_s]
+        if container_hash.has_key?(AttrJson.efficient_to_s(definition.store_key))
+          existing = container_hash[AttrJson.efficient_to_s(definition.store_key)]
           raise ArgumentError, "Can't add, store key `#{definition.store_key}` conflicts with existing attribute: #{existing.original_args}"
         end
 
-        container_hash[definition.store_key.to_s] = definition
+        container_hash[AttrJson.efficient_to_s(definition.store_key)] = definition
       end
     end
   end

data/lib/attr_json/attribute_definition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
  require 'attr_json/type/array'
 
  module AttrJson
@@ -62,7 +64,7 @@
     end
 
     def store_key
-      (@store_key || name).to_s
+      AttrJson.efficient_to_s(@store_key || name)
     end
 
     def has_default?

data/lib/attr_json/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/concern'
 require 'active_model/type'
 
@@ -136,8 +138,8 @@ module AttrJson
       def new_from_serializable(attributes = {})
         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)
-            key = attribute_def.name.to_s
+          if attribute_def = self.attr_json_registry.store_key_lookup("".freeze, AttrJson.efficient_to_s(key))
+            key = AttrJson.efficient_to_s(attribute_def.name)
           end
 
           attr_type = self.attr_json_registry.has_attribute?(key) && self.attr_json_registry.type_for_attribute(key)
@@ -184,7 +186,7 @@ module AttrJson
 
       # 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
+        attribute_names.collect { |name| [AttrJson.efficient_to_s(name), attr_json_registry.type_for_attribute(name)]}.to_h
       end
 
 
@@ -225,11 +227,11 @@ module AttrJson
 
         _attr_jsons_module.module_eval do
           define_method("#{name}=") do |value|
-            _attr_json_write(name.to_s, value)
+            _attr_json_write(AttrJson.efficient_to_s(name), value)
           end
 
           define_method("#{name}") do
-            attributes[name.to_s]
+            attributes[AttrJson.efficient_to_s(name)]
           end
         end
       end
@@ -427,7 +429,7 @@ module AttrJson
 
     def fill_in_defaults!
       self.class.attr_json_registry.definitions.each do |definition|
-        if definition.has_default? && !attributes.has_key?(definition.name.to_s)
+        if definition.has_default? && !attributes.has_key?(AttrJson.efficient_to_s(definition.name))
           self.send("#{definition.name.to_s}=", definition.provide_default!)
         end
       end
@@ -435,10 +437,10 @@ module AttrJson
 
     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)
+        attributes[AttrJson.efficient_to_s(key)] = attribute_def.cast(value)
       else
         # TODO, strict mode, ignore, raise, allow.
-        attributes[key.to_s] = value
+        attributes[AttrJson.efficient_to_s(key)] = value
       end
     end
 

data/lib/attr_json/nested_attributes/builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module NestedAttributes
     # Implementation of `build_` methods, called by the `build_` methods

data/lib/attr_json/nested_attributes/multiparameter_attribute_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module NestedAttributes
     # Rails has a weird "multiparameter attribute" thing, that is used for simple_form's

data/lib/attr_json/nested_attributes/writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/nested_attributes/multiparameter_attribute_writer'
 
 module AttrJson

data/lib/attr_json/nested_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/nested_attributes/builder'
 require 'attr_json/nested_attributes/writer'
 

data/lib/attr_json/record/query_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Record
     # Implementation class called by #jsonb_contains scope method. Ordinarily

data/lib/attr_json/record/query_scopes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/record/query_builder'
 
 module AttrJson

data/lib/attr_json/record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'attr_json/attribute_definition'
 require 'attr_json/attribute_definition/registry'
 require 'attr_json/type/container_attribute'
@@ -160,22 +162,14 @@ module AttrJson
         options.assert_valid_keys(AttributeDefinition::VALID_OPTIONS + [:validate, :accepts_nested_attributes])
         container_attribute = options[:container_attribute]
 
-        # TODO arg check container_attribute make sure it exists. Hard cause
-        # schema isn't loaded yet when class def is loaded. Maybe not.
 
-        # Want to lazily add an attribute cover to the json container attribute,
-        # 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) &&
-               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.
+        # Make sure to "lazily" register attribute for *container* class if this is the first time
+        # this container attribute hsa been encountered for this specific class. The registry
+        # helps us keep track. Kinda messy, in future we may want a more explicit API
+        # that does not require us to implicitly track first-time per-container.
+        unless self.attr_json_registry.container_attribute_registered?(model: self, attribute_name: container_attribute.to_sym)
            attribute container_attribute.to_sym, AttrJson::Type::ContainerAttribute.new(self, container_attribute), default: -> { {} }
+           self.attr_json_registry.register_container_attribute(model: self, attribute_name: container_attribute.to_sym)
         end
 
         self.attr_json_registry = attr_json_registry.with(

data/lib/attr_json/serialization_coder_from_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
 
   # A little wrapper to provide an object that provides #dump and #load method for use

data/lib/attr_json/type/array.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # You can wrap any ActiveModel::Type in one of these, and it's magically

data/lib/attr_json/type/container_attribute.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # A type that gets applied to the AR container/store jsonb attribute,

data/lib/attr_json/type/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # An ActiveModel::Type representing a particular AttrJson::Model

data/lib/attr_json/type/polymorphic_model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module AttrJson
   module Type
     # AttrJson::Type::PolymorphicModel can be used to create attr_json attributes

data/lib/attr_json/version.rb

@@ -1,3 +1,3 @@
 module AttrJson
-  VERSION = "2.2.0"
+  VERSION = "2.3.0"
 end

data/lib/attr_json.rb

@@ -10,5 +10,25 @@ require 'attr_json/record/query_scopes'
 require 'attr_json/type/polymorphic_model'
 
 module AttrJson
-
+  # We need to convert Symbols to strings a lot at present -- ActiveRecord does too, so
+  # not too suprrising.
+  #
+  # In Rails 3.0 and above, we can use Symbol#name to get a frozen string back
+  # and avoid extra allocations. https://bugs.ruby-lang.org/issues/16150
+  #
+  # Ruby 2.7 doens't yet have it though. As long as we are supporting ruby 2.7,
+  # we'll just check at runtime to keep this lean
+  if RUBY_VERSION.split('.').first.to_i >= 3
+    def self.efficient_to_s(obj)
+      if obj.kind_of?(Symbol)
+        obj.name
+      else
+        obj.to_s
+      end
+    end
+  else
+    def self.efficient_to_s(obj)
+      obj.to_s
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: attr_json
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Jonathan Rochkind
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-05 00:00:00.000000000 Z
+date: 2023-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -207,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.21
 signing_key:
 specification_version: 4
 summary: ActiveRecord attributes stored serialized in a json column, super smooth.