mastermind-nowsiany 1.0.0

data/lib/mastermind/version.rb

@@ -0,0 +1,3 @@
+module Mastermind
+  VERSION = "1.0.0"
+end

data/lib/mastermind.rb

@@ -0,0 +1,28 @@
+require "mastermind/version"
+
+module Mastermind
+  COLORS = ["R", "Y", "G", "B", "P", "M"]
+
+  COLOR_NAMES = {
+    "R" => "(r)ed",
+    "Y" => "(y)ellow",
+    "G" => "(g)reen",
+    "B" => "(b)lue",
+    "P" => "(p)ink",
+    "M" => "(m)agenta"
+  }
+
+  COLOR_CODES = {
+    "R" => :red,
+    "Y" => :yellow,
+    "G" => :green,
+    "B" => :blue,
+    "P" => :magenta,
+    "M" => :light_magenta
+  }
+
+  def self.color_option_string(num_colors)
+    COLOR_NAMES.values.first(num_colors).join(" | ")
+  end
+
+end

data/mastermind.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mastermind/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mastermind-nowsiany"
+  spec.version       = Mastermind::VERSION
+  spec.authors       = ["Nathan Owsiany"]
+  spec.email         = ["nowsiany@gmail.com"]
+  spec.summary       = %q{Command Line Mastermind}
+  spec.description   = %q{Play Mastermind through your command line... with multiplayer support.}
+  spec.homepage      = "https://github.com/ndwhtlssthr/mastermind"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "colorize", "~> 0.7"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "guard", "~> 2.8"
+  spec.add_development_dependency "guard-rspec", "~> 4.3"
+end

data/spec/cli_spec.rb

@@ -0,0 +1,46 @@
+require 'mastermind/cli'
+require 'mastermind/play_game'
+require 'mastermind/interact'
+require 'spec_helper'
+require 'stringio'
+
+RSpec.describe Mastermind::CLI do
+  it "should be able to quit" do
+    stdin = StringIO.new("Q")
+    cli = Mastermind::CLI.new(stdin, StringIO.new)
+    expect(cli.quit?).to be_falsey
+
+    cli.get_command
+    expect(cli.quit?).to be_truthy
+
+    stdin.string = "q"
+    cli.get_command
+    expect(cli.quit?).to be_truthy
+  end
+
+  it "should print intro title and content" do
+    stdin = StringIO.new("\nq")
+    stdout = StringIO.new()
+    cli = Mastermind::CLI.new(stdin, stdout)
+    cli.run
+    expect(stdout.string).to include("0;32;49m")
+    expect(stdout.string).to include("MA1N")
+    expect(stdout.string).to include("_/")
+  end
+
+  it "should print instructions when prompted" do
+    stdin = StringIO.new("i\nq")
+    stdout = StringIO.new()
+    cli = Mastermind::CLI.new(stdin, stdout)
+    cli.run
+    expect(stdout.string).to include("(i)")
+  end
+
+  it "should play the game when prompted" do
+    stdin = StringIO.new("p\nq\nq\n")
+    stdout = StringIO.new()
+    cli = Mastermind::CLI.new(stdin, stdout)
+    cli.run
+    expect(Mastermind::PlayGame.new(stdin, stdout, Mastermind::Interact.new)).to respond_to(:run)
+  end
+end

data/spec/game_round_spec.rb

@@ -0,0 +1,268 @@
+require 'mastermind/player'
+require 'mastermind/game_round'
+require 'mastermind/interact'
+require 'mastermind/processor'
+require 'spec_helper'
+require 'stringio'
+
+RSpec.describe Mastermind::GameRound do
+  attr_accessor :stdin, :stdout, :interact
+  before do
+    self.stdin = StringIO.new("\nSimon\nAlvin\n")
+    self.stdout = StringIO.new
+    self.interact = Mastermind::Interact.new
+  end
+
+  it "should generate a random secret when there is one player" do
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(1)
+    round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    expect(round.players[0].secret).to eql(["X", "X", "X", "X"])
+    thread = Thread.new do
+      round.play
+      binding.pry
+    end
+    sleep(0.1)
+    player = round.players[0]
+    colors = Mastermind::Processor.colors(6)
+    expect(player.secret).to_not eql(["X", "X", "X", "X"])
+    expect(Mastermind::Processor.validate(player.secret.join, player.secret, colors)).to be_truthy
+    thread.kill
+  end
+
+  context "when generating a single player secret" do
+    before do
+      @game = Mastermind::PlayGame.new(stdin, stdout, interact)
+      @players = @game.player_gen(1)
+      @round = Mastermind::GameRound.new(stdin, stdout, interact, @players)
+    end
+
+    it "knows the initial state of the secret is invalid" do
+      expect(@round.players[0].secret).to eql(["X", "X", "X", "X"])
+    end
+
+    it "changes the secret from its initial state" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      player = @round.players[0]
+      expect(player.secret).to_not eql(["X", "X", "X", "X"])
+      thread.kill
+    end
+
+    it "generates a valid secret" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      player = @round.players[0]
+      colors = Mastermind::Processor.colors(6)
+      expect(Mastermind::Processor.validate(player.secret.join, player.secret, colors)).to be_truthy
+      thread.kill
+    end
+  end
+
+  context "when generating multi player secrets" do
+    before do
+      stdin.string = "m\nSimon\nTheodore\nrrrr\nrrrr\n"
+      @game = Mastermind::PlayGame.new(stdin, stdout, interact)
+      @players = @game.player_gen(2)
+      @round = Mastermind::GameRound.new(stdin, stdout, interact, @players)
+    end
+
+    it "knows the initial state of each players secret is invalid" do
+      expect(@round.players[0].secret).to eql(["X", "X", "X", "X"])
+      expect(@round.players[1].secret).to eql(["X", "X", "X", "X"])
+    end
+
+    it "changes the secret from its initial state" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      player = @round.players[0]
+      expect(player.secret).to_not eql(["X", "X", "X", "X"])
+      expect(player.secret).to eql(["R", "R", "R", "R"])
+      thread.kill
+    end
+
+    it "generates a valid secret" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      player = @round.players[0]
+      colors = Mastermind::Processor.colors(6)
+      expect(Mastermind::Processor.validate(player.secret.join, player.secret, colors)).to be_truthy
+      thread.kill
+    end
+  end
+
+  it "loads a list of valid colors" do
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(1)
+    round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    expect(round.valid_colors).to eql(["R", "Y", "G", "B", "P", "M"])
+  end
+
+  it "sets max guesses to 12 for single difficulty model" do
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(1)
+    round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    expect(round.max_guesses).to eql(12)
+  end
+
+  context "when resetting a Players' round info before the round" do
+    before do
+      @game = Mastermind::PlayGame.new(stdin, stdout, interact)
+      @players = @game.player_gen(2)
+      @round = Mastermind::GameRound.new(stdin, stdout, interact, @players)
+    end
+
+    # NOTE: alternating b/w player 1 and 2 to verify it works for each player
+
+    it "resets the players password to XXXX" do
+      @round.players[0].secret = ["Z", "Z", "Z", "Z"]
+      expect(@round.players[0].secret).to_not eql(["X", "X", "X", "X"])
+      @round.player_reset
+      expect(@round.players[0].secret).to eql(["X", "X", "X", "X"])
+    end
+
+    it "sets the players round_over status to false" do
+      @round.players[1].round_over = true
+      expect(@round.players[1].round_over).to be_truthy
+      @round.player_reset
+      expect(@round.players[1].round_over).to be_falsey
+    end
+
+    it "clears the players guess log" do
+      @round.players[0].guesses = ["gggg", "gggg"]
+      expect(@round.players[0].guesses).to_not be_empty
+      @round.player_reset
+      expect(@round.players[0].guesses).to be_empty
+    end
+
+    it "it resets the time counter" do
+      test_time = Time.now
+      @round.player_reset
+      expect(@round.players[1].start_time).to be_within(1).of(test_time)
+    end
+
+    it "it resets the completion time to nil" do
+      @round.players[0].completion_time = Time.new - 500
+      expect(@round.players[0].completion_time).to_not be_nil
+      @round.player_reset
+      expect(@round.players[0].completion_time).to be_nil
+    end
+
+    it "resets a players turn position" do
+      @round.players[1].turn_pos = 1
+      expect(@round.players[1].turn_pos).to_not be_nil
+      @round.player_reset
+      expect(@round.players[1].turn_pos).to be_nil
+    end
+
+  end
+
+  it "it has a blank global string command to start with" do
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(1)
+    round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    expect(round.command).to eql("")
+  end
+
+  it "is not round over by default" do
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(1)
+    round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    expect(round.round_over).to be_falsey
+  end
+
+  it "can identify a winning guess" do
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(1)
+    round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    round.players[0].secret = ["R", "R", "R", "R"]
+    round.players[0].command = "RRRR"
+    expect(round.correct_guess?(round.players[0])).to be_truthy
+  end
+
+  it "knows how many guesses have been taken" do
+    stdin = StringIO.new("m\nsimon\ntheo\nrrrr\nrrrr\ngggg\nyyyy\nbbbb\n")
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(2)
+    round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    thread = Thread.new do
+      round.play
+    end
+    sleep(0.1)
+    expect(round.num_guesses(players[0])).to eql(2)
+    expect(round.num_guesses(players[1])).to eql(1)
+    thread.kill
+  end
+
+  context "when one player guesses correct" do
+    before do
+      stdin = StringIO.new("m\nsimon\ntheo\nrrrr\nrrrr\nrrrr\nyyyy\nbbbb\n")
+      game = Mastermind::PlayGame.new(stdin, stdout, interact)
+      players = game.player_gen(2)
+      @round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    end
+
+    it "knows that player1's round is over" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      expect(@round.players[0].round_over).to be_truthy
+      thread.kill
+    end
+
+    it "knows that the game round is not over after one player wins" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      expect(@round.round_over).to be_falsey
+      thread.kill
+    end
+
+    it "continues prompting for guesses for the other player" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      expect(@round.num_guesses(@round.players[1])).to eql(2)
+      thread.kill
+    end
+  end
+
+  context "when both players guess correctly" do
+    before do
+      stdin = StringIO.new("m\nsimon\ntheo\nrrrr\nrrrr\nrrrr\nyyyy\nbbbb\nrrrr\n")
+      game = Mastermind::PlayGame.new(stdin, stdout, interact)
+      players = game.player_gen(2)
+      @round = Mastermind::GameRound.new(stdin, stdout, interact, players)
+    end
+
+    it "knows that each players' round is over" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      expect(@round.players[0].round_over).to be_truthy
+      expect(@round.players[1].round_over).to be_truthy
+      thread.kill
+    end
+
+    it "knows that the game round is over" do
+      thread = Thread.new do
+        @round.play
+      end
+      sleep(0.1)
+      expect(@round.round_over).to be_truthy
+      thread.kill
+    end
+  end
+end

data/spec/interact_spec.rb

@@ -0,0 +1,37 @@
+require 'mastermind/interact'
+
+RSpec.describe Mastermind::Interact do
+  before do
+    @interact = Mastermind::Interact.new
+  end
+
+  it 'can return a colored string given a string input' do
+    colored = @interact.color_guess("R")
+    expect(colored).to eql("\e[0;31;49mR\e[0m")
+  end
+
+  it 'prints an intro title' do
+    expect(@interact.print_title).to include("0;32;49m")
+  end
+
+  it 'prints the main menu' do
+    expect(@interact.print_intro).to include("(i)")
+  end
+
+  it 'prints an invalid command message' do
+    invalid_cmd = "XXXX"
+    expect(@interact.print_invalid(invalid_cmd)).to include("not a valid")
+    expect(@interact.print_invalid(invalid_cmd)).to include(invalid_cmd)
+  end
+
+  it 'prints a round over message' do
+    expect(@interact.print_round_over).to include("Round over")
+  end
+
+  it 'prints an invalid guess message' do
+    invalid_cmd = "XXXX"
+    expect(@interact.print_invalid_guess(invalid_cmd)).to include("not a valid")
+    expect(@interact.print_invalid_guess(invalid_cmd)).to include(invalid_cmd)
+  end
+
+end

data/spec/play_game_spec.rb

@@ -0,0 +1,90 @@
+require 'mastermind/play_game'
+require 'mastermind/interact'
+require 'mastermind/game_round'
+require 'spec_helper'
+require 'stringio'
+require 'io/console'
+
+RSpec.describe Mastermind::PlayGame do
+  it "should be able to quit" do
+    stdin = StringIO.new("Q")
+    stdout = StringIO.new
+    interact = Mastermind::Interact.new
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    expect(game.quit?).to be_falsey
+
+    game.get_command
+    expect(game.quit?).to be_truthy
+
+    stdin.string = "q"
+    game.get_command
+    expect(game.quit?).to be_truthy
+  end
+
+  it "should print intro title and content" do
+    stdin = StringIO.new("q")
+    stdout = StringIO.new
+    interact = Mastermind::Interact.new
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    game.run
+    expect(stdout.string).to include("(s)1nG1e")
+  end
+
+  it "should generate the specified number of players" do
+    stdin = StringIO.new("\nSimon\nAlvin\n")
+    stdout = StringIO.new
+    interact = Mastermind::Interact.new
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    players = game.player_gen(2)
+    expect(players.length).to eql(2)
+    expect(players[0]).to be_a Mastermind::Player
+  end
+
+  it "gets a valid name" do
+    stdin = StringIO.new("\nANameThatIsTooLong\nAlvin\n")
+    stdout = StringIO.new
+    interact = Mastermind::Interact.new
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    name = game.get_name(1)
+    expect(stdout.string).to include("Name")
+    expect(name).to eql("Alvin")
+  end
+
+  it "can validate a name" do
+    stdin = StringIO.new("\nANameThatIsTooLong\nAlvin\n")
+    stdout = StringIO.new
+    interact = Mastermind::Interact.new
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    expect(game.valid_name?("ANameThatIsTooLong")).to be_falsey
+    expect(game.valid_name?("")).to be_falsey
+    expect(game.valid_name?("Theodore")).to be_truthy
+  end
+
+  it "should play a single player game when prompted" do
+    stdin = StringIO.new("s\nTheodore\n")
+    stdout = StringIO.new()
+    interact = Mastermind::Interact.new
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    thread = Thread.new do
+      game.run
+    end
+    players = []
+    expect(Mastermind::GameRound.new(stdin, stdout, Mastermind::Interact.new, players)).to respond_to(:play)
+    thread.kill
+  end
+
+  # note: undefined method 'noecho' for stringio... not sure how to test this...
+  it "should play a multiplayer game when prompted" do
+    stdin = StringIO.new("m\nTheodore\nAlvin\n")
+    stdout = StringIO.new()
+    interact = Mastermind::Interact.new
+    players = []
+    game = Mastermind::PlayGame.new(stdin, stdout, interact)
+    thread = Thread.new do
+      game.run
+    end
+    expect(Mastermind::GameRound.new(stdin, stdout, Mastermind::Interact.new, players)).to respond_to(:play)
+    thread.kill
+  end
+
+end

data/spec/processor_spec.rb

@@ -0,0 +1,63 @@
+require 'mastermind/processor'
+
+RSpec.describe Mastermind::Processor do
+  it "generates a random 4 char secret code" do
+    secret = Mastermind::Processor.secret(4, 6)
+    expect(secret.length).to eql(4)
+    expect(Mastermind::Processor.valid_colors?(secret.join(""), Mastermind::Processor.colors(6))).to be_truthy
+  end
+
+  it "can pull the first x numbers" do
+    expect(Mastermind::Processor.colors(3)).to eql(["R", "Y", "G"])
+  end
+
+  context "when validating a guess" do
+    it "validates that a correct length guess is valid" do
+      valid_length = Mastermind::Processor.valid_length?("RBBY", ["R", "G", "R", "R"])
+      expect(valid_length).to be_truthy
+    end
+
+    it "says that an input containing only valid colors is valid" do
+      valid_color = Mastermind::Processor.valid_colors?("MRRB", ["R", "G", "B", "Y", "P", "M"])
+      expect(valid_color).to be_truthy
+    end
+
+    it "says that an input with the correct length and colors is valid" do
+      valid = Mastermind::Processor.validate("RGMY", ["R", "G", "B", "Y"], ["R", "G", "B", "Y", "P", "M"])
+      expect(valid).to be_truthy
+    end
+
+    it "says that an input that is too long is invalid" do
+      invalid = Mastermind::Processor.validate("RG", ["R", "G", "B", "Y"], ["R", "G", "B", "Y", "P", "M"])
+      expect(invalid).to be_falsey
+    end
+
+    it "says that an input that is too short is invalid" do
+      invalid = Mastermind::Processor.validate("XRESRG", ["R", "G", "B", "Y"], ["R", "G", "B", "Y", "P", "M"])
+      expect(invalid).to be_falsey
+    end
+
+    it "says that an input with invalid letters is invalid" do
+      invalid = Mastermind::Processor.validate("RRRX", ["R", "G", "B", "Y"], ["R", "G", "B", "Y", "P", "M"])
+      expect(invalid).to be_falsey
+    end
+  end
+
+  context "when checking a valid guess" do
+    it "checks how many colors are correct but not in the correct position once" do
+      colors = Mastermind::Processor.num_correct_colors("YBBB", ["B", "P", "P", "Y"])
+      expect(colors).to eql(2)
+    end
+
+    it "checks correct_colors again..." do
+      colors = Mastermind::Processor.num_correct_colors("RRBB", ["R", "R", "R", "R"])
+      expect(colors).to eql(0)
+    end
+
+    it "checks how many colors are in the correct position" do
+      positions = Mastermind::Processor.num_correct_pos("RGYM", ["R", "M", "G", "M"])
+      expect(positions).to eql(2)
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+class StringIO
+  def noecho
+    yield self
+  end
+end