Rubyguides.com does a great job presenting all the things you can do with strings in Ruby.

I have a couple of points in my BlogPoster Ruby script where an error can cause the program to end, and I have been at odds as to how to deal with it.

I had been looking at the various Ruby Gems that I am using for tips on how they might handle errors more gracefully and didn't gain any insight.

Turns out I was looking in the wrong place.

Today I took a few minutes to search for how Ruby handles errors and exceptions, and I found the begin ... rescue ... else methods. The Bastards Book of Ruby explains them very well.

I quickly wrote this little program to make sure it worked (it does). Though I'm in the middle of a method-based rewrite of the BlogPoster program, I might hack this into the old script to see if I can keep the program from stopping when the Nokogiri and Twitter Gems encounter problems (the former with unresolvable URLs, the latter with connectivity issues).

Here is my "test" of `begin ... rescue ... else:

#!/usr/bin/env ruby

# Handling potential errors in Ruby with begin/rescue/else
# The 'error' here is trying to divide by zero.

begin
    1/0
rescue
    puts "The expression 1/0 doesn\'t work"
else
    puts "The expression 1/0 does work"
end

begin
    1/1
rescue
    puts "The expression 1/1 doesn\'t work"
else
    puts "The expression 1/1 does work"
end

# Expected output:
#
# The expression 1/0 doesn't work
# The expression 1/1 does work

Update: I tried this with "real" code, and it works!

I'm not sure if this is a Windows-specific problem (I am currently developing on Windows 10), but part of the Ruby script in my Blog Poster app allows the user to "archive" all of the text files created as blog/social posts by moving them from the main program directory to an archives directory. I could opt not to create files at all, or have the script continue to overwrite the same one for each post.

But for now I'm keeping all of the text files (which the script creates and names based on the <title> tag of URLs that are part of the post, and I have an option to move those text files to the archive directory:

Dir.glob("*.txt") {|f| FileUtils.move File.expand_path(f), "archive" }

This part of the Ruby script worked fine when I started it and was doing nothing else, but if I used it to create one or more files, invoking the "archive" feature would error out and kill the script, saying that there was a permission issue.

Laziness. I looked in Stack Overflow and found the solution, which consisted of adding :force => true to the expression:

Dir.glob("*.txt") {|f| FileUtils.move File.expand_path(f), "archive", :force => true }

Now I can create posts (and their matching .txt files, which my blog uses) and then archive them at any point without the permission error killing the script. Thanks, Stack Overflow user mudasobwa.

Update: This modification allowed the script to keep running, but any files created during the current session are NOT moved to the archive directory.

The reason the files created during the session were not deletable is due to the script reading them out in the console. I will figure out a way to provide this output without rendering the files "undeletable" via Ruby.

Here are the lines I am removing for now:

puts "This is your file:\n\n"
File.open( @yourFileName ).each do |line|
   puts line
end

I'm not quite sure how I stumbled upon the Ruby Terminal Apps Toolkit, but the gems included can definitely speed your development of interactive Ruby apps on the command line.

I just coded a menu for my app, and these gems by Piotr Murach offer a lot of ways to do this easily and to solicit and process user input.

The next thing I'm looking at doing in my app is allowing users to open lines for editing in their text editor of choice, and these TTY gems definitely do that. I wasn't thinking that shelling out to an editor would be so hard (meaning that was something that Ruby can do with no gems), but maybe this is a better (or easier) way.

The "hard" part in allowing user editing in my app is that I am assembling files to upload from a series of variables, and I think I'll have to create temporary files for editing that only include the component being modified (i.e. title, text, link, filename) because my app knows how to turn variables into a file but not a file into a series of variables, though that is something I could code into it. (But I may not do this because I am thinking of going in another direction and not creating actual files on the system at all and using Ruby to stream the data via FTP.)

That's more detail without context about the app I'm working on than you need.

tl;dr: The Ruby Terminal Apps Toolkit can speed up development of command-line based apps. You can use single gems or the whole thing. It's up to you.