random-words 1.0.6 → 1.0.8

data/lib/random-words/config.rb

@@ -48,7 +48,6 @@ module RandomWords
       rw_source = RandomWords::Source.new(@lang, @source_dir)
 
       @dictionary = rw_source.dictionary
-
     end
 
     # Tests if a uer dictionary exists
@@ -56,7 +55,9 @@ module RandomWords
     # @raise [RuntimeError] if the user dictionary is incomplete
     def user_dictionary_exist?
       if user_lang_dir
-        raise "User dictionary for #{@lang} is incomplete. Please run create_user_dictionary." unless all_parts_of_speech?(user_lang_dir, @lang)
+        raise "User dictionary for #{@lang} is incomplete. Please run create_user_dictionary." unless all_parts_of_speech?(
+          user_lang_dir, @lang
+        )
 
         true
       else
@@ -93,11 +94,11 @@ module RandomWords
       dir ||= @source_dir
       exists = true
       SPEECH_PARTS.each do |part|
-        unless File.exist?(File.join(dir, "#{part}.txt"))
-          warn "Missing #{File.join(dir, "#{part}.txt")} for #{lang}"
-          exists = false
-          break
-        end
+        next if File.exist?(File.join(dir, "#{part}.txt"))
+
+        warn "Missing #{File.join(dir, "#{part}.txt")} for #{lang}"
+        exists = false
+        break
       end
       CONFIG_FILES.each do |file|
         unless File.exist?(File.join(dir, "#{file}.yml"))
@@ -112,7 +113,8 @@ module RandomWords
     # @param lang [String] The language to create the dictionary for
     # @return [Symbol, nil] The language symbol if successful, nil otherwise
     def create_user_dictionary(lang = nil)
-      return lang.to_sym if File.directory?(File.join(config_dir, 'words', lang)) && all_parts_of_speech?(File.join(config_dir, 'words', lang), lang)
+      return lang.to_sym if File.directory?(File.join(config_dir, 'words',
+                                                      lang)) && all_parts_of_speech?(File.join(config_dir, 'words', lang), lang)
 
       lang_dir = File.join(config_dir, 'words', lang)
 
@@ -132,27 +134,29 @@ module RandomWords
       target_file = File.join(lang_dir, 'numbers.yml')
       unless File.exist?(target_file)
         FileUtils.cp(source_file, target_file)
-        warn "Created numbers.yml"
+        warn 'Created numbers.yml'
       end
 
       # Create the config.yml file if it doesn't exist
-      target_file = File.join(lang_dir, "config.yml")
+      target_file = File.join(lang_dir, 'config.yml')
 
       unless File.exist?(target_file)
         config = {
-          "name" => lang,
-          "triggers" => [lang],
-          "description" => "User dictionary for #{lang}",
+          'name' => lang,
+          'triggers' => [lang],
+          'description' => "User dictionary for #{lang}"
         }
         File.write(target_file, config.to_yaml)
         warn "Created #{target_file}"
       end
 
-      if all_parts_of_speech?(lang_dir, lang) || (RandomWords.testing && !RandomWords.tested.include?('create_user_dictionary'))
-        RandomWords.tested << 'create_user_dictionary'
-        warn "Created #{lang} in #{lang_dir}"
-        lang.to_sym
+      unless all_parts_of_speech?(lang_dir, lang) || (RandomWords.testing && !RandomWords.tested.include?('create_user_dictionary'))
+        return
       end
+
+      RandomWords.tested << 'create_user_dictionary'
+      warn "Created #{lang} in #{lang_dir}"
+      lang.to_sym
     end
 
     # List all sources available, builtin and custom
@@ -161,13 +165,15 @@ module RandomWords
       return @sources if @sources
 
       @sources = {}
-      Dir[File.join(__dir__, "words", "*")].each do |dir|
+      Dir[File.join(__dir__, 'words', '*')].each do |dir|
         next unless File.directory?(dir)
+
         name = File.basename(dir)
         @sources[name] = RandomWords::Source.new(name, dir)
       end
-      Dir[File.join(config_dir, "words", "*")].each do |dir|
+      Dir[File.join(config_dir, 'words', '*')].each do |dir|
         next unless File.directory?(dir)
+
         name = File.basename(dir)
         @sources[name] = RandomWords::Source.new(name, dir)
       end
@@ -201,7 +207,7 @@ module RandomWords
       {
         source: configuration[:source].to_source || :latin,
         sentence_length: configuration[:length].to_length || :medium,
-        paragraph_length: configuration[:paragraph_length].to_i || 5,
+        paragraph_length: configuration[:paragraph_length].to_i || 5
       }
     end
 
@@ -236,9 +242,9 @@ module RandomWords
     def create_base_config(config_file)
       FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
       config = {
-        "source" => "latin",
-        "length" => "medium",
-        "paragraph_length" => 5,
+        'source' => 'latin',
+        'length' => 'medium',
+        'paragraph_length' => 5
       }
       File.write(config_file, config.to_yaml)
       warn "Created #{config_file}"

data/lib/random-words/generator.rb

@@ -9,8 +9,8 @@ module RandomWords
   class Generator
     # @return [Array<String>] arrays of elements of speech
     attr_reader :nouns, :verbs, :passive_verbs, :adverbs, :adjectives, :articles, :clauses, :subordinate_conjunctions,
-                  :terminators, :numbers, :plural_nouns, :plural_verbs, :plural_articles, :prepositions, :coordinating_conjunctions,
-                  :all_words, :extended_punctuation
+                :terminators, :numbers, :plural_nouns, :plural_verbs, :plural_articles, :prepositions, :coordinating_conjunctions,
+                :all_words, :extended_punctuation, :phrases, :names
 
     # Whether to use extended punctuation
     # @return [Boolean] true if extended punctuation is used, false otherwise
@@ -31,7 +31,7 @@ module RandomWords
     # Define the default sentence parts
     # These parts will be used to generate random sentences and character strings
     SENTENCE_PARTS = %w[random_article random_adjective random_noun random_adverb random_verb random_adjective
-                        random_verb random_adverb].freeze
+                        random_verb random_adverb random_phrase].freeze
 
     # Initialize the generator with a source and options
     # @param source [Symbol] The source of the words (e.g., :english)
@@ -63,7 +63,8 @@ module RandomWords
       @numbers = @config.dictionary[:numbers]
       @sources = @config.sources
       @terminators = @config.dictionary[:terminators]
-      @names = [@config.dictionary[:first_names], @config.dictionary[:last_names]]
+      @names = [@config.dictionary[:first_names], @config.dictionary[:last_names], @config.dictionary[:full_names]]
+      @phrases = @config.dictionary[:phrases]
       @all_words = @config.dictionary[:all_words]
 
       @options = {
@@ -77,9 +78,7 @@ module RandomWords
       @paragraph_length = @options[:paragraph_length]
       @use_extended_punctuation = @options[:use_extended_punctuation]
 
-      if @use_extended_punctuation
-        @terminators.concat(@config.dictionary[:extended_punctuation])
-      end
+      @terminators.concat(@config.dictionary[:extended_punctuation]) if @use_extended_punctuation
       lengths
     end
 
@@ -162,6 +161,7 @@ module RandomWords
       res << random_subordinate_conjunction
       res << random_coordinating_conjunction
       res << random_number_with_plural
+      res << random_phrase
       res << random_conjunction
       res << random_passive_verb
       res << random_plural_noun
@@ -292,7 +292,7 @@ module RandomWords
         new_sentence = generate_sentence(length / 2)
 
         # Combine the sentences with random conjunctions
-        sentence = "#{sentence.strip.no_term}, #{random_coordinating_conjunction} #{new_sentence}"
+        sentence = "#{sentence.strip.no_term(terminators)}, #{random_coordinating_conjunction} #{new_sentence.no_term(terminators)}"
       end
 
       sentence.to_sent(random_terminator).fix_caps(terminators)
@@ -325,6 +325,7 @@ module RandomWords
       code_langs[Random.rand(code_langs.count)]
     end
 
+    # rubocop:disable Layout/LineLength
     # Return random code snippet
     # @param lang [Symbol] The language of the code snippet
     # @return [String] A randomly generated code snippet
@@ -332,23 +333,24 @@ module RandomWords
       code_snippets = {
         python: %(def hello_world():\n    print("Hello, World!")),
         ruby: %(def hello_world\n  puts "Hello, World!"\nend),
-        swift: %(func helloWorld() {\n    print(\"Hello, World!\")\n}),
-        javascript: %(function helloWorld() {\n    console.log(\"Hello, World!\");\n}),
+        swift: %(func helloWorld() {\n    print("Hello, World!")\n}),
+        javascript: %(function helloWorld() {\n    console.log("Hello, World!");\n}),
         css: %(body {\n    background-color: #f0f0f0;\n    font-family: Arial, sans-serif;\n}\nh1 {\n    color: #333;\n}),
         rust: %(fn main() {\n    println!("Hello, World!");\n}),
-        go: %(package main\nimport \"fmt\"\nfunc main() {\n    fmt.Println(\"Hello, World!\")\n}),
+        go: %(package main\nimport "fmt"\nfunc main() {\n    fmt.Println("Hello, World!")\n}),
         java: %(public class HelloWorld {\n    public static void main(String[] args) {\n        System.out.println("Hello, World!");\n    }\n})
       }
       lang ||= code_lang
       code_snippets[lang.to_sym]
     end
+    # rubocop:enable Layout/LineLength
 
     # Generate random markdown
     # @param settings [Hash] Settings for generating markdown
     # @return [String] A randomly generated markdown string
     def markdown(settings = {})
       input = RandomWords::LoremMarkdown.new(settings).output
-      RandomWords::HTML2Markdown.new(input)
+      RandomWords::HTML2Markdown.new(input).markdown
     end
 
     # Generate random HTML
@@ -391,7 +393,7 @@ module RandomWords
         return characters(config.min, config.max, whole_words: config.whole_words, whitespace: config.whitespace,
                                                   dead_switch: config.dead_switch + 1)
       end
-      puts "made it"
+
       truncated = config.new_result.compress[0...config.max]
       truncated.compress.length == config.max ? truncated.compress : nil
     end
@@ -410,7 +412,7 @@ module RandomWords
       sentence_components = []
 
       # Randomly decide if we include a plural noun with a number
-      sentence_components << random_number_with_plural if roll(10) # 10% chance to include a plural noun
+      # sentence_components << random_number_with_plural if roll(10) # 10% chance to include a plural noun
 
       # Construct main clause
       sentence_components << generate_main_clause
@@ -424,13 +426,14 @@ module RandomWords
         sentence_components.concat(additional_clauses)
         sentence_components.map!(&:strip)
         break if sentence_components.join(' ').length >= length
+
         conjunction = if roll(50) || (RandomWords.testing && !RandomWords.tested.include?('subordinate_conjunction'))
-          RandomWords.tested << 'subordinate_conjunction' if RandomWords.testing
-          random_subordinate_conjunction.strip
-        else
-          RandomWords.tested << 'coordinating_conjunction' if RandomWords.testing
-          random_coordinating_conjunction.strip
-        end
+                        RandomWords.tested << 'subordinate_conjunction' if RandomWords.testing
+                        random_subordinate_conjunction.strip
+                      else
+                        RandomWords.tested << 'coordinating_conjunction' if RandomWords.testing
+                        random_coordinating_conjunction.strip
+                      end
         # sentence_components.unshift(conjunction.capitalize) # Place conjunction at the start
         sentence_components << conjunction unless conjunction.empty?
       end
@@ -503,6 +506,12 @@ module RandomWords
       end
     end
 
+    # Generate a random phrase
+    # @return [String] A randomly selected phrase
+    def random_phrase
+      phrases.sample
+    end
+
     # Generate a random noun
     # @return [String] A randomly selected noun
     def random_noun
@@ -625,9 +634,14 @@ module RandomWords
     end
 
     def random_name
+      return @names[2].sample if (@names[0].empty? || @names[1].empty?) && !@names[2].empty?
+
+      return @names[2].sample if !@names[2].empty? && roll(60)
+
       first_name = @names[0].sample
+      middle_initial = roll(20) ? " #{('A'..'Z').to_a.sample}" : ''
       last_name = @names[1].sample
-      "#{first_name} #{last_name}"
+      "#{first_name}#{middle_initial} #{last_name}"
     end
 
     # Generate a random main clause
@@ -639,16 +653,19 @@ module RandomWords
     # @example
     #   generate_main_clause # Returns a random main clause
     def generate_main_clause
-
-      beginning = if roll(20)
+      start_with_phrase = roll(20)
+      start_with_plural = roll(20)
+      beginning = if start_with_phrase
+                    random_phrase
+                  elsif start_with_plural
                     "#{random_number_with_plural} #{random_adverb} #{random_plural_verb}"
                   else
                     noun = random_noun
                     adjective = random_adjective
                     "#{random_article_for_word(adjective)} #{adjective} #{noun} #{random_adverb} #{random_verb}"
                   end
-      tail = roll(50) ? " #{random_prepositional_phrase}" : ""
-      tail += roll(10) ? ", #{random_clause}" : ""
+      tail = roll(50) ? " #{random_prepositional_phrase}" : ''
+      tail += roll(10) ? ", #{random_clause}" : ''
       "#{beginning.strip.sub(/,?$/, ', ')}#{tail}"
     end
 

data/lib/random-words/hash.rb

@@ -13,4 +13,4 @@ module RandomWords
       each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v.is_a?(Hash) ? v.stringify_keys : v }
     end
   end
-end
+end

data/lib/random-words/html2markdown.rb

@@ -80,7 +80,7 @@ module RandomWords
           line = []
         end
       end
-      out << line.join(' ') + (str[-1..-1] =~ /[ \t\n]/ ? str[-1..-1] : '')
+      out << (line.join(' ') + (str[-1..-1] =~ /[ \t\n]/ ? str[-1..-1] : ''))
       out.join("\n")
     end
 
@@ -101,12 +101,12 @@ module RandomWords
         @section_level -= 1
         o
       when /h(\d+)/
-        "\n\n" + ('#' * (::Regexp.last_match(1).to_i + @section_level) + ' ' + output_for_children(node)) + "\n\n"
+        "\n\n" + (('#' * (::Regexp.last_match(1).to_i + @section_level)) + ' ' + output_for_children(node)) + "\n\n"
       when /mark/
         "==#{output_for_children(node)}=="
       when 'blockquote'
         @section_level += 1
-        o = "\n\n> #{output_for_children(node).lstrip.gsub(/\n/, "\n> ")}\n\n".gsub(/> \n(> \n)+/, "> \n")
+        o = "\n\n> #{output_for_children(node).lstrip.gsub("\n", "\n> ")}\n\n".gsub(/> \n(> \n)+/, "> \n")
         @section_level -= 1
         o
       when 'cite'
@@ -130,7 +130,7 @@ module RandomWords
           @in_pre = false
           node.text.strip
         else
-          "`#{output_for_children(node).gsub(/\n/, ' ')}`"
+          "`#{output_for_children(node).gsub("\n", ' ')}`"
         end
       when 'pre'
         @in_pre = true
@@ -185,7 +185,7 @@ module RandomWords
           %w[th td].include?(c.name)
         end.map do |c|
           output_for(c)
-        end.join.gsub(/\|\|/, '|') + header
+        end.join.gsub('||', '|') + header
       when 'th', 'td'
         "| #{output_for_children(node)} |"
       when 'text'
@@ -193,7 +193,7 @@ module RandomWords
         if (c = node.content.force_encoding(@encoding)) =~ /\S/
           c.gsub!(/\n\n+/, '<$PreserveDouble$>')
           c.gsub!(/\s+/, ' ')
-          c.gsub(/<\$PreserveDouble\$>/, "\n\n")
+          c.gsub('<$PreserveDouble$>', "\n\n")
         else
           c
         end
@@ -202,4 +202,4 @@ module RandomWords
       end
     end
   end
-end
+end

data/lib/random-words/lorem-markdown.rb

@@ -41,9 +41,9 @@ module RandomWords
       @options = defaults.merge(options)
 
       @generator = RandomWords::Generator.new(@options[:source], {
-        sentence_length: @options[:length],
-        paragraph_length: @options[:sentences]
-       })
+                                                sentence_length: @options[:length],
+                                                paragraph_length: @options[:sentences]
+                                              })
 
       @output = ''
       strong = @options[:decorate]
@@ -163,13 +163,13 @@ module RandomWords
       newline = nested ? '' : "\n\n"
       quote = "#{newline}<blockquote>\n"
       quote += paragraph(level1,
-                        em: @options[:decorate],
-                        strong: @options[:decorate],
-                        links: @options[:link],
-                        code: @options[:code],
-                        mark: @options[:mark]).gsub(
-                          /\n+/, "\n"
-                        )
+                         em: @options[:decorate],
+                         strong: @options[:decorate],
+                         links: @options[:link],
+                         code: @options[:code],
+                         mark: @options[:mark]).gsub(
+                           /\n+/, "\n"
+                         )
       quote += blockquote(level2, true).strip if level2.positive?
       "#{quote}#{cite}</blockquote>#{newline}"
     end
@@ -200,7 +200,7 @@ module RandomWords
               else
                 6
               end
-      grafs = @output.split(/\n\n/).reverse
+      grafs = @output.split("\n\n").reverse
 
       @output = header(1)
       @output += "#{grafs.slice!(-1)}\n\n"
@@ -284,13 +284,13 @@ module RandomWords
     # @param [Integer] count The number of blocks to inject.
     # @param [Proc] block The block whose result to inject.
     def inject_block(count, block)
-      grafs = @output.split(/\n\n/)
+      grafs = @output.split("\n\n")
 
-      if grafs.length < 2
-        len = 1
-      else
-        len = Random.rand(1..grafs.length / 2).to_i
-      end
+      len = if grafs.length < 2
+              1
+            else
+              Random.rand(1..grafs.length / 2).to_i
+            end
 
       @output = "#{grafs.slice!(0, len).join("\n\n")}\n\n"
 
@@ -345,7 +345,6 @@ module RandomWords
     # @param [Array] force An array of tags to force.
     # @return [String] The generated paragraph.
     def paragraph(count, em: false, strong: false, links: false, code: false, mark: false, force: [])
-
       output = ''
       s = { short: 2, medium: 4, long: 6, very_long: 8 }[@options[:length]]
       count.times do
@@ -386,7 +385,7 @@ module RandomWords
     # @param [Integer] max The maximum number of words to generate.
     # @return [String] The generated fragment.
     def fragment(min, max)
-      @generator.words(Random.rand(min..max)).no_term.downcase_first
+      @generator.words(Random.rand(min..max)).no_term(generator.terminators).downcase_first
     end
 
     # Generates a random string of characters.
@@ -395,4 +394,4 @@ module RandomWords
       @generator.characters(min, max, whole_words: false, whitespace: false).downcase
     end
   end
-end
+end

data/lib/random-words/number-to-word.rb

@@ -35,15 +35,14 @@ module RandomWords
       tmp = self / 1000
       final = (self % 1000).hundred_to_word(2, numbers)
       place = 3 # special-case the tens and below
-      until tmp.zero? do
-        final = (tmp%1000).hundred_to_word(place, numbers) + ' ' + final
+      until tmp.zero?
+        final = (tmp % 1000).hundred_to_word(place, numbers) + ' ' + final
         place += 1
-        tmp = tmp / 1000
+        tmp /= 1000
       end
-      final == '' ? 'zero' : final.sub(/\s+$/,'')
+      final == '' ? 'zero' : final.sub(/\s+$/, '')
     end
 
-
     # For testing edge cases
     def additional_tests(numbers)
       teen_to_word(numbers)
@@ -56,20 +55,22 @@ module RandomWords
 
     # Convert a number to its word representation for the hundreds place.
     def hundred_to_word(place = 0, numbers)
-      if self.zero?
+      if zero?
         ''
       elsif self < 10
-        self.append_place(self.digit_to_word(numbers), place, numbers)
+        append_place(digit_to_word(numbers), place, numbers)
       elsif self < 20
-        self.append_place(self.teen_to_word(numbers), place, numbers)
+        append_place(teen_to_word(numbers), place, numbers)
       elsif self < 100
-        self.append_place(self.tens_place_to_word(numbers), place, numbers)
+        append_place(tens_place_to_word(numbers), place, numbers)
       else
-        (hundreds,tens) = [self / 100, self % 100]
+        hundreds = self / 100
+        tens = self % 100
         if tens.zero?
-          self.append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]}", place, numbers)
+          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]}", place, numbers)
         else
-          self.append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]} " + tens.tens_place_to_word(numbers), place, numbers)
+          append_place(hundreds.digit_to_word(numbers) + " #{numbers[:places][2]} " + tens.tens_place_to_word(numbers), place,
+                       numbers)
         end
       end
     end
@@ -96,11 +97,12 @@ module RandomWords
     #   45.tens_place_to_word(numbers) # => "forty five"
     def tens_place_to_word(numbers)
       if self > 19
-        (tens, ones) = [self/10, self%10]
-        ten = numbers[:tens][tens-2]
-        ten+(ones.zero? ? '' : ' ' + ones.digit_to_word(numbers))
+        tens = self / 10
+        ones = self % 10
+        ten = numbers[:tens][tens - 2]
+        ten + (ones.zero? ? '' : ' ' + ones.digit_to_word(numbers))
       else
-        self.teen_to_word(numbers)
+        teen_to_word(numbers)
       end
     end
 
@@ -112,11 +114,11 @@ module RandomWords
     #   12.teen_to_word(numbers) # => "twelve"
     def teen_to_word(numbers)
       if self < 10
-        self.digit_to_word(numbers)
+        digit_to_word(numbers)
       elsif self < 20
-        numbers[:teens][self-10]
+        numbers[:teens][self - 10]
       else
-        self.tens_place_to_word(numbers)
+        tens_place_to_word(numbers)
       end
     end
 
@@ -127,11 +129,11 @@ module RandomWords
     # @example
     #   5.digit_to_word(numbers) # => "five"
     def digit_to_word(numbers)
-      if self.zero?
+      if zero?
         ''
       else
         numbers[:digits][self]
       end
     end
   end
-end
+end

data/lib/random-words/source.rb

@@ -18,8 +18,8 @@ module RandomWords
       @description = @config['description'] || 'No description available'
       @dictionary = from_files
       @dictionary[:all_words] = @dictionary.values.flatten.uniq
-      @dictionary[:terminators], @dictionary[:extended_punctuation] = from_file("terminators").split_terminators
-      @dictionary[:first_names], @dictionary[:last_names] = from_file("names").split_names
+      @dictionary[:terminators], @dictionary[:extended_punctuation] = from_file('terminators').split_terminators
+      @dictionary[:first_names], @dictionary[:last_names], @dictionary[:full_names] = from_file('names').split_names
     rescue StandardError
       @name = name.to_sym
       @config = {}
@@ -27,8 +27,8 @@ module RandomWords
       @description = 'No description available'
       @dictionary = from_files
       @dictionary[:all_words] = @dictionary.values.flatten.uniq
-      @dictionary[:terminators], @dictionary[:extended_punctuation] = from_file("terminators").split_terminators
-      @dictionary[:first_names], @dictionary[:last_names] = from_file("names").split_names
+      @dictionary[:terminators], @dictionary[:extended_punctuation] = from_file('terminators').split_terminators
+      @dictionary[:first_names], @dictionary[:last_names], @dictionary[:full_names] = from_file('names').split_names
     end
 
     # def to_sym
@@ -62,7 +62,8 @@ module RandomWords
         clauses: from_file('clauses'),
         coordinating_conjunctions: from_file('conjunctions-coordinating'),
         subordinate_conjunctions: from_file('conjunctions-subordinate'),
-        numbers: from_yaml('numbers')
+        numbers: from_yaml('numbers'),
+        phrases: from_file('phrases')
       }
     end
 
@@ -77,7 +78,7 @@ module RandomWords
       filename = "#{filename.sub(/\.txt$/, '')}.txt"
       path = File.join(@path, filename)
 
-      File.read(path).split("\n").map(&:strip) # Changed from split_lines to split("\n")
+      File.read(path).strip.split("\n").map(&:strip) # Changed from split_lines to split("\n")
     rescue Errno::ENOENT
       warn "File not found: #{path}"
       []
@@ -89,17 +90,17 @@ module RandomWords
     def from_yaml(filename)
       path = File.join(@path, "#{filename}.yml")
       return {} unless File.exist?(path)
+
       begin
         nums = YAML.safe_load(File.read(path), aliases: true).symbolize_keys
         nums.keys.each do |key|
-          nums[key] = nums[key].split(" ").map(&:strip) if nums[key].is_a?(String)
+          nums[key] = nums[key].split(' ').map(&:strip) if nums[key].is_a?(String)
         end
         nums
       rescue Psych::SyntaxError => e
         warn "YAML syntax error in #{path}: #{e.message}"
         {}
       end
-
     end
   end
-end
+end