How to do Ruby object serialization using JSON

Question

I have a structure of simple container classes like so (in pseudo ruby):

class A
  attr_reader :string_field1, :string_field2
  ...
end

class B
  attr_reade         


        

Answer 1

Here is my approach to to_json implementation for custom classes.

There is a little magic here using self.included in a module. Here is a very nice article from 2006 about module having both instance and class methods http://blog.jayfields.com/2006/12/ruby-instance-and-class-methods-from.html

The module is designed to be included in any class to provide to_json functionality. It intercepts attr_accessor method rather than uses its own in order to require minimal changes for existing classes.

to_json implementation is based on this answer

module JSONable
  module ClassMethods
    attr_accessor :attributes

    def attr_accessor *attrs
      self.attributes = Array attrs
      super
    end
  end

  def self.included(base)
    base.extend(ClassMethods)
  end

  def as_json options = {}
    serialized = Hash.new
    self.class.attributes.each do |attribute|
      serialized[attribute] = self.public_send attribute
    end
    serialized
  end

  def to_json *a
    as_json.to_json *a
  end
end


class CustomClass
  include JSONable
  attr_accessor :b, :c 

  def initialize b: nil, c: nil
    self.b, self.c = b, c
  end
end

a = CustomClass.new(b: "q", c: 23)
puts JSON.pretty_generate a

{
  "b": "q",
  "c": 23
}

Answer 2

Use Marshal, PStore, or another Ruby solution for non-JSON objects

One might reasonably wonder why a completely reflective language like Ruby doesn't automate JSON generation and parsing of arbitrary classes.

However, unless you stick to the JSON types, there is no place to send or receive the JSON objects except to another running Ruby. And in that case, I suspect that the conventional wisdom is "forget JSON, use a native Ruby interface like the core class Marshal.

So, if you are really sending those objects to PHP or something non-Ruby, then you should create directly JSON-supported Ruby data structures using Array and the like, and then you will have something that JSON.generate will directly deal with.

If you just need serialization it's possible you should use Marshal or PStore.

Update: Aha, ok, try this:

module AutoJ
  def auto_j
    h = {}
    instance_variables.each do |e|
      o = instance_variable_get e.to_sym
      h[e[1..-1]] = (o.respond_to? :auto_j) ? o.auto_j : o;
    end
    h
  end
  def to_json *a
    auto_j.to_json *a
  end
end

If you then include AutoJ in each of your classes, it should DTRT. In your example this results in

{
  "a": {
    "string_field1": "aa",
    "string_field2": "bb"
  },
  "b": {
    "int_field3": 123,
    "string_field4": "dd"
  }
}

You might want to change the auto_j method to return h.values instead of just h, in which case you get:

[
  ["aa", "bb"],
  [123, "dd"]
]

Answer 3

I had the same problem (mainly trying to create JSON strings of arbitrary complexity) rather than parsing them. After looking all over for a non-invasive class that will take a Ruby object (including nested arrays) and marshal it as a JSON string I finally wrote my own simple serialiser. This code also escapes special characters to create valid JSON.

http://www.keepingmyhandin.com/Downhome/Sketchup/simplejsonserializerrubyimplementation

All you have to do is:

json  = JSON.new;
jsonString = json.marshal(obj); # Where obj is a Ruby object