使用 Array 子类覆盖 Rails 模型 getter/setter

Question

I have a Rails model Segment that has an attribute consisting of an array of ranges: [0..20, 32..41, 90..200] , for instance.

There are a few methods that I would like to add to Array that would be useful specifically for dealing with arrays of ranges, like a method to sum the length of each Range in the Array:

class RangeArray < Array
  def sum
    inject(0) { |total, range| total + (1 + range.max - range.min) }
  end
end

Ideally, I'd be able to override the getters and setters in Segment so that when the array of ranges is read from the database it is automatically cast to a RangeArray, and whenever it is written to the database it is written as an Array. This seems like it should be easy to do since RangeArray is inherits from Array, but I'm having some real trouble with a few things. I get quite close with this setup:

class Segment < ApplicationRecord
  attr_accessor :ranges

  def ranges
    puts "read"
    RangeArray.new(super)
  end

  def ranges=(var)
    puts "write"
    super(RangeArray.new(var))
  end
end

With this setup, I can read the ranges, set them explicitly, save to the database, etc:

2.6.5 :071 > s = Segment.new
 => #<Segment id: nil, ranges: [], type: nil, created_at: nil, updated_at: nil> 
2.6.5 :072 > s.ranges = [2000..3000]
write
 => [2000..3000] 
2.6.5 :073 > s.ranges.class
read
 => RangeArray 
2.6.5 :074 > s.ranges.sum
read
 => 1001 

Where I'm having trouble is with the push and << methods that RangeArray should be inheriting from Array:

2.6.5 :075 > s.ranges << (40..50)
read
 => [2000..3000, 40..50] 
2.6.5 :076 > s.ranges
read
 => [2000..3000] 

It seems like this fails because trying to add an element to ranges via << calls the reader first, which generates a new RangeArray object, pushes 40..50 to it, and then discards the object.

Storing the values in an intermediate instance variable feels like it should work, but doesn't seem to make much of a difference:

  def ranges
    puts "read"
    @ranges = RangeArray.new(super)
  end

  def ranges=(var)
    puts "write"
    @ranges = super(RangeArray.new(var))
  end

I feel like I'm close here, but I'm missing something, and am not sure how to get the writer to be called during << or push . What should I do? Rather than override the getters and setters, is there some other way to change the type to which ActiveRecord casts the ranges attribute? Or perhaps I should just make a module mix-in adds methods directly to Array, and include that mix-in for each model that needs it?

Answer 1

Rails 5 introduced the Attributes API which previously was just an internal API.

It allows you to declare attributes and handle defaults and typecasting just like ActiveRecord does automatically for your database columns. It also goes a step further - it lets you declare your own types for serialization / deserialization.

This example uses Postgres and a JSONB type column as the underlying storage mechanism.

Start by declaring your custom type:

# app/types/range_array_type.rb
# This is the type that handles casting the attribute from 
# user input and serializing/deserializing the attribute from the database
# @see https://api.rubyonrails.org/classes/ActiveModel/Type/Value.html
class RangeArrayType < ActiveRecord::Type::Value
  # Type casts a value from user input (e.g. from a setter).
  def cast(value)
    value.is_a?(RangeArray) ? value : deserialize(value)
  end
  # Casts the value from the ruby type to a type that the database knows
  # how to understand.
  # in this case an array of pairs representing the bounds of the array
  # which can be serialized as JSON
  def serialize(value)
    value.map {|range| [range.begin, range.end] }.to_json
  end
  # Casts the value from an array of pairs representing the bounds or ranges
  def deserialize(value)
    case value
    when Array
      RangeArray.new( value.map {|x| x.is_a?(Range) ? x : Range.new(*x) } )
    when String
      deserialize(JSON.parse(value)) # recursion 
    else
      nil
    end
  end
end

And you want to setup your RangeArray class so that it does not inherit from Array:

require 'delegate'
class RangeArray < SimpleDelegator
  def sum
    __getobj__.sum(&:size)
  end
end

Inheriting from the core library classes can be problematic since they are implemented in C and do not behave like other classes. See Beware subclassing Ruby core classes .

Then register the type in an intitializer:

# config/initializers/types.rb
ActiveRecord::Type.register(:range_array, RangeArrayType)

And then use your new fancy type in the model:

class Segment < ApplicationRecord
  # segments.ranges is a JSONB column
  attribute :ranges, :range_array
end

This overrides the type that ActiveRecord derives from the database schema.

Lets try it out:

Loading development environment (Rails 6.0.2.1)
[1] pry(main)> segment = Segment.new(ranges: [[1,2], 3..4])
=> #<Segment:0x0000000005481868 id: nil, ranges: [1..2, 3..4], test_array: nil, created_at: nil, updated_at: nil>
[2] pry(main)> segment.save!
   (0.3ms)  BEGIN
  Segment Create (1.0ms)  INSERT INTO "segments" ("ranges", "created_at", "updated_at") VALUES ($1, $2, $3) RETURNING "id"  [["ranges", "[[1,2],[3,4]]"], ["created_at", "2020-02-02 07:20:30.982678"], ["updated_at", "2020-02-02 07:20:30.982678"]]
   (1.0ms)  COMMIT
=> true
[3] pry(main)> s = Segment.first
  Segment Load (0.9ms)  SELECT "segments".* FROM "segments" ORDER BY "segments"."id" ASC LIMIT $1  [["LIMIT", 1]]
=> #<Segment:0x0000000006518820
 id: 1,
 ranges: [1..2, 3..4],
 test_array: nil,
 created_at: Sun, 02 Feb 2020 07:02:21 UTC +00:00,
 updated_at: Sun, 02 Feb 2020 07:02:21 UTC +00:00>
[4] pry(main)> s.ranges
=> [1..2, 3..4]
[5] pry(main)> s.ranges.class.name
=> "RangeArray"