Code for appending to a certain index of an array

Question

I have a collection which, after the code has ran, looks something like the following:

[
 { title: 'alpha', lines: [ { *some object* } ] },
 { title: 'bravo', lines: [ { *some object* } ] },
 { title: 'charl', lines: [ { *some object* } ] },
 { title: 'delta', lines: [ { *some object*, *some object 2*, *some object 3* } ] m},
 { title: 'echoo', lines: [ { *some object* } ] },
]

The way that I'm doing this is:

1. Check if there is an object in the outer array that has a matching title
   • If it doesn't exist, create that object with the title and lines
2. Check if inside lines there is an object that exists at the specific supplied index
   • If it doesn't exist, create the object at that index
   • Otherwise take the existing object at that index and append val to a_or_b

This method will get called multiple times per group i.e. 4 times for alpha, 4 times for bravo, and 4 times for each line in delta. There is currently one group (but there may be more in the future) which has more than one object inside the lines.

def data_with(data, val, group, date, nom, a_or_b, line_no = 0)
 # add this group if it doesn't exist
 if data.find { |x| x[:title] == group }.nil?
 data << { title: group, lines: [] }
 end
 # if the line at the line_no doesn't exist, create it
 if data.find { |x| x[:title] == group }[:lines][line_no].nil?
 data.find { |x| x[:title] == group }[:lines][line_no] = {
 date: date,
 nom: nom,
 a_or_b.to_sym => val
 }
 else # add to the value of the line at the line_no index
 data.find { |x| x[:title] == group }[:lines][line_no][a_or_b.to_sym] += val
 end
end

What are some ways I can improve this method?

Answer 1

In general I think something feels off with your data structure and the naming of your parameters / variables is extremely difficult to understand (e.g. what is an a_or_b?).

Anyway, you could structure your code a bit more object oriented and extract helper methods. I don't know the full context of your application so this might be overkill. To provide some food for thoughts here is an example:

input = [
 { title: 'alpha', lines: [ { a_or_b: 1 } ] },
 { title: 'bravo', lines: [ { a_or_b: 1 } ] },
 { title: 'charl', lines: [ { a_or_b: 1 } ] },
 { title: 'delta', lines: [ { a_or_b: 1 } ] },
 { title: 'echoo', lines: [ { a_or_b: 1 } ] },
]
class Collection
 class Entry
 def initialize(data)
 @data = data
 end
 def ==(other)
 @data[:title] == other
 end
 def update_or_create_line_by(index:, date:, nom:, a_or_b:, value:)
 update_line_by(index: index, value: value, a_or_b: a_or_b) ||
 create_line_by(index: index, date: date, nom: nom, a_or_b: a_or_b, value: value)
 end
 def create_line_by(index:, date:, nom:, a_or_b:, value:)
 lines[index] = {
 date: date,
 nom: nom,
 a_or_b.to_sym => val
 }
 end
 def update_line_by(index:, value:, a_or_b:)
 return unless lines[index]
 lines[index][a_or_b.to_sym] += value
 end
 private
 def lines
 @data[:lines]
 end
 end
 def initialize(data)
 @data = data.map { |entry| Entry.new(entry) }
 end
 def find_or_create(title:)
 find_by(title: title) || create_by(title: title)
 end
 def find_by(title:)
 @data.find { |entry| entry == title }
 end
 def create_by(title:)
 entry = Entry.new(title)
 @data << entry
 entry
 end
end
def data_with(data, val, group, date, nom, a_or_b, line_no = 0)
 collection = Collection.new(data)
 entry = collection.find_or_create(title: group)
 entry.update_or_create_line_by(index: line_no, date: date, nom: nom, a_or_b: a_or_b, value: val)
end
data_with(input, 1, 'alpha', Time.now, 'nom', 'a_or_b', 0)
puts input
```