JSON to Ruby Class Generator

Example Input

{
  "id": 1,
  "userName": "priya_singh",
  "email": "priya@learnhubly.com",
  "isActive": true,
  "score": 98.5,
  "tags": ["developer", "admin"],
  "profile": {
    "bio": "Principal Software Engineer",
    "skills": ["Go", "React", "TypeScript"]
  },
  "deletedAt": null
}

Example Output

require 'json'

class Profile
  attr_accessor :bio, :skills

  def initialize(hash)
    @bio = hash["bio"]
    @skills = hash["skills"] || []
  end

  def self.from_json(json_string)
    new(JSON.parse(json_string))
  end
end

class User
  attr_accessor :id, :user_name, :email, :is_active, :score, :tags, :profile, :deleted_at

  def initialize(hash)
    @id = hash["id"]
    @user_name = hash["userName"]
    @email = hash["email"]
    @is_active = hash["isActive"]
    @score = hash["score"]
    @tags = hash["tags"] || []
    @profile = Profile.new(hash["profile"]) if hash["profile"]
    @deleted_at = hash["deletedAt"]
  end

  def self.from_json(json_string)
    new(JSON.parse(json_string))
  end
end

# Usage:
# user = User.from_json(api_response_body)
# user.user_name    # => "priya_singh"
# user.profile.bio  # => "Principal Software Engineer"
# user.is_active    # => true

Does it support Struct?

The tool generates PORO classes with attr_accessor and initialize. Ruby's built-in Struct is a lighter alternative for simple immutable value objects. If you want a Struct instead of a full class, the structure is straightforward: UserStruct = Struct.new(:id, :name, :email, keyword_init: true). You lose the fromJSON / initialize hash mapping that the generated class provides, but Struct gives you equality comparison, to_a, to_h, and pattern matching support out of the box. Use the generated PORO for API data objects where you want custom methods and explicit initialization logic. Use Struct for simple value objects where the built-in behavior is sufficient.

How does it handle camelCase JSON keys?

JSON from REST APIs commonly uses camelCase field names (isActive, createdAt, userName) while Ruby convention is snake_case (is_active, created_at, user_name). The generated class converts every camelCase JSON key to snake_case for the attr_accessor name and the instance variable, while preserving the original camelCase key in the initialize hash lookup. So @is_active = hash['isActive'] — the left side uses the snake_case Ruby convention and the right side uses the original JSON key. You access the attribute as user.is_active in Ruby code but the underlying JSON parsing still reads from 'isActive'. This is handled automatically for all fields.

Is it safe to use with internal API response data?

Yes. All processing runs locally in your browser. The JSON you paste — including API responses with authentication tokens, internal service URLs, user data, or proprietary response structures — never leaves your machine and is never transmitted anywhere. Generate the class, close the tab, the data is gone.

What is the difference between a PORO, Struct, OpenStruct, and dry-struct?

PORO (Plain Old Ruby Object) is a standard Ruby class with attr_accessor and a manually written initialize — what this tool generates. Maximum flexibility, no dependencies, you control every behavior. Struct is a built-in Ruby class factory that creates value objects with named members, equality comparison, and to_h/to_a — good for simple immutable data with no custom methods. OpenStruct dynamically creates methods from hash keys at instantiation — convenient for prototyping but slow (it creates singleton methods per instance) and deprecated for performance reasons in Ruby 3.x. dry-struct is a gem from the dry-rb ecosystem that provides typed, immutable struct with coercion and validation, similar to TypeScript interfaces with runtime enforcement. For a quick API integration PORO or Struct are sufficient. For domain objects with strict typing requirements, dry-struct is worth the gem dependency.

How do I use the generated class in a Rails application?

For an API-only Rails app that receives JSON request bodies: parse the request body in your controller and pass the hash to the class: user = User.new(JSON.parse(request.body.read)). Or if Rails has already parsed the body as params, use User.new(params.to_unsafe_h) after appropriate permit filtering. For calling an external API with Faraday or HTTParty and wrapping the response: user = User.from_json(response.body). For a model that bridges an external API to your Rails database layer, put the class in app/services/external/ or app/models/api/ depending on your team's conventions. The generated class does not inherit from ApplicationRecord and does not need to — it is a plain Ruby object.

How do I add validations to the generated class?

Two approaches. First, for a plain Ruby class with no Rails dependency: add a validate method that checks the attributes and raises an ArgumentError or returns false: def validate; raise ArgumentError, 'email is required' if email.nil?; end. Call it at the end of initialize. Second, for a class used with Rails, include ActiveModel::Validations: include ActiveModel::Validations and add validates :email, presence: true. This gives you the same validates macro as ActiveRecord models without database backing. Call valid? to check validations and errors to see validation failures. Either approach can be added to the generated class after generation.

Can I use the generated class with Ruby's JSON.generate for round-trip serialization?

The generated class parses JSON in (from_json) but does not include a to_json method for serialization back to JSON. To add round-trip serialization, implement to_json: def to_json(*args); { id: id, user_name: user_name, email: email }.to_json(*args); end. Note that if the API expects camelCase JSON, your to_json must convert back to camelCase. Alternatively, use the as_json method if you are in a Rails context. For a simpler approach, define a to_h method that returns all attributes as a hash and then call .to_json on the hash: def to_h; { id: id, userName: user_name, email: email }; end. This gives you an explicit mapping from Ruby attribute names back to JSON key names.

What about using the json gem's JSON::Ext::Generator::GeneratorMethods?

Adding require 'json' and including JSON::Ext::Generator::GeneratorMethods in your class gives it a to_json method, but it serializes instance variables by default — including the @ prefix in the JSON keys (@name instead of name) which is almost never what you want. Do not rely on the automatic JSON serialization built into the json gem for custom classes. Instead, define to_json explicitly as a method that returns the correct hash structure with the correct key names as described in the question above. Explicit is always better than magic for serialization — a clear to_json method is immediately understandable; automatic instance variable serialization causes surprises.