How to delete a character from the last instance of .each - ruby

Question

I want to generate a JSON in my view of a rails project. I am doing like this: (I am not a developer, it is bad coding I know)
<% #content.keywords.each do |x| %>
<% if x.type == "keyword" %>
{
"key": "<%= x.keyword %>",
"weight": <%= x.weight %>
},
<% else %>
<% end %>
<% end %>
Nonetheless, for the last keyword of my JSON
{
"key": "<%= x.keyword %>",
"weight": <%= x.weight %>
},
I have a character "," that I want do delete for my JSON to be valid. I don't know how to do it. Can you provide any help?

Answer 1

Here's how I would go about refactoring this to achieve what you want:
Make things a little easier.
Part of the reason we avoid lots of logic in an ERB file is that it makes things like this a lot more awkward. So generally we'd put this logic into a helper file, like app/helpers/keywords_helper.rb, so that we make a distinction between displaying things and computing things. For you, the helper would look like this:
module KeywordsHelper
def keywords_json
#content.keywords.map do |x|
if x.type == 'keyword'
%Q({ "key": "#{x.keyword}", "weight": "#{x.weight}" })
else
# did you mean to do nothing here?
end
end.compact.join(', ')
end
end
You'll see I haven't actually changed all that much - instead of using ERB to insert things into the page, I've used #{blah} to insert things into strings.
At the end, I do a little bit of magic:
.compact will get rid of any "null" values (nil). Before that, if x.type is not equal to "keyword", nothing will happen, which will leave you with nil. You might end up with an array like [nil, "{\"key\"...}", "{\"key\"...}", nil, nil] - and this might break some of the other solutions too. By using .compact, it will strip all the nils out and leave you with ["{\"key\"...}", "{\"key\"...}"]
.join(', ') - once we've got an array, we want to sandwich commas between each one. Join takes any array, tries to turn the items into strings (if they weren't already), and puts whatever string you choose in between. Note that I've also added a space - this isn't strictly necessary, just makes the json look prettier.
In the middle there, you see %Q( - this is one of the things that makes Ruby special. Ruby has a lot of ways of making strings. Some might say too many ways. %Q is one of my favourites - it's the same as using "I'm a string" and gives you all the same facilities, with one exception: you get to choose how you start and end your string - %Q{normally you see this}, %Q[also perfectly valid], %Q~you can even do this~ You could do this with a 'normal' string, but then we'd have to escape the double quotes, e.g. "this is \"how it's done\" in some inferior languages"
We replace the ERB with:
<%= keywords_json %>
... or, more likely,
[ <%= keywords_json %> ]
... because after all, this is a JSON array.
Go even further
This is a much nicer solution... but can we make it even nicer? Have a look at this:
module KeywordsHelper
def keywords_json
#content.keywords.map do |x|
next if x.type != 'keyword'
{ key: x.keyword, weight: x.weight }
end.compact.to_json
end
end
and your erb returns to:
<%= keywords_json %>
You'll notice this is much shorter. A few notes on what we're doing here:
next if x.type != 'keyword'
Where we had the else before, rather than have an empty section in our if... else... end we could have just done if... end. But if we don't need to do that, we can also say "skip this loop if..." - which is what I've done here. Note that we can also be explicit about what we expect to receive from a skipped loop - this is equivalent to the above:
next nil if x.type != 'keyword'
or, if there was something else you wanted return, we could put that here:
next {error: 'not a keyword'} if x.type != 'keyword'
Secondly, rather than building JSON objects in strings and joining them together, Rails provides us some handy tools. We can build Ruby objects (called Hashes) and call .to_json on them to get a valid json object. And we can even do it on arrays to get a valid json array, which is what we're doing here.
I know that's more of an answer than you were looking for, but hopefully it gives you some idea of the things you can do in ruby and gives you a good launch pad for moving on! Good luck!

Answer 2

Generally, it's impossible/difficult to withdraw content you've already written. The trick is to not write it in the first place.
I think, the minimal modification of your code would be to use each_with_index and check current index to determine if we need to write the comma or not. Something like this:
<% #content.keywords.each_with_index do |x, idx| %>
<% if x.type == "keyword" %>
<% if idx > 0 %>
,
<% end %>
{
"key": "<%= x.keyword %>",
"weight": <%= x.weight %>
}
<% end %>
<% end %>
Of course, this code is even worse than what you had, but it does the job and it's not radically different.

Answer 3

Probably what you want, is to move some of the logic out of your view and either into the model or into a helper (or a dedicated serialiser, plenty of options). For example, you could do the following (you would lose a bit of control over the actual layout, I hope that's not a problem):
In a helper:
def keywords_for_json(keywords):
keywords.filter {|k| k.type == 'keyword'}
.map {|k| {key: k.keyword, weight: x.weight} }
end
This does the filtering and converts the objects to hashes using map,
and in the view you could just do :
<%= keywords_for_json(#content.keywords).to_json %>
which converts all the hashes to json objects.
As I said, the actual logic could go in any number of places, depending on personal preference, this example uses a helper because I think it's the simplest to show here. Ideally you'd just set up the model for serialisation, using as_json and only call to_json on your collection (and pre-filter #content.keywords, maybe in your controller or in a model).