Created skeleton of directory requirements.

.gitignore

@@ -5,22 +5,37 @@
 /InstalledFiles
 /pkg/
 /spec/reports/
+/spec/examples.txt
 /test/tmp/
 /test/version_tmp/
 /tmp/
 
+# Used by dotenv library to load environment variables.
+# .env
+
 ## Specific to RubyMotion:
 .dat*
 .repl_history
 build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
 
 ## Documentation cache and generated files:
 /.yardoc/
 /_yardoc/
 /doc/
 /rdoc/
 
-## Environment normalisation:
+## Environment normalization:
 /.bundle/
 /vendor/bundle
 /lib/bundler/man/
@@ -33,3 +48,4 @@ build/
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+.DS_Store

Rakefile

@@ -0,0 +1,13 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib", "specs"]
+  t.warning = false
+  t.verbose = false
+  t.test_files = FileList['specs/*_spec.rb']
+  puts "Running TestTask"
+end
+
+task default: :test do
+    puts "Running my Rakefile"
+end

lib/Player.rb

@@ -0,0 +1,80 @@
+require_relative "../module"
+require_relative "../lib/TileBag"
+require_relative "../lib/Scoring"
+# :: module reference
+
+class Scrabble::Player
+
+  attr_reader :name, :total_score, :picked_tiles, :tilebag1
+
+  def initialize(name)
+    @name = name
+    @word_score = 0
+    @total_score = 0
+    @words_by_player = []
+    @picked_tiles = []
+
+  end
+
+  def plays
+    # returns Array of words played
+    return @words_by_player
+  end
+
+  def play(word)
+    # play(word): Function: adds the input word to words_by_player
+    # returns false if player has already won, otherwise return @word_score
+    if won?
+      return false
+    else
+      word.each_char do |letter|
+        if picked_tiles.include? letter
+          @picked_tiles.delete_at(@picked_tiles.index(letter))
+        end
+      end
+      @words_by_player << word
+      @word_score = Scrabble::Scoring.score(word)
+      return @word_score
+    end
+  end
+
+  def total_score
+    # Returns the sum of scores of played words: @total_score
+    @words_by_player.each do |word|
+      @total_score += Scrabble::Scoring.score(word)
+    end
+    return @total_score
+  end
+
+  def won?
+    # If the player has over 100 points, returns true, otherwise returns false
+    if @total_score >= 100
+      return true
+    else
+      return false
+    end
+  end
+
+  def highest_scoring_word
+    # Returns the highest scoring played word
+    return Scrabble::Scoring.highest_score_from(@words_by_player)
+  end
+
+  def highest_word_score
+    # Returns the highest_scoring_word's score
+    # proudest moment for Rachel lol
+    high_score_word = highest_scoring_word
+    highest_score = Scrabble::Scoring.score(high_score_word)
+    return highest_score
+  end
+  def tiles
+    return @picked_tiles
+  end
+
+  def draw_tiles(tile_bag)
+# fills the tile array until it has 7 letters from the given tile bag
+    @picked_tiles << tile_bag.draw_tiles(7 - @picked_tiles.length)
+    return @picked_tiles.flatten!
+  end
+# class end
+end

lib/Scoring.rb

@@ -0,0 +1,55 @@
+require_relative "../module"
+
+class Scrabble::Scoring
+
+  attr_reader :word
+  attr_accessor :total
+
+  def self.score(word)
+    # create an array of strings (letters) from word
+    # loop through letters array in order to determine total score (by referencing LETTER_HASH)
+
+    return 0 if word.nil? || word.empty?
+
+    letters = word.upcase.split('')
+
+    letters.length >= 7 ? total = 50 : total = 0
+
+    letters.each do |letter|
+      total += Scrabble::LETTER_HASH[letter]
+
+    end
+
+    return total
+
+  end
+
+  def self.highest_score_from(array_of_words)
+    # initialize two variables in order to hold max_score and max_scoring_word
+    # iterate through the array_of_words and use if statements to determine when the word and score are stored in the local variables
+    # use tie-breaking logic in if statements to determine when to score word/score into variable
+    max_score = 0
+    max_scoring_word = ""
+
+    array_of_words.each do |word|
+
+      if score(word).to_i > max_score
+        max_score = score(word)
+        max_scoring_word = word
+
+      elsif score(word).to_i == max_score
+        if word.chars.count >= 7
+          max_score = score(word)
+          max_scoring_word = word
+
+        elsif word.chars.count < max_scoring_word.chars.count
+          max_score = score(word)
+          max_scoring_word = word
+
+        end
+      end
+    end
+    return max_scoring_word
+  end
+#class end.
+end

lib/TileBag.rb

@@ -0,0 +1,51 @@
+require_relative '../lib/Scoring'
+require_relative '../module'
+require 'awesome_print'
+
+class Scrabble::TileBag
+
+attr_reader :picked_tiles
+
+  def initialize
+    # called When you use TileBag.new sets up an instance with a collection of default tiles.
+@default_tile_bag = [
+  ["A", "A", "A", "A", "A", "A", "A", "A", "A"],
+  ["B", "B"],["C", "C"], ["D", "D", "D", "D"],
+  ["E", "E", "E", "E", "E", "E", "E", "E", "E", "E", "E", "E"],
+  ["F", "F"], ["G", "G", "G"], ["H", "H"],
+  ["I", "I", "I", "I", "I", "I", "I", "I", "I"],
+  ["J"], ["K"], ["L", "L", "L", "L"], ["M", "M"],
+  ["N", "N", "N", "N", "N", "N"],
+  ["O", "O", "O", "O", "O", "O", "O", "O"],
+  ["P", "P"], ["Q"], ["R", "R", "R", "R", "R", "R"],
+  ["S", "S", "S", "S"], ["T", "T", "T", "T", "T", "T"],
+  ["U", "U", "U", "U"], ["V", "V", "V", "V"], ["W", "W"],
+  ["X"], ["Y", "Y"], ["Z"]
+  ]
+
+  @flattened_default_tile_bag = @default_tile_bag.flatten
+  @picked_tiles = []
+
+  end
+
+  def draw_tiles(num)
+    # Purpose: returns a number (num) of random tiles, removes those tiles from default set. if statement for number of tiles left in bag!  Throw error if try to draw more tiles than are left in bag: "There are only #{num_tiles_remain} left in the bag!"
+    @flattened_default_tile_bag.shuffle!
+
+    if @flattened_default_tile_bag.length < num || num > 7 || num + picked_tiles.length > 7
+      raise ArgumentError, "This is a friendly reminder that you're terminal."
+    else
+      picked_tiles << @flattened_default_tile_bag.pop(num)
+      return picked_tiles.flatten!
+    end
+
+  end
+
+  def tiles_remaining
+    # returns the numbers of tiles remaining in the bag.
+  num_tiles_remain = @flattened_default_tile_bag.length
+  return num_tiles_remain
+
+  end
+
+end

module.rb

@@ -0,0 +1,13 @@
+# module.rb
+
+module Scrabble
+  LETTER_HASH = {
+  "A"=> 1, "E" => 1, "I"=> 1, "O"=> 1, "U"=> 1, "L"=> 1, "N"=> 1, "R"=> 1, "S"=> 1, "T"=> 1,
+  "D"=> 2, "G"=> 2,
+  "B"=> 3, "C"=> 3, "M"=> 3, "P"=> 3,
+  "F"=> 4, "H"=> 4, "V"=> 4, "W"=> 4, "Y"=> 4,
+  "K"=> 5,
+  "J"=> 8, "X"=> 8,
+  "Q"=> 10, "Z"=> 10
+  }
+end

notes.md

@@ -0,0 +1,75 @@
+_____________
+CURRENT IDEA:
+1. create a variable for max_score and max_scoring_word
+max_score = 0
+max_scoring_word = ""
+2. iterate through array_of_words ( array_of_words.each do |word|
+) and within that put if/elsif statements
+3. For the if/elsif statements within loop ("if score(word).to_i > max_score", and then also "if score(word).to_i == max_score")
+4. ONLY if they are equal, do if statements below
+
+____________
+FOR TIE-BREAKER IF STATEMENTS
+1. word.chars.count >= 7 and then also word.chars.count < max_scoring_word.chars.count (so this deals with a couple of the tests we wrote earlier - basically just wrote this based on what we generated earlier)
+then put this for both: max_score = score(word)
+max_scoring_word = word
+
+This SHOULD account for the tie-breaker situations we wrote tests for earlier.  I forgot about the .chars method that you can call on a string - it just looks at the characters and then the .count method counts them up!
+____________
+OLD IDEAS:
+1. when looping through array of words, assign key as word (as string) and value as total amount
+2. sort hash.values.sort.reverse -> will give us array of sorted values (highest to lowest)
+
+3. are there any repeating values :.map same as .collect : goes through array or hash and does whatever you ask it to do -> then sticks answer into an array
+4. only keep highest repeating values (delete others)
+5. if there are highest repeating values THEN continue:
+6. create array of key lengths of remaining repeating values
+hash = { "Cat" => 7, "Doggy" => 15, "Joe" => 5 }
+array = []
+
+hash.each do |k, v|
+
+    array << k.length
+end
+
+puts array
+_________
+OLD CODE:
+def self.highest_score_from(array_of_words)
+  # output is word in array with highest_score_from
+  scored_words_array = []
+  array_of_words.each do |word|
+     scored_words_array << score(word).to_i
+  end
+  return scored_words_array.max
+end
+________________
+Ideas:
+if max_scores_array has length of 1 - then DONE and return word that wins
+else
+iterate through this
+tie breaker method with ifs  (compare with arrays, and then to return word refer to corresponding index)
+end
+
+if statements:
+.min_by - Enumerables: array.min_by { |word| word.length } - will help with tied with 3 or 2 words when we return the one with fewer letters
+
+if tie with two words of same length and value -> return max_scoring_words.first
+
+word.index[word]
+_______________________
+
+test cases ->
+# tied with 2
+# two thirty point words (frizzy and mezuzah both = 30) and two others
+["frizzy", "mezuzah", "cat", "milk"]
+
+[30, 30, 5, 6]
+# tied with 3
+# three twenty point words (boxwood, chintz, bozeman) and three others
+["boxwood", "chintz", "bozeman" "dog", "litter", "bike"]
+
+# tie with one 7-letter word and one with fewer letters
+["acardia", "abyss", "dog", "cat"]
+# tie with two words of same length and value
+["nuzzle", "nozzle", "dog", "cat"]

specs/Spec_helper.rb

@@ -0,0 +1,11 @@
+# Spec_helper.rb
+
+require 'simplecov'
+SimpleCov.start
+
+require 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new

specs/coverage/.last_run.json

@@ -0,0 +1,5 @@
+{
+  "result": {
+    "covered_percent": 100.0
+  }
+}

specs/coverage/.resultset.json

@@ -0,0 +1,7 @@
+{
+  "RSpec": {
+    "coverage": {
+    },
+    "timestamp": 1472667020
+  }
+}