Translator for the English language
How's this looking as an OOP language overall?


Ruby is actually multi-paradigm.
It allows you to use OO, and it gives you the option not to.
For example you didn't use any objects,
so you didn't actually employ OOP.

For improvements:


Your {lang}_translate code is very repetitive,
you can change it to a class to reduce repetitiveness.
You load the YAML file on each word translated (or incorrectly inputted),
and so you should load it once.
You have to add multiple things when you add a new language.


Both the index and language in the case.
Both the index and language in the puts
The language file in the new {lang}_translate function.


You can remove this all if you use a list and a class.




First, to remove the first two points,
I would make a class that lazily loads the translations.
And implements the translation.
Also I personally think your case statement in {lang}_translate is better as if elsif else.
exit seems like a bad design here,
if you were to want to allow the user to change language by entering 'q',
you will have to remove the exit.

class Translate
    def initialize(file_name)
        @file_name = file_name
    end

    def set_translation
        @translations = YAML.load_file @file_name
    end

    def translate
        puts "Enter word or phrase to be translated to English, press 'Q' to quit:"
        input = gets.chomp
        if (@translations || set_translation)[input]?
            puts "The translation from Spanish to English is: #{@translations[input]}"
        elsif input =~ /q/i
            return
        else
            puts "Invalid word or phrase redirecting..."
            translate
        end
    end
end

spanish = Translate.new('spanish.yaml')
spanish.translate


This can then be expanded easily to allow any language,
by just passing a different file path.



As for welcome,
I would recommend using an Array so you have control over the order.
And so you can specify languages by only name and file.

languages = [
    ["Spanish", Translate.new('spanish.yaml')],
    ["Russian", Translate.new('russian.yaml')],
    ["Arabic", Translate.new('arabic.yaml')]
]


Being able to use this in the output is a simple each_with_index.

For the program to automatically call translate
you need to get the index of the language in the languages Array.
Where you get the index either via a regex or .index.
Finally you then check if it's valid input, and output correctly.

def welcome
    languages = [
        ["Spanish", Translate.new('spanish.yaml')],
        ["Russian", Translate.new('russian.yaml')],
        ["Arabic", Translate.new('arabic.yaml')]
    ]

    puts "Welcome to the Translation Center! Please enter the language you would like to translate to English or you can choose from the list below:"
    languages.each_with_index { |item, index| puts String(index + 1) + '. ' + item[0] }
    language = gets.chomp!.downcase

    index = if /^\d+$/.match(language) then
        Integer(language) - 1
    else
        languages.index { |x| x[0].downcase == language }
    end

    if index.nil? or (language = languages[index][1]).nil?
        puts "Language is not yet supported within Translation Center."
    else
        language.translate
    end
end




Finally, I think that you should allow users to input more than one word or phrase at a time. This would be adding a simple infinite loop to Translate.translate, and changing it to not be recursive.