panko_serializer 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 933667f4549f885acffbbd822422f568a0b5ba737b05bc2f333299e9d2ba3085
-  data.tar.gz: 20f6302ef51561dce29e0608ad2a22334c0d8625f62cf815d7d31fb9a30e49f6
+  metadata.gz: d979b96c2fb100900b8ee11656f8a9d8d78eecb28b58d3d6c26e1db63c34c829
+  data.tar.gz: 43f9c3badbeff01f514923de689c6fb300b72db18e3d0a751684009afcf559db
 SHA512:
-  metadata.gz: a520312057f8f41687f6051faff37eb2061ca2b4d4939d54631b52250e120277c920b455480ca0977d4112a7f80200b960948c85895377574f0b324c1be976ac
-  data.tar.gz: '0779d69d34164e6d6fd361909bc1a4395c047f80190f61753dbcff817bef8ddd415278dfccd863bfff53ff0d5558dce6b6137d8c47e3cd8a989ec7cac9860761'
+  metadata.gz: 6ec1e557bc67c0bcb2743582fd93a18410b05161c3ea760943cc33e65f1c571f7a3d0d99bdb25870a8a87177e19bdc652cea15a4d5da56e6b087df56bf80640f
+  data.tar.gz: 792a57264e47d36207515fe6c4d2bdd9d4fab7ba0e34fe8b6b558e997ae691897b78e36a07306075438fe680f667b6d67c71f3d701301c7c5abc353893388be4

data/lib/panko/code_gen/active_record/access_classifier.rb

@@ -4,7 +4,7 @@ module Panko::CodeGen
   module ActiveRecord
     # Columns read through AR's own generated reader classify as +:column+.
     # A user override of a column reader classifies as +:method+, so the
-    # Specialized path never bypasses it. Call +DefineAttributeMethods.ensure!+
+    # Specialized path never bypasses it. Call +define_attribute_methods+
     # first, or non-column readers (+attribute+, +alias_attribute+) raise +UnknownSourceError+.
     module AccessClassifier
       def self.classify(klass, source)

data/lib/panko/code_gen/compiler.rb

@@ -5,28 +5,34 @@ module Panko::CodeGen
     # A table, not +to_s.upcase+: the +:hash+ suffix is +Hash+, not +HASH+.
     OUTPUT_SUFFIXES = {json: "JSON", hash: "Hash"}.freeze
 
-    def initialize(descriptor, output:, config:, validator: Validators::Validator.new,
-      generator: Generator.new)
+    def initialize(descriptor, output:, config:)
       @descriptor = descriptor
       @output = output
       @config = config
-      @validator = validator
-      @generator = generator
-      @cache = CompileCache.new
+      # Identity, not equality: equal but distinct Descriptors compile to separate classes.
+      @compiled = {}.compare_by_identity
     end
 
     def compile
-      @validator.validate(@descriptor, output: @output, config: @config)
-      source = @generator.emit(@descriptor, output: @output, config: @config)
+      Validators::Validator.validate(@descriptor, output: @output, config: @config)
+      source = Generator.emit(@descriptor, output: @output, config: @config)
       namespace = Class.new
       bind_anonymous_parents(namespace)
-      namespace.module_eval(source, synthetic_path, 1)
-      cache_descendants(@descriptor, namespace)
-      @cache.get(@descriptor)
+      evaluate(namespace, source)
+      collect_classes(@descriptor, namespace)
+      @compiled.fetch(@descriptor)
     end
 
     private
 
+    # SyntaxError is a ScriptError, which a bare +rescue+ (Panko.compile_all, the
+    # auto-specialization fallback) does not catch.
+    def evaluate(namespace, source)
+      namespace.module_eval(source, synthetic_path, 1)
+    rescue SyntaxError => error
+      raise CompileError, "#{@descriptor.name}: generated #{@output} source does not parse: #{error.message}"
+    end
+
     # A Hash, not one constant per class: +const_set+ gives an anonymous class a name,
     # which would change +parent_class.name+ for the next compile.
     def bind_anonymous_parents(namespace)
@@ -43,13 +49,12 @@ module Panko::CodeGen
       "(#{GENERATOR_NAME}: #{@descriptor.name}/#{@output})"
     end
 
-    def cache_descendants(descriptor, namespace)
-      @cache.lookup_or_compile(descriptor) do
-        klass = namespace.const_get(:"#{descriptor.name}_#{OUTPUT_SUFFIXES.fetch(@output)}")
-        @cache.set(descriptor, klass)
-        descriptor.associations.each do |assoc|
-          assoc.descriptors.each { |child| cache_descendants(child, namespace) }
-        end
+    # Records the class before descending, so a cycle back to this Descriptor stops here.
+    def collect_classes(descriptor, namespace)
+      return if @compiled.key?(descriptor)
+      @compiled[descriptor] = namespace.const_get(:"#{descriptor.name}_#{OUTPUT_SUFFIXES.fetch(@output)}")
+      descriptor.associations.each do |assoc|
+        assoc.descriptors.each { |child| collect_classes(child, namespace) }
       end
     end
   end

data/lib/panko/code_gen/config.rb

@@ -8,7 +8,6 @@ module Panko::CodeGen
   # - +supports_root_key+: when +false+, passing +root_key:+ raises +ArgumentError+.
   # - +json_column_emit+ (JSON mode, Specialized path only): +:wire_format+ writes the
   #   stored bytes after a well-formedness check, +:html_safe+ the typed value, escaped.
-  # - +pool_writer+: no effect in Hash output mode.
   # - +guarded_model+: a record of another class goes to the generic body.
   #   Needs a named +descriptor.model+.
   Config = Data.define(
@@ -17,7 +16,6 @@ module Panko::CodeGen
     :hash_record_key_type,
     :hash_output_key_type,
     :json_column_emit,
-    :pool_writer,
     :guarded_model
   )
 
@@ -27,7 +25,6 @@ module Panko::CodeGen
     hash_record_key_type: :string,
     hash_output_key_type: :string,
     json_column_emit: :wire_format,
-    pool_writer: true,
     guarded_model: false
   }.freeze
 
@@ -50,7 +47,6 @@ module Panko::CodeGen
       validate_enum!(:hash_record_key_type, values[:hash_record_key_type])
       validate_enum!(:hash_output_key_type, values[:hash_output_key_type])
       validate_json_column_emit!(values[:json_column_emit])
-      validate_boolean!(:pool_writer, values[:pool_writer])
       validate_boolean!(:guarded_model, values[:guarded_model])
     end
 

data/lib/panko/code_gen/descriptor.rb

@@ -94,8 +94,10 @@ module Panko::CodeGen
       StructuralValidation.validate_kind!("Association#kind", kind)
       StructuralValidation.validate_descriptor!("Association#descriptor", descriptor)
       StructuralValidation.validate_symbol!("Association#source", source)
-      # +if+ must be a Callable: a Symbol passes this check but fails at compile
-      # (Symbol has no +arity+).
+      # A method name is not supported here (unlike a MethodAttribute body), so a Symbol is rejected up front.
+      if if_callable.is_a?(Symbol)
+        raise DescriptorError, "Association#if: must be a Callable, not a Symbol; got #{if_callable.inspect}"
+      end
       StructuralValidation.validate_callable!("Association#if", if_callable) unless if_callable.nil?
       StructuralValidation.validate_array_of!("Association#variants", variants, Descriptor, "Descriptor")
       validate_variants!(variants)

data/lib/panko/code_gen/descriptor_builder.rb

@@ -87,7 +87,7 @@ module Panko
       # A declared model missing one of the sources would stop the whole parent from compiling,
       # so it is left out and its records get the unspecialized child.
       def serves?(klass, descriptor)
-        ActiveRecord::DefineAttributeMethods.ensure!(klass)
+        klass.define_attribute_methods
         sources = descriptor.attributes.map(&:source) + descriptor.associations.map(&:source)
         sources.all? do |source|
           ActiveRecord::AccessClassifier.classify(klass, source)

data/lib/panko/code_gen/dump.rb

@@ -2,19 +2,16 @@
 
 module Panko::CodeGen
   class Dump
-    def initialize(descriptor, output:, config:, path:,
-      validator: Validators::Validator.new, generator: Generator.new)
+    def initialize(descriptor, output:, config:, path:)
       @descriptor = descriptor
       @output = output
       @config = config
       @path = path
-      @validator = validator
-      @generator = generator
     end
 
     def dump
       validate_path!
-      @validator.validate(@descriptor, output: @output, config: @config)
+      Validators::Validator.validate(@descriptor, output: @output, config: @config)
       if @descriptor.associations.empty?
         write_flat
       else
@@ -34,7 +31,7 @@ module Panko::CodeGen
     end
 
     def write_flat
-      source = @generator.emit(@descriptor, output: @output, config: @config)
+      source = Generator.emit(@descriptor, output: @output, config: @config)
       File.write(@path, source)
     end
 

data/lib/panko/code_gen/generator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Panko::CodeGen
-  class Generator
+  module Generator
     OUTPUT_MODES = %i[json hash].freeze
 
     # Sinks are stateless, so one frozen instance per mode serves every emit.
@@ -16,8 +16,8 @@ module Panko::CodeGen
       end
     end
 
-    def emit(descriptor, output:, config:)
-      Generators::ClassEmitter.new(self.class.sink_for(output)).emit(descriptor, config)
+    def self.emit(descriptor, output:, config:)
+      Generators::ClassEmitter.new(sink_for(output)).emit(descriptor, config)
     end
   end
 end

data/lib/panko/code_gen/generators/class_emitter.rb

@@ -76,16 +76,16 @@ module Panko::CodeGen
           builder.line "_construct_cache[descriptor.__id__] = self" if cyclic_self
           descriptor.method_attributes.each_with_index do |method_attribute, index|
             next if method_attribute.body.is_a?(Symbol)
-            ivar = GeneratedNames.callable_ivar(method_attribute)
+            ivar = GeneratedNames.callable_ivar(index)
             builder.line "#{ivar} = descriptor.method_attributes[#{index}].body"
           end
           descriptor.associations.each_with_index do |assoc, i|
             if assoc.if
-              builder.line "#{GeneratedNames.if_guard_ivar(assoc)} = descriptor.associations[#{i}].if"
+              builder.line "#{GeneratedNames.if_guard_ivar(i)} = descriptor.associations[#{i}].if"
             end
             builder.line emit_serializer_assignment(descriptor, assoc, i, cyclic_ids)
             assoc.variants.each_with_index do |variant, v|
-              builder.line "#{GeneratedNames.variant_serializer_ivar(assoc, v)} = " \
+              builder.line "#{GeneratedNames.variant_serializer_ivar(i, v)} = " \
                 "#{GeneratedNames.class_name(variant, @sink.suffix)}.new(descriptor: descriptor.associations[#{i}].variants[#{v}])"
             end
           end
@@ -96,7 +96,7 @@ module Panko::CodeGen
       # The cache is passed only when both ends are cyclic: a child outside
       # the cycle has a constructor without the +_construct_cache:+ kwarg.
       def emit_serializer_assignment(descriptor, assoc, i, cyclic_ids)
-        ivar = GeneratedNames.serializer_ivar(assoc)
+        ivar = GeneratedNames.serializer_ivar(i)
         if assoc.descriptor.equal?(descriptor)
           "#{ivar} = self"
         elsif cyclic_ids[descriptor.__id__] && cyclic_ids[assoc.descriptor.__id__]

data/lib/panko/code_gen/generators/field_index.rb

@@ -20,11 +20,9 @@ module Panko::CodeGen
         index
       end
 
-      # The +name: N+ shorthand parses only for identifier-style names.
+      # Ruby 3.4+ +Hash#inspect+ quotes a Symbol key that is not an identifier (+"2fa": 0+).
       def to_hash_literal(field_index)
-        return "{}" if field_index.empty?
-        pairs = field_index.map { |name, idx| "#{name}: #{idx}" }
-        "{#{pairs.join(", ")}}"
+        field_index.inspect
       end
     end
   end

data/lib/panko/code_gen/generators/field_walk.rb

@@ -19,15 +19,15 @@ module Panko::CodeGen
             sink.attribute(attribute, read_expr.call(attribute.source), config, index, builder)
           end
         end
-        descriptor.associations.each do |association|
+        descriptor.associations.each_with_index do |association, position|
           sink.association(
-            association, read_expr.call(association.source), config,
+            association, position, read_expr.call(association.source), config,
             field_index.fetch(GeneratedNames.filter_key(association)), builder
           )
         end
-        descriptor.method_attributes.each do |method_attribute|
+        descriptor.method_attributes.each_with_index do |method_attribute, position|
           sink.method_attribute(
-            method_attribute, config,
+            method_attribute, position, config,
             field_index.fetch(GeneratedNames.filter_key(method_attribute)), builder
           )
         end

data/lib/panko/code_gen/generators/generated_names.rb

@@ -11,20 +11,40 @@ module Panko::CodeGen
         "#{descriptor.name}_#{suffix}"
       end
 
-      def serializer_ivar(association)
-        "@#{association.name}_serializer"
+      # Field names can hold any character, so instance variables are named by
+      # the Field's position in its Descriptor list, never by its name.
+      def serializer_ivar(position)
+        "@child_#{position}"
       end
 
-      def variant_serializer_ivar(association, index)
-        "#{serializer_ivar(association)}_#{index}"
+      def variant_serializer_ivar(position, index)
+        "#{serializer_ivar(position)}_#{index}"
       end
 
-      def callable_ivar(method_attribute)
-        "@cb_#{method_attribute.name}"
+      def callable_ivar(position)
+        "@cb_#{position}"
       end
 
-      def if_guard_ivar(association)
-        "@cb_if_#{association.name}"
+      def if_guard_ivar(position)
+        "@cb_if_#{position}"
+      end
+
+      # Names reach generated source only as escaped literals, so a quote or an
+      # interpolation in a name cannot change the code.
+      def string_literal(name)
+        name.to_s.inspect
+      end
+
+      def symbol_literal(name)
+        name.to_sym.inspect
+      end
+
+      PLAIN_METHOD_NAME = /\A[A-Za-z_][A-Za-z0-9_]*[?!]?\z/
+
+      # A name dot syntax cannot parse (+2fa+, +a-b+) is called through +__send__+.
+      def method_call(receiver, name)
+        return "#{receiver}.#{name}" if PLAIN_METHOD_NAME.match?(name.to_s)
+        "#{receiver}.__send__(#{symbol_literal(name)})"
       end
 
       def write_one

data/lib/panko/code_gen/generators/hash_sink.rb

@@ -107,10 +107,10 @@ module Panko::CodeGen
         end
       end
 
-      def method_attribute(method_attribute, config, index, builder)
+      def method_attribute(method_attribute, position, config, index, builder)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
-          builder.line "value = #{method_attribute_call_expression(method_attribute)}"
+          builder.line "value = #{method_attribute_call_expression(method_attribute, position)}"
           builder.line "unless value.equal?(Panko::CodeGen::SKIP)"
           builder.indent do
             builder.line "result[#{key_literal(method_attribute.name, config)}] = Panko::CodeGen.cast_datetime(value)"
@@ -120,21 +120,21 @@ module Panko::CodeGen
         builder.line "end"
       end
 
-      def association(association, source_read_expr, config, index, builder)
+      def association(association, position, source_read_expr, config, index, builder)
         key_lit = key_literal(association.name, config)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
-          with_if_guard(association, builder) do
+          with_if_guard(association, position, builder) do
             case association.kind
             when :has_one
               builder.line "value = #{source_read_expr}"
               if config.null_for_missing_has_one
-                has_one_default(association, key_lit, builder)
+                has_one_default(association, position, key_lit, builder)
               else
-                has_one_omit(association, key_lit, builder)
+                has_one_omit(association, position, key_lit, builder)
               end
             when :has_many
-              has_many(association, source_read_expr, key_lit, builder)
+              has_many(association, position, source_read_expr, key_lit, builder)
             end
           end
         end
@@ -145,33 +145,33 @@ module Panko::CodeGen
 
       def key_literal(name, config)
         case config.hash_output_key_type
-        when :symbol then ":#{name}"
-        else %("#{name}")
+        when :symbol then GeneratedNames.symbol_literal(name)
+        else GeneratedNames.string_literal(name)
         end
       end
 
-      def has_one_default(association, key_lit, builder)
+      def has_one_default(association, position, key_lit, builder)
         builder.line "result[#{key_lit}] = if value.nil?"
         builder.indent { builder.line "nil" }
         builder.line "else"
         builder.indent do
-          child_write(association, "value", builder) do |ivar|
+          child_write(association, position, "value", builder) do |ivar|
             "#{ivar}.#{GeneratedNames.to_hash}(value, context, scope, #{child_filter_expr(association)})"
           end
         end
         builder.line "end"
       end
 
-      def has_one_omit(association, key_lit, builder)
+      def has_one_omit(association, position, key_lit, builder)
         builder.line "unless value.nil?"
         builder.indent do
           if association.variants.empty?
-            builder.line "result[#{key_lit}] = #{GeneratedNames.serializer_ivar(association)}." \
+            builder.line "result[#{key_lit}] = #{GeneratedNames.serializer_ivar(position)}." \
               "#{GeneratedNames.to_hash}(value, context, scope, #{child_filter_expr(association)})"
           else
             builder.line "result[#{key_lit}] = begin"
             builder.indent do
-              child_write(association, "value", builder) do |ivar|
+              child_write(association, position, "value", builder) do |ivar|
                 "#{ivar}.#{GeneratedNames.to_hash}(value, context, scope, #{child_filter_expr(association)})"
               end
             end
@@ -182,18 +182,18 @@ module Panko::CodeGen
       end
 
       # +child_filter+ is looked up once per record, not once per element.
-      def has_many(association, source_read_expr, key_lit, builder)
+      def has_many(association, position, source_read_expr, key_lit, builder)
         builder.line "child_filter = #{child_filter_expr(association)}"
         if association.variants.empty?
           builder.line(
             "result[#{key_lit}] = #{source_read_expr}.map { |element| " \
-              "#{GeneratedNames.serializer_ivar(association)}.#{GeneratedNames.to_hash}(element, context, scope, child_filter) }"
+              "#{GeneratedNames.serializer_ivar(position)}.#{GeneratedNames.to_hash}(element, context, scope, child_filter) }"
           )
           return
         end
         builder.line "result[#{key_lit}] = #{source_read_expr}.map do |element|"
         builder.indent do
-          child_write(association, "element", builder) do |ivar|
+          child_write(association, position, "element", builder) do |ivar|
             "#{ivar}.#{GeneratedNames.to_hash}(element, context, scope, child_filter)"
           end
         end
@@ -203,7 +203,7 @@ module Panko::CodeGen
       # +format_raw+ returns nil for raw values it cannot format; the typed-read
       # fallback then goes through +cast_datetime+ so a Time still becomes a String.
       def datetime_column_attribute(attribute, config, index, builder)
-        source_lit = %("#{attribute.source}")
+        source_lit = GeneratedNames.string_literal(attribute.source)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
           builder.line "value = Panko::CodeGen::DateTimeFormat.format_raw(record.read_attribute_before_type_cast(#{source_lit}))"

data/lib/panko/code_gen/generators/json_sink.rb

@@ -32,7 +32,6 @@ module Panko::CodeGen
       end
 
       def emit_class_constants(descriptor, config, builder)
-        return unless config.pool_writer
         subclass = defined?(ActiveSupport::IsolatedExecutionState) ? "IsolatedExecutionState" : "ThreadLocal"
         builder.line "POOL = Panko::CodeGen::WritersPool::#{subclass}.new"
       end
@@ -47,7 +46,7 @@ module Panko::CodeGen
           if config.supports_root_key
             builder.line "validate_root_key!(root_key)"
           end
-          with_writer(config, builder) { emit_serialize_one_body(config, builder) }
+          with_writer(builder) { emit_serialize_one_body(config, builder) }
         end
         builder.line "end"
       end
@@ -62,7 +61,7 @@ module Panko::CodeGen
           if config.supports_root_key
             builder.line "validate_root_key!(root_key)"
           end
-          with_writer(config, builder) { emit_serialize_many_body(config, builder) }
+          with_writer(builder) { emit_serialize_many_body(config, builder) }
         end
         builder.line "end"
       end
@@ -103,7 +102,7 @@ module Panko::CodeGen
       def attribute(attribute, read_expr, config, index, builder, cast: true)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
-          builder.line %(writer.push_value(#{read_expr}, "#{attribute.name}"))
+          builder.line "writer.push_value(#{read_expr}, #{GeneratedNames.string_literal(attribute.name)})"
         end
         builder.line "end"
       end
@@ -119,33 +118,34 @@ module Panko::CodeGen
       end
 
       # +equal?+, not +==+, so an object that overrides +==+ cannot match +SKIP+.
-      def method_attribute(method_attribute, config, index, builder)
+      def method_attribute(method_attribute, position, config, index, builder)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
-          builder.line "value = #{method_attribute_call_expression(method_attribute)}"
+          builder.line "value = #{method_attribute_call_expression(method_attribute, position)}"
           builder.line "unless value.equal?(Panko::CodeGen::SKIP)"
           builder.indent do
-            builder.line %(writer.push_value(value, "#{method_attribute.name}"))
+            builder.line "writer.push_value(value, #{GeneratedNames.string_literal(method_attribute.name)})"
           end
           builder.line "end"
         end
         builder.line "end"
       end
 
-      def association(association, source_read_expr, config, index, builder)
+      def association(association, position, source_read_expr, config, index, builder)
+        key_lit = GeneratedNames.string_literal(association.name)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
-          with_if_guard(association, builder) do
+          with_if_guard(association, position, builder) do
             case association.kind
             when :has_one
               builder.line "value = #{source_read_expr}"
               if config.null_for_missing_has_one
-                has_one_default(association, builder)
+                has_one_default(association, position, key_lit, builder)
               else
-                has_one_omit(association, builder)
+                has_one_omit(association, position, key_lit, builder)
               end
             when :has_many
-              has_many(association, source_read_expr, builder)
+              has_many(association, position, source_read_expr, key_lit, builder)
             end
           end
         end
@@ -155,21 +155,16 @@ module Panko::CodeGen
       private
 
       # +result+ starts nil so a body that raises hands checkin nil, and the writer is dropped.
-      def with_writer(config, builder, &block)
-        if config.pool_writer
-          builder.line "writer = POOL.checkout"
-          builder.line "result = nil"
-          builder.line "begin"
-          builder.indent(&block)
-          builder.line "ensure"
-          builder.indent do
-            builder.line "POOL.checkin(writer, result)"
-          end
-          builder.line "end"
-        else
-          builder.line "writer = Oj::StringWriter.new(mode: :rails)"
-          yield
+      def with_writer(builder, &block)
+        builder.line "writer = POOL.checkout"
+        builder.line "result = nil"
+        builder.line "begin"
+        builder.indent(&block)
+        builder.line "ensure"
+        builder.indent do
+          builder.line "POOL.checkin(writer, result)"
         end
+        builder.line "end"
       end
 
       def emit_serialize_one_body(config, builder)
@@ -205,36 +200,36 @@ module Panko::CodeGen
 
       # A non-nil +has_one+ pushes its key separately instead of +push_object("name")+: the
       # child's +_write_one+ opens its own +push_object+ frame.
-      def has_one_default(association, builder)
+      def has_one_default(association, position, key_lit, builder)
         builder.line "if value.nil?"
-        builder.indent { builder.line %(writer.push_value(nil, "#{association.name}")) }
+        builder.indent { builder.line "writer.push_value(nil, #{key_lit})" }
         builder.line "else"
         builder.indent do
-          builder.line %(writer.push_key("#{association.name}"))
-          child_write(association, "value", builder) do |ivar|
+          builder.line "writer.push_key(#{key_lit})"
+          child_write(association, position, "value", builder) do |ivar|
             "#{ivar}.#{GeneratedNames.write_one}(value, writer, context, scope, #{child_filter_expr(association)})"
           end
         end
         builder.line "end"
       end
 
-      def has_one_omit(association, builder)
+      def has_one_omit(association, position, key_lit, builder)
         builder.line "unless value.nil?"
         builder.indent do
-          builder.line %(writer.push_key("#{association.name}"))
-          child_write(association, "value", builder) do |ivar|
+          builder.line "writer.push_key(#{key_lit})"
+          child_write(association, position, "value", builder) do |ivar|
             "#{ivar}.#{GeneratedNames.write_one}(value, writer, context, scope, #{child_filter_expr(association)})"
           end
         end
         builder.line "end"
       end
 
-      def has_many(association, source_read_expr, builder)
+      def has_many(association, position, source_read_expr, key_lit, builder)
         builder.line "child_filter = #{child_filter_expr(association)}"
-        builder.line %(writer.push_array("#{association.name}"))
+        builder.line "writer.push_array(#{key_lit})"
         builder.line "#{source_read_expr}.each do |element|"
         builder.indent do
-          child_write(association, "element", builder) do |ivar|
+          child_write(association, position, "element", builder) do |ivar|
             "#{ivar}.#{GeneratedNames.write_one}(element, writer, context, scope, child_filter)"
           end
         end
@@ -246,11 +241,11 @@ module Panko::CodeGen
       # (non-String, empty, malformed) falls back to the typed read.
       def json_column_attribute(attribute, config, index, builder)
         if config.json_column_emit == :html_safe
-          attribute(attribute, %(record._read_attribute("#{attribute.source}")), config, index, builder)
+          attribute(attribute, "record._read_attribute(#{GeneratedNames.string_literal(attribute.source)})", config, index, builder)
           return
         end
-        source_lit = %("#{attribute.source}")
-        key_lit = %("#{attribute.name}")
+        source_lit = GeneratedNames.string_literal(attribute.source)
+        key_lit = GeneratedNames.string_literal(attribute.name)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
           builder.line %(raw = record.read_attribute_before_type_cast(#{source_lit}))
@@ -277,11 +272,12 @@ module Panko::CodeGen
       end
 
       def datetime_column_attribute(attribute, index, builder)
-        source_lit = %("#{attribute.source}")
+        source_lit = GeneratedNames.string_literal(attribute.source)
         builder.line "unless filters.drops?(#{index})"
         builder.indent do
           builder.line "value = Panko::CodeGen::DateTimeFormat.format_raw(record.read_attribute_before_type_cast(#{source_lit}))"
-          builder.line %(writer.push_value(value || record._read_attribute(#{source_lit}), "#{attribute.name}"))
+          builder.line "writer.push_value(value || record._read_attribute(#{source_lit}), " \
+            "#{GeneratedNames.string_literal(attribute.name)})"
         end
         builder.line "end"
       end

data/lib/panko/code_gen/generators/record_access/generic.rb

@@ -27,7 +27,7 @@ module Panko::CodeGen
             builder.indent do
               FieldWalk.emit_fields(
                 descriptor, config, field_index, builder, sink,
-                read_expr: ->(source) { "record.#{source}" }
+                read_expr: ->(source) { GeneratedNames.method_call("record", source) }
               )
             end
             builder.line "end"
@@ -60,7 +60,7 @@ module Panko::CodeGen
           builder.indent do
             FieldWalk.emit_fields(
               descriptor, config, field_index, builder, sink,
-              read_expr: ->(source) { "record.#{source}" }
+              read_expr: ->(source) { GeneratedNames.method_call("record", source) }
             )
           end
           builder.line "end"
@@ -82,8 +82,8 @@ module Panko::CodeGen
 
         def self.hash_read_expr(source_name, config)
           case config.hash_record_key_type
-          when :symbol then "record[:#{source_name}]"
-          else %(record["#{source_name}"])
+          when :symbol then "record[#{GeneratedNames.symbol_literal(source_name)}]"
+          else "record[#{GeneratedNames.string_literal(source_name)}]"
           end
         end
       end

data/lib/panko/code_gen/generators/record_access/specialized.rb

@@ -13,7 +13,7 @@ module Panko::CodeGen
             Generic.emit_parent_class_ivar_writes(descriptor, builder)
             FieldWalk.emit_fields(
               descriptor, config, field_index, builder, sink,
-              read_expr: ->(source) { "record.#{source}" },
+              read_expr: ->(source) { GeneratedNames.method_call("record", source) },
               attribute_emit: ->(attribute, index) { sink.specialized_attribute(attribute, ar_model, config, index, builder) }
             )
           end
@@ -45,21 +45,23 @@ module Panko::CodeGen
         # SELECT alias named like a method (+thing_ids+ next to +has_many :things+) returns the selected value.
         def self.attribute_read_expr(attribute, ar_model)
           source = attribute.source
-          return "record.#{source}" if ar_model.nil?
-          return %(record._read_attribute("#{source}")) if ActiveRecord::AccessClassifier.classify(ar_model, source) == :column
-          return "record.#{source}" if declared_attribute?(ar_model, source)
-          %((record._has_attribute?("#{source}") ? record._read_attribute("#{source}") : record.#{source}))
+          method_read = GeneratedNames.method_call("record", source)
+          return method_read if ar_model.nil?
+          source_lit = GeneratedNames.string_literal(source)
+          return "record._read_attribute(#{source_lit})" if ActiveRecord::AccessClassifier.classify(ar_model, source) == :column
+          return method_read if declared_attribute?(ar_model, source)
+          "(record._has_attribute?(#{source_lit}) ? record._read_attribute(#{source_lit}) : #{method_read})"
         end
 
         def self.declared_attribute?(ar_model, source)
           ar_model.attribute_types.key?(source.to_s) || ar_model.attribute_aliases.key?(source.to_s)
         end
 
-        # Called here too so the Generator works without the validators; repeating +ensure!+ is safe.
+        # Called here too so the Generator works without the validators.
         def self.ar_model(descriptor)
           model = descriptor.model
           return nil unless model.respond_to?(:columns_hash) && model.respond_to?(:attribute_methods_generated?)
-          ActiveRecord::DefineAttributeMethods.ensure!(model)
+          model.define_attribute_methods
           model
         end
 

data/lib/panko/code_gen/generators/release.rb

@@ -25,11 +25,11 @@ module Panko::CodeGen
         end
       end
 
-      def child_ivars(assoc)
+      def child_ivars(assoc, position)
         variants = assoc.variants.each_with_index.map do |variant, index|
-          [GeneratedNames.variant_serializer_ivar(assoc, index), variant]
+          [GeneratedNames.variant_serializer_ivar(position, index), variant]
         end
-        [[GeneratedNames.serializer_ivar(assoc), assoc.descriptor], *variants]
+        [[GeneratedNames.serializer_ivar(position), assoc.descriptor], *variants]
       end
 
       # Every class defines +_release+, even an empty one: the serializers call it
@@ -42,8 +42,8 @@ module Panko::CodeGen
             builder.line "@context = nil"
             builder.line "@scope = nil"
           end
-          descriptor.associations.each do |assoc|
-            child_ivars(assoc).each do |ivar, child|
+          descriptor.associations.each_with_index do |assoc, position|
+            child_ivars(assoc, position).each do |ivar, child|
               next if child.equal?(descriptor)
               # Ends the chain without per-call visited state; such serializers keep their last record until the next call.
               next if cyclic_ids[descriptor.__id__] && cyclic_ids[child.__id__]

data/lib/panko/code_gen/generators/sink.rb

@@ -6,14 +6,14 @@ module Panko::CodeGen
       # The child's +FIELD_INDEX+ is read through its class name when the method runs, so
       # self-recursive Descriptors resolve it.
       def child_filter_expr(association)
-        "filters.child(:#{GeneratedNames.filter_key(association)}, " \
+        "filters.child(#{GeneratedNames.symbol_literal(GeneratedNames.filter_key(association))}, " \
           "#{GeneratedNames.class_name(association.descriptor, suffix)}::#{GeneratedNames.field_index_const})"
       end
 
       # +case+/+when+, not an +if+/+elsif+ chain of +instance_of?+: under YJIT the chain gets
       # slower once the call site has warmed on one class. HashSink uses the +case+ as an expression.
-      def child_write(association, record_expr, builder, &call_for)
-        base_call = call_for.call(GeneratedNames.serializer_ivar(association))
+      def child_write(association, position, record_expr, builder, &call_for)
+        base_call = call_for.call(GeneratedNames.serializer_ivar(position))
         if association.variants.empty?
           builder.line base_call
           return
@@ -24,7 +24,7 @@ module Panko::CodeGen
           builder.line "when #{model}"
           builder.indent do
             builder.line "if #{record_expr}.instance_of?(#{model})"
-            builder.indent { builder.line call_for.call(GeneratedNames.variant_serializer_ivar(association, index)) }
+            builder.indent { builder.line call_for.call(GeneratedNames.variant_serializer_ivar(position, index)) }
             builder.line "else"
             builder.indent { builder.line base_call }
             builder.line "end"
@@ -42,9 +42,9 @@ module Panko::CodeGen
       end
 
       # The guard wraps the Source read too, so a falsy +if:+ skips the read.
-      def with_if_guard(association, builder)
+      def with_if_guard(association, position, builder)
         if association.if
-          builder.line "if #{if_guard_call_expression(GeneratedNames.if_guard_ivar(association), association.if.arity)}"
+          builder.line "if #{if_guard_call_expression(GeneratedNames.if_guard_ivar(position), association.if.arity)}"
           builder.indent { yield }
           builder.line "end"
         else
@@ -64,10 +64,10 @@ module Panko::CodeGen
 
       # Symbol bodies need the explicit +self.+: a bare name such as +record+ or +value+ would
       # resolve to a local of the generated method.
-      def method_attribute_call_expression(method_attribute)
+      def method_attribute_call_expression(method_attribute, position)
         body = method_attribute.body
-        return "self.#{body}" if body.is_a?(Symbol)
-        ivar = GeneratedNames.callable_ivar(method_attribute)
+        return GeneratedNames.method_call("self", body) if body.is_a?(Symbol)
+        ivar = GeneratedNames.callable_ivar(position)
         case body.arity
         when 0 then "#{ivar}.call"
         when 1 then "#{ivar}.call(record)"

data/lib/panko/code_gen/validators/source_resolution.rb

@@ -23,7 +23,7 @@ module Panko::CodeGen
         def classify_attributes!(descriptor)
           model = descriptor.model
           return unless ar_class?(model)
-          ActiveRecord::DefineAttributeMethods.ensure!(model)
+          model.define_attribute_methods
           descriptor.attributes.each do |attribute|
             classify_or_raise!(model, attribute, descriptor.name)
           end

data/lib/panko/code_gen/validators/validator.rb

@@ -2,16 +2,12 @@
 
 module Panko::CodeGen
   module Validators
-    class Validator
+    module Validator
       # Order matters: an arity error is reported before a source or name error.
-      DEFAULT_RULES = [CallableArity, SourceResolution, NameUniqueness].freeze
+      RULES = [CallableArity, SourceResolution, NameUniqueness].freeze
 
-      def initialize(rules: DEFAULT_RULES)
-        @rules = rules
-      end
-
-      def validate(descriptor, output:, config:)
-        @rules.each { |rule| rule.validate(descriptor, output: output, config: config) }
+      def self.validate(descriptor, output:, config:)
+        RULES.each { |rule| rule.validate(descriptor, output: output, config: config) }
         nil
       end
     end

data/lib/panko/code_gen.rb

@@ -16,7 +16,6 @@ require_relative "code_gen/code_builder"
 require_relative "code_gen/filter"
 require_relative "code_gen/datetime_format"
 require_relative "code_gen/active_record/access_classifier"
-require_relative "code_gen/active_record/define_attribute_methods"
 require_relative "code_gen/validators/callable_arity"
 require_relative "code_gen/validators/source_resolution"
 require_relative "code_gen/validators/name_uniqueness"
@@ -36,7 +35,6 @@ require_relative "code_gen/generators/banner"
 require_relative "code_gen/generators/class_emitter"
 require_relative "code_gen/generators/fanout"
 require_relative "code_gen/generator"
-require_relative "code_gen/compile_cache"
 require_relative "code_gen/compiler"
 require_relative "code_gen/dump"
 require_relative "code_gen/writers_pool"

data/lib/panko/serializer.rb

@@ -104,7 +104,8 @@ module Panko
           name: options.fetch(:name, name).to_s.to_sym,
           kind: kind,
           descriptor: descriptor,
-          source: name.to_sym
+          source: name.to_sym,
+          if: options[:if]
         )
       end
 

data/lib/panko/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Panko
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: panko_serializer
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Yosi Attias
@@ -68,9 +68,7 @@ files:
 - lib/panko/array_serializer.rb
 - lib/panko/code_gen.rb
 - lib/panko/code_gen/active_record/access_classifier.rb
-- lib/panko/code_gen/active_record/define_attribute_methods.rb
 - lib/panko/code_gen/code_builder.rb
-- lib/panko/code_gen/compile_cache.rb
 - lib/panko/code_gen/compiler.rb
 - lib/panko/code_gen/config.rb
 - lib/panko/code_gen/datetime_format.rb

data/lib/panko/code_gen/active_record/define_attribute_methods.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Panko::CodeGen
-  module ActiveRecord
-    module DefineAttributeMethods
-      def self.ensure!(klass)
-        return if klass.attribute_methods_generated?
-        klass.define_attribute_methods
-        nil
-      end
-    end
-  end
-end

data/lib/panko/code_gen/compile_cache.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Panko::CodeGen
-  # Descriptor -> Generated Class, one entry per unique Descriptor in a tree.
-  class CompileCache
-    # Keyed by +__id__+, so equal but distinct Descriptors get separate entries.
-    def initialize
-      @store = {}
-    end
-
-    def get(descriptor)
-      @store[descriptor.__id__]
-    end
-
-    def set(descriptor, generated_class)
-      @store[descriptor.__id__] = generated_class
-    end
-
-    # The block must call +#set+ before it descends into children, so a recursive
-    # call on the same Descriptor hits the entry and the cycle ends.
-    def lookup_or_compile(descriptor)
-      cached = @store[descriptor.__id__]
-      return cached if cached
-      yield
-      @store[descriptor.__id__]
-    end
-  end
-end