MonkeyEngine 1.1.0 → 2.0.1

data/lib/MonkeyKeyboard/keyboard_key.rb

@@ -1,9 +1,20 @@
+# frozen_string_literal: true
+
 require_relative 'keyboard_char'
 
 # Represents a keyboard key.
 class KeyboardKey
   attr_reader :keyboard_char, :keyboard_shift_char, :keyboard_key_section, :keyboard_key_weight
 
+  def self.make_key(char, shift_char, keyboard_key_section, keyboard_key_weight)
+    # TODO: Check keyboard_key_section is :left or :right
+
+    keyboard_char = KeyboardChar.new char
+    keyboard_shift_char = KeyboardChar.new shift_char
+
+    KeyboardKey.new keyboard_char, keyboard_shift_char, keyboard_key_section, keyboard_key_weight
+  end
+
   def initialize(keyboard_char, keyboard_shift_char, keyboard_key_section, keyboard_key_weight)
     # TODO: Check keyboard_char is_a? KeyboardChar
     # TODO: Check keyboard_shift_char is_a? KeyboardChar
@@ -14,13 +25,4 @@ class KeyboardKey
     @keyboard_key_section = keyboard_key_section
     @keyboard_key_weight = keyboard_key_weight
   end
-
-  def self.make_key(char, shift_char, keyboard_key_section, keyboard_key_weight)
-    # TODO: Check keyboard_key_section is :left or :right
-
-    keyboard_char = KeyboardChar.new char
-    keyboard_shift_char = KeyboardChar.new shift_char
-
-    KeyboardKey.new keyboard_char, keyboard_shift_char, keyboard_key_section, keyboard_key_weight
-  end
-end
+end

data/lib/MonkeyKeyboard/keyboard_key_evaluator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class KeyboardKeyEvaluator
   def initialize
     @shift_on = false
@@ -8,18 +10,14 @@ class KeyboardKeyEvaluator
     @shift_on = !@shift_on if keyboard_key.keyboard_char.char == :shift
     @caps_on = !@shift_on if keyboard_key.keyboard_char.char == :caps
 
-    return nil if keyboard_key.keyboard_char.char.is_a? Symbol
+    return if keyboard_key.keyboard_char.char.is_a? Symbol
 
-    if @shift_on
-      return keyboard_key.keyboard_shift_char.char
-    end
+    return keyboard_key.keyboard_shift_char.char if @shift_on
 
     char = keyboard_key.keyboard_char.char
 
-    if @caps_on
-      return char.upcase
-    end
+    return char.upcase if @caps_on
 
     char
   end
-end
+end

data/lib/MonkeyKeyboard/monkey_keyboard_en_us.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'pry-byebug'
 require 'singleton'
 require 'LittleWeasel'
 
@@ -6,101 +9,106 @@ require_relative 'keyboard_key'
 require_relative 'keyboard_input'
 require_relative 'keyboard_key_evaluator'
 
-
 module MonkeyEngine
-
   class MonkeyKeyboardEnUs
     include Singleton
 
     attr_reader :keys, :left_keys, :right_keys
 
     def initialize
+      LittleWeasel.configure { |config| }
 
       @keys = [
-          # Row 1 of 5
-          KeyboardKey::make_key('`', '~', :left, 1),
-          KeyboardKey::make_key('1', '!', :left, 1),
-          KeyboardKey::make_key('2', '@', :left, 1),
-          KeyboardKey::make_key('3', '#', :left, 1),
-          KeyboardKey::make_key('4', '$', :left, 1),
-          KeyboardKey::make_key('5', '%', :left, 1),
-          KeyboardKey::make_key('6', '^', :left, 1),
-          KeyboardKey::make_key('7', '&', :right, 1),
-          KeyboardKey::make_key('8', '*', :right, 1),
-          KeyboardKey::make_key('9', '(', :right, 1),
-          KeyboardKey::make_key('0', ')', :right, 1),
-          KeyboardKey::make_key('-', '_', :right, 1),
-          KeyboardKey::make_key('=', '+', :right, 1),
-          KeyboardKey::make_key(:del, :del, :right, 1),
-
-          # Row 2 of 5
-          KeyboardKey::make_key(:tab, :tab, :left, 2),
-          KeyboardKey::make_key('q', 'Q', :left, 1),
-          KeyboardKey::make_key('w', 'W', :left, 1),
-          KeyboardKey::make_key('e', 'E', :left, 1),
-          KeyboardKey::make_key('r', 'R', :left, 1),
-          KeyboardKey::make_key('t', 'T', :left, 1),
-          KeyboardKey::make_key('y', 'Y', :left, 1),
-          KeyboardKey::make_key('u', 'U', :right, 1),
-          KeyboardKey::make_key('i', 'I', :right, 1),
-          KeyboardKey::make_key('o', 'O', :right, 1),
-          KeyboardKey::make_key('p', 'P', :right, 1),
-          KeyboardKey::make_key('', '{', :right, 1),
-          KeyboardKey::make_key('', '}', :right, 1),
-          KeyboardKey::make_key('\\', '|', :right, 1),
-
-          # Row 3 of 5
-          KeyboardKey::make_key(:caps, :caps, :left, 3),
-          KeyboardKey::make_key('a', 'A', :left, 1),
-          KeyboardKey::make_key('s', 'S', :left, 1),
-          KeyboardKey::make_key('d', 'D', :left, 1),
-          KeyboardKey::make_key('f', 'F', :left, 1),
-          KeyboardKey::make_key('g', 'G', :left, 1),
-          KeyboardKey::make_key('h', 'H', :right, 1),
-          KeyboardKey::make_key('j', 'J', :right, 1),
-          KeyboardKey::make_key('k', 'K', :right, 1),
-          KeyboardKey::make_key('l', 'L', :right, 1),
-          KeyboardKey::make_key(';', ':', :right, 1),
-          KeyboardKey::make_key('\'', '"', :right, 1),
-          KeyboardKey::make_key(:enter, :enter, :right, 2),
-
-          # Row 4 of 5
-          KeyboardKey::make_key(:shift, :shift, :left, 5),
-          KeyboardKey::make_key('z', 'Z', :left, 1),
-          KeyboardKey::make_key('x', 'X', :left, 1),
-          KeyboardKey::make_key('c', 'C', :left, 1),
-          KeyboardKey::make_key('v', 'V', :left, 1),
-          KeyboardKey::make_key('b', 'B', :left, 1),
-          KeyboardKey::make_key('n', 'N', :right, 1),
-          KeyboardKey::make_key('m', 'M', :right, 1),
-          KeyboardKey::make_key(',', '<', :right, 1),
-          KeyboardKey::make_key('.', '>', :right, 1),
-          KeyboardKey::make_key('/', '?', :right, 1),
-          KeyboardKey::make_key(:shift, :shift, :right, 5),
-
-          # Row 5 of 5
-          KeyboardKey::make_key(:space, :space, :left, 2),
-          KeyboardKey::make_key(:space, :space, :right, 2)
+        # Row 1 of 5
+        KeyboardKey.make_key('`', '~', :left, 1),
+        KeyboardKey.make_key('1', '!', :left, 1),
+        KeyboardKey.make_key('2', '@', :left, 1),
+        KeyboardKey.make_key('3', '#', :left, 1),
+        KeyboardKey.make_key('4', '$', :left, 1),
+        KeyboardKey.make_key('5', '%', :left, 1),
+        KeyboardKey.make_key('6', '^', :left, 1),
+        KeyboardKey.make_key('7', '&', :right, 1),
+        KeyboardKey.make_key('8', '*', :right, 1),
+        KeyboardKey.make_key('9', '(', :right, 1),
+        KeyboardKey.make_key('0', ')', :right, 1),
+        KeyboardKey.make_key('-', '_', :right, 1),
+        KeyboardKey.make_key('=', '+', :right, 1),
+        KeyboardKey.make_key(:del, :del, :right, 1),
+
+        # Row 2 of 5
+        KeyboardKey.make_key(:tab, :tab, :left, 2),
+        KeyboardKey.make_key('q', 'Q', :left, 1),
+        KeyboardKey.make_key('w', 'W', :left, 1),
+        KeyboardKey.make_key('e', 'E', :left, 1),
+        KeyboardKey.make_key('r', 'R', :left, 1),
+        KeyboardKey.make_key('t', 'T', :left, 1),
+        KeyboardKey.make_key('y', 'Y', :left, 1),
+        KeyboardKey.make_key('u', 'U', :right, 1),
+        KeyboardKey.make_key('i', 'I', :right, 1),
+        KeyboardKey.make_key('o', 'O', :right, 1),
+        KeyboardKey.make_key('p', 'P', :right, 1),
+        KeyboardKey.make_key('', '{', :right, 1),
+        KeyboardKey.make_key('', '}', :right, 1),
+        KeyboardKey.make_key('\\', '|', :right, 1),
+
+        # Row 3 of 5
+        KeyboardKey.make_key(:caps, :caps, :left, 3),
+        KeyboardKey.make_key('a', 'A', :left, 1),
+        KeyboardKey.make_key('s', 'S', :left, 1),
+        KeyboardKey.make_key('d', 'D', :left, 1),
+        KeyboardKey.make_key('f', 'F', :left, 1),
+        KeyboardKey.make_key('g', 'G', :left, 1),
+        KeyboardKey.make_key('h', 'H', :right, 1),
+        KeyboardKey.make_key('j', 'J', :right, 1),
+        KeyboardKey.make_key('k', 'K', :right, 1),
+        KeyboardKey.make_key('l', 'L', :right, 1),
+        KeyboardKey.make_key(';', ':', :right, 1),
+        KeyboardKey.make_key('\'', '"', :right, 1),
+        KeyboardKey.make_key(:enter, :enter, :right, 2),
+
+        # Row 4 of 5
+        KeyboardKey.make_key(:shift, :shift, :left, 5),
+        KeyboardKey.make_key('z', 'Z', :left, 1),
+        KeyboardKey.make_key('x', 'X', :left, 1),
+        KeyboardKey.make_key('c', 'C', :left, 1),
+        KeyboardKey.make_key('v', 'V', :left, 1),
+        KeyboardKey.make_key('b', 'B', :left, 1),
+        KeyboardKey.make_key('n', 'N', :right, 1),
+        KeyboardKey.make_key('m', 'M', :right, 1),
+        KeyboardKey.make_key(',', '<', :right, 1),
+        KeyboardKey.make_key('.', '>', :right, 1),
+        KeyboardKey.make_key('/', '?', :right, 1),
+        KeyboardKey.make_key(:shift, :shift, :right, 5),
+
+        # Row 5 of 5
+        KeyboardKey.make_key(:space, :space, :left, 2),
+        KeyboardKey.make_key(:space, :space, :right, 2)
       ]
 
       @left_keys = []
       @right_keys = []
 
-      @keys.each { |key|
+      @keys.each do |key|
         # Separate the keys on the left side of the keyboard...
-        key.keyboard_key_weight.times do
-          left_keys.push(key)
-        end if key.keyboard_key_section == :left
+        if key.keyboard_key_section == :left
+          key.keyboard_key_weight.times do
+            left_keys.push(key)
+          end
+        end
 
         # Separate the keys on the right side of the keyboard...
+        next unless key.keyboard_key_section == :right
+
         key.keyboard_key_weight.times do
           right_keys.push(key)
-        end if key.keyboard_key_section == :right
-      }
+        end
+      end
 
       @keys.freeze
       @keys_left.freeze
       @keys_right.freeze
+
+      @en_us_dictionary = create_dictionary
     end
 
     def get_keyboard_input
@@ -114,24 +122,36 @@ module MonkeyEngine
       keyboard_key_evaluator = KeyboardKeyEvaluator.new
 
       # Take the keys until we hit a key that terminates a word...
-      keyboard_input.input = keys.take_while { |key|
+      keyboard_input.input = keys.take_while do |key|
         !keyboard_char_ends_word?(key.keyboard_char.char)
-      }.collect { |key| keyboard_key_evaluator.get_char(key) }.compact
+      end.filter_map { |key| keyboard_key_evaluator.get_char(key) }
 
       # Keep going until we get something...
       keyboard_input = get_keyboard_input if keyboard_input.input.empty?
-
-      keyboard_input.is_word = LittleWeasel::Checker.instance.exists?(keyboard_input.input_to_s, 
-        exclude_alphabet: true, strip_whitespace: true, ignore_numeric: false, single_word_mode: true)
+      keyboard_input.is_word = en_us_dictionary.word_results(keyboard_input.input_to_s).success?
 
       keyboard_input
     end
 
     # Returns true if the character causes a word termination.
     def keyboard_char_ends_word?(char)
-      return char == :tab || char == :enter || char == :space || char == '.'
+      [:tab, :enter, :space, '.'].include?(char)
     end
 
-  end
+    private
+
+    attr_accessor :en_us_dictionary
 
-end
+    def create_dictionary
+      dictionary_manager = LittleWeasel::DictionaryManager.new
+      en_us_key = LittleWeasel::DictionaryKey.new(language: :en, region: :us)
+      en_us_dictionary = dictionary_manager.create_dictionary_from_file(
+        dictionary_key: en_us_key, file: "dictionaries/#{en_us_key}.txt"
+      )
+      en_us_dictionary.add_preprocessors(word_preprocessors: [LittleWeasel::Preprocessors::EnUs::CapitalizePreprocessor.new])
+      en_us_dictionary.add_filters(word_filters: [LittleWeasel::Filters::EnUs::SingleCharacterWordFilter.new])
+
+      en_us_dictionary
+    end
+  end
+end

data/lib/MonkeyKeyboardEnUs.rb

@@ -1 +1,3 @@
-require_relative 'MonkeyKeyboard/monkey_keyboard_en_us'
+# frozen_string_literal: true
+
+require_relative 'MonkeyKeyboard/monkey_keyboard_en_us'

data/lib/MonkeyManager/monkey_manager.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require 'forwardable'
 
 module MonkeyEngine
-
   # The MonkeyManager.
   #
   # This class provides the functionality needed to manage Monkeys (See Monkey, MonkeyService)
@@ -18,11 +19,9 @@ module MonkeyEngine
     # The constructor
     #
     def initialize
-      @monkeys = Array.new
+      @monkeys = []
     end
 
-    public
-
     # Adds the Monkey to the list of Monkeys to be managed.
     #
     # @param (Monkey, #read) monkey The Monkey to add.
@@ -33,8 +32,10 @@ module MonkeyEngine
     # @raise [MonkeyEngine::Exceptions::UniqueObjectException] if monkey already exists.
     #
     def add(monkey)
-      raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "Parameter 'monkey' is not Monkey object" unless monkey.is_a? Monkey
-      raise MonkeyEngine::Exceptions::UniqueObjectException.new "Monkeys must be unique" if exists? monkey
+      unless monkey.is_a? Monkey
+        raise MonkeyEngine::Exceptions::InvalidArgumentTypeException, "Parameter 'monkey' is not Monkey object"
+      end
+      raise MonkeyEngine::Exceptions::UniqueObjectException, 'Monkeys must be unique' if exists? monkey
 
       @monkeys.push(monkey)
       monkey
@@ -66,7 +67,7 @@ module MonkeyEngine
     #
     def alive?(monkey)
       monkey = get(monkey)
-      monkey.alive? unless monkey.nil?
+      monkey&.alive?
     end
 
     # Returns the Monkey indicated by *monkey*.
@@ -81,14 +82,15 @@ module MonkeyEngine
     # @raise [MonkeyEngine::Exceptions::InvalidArgumentTypeException] if parameter monkey is not a Monkey, Symbol, or String object.
     #
     def get(monkey)
-      return nil if @monkeys.empty?
+      return if @monkeys.empty?
 
       # TODO: This seems inefficient.
-      return @monkeys.select { |m| m.monkey_symbol == monkey }.first if monkey.is_a? Symbol
-      return @monkeys.select { |m| m.monkey_symbol == monkey.to_sym }.first if monkey.is_a? String
-      return @monkeys.select { |m| m.monkey_symbol == monkey.monkey_symbol }.first if monkey.is_a? Monkey
+      return @monkeys.find { |m| m.monkey_symbol == monkey } if monkey.is_a? Symbol
+      return @monkeys.find { |m| m.monkey_symbol == monkey.to_sym } if monkey.is_a? String
+      return @monkeys.find { |m| m.monkey_symbol == monkey.monkey_symbol } if monkey.is_a? Monkey
 
-      raise MonkeyEngine::Exceptions::InvalidArgumentTypeException.new "Parameter 'monkey' is not a Symbol, String or Monkey object"
+      raise MonkeyEngine::Exceptions::InvalidArgumentTypeException,
+        "Parameter 'monkey' is not a Symbol, String or Monkey object"
     end
 
     # Returns a duplicate Array of Monkey objects managed by this MonkeyManager.
@@ -120,7 +122,7 @@ module MonkeyEngine
     # @return [Array, nil] Returns an [Array] of Monkey objects, or, nil, if no Monkey objects are being managed by
     #    this MonkeyManager.
     #
-    def join_all(limit=nil)
+    def join_all(limit = nil)
       limit = 0 unless limit.nil?
       @monkeys.each { |monkey| monkey.join limit } unless @monkeys.empty?
     end
@@ -152,11 +154,11 @@ module MonkeyEngine
     # @return [Array] an Array of Monkey objects that were killed.
     #
     def kill_all!
-      @monkeys.each { |monkey| monkey.kill } unless @monkeys.empty?
+      @monkeys.each(&:kill) unless @monkeys.empty?
       monkeys = @monkeys.dup
       @monkeys.clear
 
       monkeys
     end
   end
-end
+end

data/lib/MonkeyManager.rb

@@ -1 +1,3 @@
-require_relative 'MonkeyManager/monkey_manager'
+# frozen_string_literal: true
+
+require_relative 'MonkeyManager/monkey_manager'

data/lib/MonkeyService/monkey_service.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'singleton'
 require 'observer'
 require 'forwardable'
@@ -7,7 +9,6 @@ require 'MonkeyEngine'
 require 'MonkeyManager'
 
 module MonkeyEngine
-
   # The monkey service.
   #
   # Provides the main interface for all functionality relating to
@@ -38,7 +39,7 @@ module MonkeyEngine
     #
     def add(monkey)
       @monkey_manager.add(monkey).start
-      do_notify_observers(:add, {monkey: monkey})
+      do_notify_observers(:add, { monkey: monkey })
     end
 
     # Determines if any Monkeys that are being managed by the
@@ -49,13 +50,13 @@ module MonkeyEngine
     # @return [Boolean] true if any Monkeys are alive, false otherwise.
     #
     def any_alive?
-      return false if @monkey_manager.count == 0
+      return false if @monkey_manager.count.zero?
 
       alive_count = 0
 
       @monkey_manager.each { |monkey| alive_count += 1 if monkey.alive? }
 
-      alive_count > 0
+      alive_count.positive?
     end
 
     # Kills the monkey.
@@ -72,7 +73,7 @@ module MonkeyEngine
     #
     def kill!(monkey)
       @monkey_manager.kill!(monkey)
-      do_notify_observers(:kill!, {monkey: monkey})
+      do_notify_observers(:kill!, { monkey: monkey })
     end
 
     # Kills all monkeys managed by the underlying MonkeyManager.
@@ -109,7 +110,7 @@ module MonkeyEngine
     # @return (Boolean) true if the action performed has been completed (Action#action_completed?), false otherwise.
     #
     def monkey_do(action)
-      do_notify_observers(:action_completed, {action: action}) if @engine.do_action action
+      do_notify_observers(:action_completed, { action: action }) if @engine.do_action action
     end
 
     # Evaluates the given action, to determine whether or not the action is completed (Action#action_completed?).
@@ -131,7 +132,5 @@ module MonkeyEngine
       changed
       notify_observers(Time.now, param1, param2)
     end
-
   end
-
-end
+end

data/lib/MonkeyService.rb

@@ -1 +1,3 @@
-require_relative 'MonkeyService/monkey_service'
+# frozen_string_literal: true
+
+require_relative 'MonkeyService/monkey_service'

data/lib/tasks/engine.rb

@@ -1,77 +1,72 @@
-require 'pry'
+# frozen_string_literal: true
 
+require 'pry-byebug'
+require 'colorize'
 require 'yaml'
-require "minitest/autorun"
+require 'minitest/autorun'
 require 'LittleWeasel'
 
-require File.expand_path('../../MonkeyFactory', __FILE__)
-require File.expand_path('../../MonkeyEngine', __FILE__)
+require File.expand_path('../MonkeyFactory', __dir__)
+require File.expand_path('../MonkeyEngine', __dir__)
+
+LittleWeasel.configure { |config| }
 
 module Runner
-  
   class MonkeyRun
-    attr_reader :monkey_service, :runtime, :thread, :words
+    attr_reader :monkey_service, :runtime, :thread, :monkey_words
 
     def initialize(monkey_service, runtime)
-      @words = Array.new
+      @monkey_words = {}
       @monkey_service = monkey_service
       @runtime = runtime.to_i
 
       @monkey_service.add_observer self
 
-      @thread = Thread.new {
+      @thread = Thread.new do
         go
         sleep @runtime
-      }
-
-      self
+      end
     end
 
-    #protected
-
     def go
-      @monkey_service.add(MonkeyFactory::create :groucho)
-      @monkey_service.add(MonkeyFactory::create :harpo)
-      @monkey_service.add(MonkeyFactory::create :chico)
-      @monkey_service.add(MonkeyFactory::create :zeppo)
+      @monkey_service.add(MonkeyFactory.create(:groucho))
+      @monkey_service.add(MonkeyFactory.create(:harpo))
+      @monkey_service.add(MonkeyFactory.create(:chico))
+      @monkey_service.add(MonkeyFactory.create(:zeppo))
     end
 
-    def update(time, action, param)
-      begin
-
-        return unless param.is_a?(Hash) && param.has_key?(:action)
-
-        if param[:action].is_a?(MonkeyActionType) && action == :action_completed
-        
-          monkey = param[:action].monkey.monkey_symbol.to_s
-          is_word = param[:action].keyboard_input.is_word
-          word = param[:action].keyboard_input.input_to_s
-
-          #if param[:action].is_a?(MonkeyActionType) && action == :action_completed
-            puts "Monkey: [#{monkey.capitalize}] | Is Word: [#{is_word}] | Value: [#{word.capitalize}]"
-          #end
-
-          if is_word
-            @words << { word: word, monkey: monkey }
-          end
+    def update(_time, action, param)
+      return unless param.is_a?(Hash) && param.key?(:action)
+
+      if param[:action].is_a?(MonkeyActionType) && action == :action_completed
+        monkey = param[:action].monkey.monkey_symbol.to_s
+        is_word = param[:action].keyboard_input.is_word
+        word = param[:action].keyboard_input.input_to_s
+
+        message = "Monkey: [#{monkey.capitalize}] | Is Word: [#{is_word}] | Value: [#{word.capitalize}]"
+        if is_word
+          @monkey_words[monkey] = {} unless @monkey_words[monkey]
+          @monkey_words[monkey][word] = 0 unless @monkey_words.dig(monkey, word)
+          times = @monkey_words[monkey][word] += 1
+          puts "#{message} | Times: #{times} so far!".colorize(color: :green, mode: :bold)
+          return
         end
-      rescue Exception => e
-        puts "Exception: #{e}"
+
+        puts message
       end
+    rescue StandardError => e
+      puts "StandardError: #{e}"
     end
   end
 end
 
-
 namespace :engine do
-  desc "Run the MonkeyEngine"
+  desc 'Run the MonkeyEngine'
   task :run do
-    runtime = 15 #ARGV[0]
+    runtime = 60 * 2
 
     service = MonkeyEngine::MonkeyService.instance
 
-    LittleWeasel::Checker.instance.options = {exclude_alphabet: true, strip_whitespace: false, ignore_numeric: false}
-
     runner = Runner::MonkeyRun.new service, runtime
     runner.thread.join
 
@@ -79,25 +74,39 @@ namespace :engine do
     service.join_all(10)
     sleep(3)
 
-    runner.words.sort!{|a,b| a[:monkey]<=>b[:monkey]}
+    monkey_words_sorted = runner.monkey_words.sort_by { |key, _value| key }
 
     puts '-----------------------------------------'
-    puts "Valid words:"
-
-    runner.words.each_with_index { |word, index|
-      if word[:word].length > 2
-        puts "#{index + 1}. Monkey [#{word[:monkey].capitalize}] typed [#{word[:word].capitalize}] <=== #{word[:word].length}-letter word!"
-      else
-        puts "#{index + 1}. Monkey [#{word[:monkey].capitalize}] typed [#{word[:word].capitalize}]"
+    puts 'Valid words:'
+
+    word_index = 0
+
+    monkey_words_sorted.each do |monkey_word_info|
+      monkey = monkey_word_info[0]
+      monkey_word_info[1].each do |monkey_word|
+        word_index += 1
+        word = monkey_word[0]
+        times = monkey_word[1]
+        if word.length > 1
+          puts "#{word_index}. Monkey [#{monkey.capitalize}] typed [#{word.capitalize}] [#{times}] time(s) " \
+               "<=== #{word.length}-letter word!".colorize(
+                 color: :green, mode: :bold
+               )
+        else
+          puts "#{word_index}. Monkey [#{monkey.capitalize}] typed [#{word.capitalize}] [#{times}] time(s)"
+            .colorize(color: :green)
+        end
       end
-    }
+    end
+    total_valid_words_count = runner.monkey_words.inject(0) do |sum, monkey_word_info|
+      sum + monkey_word_info[1].keys.count
+    end
 
     puts '-----------------------------------------'
-    puts "Total valid words: #{runner.words.count}"
+    puts "Total valid words: #{total_valid_words_count}"
+    puts 'These monkeys can type!' if total_valid_words_count.positive?
     puts 'Done.'
     puts
     puts
   end
 end
-
-