PlayRockPaperScissorsGame 2.2.4 → 2.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c1015020d251332e0b2be0db5ac330a37cc46d9
-  data.tar.gz: 6dc05775f91dd30253190f37253346dfd4ca761c
+  metadata.gz: 4b3fc06f4d65bfd48e21b4426e9eb132c07a149b
+  data.tar.gz: ae5db8785077f8f2f894822d246f5abee54ee156
 SHA512:
-  metadata.gz: 866311fa990c33a9e77772e9c99db464e690e0c8ed78db3559c0b7b2ef061a004060f71fe87f468e4f6b60b242067225befa3430853a47bf6182e74498e235c0
-  data.tar.gz: f3986f9fe53c3dc4adf444a664582a704cda75f307cdd3c18a7e01c32f4997808c50770b8c0ab0220e4f620dfee283e27a30bb8e2d2c854cc70d23e047f8cc30
+  metadata.gz: 51a2b1dea0d717090474b09721b9df34ab1e8eb55649f75627031e01ed69977b461988c35cdd6238980ec05d20156d52c0634f038f307899262c057505c94b16
+  data.tar.gz: d19e73ab940e73cb8b3703f49f844cff8c61cb457e685c1f1823004b3f858519c691aa8ed4068391ad4ee699511f4d036d5021fa0b3f56fa67f4abeda89c33f3

data/bin/PlayRockPaperScissorsGame

@@ -4,27 +4,23 @@
 |====================================|
 | Req Ruby Ver | Req Ruby Gems Ver   |
 |--------------|---------------------|
-| >= v2.0.0    | >= v2.6.10          |
+| >= v2.0.0    | >= v2.6.0           |
 |====================================|
 =end
 
 
-class PlayRockPaperScissorsGame 
+class PlayRockPaperScissorsGame
+
+  require_relative "./../lib/rps/version.rb"
 
   # intiate the colorize gem
   require "colorized_string"
   ColorizedString.colors   
   ColorizedString.modes  
 
-  module Constants 
-    protected # make constants protected
-    NTRY_TO_SYM = { 'p' => :PAPER,  'r' => :ROCK, 's' => :SCISSORS } 
-    VALID_ENTRIES = NTRY_TO_SYM.keys 
-    COMPUTER_CHOICES = NTRY_TO_SYM.values
-    WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]] # format: player choice, computer choice
-    LOSERS = WINNERS.map { |i,j| [j,i] } # this will take the original `WINNERS` array and flip the symbols, thus returning a loss for the user/player
-    INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""]
-  end
+  require_relative "./../lib/Constants.rb"
+
+  protected_methods :Constants
 
   class << self
     def continue(str1,str2,str3) # pass in 3 parameters
@@ -34,7 +30,9 @@ class PlayRockPaperScissorsGame
       puts  ColorizedString[str3].colorize(:color => :green)
     end 
   end 
+
   continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2])
+
   def initialize
     @player_score = @computer_score = @ties = 0 
   end 
@@ -70,39 +68,11 @@ class PlayRockPaperScissorsGame
     end 
     gets
   end 
-  module PrivateMethods
-    private
-    class << self
-      def player_choice
-        loop do
-          print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green)
-          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(:green) 
-          end
-          # # one may also do this:
-          # 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)
-        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) 
-        return :WIN  if pl > co 
-        return :LOSE if pl < co
-        return :TIE  if pl = co 
-      end 
-    end
-  end
+
+  require_relative "./../lib/PrivateMethods.rb"
+  
+  private_methods :PrivateMethods
+
 end 
 
 PlayRockPaperScissorsGame.new.play(2) # best of 3

data/bin/rps

@@ -4,36 +4,35 @@
 |====================================|
 | Req Ruby Ver | Req Ruby Gems Ver   |
 |--------------|---------------------|
-| >= v2.0.0    | >= v2.6.10          |
+| >= v2.0.0    | >= v2.6.0           |
 |====================================|
 =end
 
 
-class PlayRockPaperScissorsGame 
+class PlayRockPaperScissorsGame
 
+  require_relative "./../lib/rps/version.rb"
+
+  # intiate the colorize gem
   require "colorized_string"
   ColorizedString.colors   
   ColorizedString.modes  
 
-  module Constants 
-    protected
-    NTRY_TO_SYM = { 'p' => :PAPER,  'r' => :ROCK, 's' => :SCISSORS } 
-    VALID_ENTRIES = NTRY_TO_SYM.keys 
-    COMPUTER_CHOICES = NTRY_TO_SYM.values
-    WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]] # format: player choice, computer choice
-    LOSERS = WINNERS.map { |i,j| [j,i] } # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
-    INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""]
-  end
+  require_relative "./../lib/Constants.rb"
+
+  protected_methods :Constants
 
   class << self
-    def continue(str1, str2, str3)
+    def continue(str1,str2,str3) # pass in 3 parameters
       puts  ColorizedString[str1].colorize(:color => :green) 
       print ColorizedString[str2].colorize(:color => :green)
-      gets 
+      gets # press enter or return to continue
       puts  ColorizedString[str3].colorize(:color => :green)
     end 
   end 
+
   continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2])
+
   def initialize
     @player_score = @computer_score = @ties = 0 
   end 
@@ -42,7 +41,7 @@ class PlayRockPaperScissorsGame
       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 
+      computer = Constants::COMPUTER_CHOICES.sample # chooses a random option
       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] 
@@ -69,40 +68,11 @@ class PlayRockPaperScissorsGame
     end 
     gets
   end 
-  module PrivateMethods
-    private
-    class << self
-      def player_choice
-        loop do
-          print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green)
-          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(:green) 
-          end
-          # # one may also do this:
-          # 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)
-        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) 
-        return :WIN  if pl > co 
-        return :LOSE if pl < co
-        return :TIE  if pl = co 
-      end 
-    end
-  end
-end 
 
-PlayRockPaperScissorsGame.new.play(2) # best of 3
+  require_relative "./../lib/PrivateMethods.rb"
+  
+  private_methods :PrivateMethods
+
+end 
 
+PlayRockPaperScissorsGame.new.play(2) # best of 3

data/lib/{ref/Constants.rb → Constants.rb}

@@ -2,7 +2,6 @@ require "colorized_string"
 ColorizedString.colors   
 ColorizedString.modes  
 module Constants 
-  protected
   NTRY_TO_SYM = { 
     'p' => :PAPER, 
     'r' => :ROCK, 

data/lib/{ref/PrivateMethods.rb → PrivateMethods.rb}

@@ -2,12 +2,11 @@ require "colorized_string"
 ColorizedString.colors   
 ColorizedString.modes  
 module PrivateMethods
-  private
   class << self
     def player_choice
       loop do
         print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green)
-        choice = gets.chomp.downcasec
+        choice = gets.chomp.downcase
         if Constants::NTRY_TO_SYM.key?(choice)
           return Constants::NTRY_TO_SYM[choice]
         elsif choice != Constants::VALID_ENTRIES
@@ -27,10 +26,10 @@ module PrivateMethods
       return :LOSE if Constants::LOSERS.include?(plays)
       return :TIE  if !:WIN | !:LOSE
     end 
-    def final_outcome(pl, co) 
+    def final_outcome(pl,co) 
       return :WIN  if pl > co 
       return :LOSE if pl < co
       return :TIE  if pl = co 
     end 
   end
-end
+end

data/lib/rps/version.rb

@@ -1,3 +1,3 @@
-module PlayRockPaperScissorsGame
-  VERSION = "2.2.4"
+module RockPaperScissors
+  VERSION = "2.2.7"
 end

data/rps.gemspec

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

data/test/test_rps.rb

@@ -2,27 +2,23 @@
 |====================================|
 | Req Ruby Ver | Req Ruby Gems Ver   |
 |--------------|---------------------|
-| >= v2.0.0    | >= v2.6.10          |
+| >= v2.0.0    | >= v2.6.0           |
 |====================================|
 =end
 
 class RakeTest # create test
 
+  require_relative "./../lib/rps/version.rb"
+
   require "colorized_string"
   ColorizedString.colors
   ColorizedString.modes
 
-  module Constants 
-    protected
-    NTRY_TO_SYM = { 'p' => :PAPER,  'r' => :ROCK, 's' => :SCISSORS } 
-    VALID_ENTRIES = NTRY_TO_SYM.keys 
-    COMPUTER_CHOICES = NTRY_TO_SYM.values
-    WINNERS = [[:SCISSORS, :PAPER], [:PAPER, :ROCK], [:ROCK, :SCISSORS]] # format: player choice, computer choice
-    LOSERS = WINNERS.map { |i,j| [j,i] } # this will take the original WINNERS array and flip the symbols, thus returning a loss for the user/player
-    INIT_STRINGS = ["You are about to enter a rock-paper-scissors best of 3 match.", "Press the return/enter key to continue...", ""]
-  end
+  require_relative "./../lib/Constants.rb"
+  protected_methods :Constants 
+
   class << self
-    def continue(str1, str2, str3)
+    def continue(str1,str2,str3)
       puts  ColorizedString[str1].colorize(:color => :green) 
       print ColorizedString[str2].colorize(:color => :green)
       gets 
@@ -65,39 +61,9 @@ class RakeTest # create test
     end 
     gets
   end 
-  module PrivateMethods
-    private
-    class << self
-      def player_choice
-        loop do
-          print ColorizedString["Choose rock (r), paper (p) or scissors (s): "].colorize(:green)
-          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(:green)
-          end
-          # # one may also do this:
-          # 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)
-        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) 
-        return :WIN  if pl > co 
-        return :LOSE if pl < co
-        return :TIE  if pl = co 
-      end 
-    end
-  end
+  require_relative "./../lib/PrivateMethods.rb"
+  private_methods :PrivateMethods
+
 end 
 
 RakeTest.new.testPlay(2) # best of 3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: PlayRockPaperScissorsGame
 version: !ruby/object:Gem::Version
-  version: 2.2.4
+  version: 2.2.7
 platform: ruby
 authors:
 - bag3318
@@ -153,9 +153,8 @@ files:
 - exec/rps.bash
 - exec/run.bat
 - exec/uninstall.sh
-- lib/ref/Constants.rb
-- lib/ref/PrivateMethods.rb
-- lib/rps.rb
+- lib/Constants.rb
+- lib/PrivateMethods.rb
 - lib/rps/version.rb
 - rps.gemspec
 - test/test_rps.rb

data/lib/rps.rb

@@ -1,66 +0,0 @@
-=begin
-|====================================|
-| Req Ruby Ver | Req Ruby Gems Ver   |
-|--------------|---------------------|
-| >= v2.0.0    | >= v2.6.10          |
-|====================================|
-=end
-
-class PlayRockPaperScissorsGame 
-
-  require "colorized_string"
-  ColorizedString.colors
-  ColorizedString.modes
-
-  require "ref/Constants.rb"
-
-  class << self
-    def continue(str1, str2, str3)
-      puts  ColorizedString[str1].colorize(:color => :green) 
-      print ColorizedString[str2].colorize(:color => :green)
-      gets 
-      puts  ColorizedString[str3].colorize(:color => :green)
-    end 
-  end 
-  continue(Constants::INIT_STRINGS[0], Constants::INIT_STRINGS[1], Constants::INIT_STRINGS[2])
-  def initialize
-    @player_score = @computer_score = @ties = 0 
-  end 
-  def play(winning_score) 
-    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 
-      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] 
-      when :WIN
-        puts ColorizedString["#{player.to_s.capitalize} beats #{computer.to_s.downcase}, player wins the round"].colorize(:red) 
-        @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 
-        puts ColorizedString["Tie, choose again"].colorize(:red) 
-        @ties += 1
-      end
-    end
-    puts ColorizedString["\nFinal score: player: #{@player_score}, "].colorize(:blue) +
-         ColorizedString["computer: #{@computer_score} (ties: #{@ties})"].colorize(:blue) 
-    case PrivateMethods.final_outcome(@player_score, @computer_score)
-    when :WIN 
-      puts ColorizedString["Player wins!"].colorize(:red) 
-    when :LOSE
-      puts ColorizedString["Computer wins!"].colorize(:red)
-    else 
-      puts ColorizedString["It's a tie!"].colorize(:red) 
-    end 
-    gets
-  end 
-  require "ref/PrivateMethods.rb"
-end
-
-
-PlayRockPaperScissorsGame.new.play(2) # best of 3
-