PlayRockPaperScissorsGame 2.4.5 → 2.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6d3f456481168045ae2133a56134fb160452878
-  data.tar.gz: 4cbf42f75645e25b7d46e9dfe0cc9625f757c687
+  metadata.gz: 1ff4f5604e96223fb57fa294a054b41440482682
+  data.tar.gz: 9f1a60be06652f272b04664f2eafad5def5b28d5
 SHA512:
-  metadata.gz: 0f6e1bd7df78a492b71dd5fde1b449bf08be9b98ff82e921cbb6a81c146bc0534e4207e06c36e73163a9f7bfd5633188a45175b71eb29915d69f683992367aa0
-  data.tar.gz: 766d74e6fd4b39b4bc0e1360a68a3b0c70dc9ed55fea9b24aa44bb67d4531760b8da43ec6c2c80804f28c22016fb025b15981ad648054726d3fa428cbf2e6708
+  metadata.gz: 900e13faf5087fec53264e1c6177a9ab31bad6addbfa825a018321aa9c7790f750f820569e2bf8a0b7c0b0946ea6525d5fa2ff4256ce6f2055bf1b1dc7752c86
+  data.tar.gz: 6b16efbf00ba73a2bc1bef6de99a09543fab32e8488dd5c29c977e87768c10021f6eee46facc3cc92967c0b7922044f29bac59831c6d98ec1f863f91a0d9d093

data/bin/PlayRockPaperScissorsGame

@@ -23,8 +23,8 @@ class PlayRockPaperScissorsGame
 
   class << self # make continue a self calling method
     def continue(str1,str2,str3) # pass in 3 parameters
-      puts  ColorizedString[str1].colorize(:color => :green) # make string output green text
-      print ColorizedString[str2].colorize(:color => :green)
+      puts  str1 # make string output green text
+      print str2
       gets # press enter or return to continue
       puts  str3
     end 

data/bin/rps

@@ -23,10 +23,10 @@ class PlayRockPaperScissorsGame
   protected_methods :Constants
 
   class << self
-    def continue(str1,str2,str3) # pass in 3 parameters
-      puts  ColorizedString[str1].colorize(:color => :green) 
-      print ColorizedString[str2].colorize(:color => :green)
-      gets # press enter or return to continue
+    def continue(str1,str2,str3)
+      puts  str1 
+      print str2
+      gets 
       puts  str3
     end 
   end 

data/docs/Code.md

@@ -28,7 +28,7 @@ __`% rps`__
 class PlayRockPaperScissorsGame # define master class
 
   module RockPaperScissors
-    VERSION = "2.4.5" # define version constant
+    VERSION = "2.4.6" # define version constant
   end
   
   # intiate the colorize gem
@@ -50,7 +50,7 @@ class PlayRockPaperScissorsGame # define master class
       [:PAPER   , :ROCK], 
       [:ROCK    , :SCISSORS]
     ] 
-    LOSERS = WINNERS.map { |pc,cc| [cc,pc] } # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
+    LOSERS = WINNERS.map { |player_choice,computer_choice| [computer_choice,player_choice] } # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
     INIT_STRINGS = [
       ColorizedString["You are about to enter a rock-paper-scissors best of 3 match."].colorize(:green), 
       ColorizedString["Press the return/enter key to continue..."].colorize(:green), 
@@ -62,8 +62,8 @@ class PlayRockPaperScissorsGame # define master class
 
   class << self # define a self calling method within the parent class
     def continue(str1,str2,str3) # pass in 3 parameters
-      puts  ColorizedString[str1].colorize(:color => :green) 
-      print ColorizedString[str2].colorize(:color => :green)
+      puts  str1 
+      print str2
       gets # press enter or return to continue
       puts  str3
     end 
@@ -133,7 +133,7 @@ class PlayRockPaperScissorsGame # define master class
       def player_outcome(plays) # define method for the player's outcome while passing in a parameter of type array
         return :WIN  if Constants::WINNERS.include?(plays) # return a win if the one of the sub-arrays in the winners array is called
         return :LOSE if Constants::LOSERS.include?(plays) # return a loss if any of the mapped sub-arrays in the losers constant is present
-        return :TIE  if !:WIN | !:LOSE # return a tie if not (!) win or if not loose
+        return :TIE  if !:WIN | !:LOSE # return a tie if not (!) win or if not lose
       end 
       def final_outcome(pl,co) # define final outcome method
         return :WIN  if pl > co 

data/docs/Comparing_Code.md

@@ -1,6 +1,9 @@
 ---
+# start YAML
 layout: default
 title: Comparing Code - Play Rock Paper Scissors Game
+permalink: /Comparing_Code.html
+# end YAML
 ---
 
 [//]: # (start markdown)
@@ -13,7 +16,7 @@ title: Comparing Code - Play Rock Paper Scissors Game
   - [Beginner's Code](#beginners-code)
     - [Beginner's Code Pros](#beginners-code-pros)
     - [Beginner's Code Cons](#beginners-code-cons)
-    - [What Beginner's Code Looks :ike](#what-beginners-code-looks-ike)
+    - [What Beginner's Code Looks Like](#what-beginners-code-looks-like)
   - [Advanced Code](#advanced-code)
     - [Advanced Code Pros](#advanced-code-pros)
     - [Advanced Code Cons](#advanced-code-cons)
@@ -23,30 +26,30 @@ title: Comparing Code - Play Rock Paper Scissors Game
 ## Beginner's Code
 
 ### Beginner's Code Pros
+
 + Simple
 - Easy to understand
 * Short
 
 ### Beginner's Code Cons
+
 + Unorganized
 - Lacks modularization
 * Many `if`s and `else`s
 
-### What Beginner's Code Looks :ike
+### What Beginner's Code Looks Like
 
-__`% ruby beginner.rb`__
+__`% ruby beginner-rps.rb`__
 
 [//]: # (end markdown)
 
 [//]: # (start ruby)
-
 ```ruby
 options = ["rock", "paper", "scissors"]
 computer_choice = options[rand(options.length)] 
- # the above line chooses a random pick in the options array, and the `options.length` means to choose from however many options there are in the `options` array
 puts "What's your choice?"
 puts "rock, paper, or scissors"
-user_input = gets.chomp.downcase # `gets.chomp` reads user input, .downcase is like `.toLowerCase()` in javascript
+user_input = gets.chomp.downcase 
 loop do 
   if (user_input == "rock" || user_input == "paper" || user_input == "scissors")
     if (user_input == computer_choice)
@@ -63,17 +66,19 @@ loop do
       puts "computer choice is: " + computer_choice + " ,computer wins :("
     elsif (user_input == "scissors" && computer_choice == "paper")
       puts "computer choice is: " + computer_choice + " , you win! :)"
+    else
+      puts "Invalid choice, enter Rock, Paper, or Scissors"
+      puts "What's your choice?"
+      user_input = gets.chomp.downcase
     end
-    else 
-    puts "Invalid choice, enter Rock, Paper, or Scissors"
-    puts "What's your choice?"
-    user_input = gets.chomp.downcase # have the user choose again
   end
-  break # break the loop after all the above has been completed
+  break
 end
 ```
 [//]: # (end ruby)
+
 [//]: # (start markdown)
+
 ## Advanced Code
 
 ### Advanced Code Pros
@@ -89,34 +94,33 @@ end
 
 ### What Advanced Code Looks Like
 
-__`% ruby advanced.rb`__
+__`% ruby advanced-rps.rb`__
 
 [//]: # (end markdown)
 
 [//]: # (start ruby)
 ```ruby
-class PlayRockPaperScissorsGame # define master class
+class PlayRockPaperScissorsGame
   
-  # intiate the colorize gem
+  # import colorize gem
   require "colorized_string"
-  ColorizedString.colors # import colors; ex: red, green, blue
-  ColorizedString.modes  # import modes; ex: bold, italic, underline
+  ColorizedString.colors # import colors
+  ColorizedString.modes  # import modes (bold, etc...)
 
   module Constants 
-    NTRY_TO_SYM = { # define constants from an entry to a symbol class
+    NTRY_TO_SYM = { 
       'p' => :PAPER, 
       'r' => :ROCK, 
       's' => :SCISSORS 
     } 
-    VALID_ENTRIES = NTRY_TO_SYM.keys # create valid entries
-    COMPUTER_CHOICES = NTRY_TO_SYM.values # define computer choices
-    WINNERS = [ # define winners
-      # format: player choice, computer choice
+    VALID_ENTRIES = NTRY_TO_SYM.keys 
+    COMPUTER_CHOICES = NTRY_TO_SYM.values 
+    WINNERS = [ 
       [:SCISSORS, :PAPER], 
       [:PAPER   , :ROCK], 
       [:ROCK    , :SCISSORS]
     ] 
-    LOSERS = WINNERS.map { |pc,cc| [cc,pc] } # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
+    LOSERS = WINNERS.map { |player_choice,computer_choice| [computer_choice,player_choice] } # flip the values in the WINNERS array
     INIT_STRINGS = [
       ColorizedString["You are about to enter a rock-paper-scissors best of 3 match."].colorize(:green), 
       ColorizedString["Press the return/enter key to continue..."].colorize(:green), 
@@ -124,46 +128,44 @@ class PlayRockPaperScissorsGame # define master class
     ]
   end
 
-  protected_methods :Constants # make the constants module protected
+  protected_methods :Constants # make constants module protected
 
-  class << self # define a self calling method within the parent class
-    def continue(str1,str2,str3) # pass in 3 parameters
-      puts  ColorizedString[str1].colorize(:color => :green) 
-      print ColorizedString[str2].colorize(:color => :green)
-      gets # press enter or return to continue
+  class << self 
+    def continue(str1,str2,str3)
+      puts  str1
+      print str2
+      gets
       puts  str3
     end 
   end 
 
-  continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2]) # call continue method
+  continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2])
 
-  def initialize # initialize variables
+  def initialize
     @player_score = @computer_score = @ties = 0 
   end 
   def play(winning_score) 
-    while @player_score < winning_score && @computer_score < winning_score # both the computer's score and the player's score have to be less than the value passed in for the winning score at the end
+    while @player_score < winning_score && @computer_score < winning_score 
       puts ColorizedString["Player score: #{@player_score}, "].colorize(:blue) + 
            ColorizedString["Computer score: #{@computer_score}, Ties: #{@ties}"].colorize(:blue) 
       player = PrivateMethods.player_choice 
-      computer = Constants::COMPUTER_CHOICES.sample # chooses a "random" option
+      computer = Constants::COMPUTER_CHOICES.sample 
       puts ColorizedString["\nPlayer chooses #{player.to_s.downcase}"].colorize(:blue) 
       puts ColorizedString["Computer chooses #{computer.to_s.downcase}"].colorize(:blue)
-      case PrivateMethods.player_outcome [player, computer] # define a reference call for player and computer for the arrays called in the player_outcome method
+      case PrivateMethods.player_outcome [player, computer]
       when :WIN
         puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red) 
-        @player_score += 1 # @player_score = @player_score + 1
+        @player_score += 1
       when :LOSE
         puts ColorizedString["#{computer.to_s.capitalize} beats #{player.to_s.downcase}, computer wins the round"].colorize(:red)
         @computer_score += 1 
-      else # since there is only 1 option left, there is no need to define when :TIE
+      else
         puts ColorizedString["Tie, choose again"].colorize(:red) 
         @ties += 1
-        # since tie is not in the original pass-in argument for the while loop, it will not be affected by the winning score
       end
     end
     puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
          ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue)
-    # define a case for the final outcomes  
     case PrivateMethods.final_outcome(@player_score, @computer_score)
     when :WIN 
       puts ColorizedString["Player wins!"].colorize(:red) 
@@ -176,44 +178,36 @@ class PlayRockPaperScissorsGame # define master class
   end 
 
   module PrivateMethods 
-    class << self # make all methods below self calling methods of this class (PlayRockPaperScissorsGame) so that the other methods will not to call their parents of these methods
+    class << self 
       def player_choice
-        loop do # for loop with no arguments passed in
+        loop do 
           print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green)
-          choice = gets.chomp.downcase # read user input and convert all to lower case
-          # define valid and invalid entries by using an if else-if statement(s)
-          if Constants::NTRY_TO_SYM.key?(choice) # if the NTRY_TO_SYM array's key is one of the keys defined in the original array
-            return Constants::NTRY_TO_SYM[choice] # return the users choice
-          elsif choice != Constants::VALID_ENTRIES # else if it is not one of the valid entries...
-            puts ColorizedString["That entry is invalid. Please re-enter."].colorize(:red) # return an error message
+          choice = gets.chomp.downcase 
+          if Constants::NTRY_TO_SYM.key?(choice)
+            return Constants::NTRY_TO_SYM[choice] 
+          elsif choice != Constants::VALID_ENTRIES
+            puts ColorizedString["That entry is invalid. Please re-enter."].colorize(:red)
           end
-          # # one may also do this (albeit more useless):
-          # case
-          # when Constants::NTRY_TO_SYM.key?(choice)
-          #   return Constants::NTRY_TO_SYM[choice]
-          # when choice != Constants::VALID_ENTRIES
-          #   puts ColorizedString["That entry is invalid. Please re-enter."].colorize(:green) 
-          # end
         end 
       end 
-      def player_outcome(plays) # define method for the player's outcome while passing in a parameter of type array
-        return :WIN  if Constants::WINNERS.include?(plays) # return a win if the one of the sub-arrays in the winners array is called
-        return :LOSE if Constants::LOSERS.include?(plays) # return a loss if any of the mapped sub-arrays in the losers constant is present
-        return :TIE  if !:WIN | !:LOSE # return a tie if not (!) win or if not loose
+      def player_outcome(plays)
+        return :WIN  if Constants::WINNERS.include?(plays) 
+        return :LOSE if Constants::LOSERS.include?(plays)
+        return :TIE  if !:WIN | !:LOSE
       end 
-      def final_outcome(pl,co) # define final outcome method
+      def final_outcome(pl,co)
         return :WIN  if pl > co 
         return :LOSE if pl < co
-        return :TIE  if pl = co # this can never happen due to the code in the play method, but it is worth noting
+        return :TIE  if pl = co # this could never happen due to the code in the play method; however, it is worth noting
       end 
     end
   end
   
-  private_methods :PrivateMethods # make the PrivateMethods module private
+  private_methods :PrivateMethods 
 
 end 
 
-PlayRockPaperScissorsGame.new.play(2) # call the play method and pass in 3 (0, 1, 2) for the winning score
+PlayRockPaperScissorsGame.new.play(2) 
 ```
 [//]: # (end ruby)
 

data/docs/_config.yml

@@ -11,4 +11,6 @@ exclude: [
   LICENSE
 ]
 include:
-  - index.md
+  - index.md
+  - Code.md
+  - Comparing_Code.md

data/docs/_layouts/default.html

@@ -8,8 +8,8 @@
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
     <link rel="stylesheet" href="{{ '/assets/css/style.css?v=' | append: site.github.build_revision | relative_url }}">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">

data/docs/_site/CODE_OF_CONDUCT.html

@@ -7,9 +7,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
-    <link rel="stylesheet" href="/assets/css/style.css?v=b6dce77cfbf038800279b1f621a6690f834078a8">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/style.css?v=a619aba449fd31773059e12d98817087fdec295e">
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">

data/docs/_site/CONTRIBUTING.html

@@ -7,9 +7,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
-    <link rel="stylesheet" href="/assets/css/style.css?v=b6dce77cfbf038800279b1f621a6690f834078a8">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/style.css?v=a619aba449fd31773059e12d98817087fdec295e">
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">

data/docs/_site/Code.html

@@ -7,9 +7,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
-    <link rel="stylesheet" href="/assets/css/style.css?v=b6dce77cfbf038800279b1f621a6690f834078a8">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/style.css?v=a619aba449fd31773059e12d98817087fdec295e">
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">
@@ -53,7 +53,7 @@
 <span class="k">class</span> <span class="nc">PlayRockPaperScissorsGame</span> <span class="c1"># define master class</span>
 
   <span class="k">module</span> <span class="nn">RockPaperScissors</span>
-    <span class="no">VERSION</span> <span class="o">=</span> <span class="s2">"2.4.5"</span> <span class="c1"># define version constant</span>
+    <span class="no">VERSION</span> <span class="o">=</span> <span class="s2">"2.4.6"</span> <span class="c1"># define version constant</span>
   <span class="k">end</span>
   
   <span class="c1"># intiate the colorize gem</span>
@@ -75,7 +75,7 @@
       <span class="p">[</span><span class="ss">:PAPER</span>   <span class="p">,</span> <span class="ss">:ROCK</span><span class="p">],</span> 
       <span class="p">[</span><span class="ss">:ROCK</span>    <span class="p">,</span> <span class="ss">:SCISSORS</span><span class="p">]</span>
     <span class="p">]</span> 
-    <span class="no">LOSERS</span> <span class="o">=</span> <span class="no">WINNERS</span><span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">pc</span><span class="p">,</span><span class="n">cc</span><span class="o">|</span> <span class="p">[</span><span class="n">cc</span><span class="p">,</span><span class="n">pc</span><span class="p">]</span> <span class="p">}</span> <span class="c1"># this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player</span>
+    <span class="no">LOSERS</span> <span class="o">=</span> <span class="no">WINNERS</span><span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">player_choice</span><span class="p">,</span><span class="n">computer_choice</span><span class="o">|</span> <span class="p">[</span><span class="n">computer_choice</span><span class="p">,</span><span class="n">player_choice</span><span class="p">]</span> <span class="p">}</span> <span class="c1"># this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player</span>
     <span class="no">INIT_STRINGS</span> <span class="o">=</span> <span class="p">[</span>
       <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"You are about to enter a rock-paper-scissors best of 3 match."</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:green</span><span class="p">),</span> 
       <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Press the return/enter key to continue..."</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:green</span><span class="p">),</span> 
@@ -87,8 +87,8 @@
 
   <span class="k">class</span> <span class="o">&lt;&lt;</span> <span class="nb">self</span> <span class="c1"># define a self calling method within the parent class</span>
     <span class="k">def</span> <span class="nf">continue</span><span class="p">(</span><span class="n">str1</span><span class="p">,</span><span class="n">str2</span><span class="p">,</span><span class="n">str3</span><span class="p">)</span> <span class="c1"># pass in 3 parameters</span>
-      <span class="nb">puts</span>  <span class="no">ColorizedString</span><span class="p">[</span><span class="n">str1</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:color</span> <span class="o">=&gt;</span> <span class="ss">:green</span><span class="p">)</span> 
-      <span class="nb">print</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="n">str2</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:color</span> <span class="o">=&gt;</span> <span class="ss">:green</span><span class="p">)</span>
+      <span class="nb">puts</span>  <span class="n">str1</span> 
+      <span class="nb">print</span> <span class="n">str2</span>
       <span class="nb">gets</span> <span class="c1"># press enter or return to continue</span>
       <span class="nb">puts</span>  <span class="n">str3</span>
     <span class="k">end</span> 
@@ -158,7 +158,7 @@
       <span class="k">def</span> <span class="nf">player_outcome</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span> <span class="c1"># define method for the player's outcome while passing in a parameter of type array</span>
         <span class="k">return</span> <span class="ss">:WIN</span>  <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">WINNERS</span><span class="p">.</span><span class="nf">include?</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span> <span class="c1"># return a win if the one of the sub-arrays in the winners array is called</span>
         <span class="k">return</span> <span class="ss">:LOSE</span> <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">LOSERS</span><span class="p">.</span><span class="nf">include?</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span> <span class="c1"># return a loss if any of the mapped sub-arrays in the losers constant is present</span>
-        <span class="k">return</span> <span class="ss">:TIE</span>  <span class="k">if</span> <span class="o">!</span><span class="ss">:WIN</span> <span class="o">|</span> <span class="o">!</span><span class="ss">:LOSE</span> <span class="c1"># return a tie if not (!) win or if not loose</span>
+        <span class="k">return</span> <span class="ss">:TIE</span>  <span class="k">if</span> <span class="o">!</span><span class="ss">:WIN</span> <span class="o">|</span> <span class="o">!</span><span class="ss">:LOSE</span> <span class="c1"># return a tie if not (!) win or if not lose</span>
       <span class="k">end</span> 
       <span class="k">def</span> <span class="nf">final_outcome</span><span class="p">(</span><span class="n">pl</span><span class="p">,</span><span class="n">co</span><span class="p">)</span> <span class="c1"># define final outcome method</span>
         <span class="k">return</span> <span class="ss">:WIN</span>  <span class="k">if</span> <span class="n">pl</span> <span class="o">&gt;</span> <span class="n">co</span> 

data/docs/_site/Comparing_Code.html

@@ -7,9 +7,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
-    <link rel="stylesheet" href="/assets/css/style.css?v=b6dce77cfbf038800279b1f621a6690f834078a8">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/style.css?v=a619aba449fd31773059e12d98817087fdec295e">
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">
@@ -45,7 +45,7 @@
         <ul>
           <li><a href="#beginners-code-pros">Beginner’s Code Pros</a></li>
           <li><a href="#beginners-code-cons">Beginner’s Code Cons</a></li>
-          <li><a href="#what-beginners-code-looks-ike">What Beginner’s Code Looks :ike</a></li>
+          <li><a href="#what-beginners-code-looks-like">What Beginner’s Code Looks Like</a></li>
         </ul>
       </li>
       <li><a href="#advanced-code">Advanced Code</a>
@@ -63,6 +63,7 @@
 <h2 id="beginners-code">Beginner’s Code</h2>
 
 <h3 id="beginners-code-pros">Beginner’s Code Pros</h3>
+
 <ul>
   <li>Simple</li>
   <li>Easy to understand</li>
@@ -70,22 +71,22 @@
 </ul>
 
 <h3 id="beginners-code-cons">Beginner’s Code Cons</h3>
+
 <ul>
   <li>Unorganized</li>
   <li>Lacks modularization</li>
   <li>Many <code class="highlighter-rouge">if</code>s and <code class="highlighter-rouge">else</code>s</li>
 </ul>
 
-<h3 id="what-beginners-code-looks-ike">What Beginner’s Code Looks :ike</h3>
+<h3 id="what-beginners-code-looks-like">What Beginner’s Code Looks Like</h3>
 
-<p><strong><code class="highlighter-rouge">% ruby beginner.rb</code></strong></p>
+<p><strong><code class="highlighter-rouge">% ruby beginner-rps.rb</code></strong></p>
 
 <div class="language-ruby highlighter-rouge"><pre class="highlight"><code><span class="n">options</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"rock"</span><span class="p">,</span> <span class="s2">"paper"</span><span class="p">,</span> <span class="s2">"scissors"</span><span class="p">]</span>
 <span class="n">computer_choice</span> <span class="o">=</span> <span class="n">options</span><span class="p">[</span><span class="nb">rand</span><span class="p">(</span><span class="n">options</span><span class="p">.</span><span class="nf">length</span><span class="p">)]</span> 
- <span class="c1"># the above line chooses a random pick in the options array, and the `options.length` means to choose from however many options there are in the `options` array</span>
 <span class="nb">puts</span> <span class="s2">"What's your choice?"</span>
 <span class="nb">puts</span> <span class="s2">"rock, paper, or scissors"</span>
-<span class="n">user_input</span> <span class="o">=</span> <span class="nb">gets</span><span class="p">.</span><span class="nf">chomp</span><span class="p">.</span><span class="nf">downcase</span> <span class="c1"># `gets.chomp` reads user input, .downcase is like `.toLowerCase()` in javascript</span>
+<span class="n">user_input</span> <span class="o">=</span> <span class="nb">gets</span><span class="p">.</span><span class="nf">chomp</span><span class="p">.</span><span class="nf">downcase</span> 
 <span class="kp">loop</span> <span class="k">do</span> 
   <span class="k">if</span> <span class="p">(</span><span class="n">user_input</span> <span class="o">==</span> <span class="s2">"rock"</span> <span class="o">||</span> <span class="n">user_input</span> <span class="o">==</span> <span class="s2">"paper"</span> <span class="o">||</span> <span class="n">user_input</span> <span class="o">==</span> <span class="s2">"scissors"</span><span class="p">)</span>
     <span class="k">if</span> <span class="p">(</span><span class="n">user_input</span> <span class="o">==</span> <span class="n">computer_choice</span><span class="p">)</span>
@@ -102,16 +103,17 @@
       <span class="nb">puts</span> <span class="s2">"computer choice is: "</span> <span class="o">+</span> <span class="n">computer_choice</span> <span class="o">+</span> <span class="s2">" ,computer wins :("</span>
     <span class="k">elsif</span> <span class="p">(</span><span class="n">user_input</span> <span class="o">==</span> <span class="s2">"scissors"</span> <span class="o">&amp;&amp;</span> <span class="n">computer_choice</span> <span class="o">==</span> <span class="s2">"paper"</span><span class="p">)</span>
       <span class="nb">puts</span> <span class="s2">"computer choice is: "</span> <span class="o">+</span> <span class="n">computer_choice</span> <span class="o">+</span> <span class="s2">" , you win! :)"</span>
+    <span class="k">else</span>
+      <span class="nb">puts</span> <span class="s2">"Invalid choice, enter Rock, Paper, or Scissors"</span>
+      <span class="nb">puts</span> <span class="s2">"What's your choice?"</span>
+      <span class="n">user_input</span> <span class="o">=</span> <span class="nb">gets</span><span class="p">.</span><span class="nf">chomp</span><span class="p">.</span><span class="nf">downcase</span>
     <span class="k">end</span>
-    <span class="k">else</span> 
-    <span class="nb">puts</span> <span class="s2">"Invalid choice, enter Rock, Paper, or Scissors"</span>
-    <span class="nb">puts</span> <span class="s2">"What's your choice?"</span>
-    <span class="n">user_input</span> <span class="o">=</span> <span class="nb">gets</span><span class="p">.</span><span class="nf">chomp</span><span class="p">.</span><span class="nf">downcase</span> <span class="c1"># have the user choose again</span>
   <span class="k">end</span>
-  <span class="k">break</span> <span class="c1"># break the loop after all the above has been completed</span>
+  <span class="k">break</span>
 <span class="k">end</span>
 </code></pre>
 </div>
+
 <h2 id="advanced-code">Advanced Code</h2>
 
 <h3 id="advanced-code-pros">Advanced Code Pros</h3>
@@ -131,30 +133,29 @@
 
 <h3 id="what-advanced-code-looks-like">What Advanced Code Looks Like</h3>
 
-<p><strong><code class="highlighter-rouge">% ruby advanced.rb</code></strong></p>
+<p><strong><code class="highlighter-rouge">% ruby advanced-rps.rb</code></strong></p>
 
-<div class="language-ruby highlighter-rouge"><pre class="highlight"><code><span class="k">class</span> <span class="nc">PlayRockPaperScissorsGame</span> <span class="c1"># define master class</span>
+<div class="language-ruby highlighter-rouge"><pre class="highlight"><code><span class="k">class</span> <span class="nc">PlayRockPaperScissorsGame</span>
   
-  <span class="c1"># intiate the colorize gem</span>
+  <span class="c1"># import colorize gem</span>
   <span class="nb">require</span> <span class="s2">"colorized_string"</span>
-  <span class="no">ColorizedString</span><span class="p">.</span><span class="nf">colors</span> <span class="c1"># import colors; ex: red, green, blue</span>
-  <span class="no">ColorizedString</span><span class="p">.</span><span class="nf">modes</span>  <span class="c1"># import modes; ex: bold, italic, underline</span>
+  <span class="no">ColorizedString</span><span class="p">.</span><span class="nf">colors</span> <span class="c1"># import colors</span>
+  <span class="no">ColorizedString</span><span class="p">.</span><span class="nf">modes</span>  <span class="c1"># import modes (bold, etc...)</span>
 
   <span class="k">module</span> <span class="nn">Constants</span> 
-    <span class="no">NTRY_TO_SYM</span> <span class="o">=</span> <span class="p">{</span> <span class="c1"># define constants from an entry to a symbol class</span>
+    <span class="no">NTRY_TO_SYM</span> <span class="o">=</span> <span class="p">{</span> 
       <span class="s1">'p'</span> <span class="o">=&gt;</span> <span class="ss">:PAPER</span><span class="p">,</span> 
       <span class="s1">'r'</span> <span class="o">=&gt;</span> <span class="ss">:ROCK</span><span class="p">,</span> 
       <span class="s1">'s'</span> <span class="o">=&gt;</span> <span class="ss">:SCISSORS</span> 
     <span class="p">}</span> 
-    <span class="no">VALID_ENTRIES</span> <span class="o">=</span> <span class="no">NTRY_TO_SYM</span><span class="p">.</span><span class="nf">keys</span> <span class="c1"># create valid entries</span>
-    <span class="no">COMPUTER_CHOICES</span> <span class="o">=</span> <span class="no">NTRY_TO_SYM</span><span class="p">.</span><span class="nf">values</span> <span class="c1"># define computer choices</span>
-    <span class="no">WINNERS</span> <span class="o">=</span> <span class="p">[</span> <span class="c1"># define winners</span>
-      <span class="c1"># format: player choice, computer choice</span>
+    <span class="no">VALID_ENTRIES</span> <span class="o">=</span> <span class="no">NTRY_TO_SYM</span><span class="p">.</span><span class="nf">keys</span> 
+    <span class="no">COMPUTER_CHOICES</span> <span class="o">=</span> <span class="no">NTRY_TO_SYM</span><span class="p">.</span><span class="nf">values</span> 
+    <span class="no">WINNERS</span> <span class="o">=</span> <span class="p">[</span> 
       <span class="p">[</span><span class="ss">:SCISSORS</span><span class="p">,</span> <span class="ss">:PAPER</span><span class="p">],</span> 
       <span class="p">[</span><span class="ss">:PAPER</span>   <span class="p">,</span> <span class="ss">:ROCK</span><span class="p">],</span> 
       <span class="p">[</span><span class="ss">:ROCK</span>    <span class="p">,</span> <span class="ss">:SCISSORS</span><span class="p">]</span>
     <span class="p">]</span> 
-    <span class="no">LOSERS</span> <span class="o">=</span> <span class="no">WINNERS</span><span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">pc</span><span class="p">,</span><span class="n">cc</span><span class="o">|</span> <span class="p">[</span><span class="n">cc</span><span class="p">,</span><span class="n">pc</span><span class="p">]</span> <span class="p">}</span> <span class="c1"># this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player</span>
+    <span class="no">LOSERS</span> <span class="o">=</span> <span class="no">WINNERS</span><span class="p">.</span><span class="nf">map</span> <span class="p">{</span> <span class="o">|</span><span class="n">player_choice</span><span class="p">,</span><span class="n">computer_choice</span><span class="o">|</span> <span class="p">[</span><span class="n">computer_choice</span><span class="p">,</span><span class="n">player_choice</span><span class="p">]</span> <span class="p">}</span> <span class="c1"># flip the values in the WINNERS array</span>
     <span class="no">INIT_STRINGS</span> <span class="o">=</span> <span class="p">[</span>
       <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"You are about to enter a rock-paper-scissors best of 3 match."</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:green</span><span class="p">),</span> 
       <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Press the return/enter key to continue..."</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:green</span><span class="p">),</span> 
@@ -162,46 +163,44 @@
     <span class="p">]</span>
   <span class="k">end</span>
 
-  <span class="nb">protected_methods</span> <span class="ss">:Constants</span> <span class="c1"># make the constants module protected</span>
+  <span class="nb">protected_methods</span> <span class="ss">:Constants</span> <span class="c1"># make constants module protected</span>
 
-  <span class="k">class</span> <span class="o">&lt;&lt;</span> <span class="nb">self</span> <span class="c1"># define a self calling method within the parent class</span>
-    <span class="k">def</span> <span class="nf">continue</span><span class="p">(</span><span class="n">str1</span><span class="p">,</span><span class="n">str2</span><span class="p">,</span><span class="n">str3</span><span class="p">)</span> <span class="c1"># pass in 3 parameters</span>
-      <span class="nb">puts</span>  <span class="no">ColorizedString</span><span class="p">[</span><span class="n">str1</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:color</span> <span class="o">=&gt;</span> <span class="ss">:green</span><span class="p">)</span> 
-      <span class="nb">print</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="n">str2</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:color</span> <span class="o">=&gt;</span> <span class="ss">:green</span><span class="p">)</span>
-      <span class="nb">gets</span> <span class="c1"># press enter or return to continue</span>
+  <span class="k">class</span> <span class="o">&lt;&lt;</span> <span class="nb">self</span> 
+    <span class="k">def</span> <span class="nf">continue</span><span class="p">(</span><span class="n">str1</span><span class="p">,</span><span class="n">str2</span><span class="p">,</span><span class="n">str3</span><span class="p">)</span>
+      <span class="nb">puts</span>  <span class="n">str1</span>
+      <span class="nb">print</span> <span class="n">str2</span>
+      <span class="nb">gets</span>
       <span class="nb">puts</span>  <span class="n">str3</span>
     <span class="k">end</span> 
   <span class="k">end</span> 
 
-  <span class="n">continue</span><span class="p">(</span><span class="no">Constants</span><span class="o">::</span><span class="no">INIT_STRINGS</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="no">Constants</span><span class="o">::</span><span class="no">INIT_STRINGS</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="no">Constants</span><span class="o">::</span><span class="no">INIT_STRINGS</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span> <span class="c1"># call continue method</span>
+  <span class="n">continue</span><span class="p">(</span><span class="no">Constants</span><span class="o">::</span><span class="no">INIT_STRINGS</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="no">Constants</span><span class="o">::</span><span class="no">INIT_STRINGS</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="no">Constants</span><span class="o">::</span><span class="no">INIT_STRINGS</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
 
-  <span class="k">def</span> <span class="nf">initialize</span> <span class="c1"># initialize variables</span>
+  <span class="k">def</span> <span class="nf">initialize</span>
     <span class="vi">@player_score</span> <span class="o">=</span> <span class="vi">@computer_score</span> <span class="o">=</span> <span class="vi">@ties</span> <span class="o">=</span> <span class="mi">0</span> 
   <span class="k">end</span> 
   <span class="k">def</span> <span class="nf">play</span><span class="p">(</span><span class="n">winning_score</span><span class="p">)</span> 
-    <span class="k">while</span> <span class="vi">@player_score</span> <span class="o">&lt;</span> <span class="n">winning_score</span> <span class="o">&amp;&amp;</span> <span class="vi">@computer_score</span> <span class="o">&lt;</span> <span class="n">winning_score</span> <span class="c1"># both the computer's score and the player's score have to be less than the value passed in for the winning score at the end</span>
+    <span class="k">while</span> <span class="vi">@player_score</span> <span class="o">&lt;</span> <span class="n">winning_score</span> <span class="o">&amp;&amp;</span> <span class="vi">@computer_score</span> <span class="o">&lt;</span> <span class="n">winning_score</span> 
       <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Player score: </span><span class="si">#{</span><span class="vi">@player_score</span><span class="si">}</span><span class="s2">, "</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:blue</span><span class="p">)</span> <span class="o">+</span> 
            <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Computer score: </span><span class="si">#{</span><span class="vi">@computer_score</span><span class="si">}</span><span class="s2">, Ties: </span><span class="si">#{</span><span class="vi">@ties</span><span class="si">}</span><span class="s2">"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:blue</span><span class="p">)</span> 
       <span class="n">player</span> <span class="o">=</span> <span class="no">PrivateMethods</span><span class="p">.</span><span class="nf">player_choice</span> 
-      <span class="n">computer</span> <span class="o">=</span> <span class="no">Constants</span><span class="o">::</span><span class="no">COMPUTER_CHOICES</span><span class="p">.</span><span class="nf">sample</span> <span class="c1"># chooses a "random" option</span>
+      <span class="n">computer</span> <span class="o">=</span> <span class="no">Constants</span><span class="o">::</span><span class="no">COMPUTER_CHOICES</span><span class="p">.</span><span class="nf">sample</span> 
       <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"</span><span class="se">\n</span><span class="s2">Player chooses </span><span class="si">#{</span><span class="n">player</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">downcase</span><span class="si">}</span><span class="s2">"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:blue</span><span class="p">)</span> 
       <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Computer chooses </span><span class="si">#{</span><span class="n">computer</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">downcase</span><span class="si">}</span><span class="s2">"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:blue</span><span class="p">)</span>
-      <span class="k">case</span> <span class="no">PrivateMethods</span><span class="p">.</span><span class="nf">player_outcome</span> <span class="p">[</span><span class="n">player</span><span class="p">,</span> <span class="n">computer</span><span class="p">]</span> <span class="c1"># define a reference call for player and computer for the arrays called in the player_outcome method</span>
+      <span class="k">case</span> <span class="no">PrivateMethods</span><span class="p">.</span><span class="nf">player_outcome</span> <span class="p">[</span><span class="n">player</span><span class="p">,</span> <span class="n">computer</span><span class="p">]</span>
       <span class="k">when</span> <span class="ss">:WIN</span>
         <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"</span><span class="si">#{</span><span class="n">player</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">capitalize</span><span class="si">}</span><span class="s2"> beats </span><span class="si">#{</span><span class="n">computer</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">downcase</span><span class="si">}</span><span class="s2">, player wins the round"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:red</span><span class="p">)</span> 
-        <span class="vi">@player_score</span> <span class="o">+=</span> <span class="mi">1</span> <span class="c1"># @player_score = @player_score + 1</span>
+        <span class="vi">@player_score</span> <span class="o">+=</span> <span class="mi">1</span>
       <span class="k">when</span> <span class="ss">:LOSE</span>
         <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"</span><span class="si">#{</span><span class="n">computer</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">capitalize</span><span class="si">}</span><span class="s2"> beats </span><span class="si">#{</span><span class="n">player</span><span class="p">.</span><span class="nf">to_s</span><span class="p">.</span><span class="nf">downcase</span><span class="si">}</span><span class="s2">, computer wins the round"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:red</span><span class="p">)</span>
         <span class="vi">@computer_score</span> <span class="o">+=</span> <span class="mi">1</span> 
-      <span class="k">else</span> <span class="c1"># since there is only 1 option left, there is no need to define when :TIE</span>
+      <span class="k">else</span>
         <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Tie, choose again"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:red</span><span class="p">)</span> 
         <span class="vi">@ties</span> <span class="o">+=</span> <span class="mi">1</span>
-        <span class="c1"># since tie is not in the original pass-in argument for the while loop, it will not be affected by the winning score</span>
       <span class="k">end</span>
     <span class="k">end</span>
     <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"</span><span class="se">\n</span><span class="s2">Final score: player: </span><span class="si">#{</span><span class="vi">@player_score</span><span class="si">}</span><span class="s2">, "</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:blue</span><span class="p">)</span> <span class="o">+</span>
          <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"computer: </span><span class="si">#{</span><span class="vi">@computer_score</span><span class="si">}</span><span class="s2"> (ties: </span><span class="si">#{</span><span class="vi">@ties</span><span class="si">}</span><span class="s2">)"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:blue</span><span class="p">)</span>
-    <span class="c1"># define a case for the final outcomes  </span>
     <span class="k">case</span> <span class="no">PrivateMethods</span><span class="p">.</span><span class="nf">final_outcome</span><span class="p">(</span><span class="vi">@player_score</span><span class="p">,</span> <span class="vi">@computer_score</span><span class="p">)</span>
     <span class="k">when</span> <span class="ss">:WIN</span> 
       <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Player wins!"</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:red</span><span class="p">)</span> 
@@ -214,44 +213,36 @@
   <span class="k">end</span> 
 
   <span class="k">module</span> <span class="nn">PrivateMethods</span> 
-    <span class="k">class</span> <span class="o">&lt;&lt;</span> <span class="nb">self</span> <span class="c1"># make all methods below self calling methods of this class (PlayRockPaperScissorsGame) so that the other methods will not to call their parents of these methods</span>
+    <span class="k">class</span> <span class="o">&lt;&lt;</span> <span class="nb">self</span> 
       <span class="k">def</span> <span class="nf">player_choice</span>
-        <span class="kp">loop</span> <span class="k">do</span> <span class="c1"># for loop with no arguments passed in</span>
+        <span class="kp">loop</span> <span class="k">do</span> 
           <span class="nb">print</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"Choose rock (r), paper (p) or scissors (s): "</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:green</span><span class="p">)</span>
-          <span class="n">choice</span> <span class="o">=</span> <span class="nb">gets</span><span class="p">.</span><span class="nf">chomp</span><span class="p">.</span><span class="nf">downcase</span> <span class="c1"># read user input and convert all to lower case</span>
-          <span class="c1"># define valid and invalid entries by using an if else-if statement(s)</span>
-          <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">NTRY_TO_SYM</span><span class="p">.</span><span class="nf">key?</span><span class="p">(</span><span class="n">choice</span><span class="p">)</span> <span class="c1"># if the NTRY_TO_SYM array's key is one of the keys defined in the original array</span>
-            <span class="k">return</span> <span class="no">Constants</span><span class="o">::</span><span class="no">NTRY_TO_SYM</span><span class="p">[</span><span class="n">choice</span><span class="p">]</span> <span class="c1"># return the users choice</span>
-          <span class="k">elsif</span> <span class="n">choice</span> <span class="o">!=</span> <span class="no">Constants</span><span class="o">::</span><span class="no">VALID_ENTRIES</span> <span class="c1"># else if it is not one of the valid entries...</span>
-            <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"That entry is invalid. Please re-enter."</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:red</span><span class="p">)</span> <span class="c1"># return an error message</span>
+          <span class="n">choice</span> <span class="o">=</span> <span class="nb">gets</span><span class="p">.</span><span class="nf">chomp</span><span class="p">.</span><span class="nf">downcase</span> 
+          <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">NTRY_TO_SYM</span><span class="p">.</span><span class="nf">key?</span><span class="p">(</span><span class="n">choice</span><span class="p">)</span>
+            <span class="k">return</span> <span class="no">Constants</span><span class="o">::</span><span class="no">NTRY_TO_SYM</span><span class="p">[</span><span class="n">choice</span><span class="p">]</span> 
+          <span class="k">elsif</span> <span class="n">choice</span> <span class="o">!=</span> <span class="no">Constants</span><span class="o">::</span><span class="no">VALID_ENTRIES</span>
+            <span class="nb">puts</span> <span class="no">ColorizedString</span><span class="p">[</span><span class="s2">"That entry is invalid. Please re-enter."</span><span class="p">].</span><span class="nf">colorize</span><span class="p">(</span><span class="ss">:red</span><span class="p">)</span>
           <span class="k">end</span>
-          <span class="c1"># # one may also do this (albeit more useless):</span>
-          <span class="c1"># case</span>
-          <span class="c1"># when Constants::NTRY_TO_SYM.key?(choice)</span>
-          <span class="c1">#   return Constants::NTRY_TO_SYM[choice]</span>
-          <span class="c1"># when choice != Constants::VALID_ENTRIES</span>
-          <span class="c1">#   puts ColorizedString["That entry is invalid. Please re-enter."].colorize(:green) </span>
-          <span class="c1"># end</span>
         <span class="k">end</span> 
       <span class="k">end</span> 
-      <span class="k">def</span> <span class="nf">player_outcome</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span> <span class="c1"># define method for the player's outcome while passing in a parameter of type array</span>
-        <span class="k">return</span> <span class="ss">:WIN</span>  <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">WINNERS</span><span class="p">.</span><span class="nf">include?</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span> <span class="c1"># return a win if the one of the sub-arrays in the winners array is called</span>
-        <span class="k">return</span> <span class="ss">:LOSE</span> <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">LOSERS</span><span class="p">.</span><span class="nf">include?</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span> <span class="c1"># return a loss if any of the mapped sub-arrays in the losers constant is present</span>
-        <span class="k">return</span> <span class="ss">:TIE</span>  <span class="k">if</span> <span class="o">!</span><span class="ss">:WIN</span> <span class="o">|</span> <span class="o">!</span><span class="ss">:LOSE</span> <span class="c1"># return a tie if not (!) win or if not loose</span>
+      <span class="k">def</span> <span class="nf">player_outcome</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span>
+        <span class="k">return</span> <span class="ss">:WIN</span>  <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">WINNERS</span><span class="p">.</span><span class="nf">include?</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span> 
+        <span class="k">return</span> <span class="ss">:LOSE</span> <span class="k">if</span> <span class="no">Constants</span><span class="o">::</span><span class="no">LOSERS</span><span class="p">.</span><span class="nf">include?</span><span class="p">(</span><span class="n">plays</span><span class="p">)</span>
+        <span class="k">return</span> <span class="ss">:TIE</span>  <span class="k">if</span> <span class="o">!</span><span class="ss">:WIN</span> <span class="o">|</span> <span class="o">!</span><span class="ss">:LOSE</span>
       <span class="k">end</span> 
-      <span class="k">def</span> <span class="nf">final_outcome</span><span class="p">(</span><span class="n">pl</span><span class="p">,</span><span class="n">co</span><span class="p">)</span> <span class="c1"># define final outcome method</span>
+      <span class="k">def</span> <span class="nf">final_outcome</span><span class="p">(</span><span class="n">pl</span><span class="p">,</span><span class="n">co</span><span class="p">)</span>
         <span class="k">return</span> <span class="ss">:WIN</span>  <span class="k">if</span> <span class="n">pl</span> <span class="o">&gt;</span> <span class="n">co</span> 
         <span class="k">return</span> <span class="ss">:LOSE</span> <span class="k">if</span> <span class="n">pl</span> <span class="o">&lt;</span> <span class="n">co</span>
-        <span class="k">return</span> <span class="ss">:TIE</span>  <span class="k">if</span> <span class="n">pl</span> <span class="o">=</span> <span class="n">co</span> <span class="c1"># this can never happen due to the code in the play method, but it is worth noting</span>
+        <span class="k">return</span> <span class="ss">:TIE</span>  <span class="k">if</span> <span class="n">pl</span> <span class="o">=</span> <span class="n">co</span> <span class="c1"># this could never happen due to the code in the play method; however, it is worth noting</span>
       <span class="k">end</span> 
     <span class="k">end</span>
   <span class="k">end</span>
   
-  <span class="nb">private_methods</span> <span class="ss">:PrivateMethods</span> <span class="c1"># make the PrivateMethods module private</span>
+  <span class="nb">private_methods</span> <span class="ss">:PrivateMethods</span> 
 
 <span class="k">end</span> 
 
-<span class="no">PlayRockPaperScissorsGame</span><span class="p">.</span><span class="nf">new</span><span class="p">.</span><span class="nf">play</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="c1"># call the play method and pass in 3 (0, 1, 2) for the winning score</span>
+<span class="no">PlayRockPaperScissorsGame</span><span class="p">.</span><span class="nf">new</span><span class="p">.</span><span class="nf">play</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> 
 </code></pre>
 </div>
 

data/docs/_site/How_to_Build.html

@@ -7,9 +7,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
-    <link rel="stylesheet" href="/assets/css/style.css?v=b6dce77cfbf038800279b1f621a6690f834078a8">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/style.css?v=a619aba449fd31773059e12d98817087fdec295e">
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">

data/docs/_site/Testing.html

@@ -7,9 +7,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
-    <link rel="stylesheet" href="/assets/css/style.css?v=b6dce77cfbf038800279b1f621a6690f834078a8">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/style.css?v=a619aba449fd31773059e12d98817087fdec295e">
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">

data/docs/_site/index.html

@@ -7,9 +7,9 @@
     <meta name="viewport" content="width=device-width, initial-scale=1">
     <meta name="theme-color" content="#157878">
     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
-    <link rel="stylesheet" href="/assets/css/style.css?v=b6dce77cfbf038800279b1f621a6690f834078a8">
-    <link rel="stylesheet" href="assets/css/pace.css" />
-    <script src="assets/js/pace.min.js"></script>
+    <link rel="stylesheet" href="/assets/css/style.css?v=a619aba449fd31773059e12d98817087fdec295e">
+    <link rel="stylesheet" href="/assets/css/pace.css" />
+    <script src="/assets/js/pace.min.js"></script>
   </head>
   <body>
     <section class="page-header">

data/lib/rps/version.rb

@@ -1,3 +1,3 @@
 module RockPaperScissors
-  VERSION = "2.4.5"
+  VERSION = "2.4.6"
 end

data/rps.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec| 
   spec.name                             = "PlayRockPaperScissorsGame"
-  spec.version                          = "2.4.5"
+  spec.version                          = "2.4.6"
   spec.date                             = "2017-04-07"
   spec.summary                          = "A Rock Paper Scissors Ruby Gem"
   spec.description                      = <<-EOF 

data/test/test_rps.rb

@@ -19,8 +19,8 @@ class RakeTest # create test
 
   class << self
     def continue(str1,str2,str3)
-      puts  ColorizedString[str1].colorize(:color => :green) 
-      print ColorizedString[str2].colorize(:color => :green)
+      puts  str1 
+      print str2
       gets 
       puts  str3
     end 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: PlayRockPaperScissorsGame
 version: !ruby/object:Gem::Version
-  version: 2.4.5
+  version: 2.4.6
 platform: ruby
 authors:
 - bag3318