Welcome to our lesson on mastering data aggregation and data streams with JSON formatting in Ruby.

In this lesson, we'll start by building a basic sales records aggregator and then extend its functionality to handle more complex operations, such as filtering, data aggregation, and JSON formatting. By the end of this session, you’ll be able to manage and format data streams efficiently with Ruby.

To begin, we’ll implement a basic sales record aggregator with essential methods:

• add_sale(sale_id, amount) — Adds a sale record with a unique identifier sale_id and an amount. If a sale with the same sale_id already exists, it updates the amount.
• get_sale(sale_id) — Retrieves the sale amount associated with the sale_id. If the sale does not exist, it returns nil.
• delete_sale(sale_id) — Deletes the sale record with the given sale_id. Returns true if the sale was deleted and false if the sale does not exist.

With these methods in place, let’s proceed to the code.

Here is the complete code for the starter task:

The initialize method sets up an empty hash to store sales records. The add_sale method either adds a new sale or updates the amount if a sale with the same ID already exists. The get_sale method retrieves the amount for a given sale ID, returning nil if the sale does not exist. The delete_sale method removes the sale record for a specified sale ID, returning false if the sale does not exist.

To test these methods, here’s some example usage:

With the basic aggregator working, let’s expand its functionality to handle more advanced operations.

To increase the functionality of our sales aggregator, we’ll introduce new methods for advanced data aggregation, filtering, and JSON formatting:

• aggregate_sales(min_amount = 0) — Returns a hash with the total number of sales and the total amount of sales where the sale amount is above min_amount. The hash format is:
• format_sales(min_amount = 0) — Returns the sales data, filtered by min_amount, formatted as JSON. Includes aggregated sales statistics in the output.
• add_sale(sale_id, amount, date) — Adds or updates a sale record with sale_id, amount, and a date in the format "YYYY-MM-DD".
• get_sales_in_date_range(start_date, end_date) — Retrieves all sales within the specified date range, inclusive, including each sale’s sale_id, amount, and date.

Let’s implement these methods step-by-step, using map, select, and reduce where applicable.

We’ll first modify the add_sale method to accept a date, so each sale record includes a date in addition to the amount.

This change allows each sale to store both an amount and a date, preparing the data structure for date-based filtering.

The aggregate_sales method will aggregate sales that exceed the specified min_amount, returning the total number of qualifying sales and the total sales amount. Here, we can use reduce to streamline the aggregation.

In aggregate_sales, reduce iterates through each sale and updates the accumulator (acc) with the count and sum of sales above min_amount. This approach makes the method concise and efficient for handling aggregations.

Example usage:

The format_sales method will output the sales data in JSON format, filtered by min_amount, and include aggregated statistics. We’ll use select and map here.

In format_sales, select filters the sales, and map converts the filtered result (which is an array of key-value pairs) into an array of hashes, each containing sale_id, amount, and date. The use of JSON.generate with quirks_mode: true avoids adding slashes in the output by generating JSON strings with unescaped forward slashes.

Example usage:

Finally, let’s implement the get_sales_in_date_range method to retrieve sales within a specific date range, using select and map to streamline the process.

In get_sales_in_date_range, select filters the sales within the specified date range, and map formats the results as an array of hashes, each containing sale_id, amount, and date.

Example usage:

Congratulations! You’ve extended a basic sales aggregator into a fully functional data management tool, capable of filtering, aggregating, and formatting sales data in JSON using Ruby’s powerful select, map, and reduce methods. These skills are invaluable for efficiently handling data streams, especially with larger datasets.

Experiment with similar tasks to reinforce your understanding. Great job, and see you in the next lesson!