How to Convert YAML to JSON in Ruby

How to Convert YAML to JSON in Ruby

Converting YAML to JSON is a common task in many Ruby applications, especially when working with configuration files, data exchange, or APIs. YAML (YAML Ain't Markup Language) is a human-readable serialization format, while JSON (JavaScript Object Notation) is a lightweight data interchange format. In this guide, we will explore how to convert YAML to JSON in Ruby, covering the basics, edge cases, common mistakes, and performance tips.

Quick Example

Here is a minimal example that converts a YAML string to JSON:

require 'yaml'
require 'json'

yaml_string = "name: John Doe
age: 30"

json_string = JSON.generate(YAML.safe_load(yaml_string))

puts json_string
# Output: {"name":"John Doe","age":30}

This example uses the yaml and json gems, which are part of the Ruby Standard Library.

Step-by-Step Breakdown

Let's break down the code:

require 'yaml'
require 'json'

We require the yaml and json gems, which provide the necessary functionality for parsing YAML and generating JSON.

yaml_string = "name: John Doe
age: 30"

We define a YAML string with two key-value pairs.

json_string = JSON.generate(YAML.safe_load(yaml_string))

We use YAML.safe_load to parse the YAML string into a Ruby hash. The safe_load method is used to prevent arbitrary code execution, which is a security best practice. We then pass the hash to JSON.generate, which converts the hash to a JSON string.

puts json_string
# Output: {"name":"John Doe","age":30}

Finally, we print the resulting JSON string.

Handling Edge Cases

Empty/Null Input

When dealing with empty or null input, we should handle the case where the input YAML string is empty or nil. We can add a simple check:

yaml_string = nil

if yaml_string
  json_string = JSON.generate(YAML.safe_load(yaml_string))
else
  json_string = "{}"
end

In this example, if the input YAML string is nil, we set the output JSON string to an empty object ({}).

Invalid Input

If the input YAML string is invalid, YAML.safe_load will raise a Psych::SyntaxError. We can rescue this exception and handle it accordingly:

begin
  json_string = JSON.generate(YAML.safe_load(yaml_string))
rescue Psych::SyntaxError => e
  json_string = "{ error: 'Invalid YAML input' }"
end

In this example, if the input YAML string is invalid, we catch the exception and set the output JSON string to an error object.

Large Input

When dealing with large input YAML strings, we should be mindful of performance. One approach is to use a streaming YAML parser, such as yaml-stream. However, this is outside the scope of this article.

Unicode/Special Characters

YAML and JSON both support Unicode characters. However, when working with special characters, we should ensure that our code handles them correctly. For example, we can use the utf-8 encoding when reading and writing files:

File.open('input.yaml', 'r:UTF-8') do |file|
  yaml_string = file.read
  # ...
end

Common Mistakes

1. Using YAML.load instead of YAML.safe_load

YAML.load can execute arbitrary code, which is a security risk. Always use YAML.safe_load instead.

# Wrong
json_string = JSON.generate(YAML.load(yaml_string))

# Correct
json_string = JSON.generate(YAML.safe_load(yaml_string))

2. Not handling empty or null input

Failing to handle empty or null input can lead to errors or unexpected behavior.

# Wrong
json_string = JSON.generate(YAML.safe_load(yaml_string)) if yaml_string

# Correct
if yaml_string
  json_string = JSON.generate(YAML.safe_load(yaml_string))
else
  json_string = "{}"
end

3. Not rescuing Psych::SyntaxError

Failing to rescue Psych::SyntaxError can lead to unhandled exceptions.

# Wrong
json_string = JSON.generate(YAML.safe_load(yaml_string))

# Correct
begin
  json_string = JSON.generate(YAML.safe_load(yaml_string))
rescue Psych::SyntaxError => e
  json_string = "{ error: 'Invalid YAML input' }"
end

Performance Tips

1. Use JSON.generate instead of to_json

JSON.generate is faster and more efficient than to_json.

# Slow
json_string = YAML.safe_load(yaml_string).to_json

# Fast
json_string = JSON.generate(YAML.safe_load(yaml_string))

2. Use YAML.safe_load instead of YAML.load

YAML.safe_load is faster and more secure than YAML.load.

# Slow and insecure
json_string = JSON.generate(YAML.load(yaml_string))

# Fast and secure
json_string = JSON.generate(YAML.safe_load(yaml_string))

3. Use a streaming YAML parser for large input

For large input YAML strings, consider using a streaming YAML parser, such as yaml-stream.

FAQ

Q: What is the difference between YAML.load and YAML.safe_load?

A: YAML.load can execute arbitrary code, while YAML.safe_load is a safer alternative that only loads YAML data.

Q: How do I handle invalid YAML input?

A: You can rescue Psych::SyntaxError and handle it accordingly.

Q: What is the best way to handle large input YAML strings?

A: Consider using a streaming YAML parser, such as yaml-stream.

Q: How do I ensure that my code handles Unicode characters correctly?

A: Use the utf-8 encoding when reading and writing files, and ensure that your code uses Unicode-aware libraries and functions.

Q: What is the difference between JSON.generate and to_json?

A: JSON.generate is faster and more efficient than to_json.