The Art of Ruby Scripting

Scripting doesn't have to be a headache. Ruby is uniquely powerful at transforming tedious tasks into quick, elegant solutions. Let's dive deep into two realistic, everyday scripting challenges to showcase just how clearly and succinctly Ruby handles complex tasks.

CASE STUDY 001 - Compress Your Videos

Imagine finding yourself with a folder filled with large MOV and MP4 video files and needing an efficient way to compress them all. Here's how easily Ruby accomplishes this:

video_files = Dir.glob("{*.mov,*.mp4}", base: "videos")

Dir.chdir('videos')

video_files.each do |video_file|
  file = video_file.sub(/\.(mov|mp4)$/, '_compressed.\1')

  `ffmpeg -i #{video_file} -vcodec h264 -acodec mp3 #{file}`
end

Line-by-Line Explanation

The first line uses Ruby's built-in Dir.glob method to efficiently find and list all .mov and .mp4 video files inside the "videos" directory. The curly braces {*.mov,*.mp4} represent a concise pattern that matches all files ending with either .mov or .mp4.

Next, Dir.chdir('videos') changes the current working directory to the "videos" folder, ensuring the script can execute commands directly on the listed files.

The video_files.each loop iterates through each collected video file, allowing actions to be performed individually on each one.

Within the loop, video_file.sub(/\.(mov|mp4)$/, '_compressed.\1') uses Ruby's powerful regular expression substitution to create a new filename for each video file. The original file extension (.mov or .mp4) is captured by the (mov|mp4) group and then reused (\1) in the new filename, appending _compressed right before the file extension.

Finally, the command enclosed in backticks executes the external command-line tool ffmpeg to compress each video file using the specified codecs: h264 for video and mp3 for audio, writing the compressed output to the newly defined filename.

Ruby's clarity, concise syntax, and expressive methods significantly enhance script readability, allowing developers to quickly understand and maintain their automation tasks with minimal effort.

CASE STUDY 002 - Bulk Renaming and Organizing Your Photo Library

Imagine having thousands of photos scattered in a directory, each with generic filenames like IMG_1234.JPG. You want to rename them based on the date stored in their EXIF metadata and neatly organize them into folders by year and month. Ruby handles this complex task elegantly:

require 'bundler/inline'

gemfile do
  source 'https://rubygems.org'
  gem 'mini_exiftool'
end

require 'mini_exiftool'
require 'fileutils'

photos = Dir.glob("photos/*.JPG")

photos.each do |photo|
  exif       = MiniExiftool.new(photo)
  date_taken = exif.date_time_original
  
  next unless date_taken
  
  year_month    = date_taken.strftime("%Y/%m")
  new_directory = "organized_photos/#{year_month}"
  
  FileUtils.mkdir_p(new_directory)
  
  new_filename = date_taken.strftime("%Y-%m-%d_%H-%M-%S.jpg")
  new_filepath = File.join(new_directory, new_filename)
  
  FileUtils.cp(photo, new_filepath)
endruby

Line-by-Line Explanation

First, the bundler/inline method allows including the mini_exiftool gem directly in the script without needing a separate Gemfile.

The inline gemfile do block explicitly declares the required external gem (mini_exiftool) and sets the gem source.

The script then requires the necessary modules: mini_exiftool for EXIF data extraction and Ruby’s built-in fileutils for file operations.

photos = Dir.glob("photos/*.JPG") collects all .JPG photo files within the photos directory.

Within the loop, MiniExiftool.new(photo) creates an object to access the photo's EXIF metadata. date_time_original retrieves the original date and time the photo was taken.

The script uses next unless date_taken to skip files without EXIF date data, ensuring robust handling of incomplete data.

Using strftime, the script formats the date into a year/month structure (YYYY/MM) for the new directories.

FileUtils.mkdir_p(new_directory) creates the directory path (organized_photos/YYYY/MM) if it doesn't already exist.

The filename itself is formatted clearly as YYYY-MM-DD_HH-MM-SS.jpg.

Finally, FileUtils.cp(photo, new_filepath) copies the photo into the newly created directory with its new, meaningful filename.

Ruby turns this potentially complex and tedious manual task into a straightforward, maintainable script.

Conclusion

Forget complicated scripts in other languages. With Ruby, scripting becomes straightforward, powerful, and elegant.

Ready to simplify your scripting life?

Try Ruby. It's fantastic and unbeatable.

Also, you can use the coupon code RC40 to get 40% OFF on RubyCademy

🔗 https://www.rubycademy.com

Voilà!