songfile 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7df1397b9db1fa3f47f171ffb299e5bf1adb4cf13c79a46d530d38ca8bf3c827
+  data.tar.gz: a7fc63446d0eb7e1d0dd62e3e2e07acada88837d7c79df54fc6a0ed19eefdf82
+SHA512:
+  metadata.gz: e6d6bbef6b0464361f0c01d50f33d1e2a552ca911c9a427f1cd34d763ab953d760af6640ccb717b642870ea040677e08851acb4976f1504cff7c2b134be4459b
+  data.tar.gz: 46c141fa5607114913b52f9dbf8e31080ecf31e19ff09ae5a21aed71b06e278025f3c32e3d649e26234f451cf1bd072779757e3e566843baf5b40428100120c0

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2022 Jamie Clark / The Pragmatic Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.txt

@@ -0,0 +1,9 @@
+************************************** BASIC INSTRUCTIONS **************************************
+TO RUN DEFAULT CSV SHEET (THE WALL)):
+ruby bin/songfile
+
+TO RUN DARK SIDE OF THE MOON ALBUM SONGS
+ruby bin/songfile bin/DSOTM.csv
+
+TO RUN SPECS:
+rspec (not "rspec .")

data/bin/DSOTM.csv

@@ -0,0 +1,10 @@
+Speak to Me,1000
+Breathe,500
+On the Run,900
+Time,300
+The Great Gig in the Sky,100
+Money,200
+Us and Them,400
+Any Colour You Like,800
+Brain Damage,700
+Eclipse,600

data/bin/THE_WALL.csv

@@ -0,0 +1,13 @@
+In the Flesh?,100
+Vera,200
+Hey You,300
+Run Like Hell,400
+Comfortably Numb,500
+Pigs on the Wing,600
+Another Brick in the Wall Part 1,700
+Is There Anybody Out There?,800
+The Trial,900
+Stop,1000
+Goodbye Blue Sky, 1100
+Young Lust,
+Nobody Home,

data/bin/songfile

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+#(File created 9:47pm on 5/8/22)
+#end of day one is 8:24pm-10:47pm 5/8/22
+#day two is 5:45pm - .... 9pm 5/24/22
+#day three is 9:55pm - ....  11:15pm 6/8/22 (oof)
+#day four is 7:30pm - 8:30pm, resumed at 9:40pm - 1am  6/14/22 
+#day five is 12:45pm - 1:30pm before work 6/15/22 
+#day six is 12am - 7:05pm 7 hours straight 6/18/22 
+#day seven is 4:30pm - 8:15pm and 10pm - 12:30am 6/19/22 
+#day eight is 8:55pm - 11:45pm 6/20/22 
+#day nine is 11:47pm - 5:34am!! 6/22/22 (night)
+#day ten is 8:08pm - 12:24am and 12:50am - 3:30am 6/22/22 (day)
+
+require_relative '../lib/songfile/playlist' # calls the playlist class file 
+require_relative '../lib/songfile/song' # calls the song class file 
+require_relative '../lib/songfile/die'
+require_relative '../lib/songfile/council'
+require_relative '../lib/songfile/classic_song'
+
+# (technically require_relative 'song' isnt needed here as well since it is referenced within the playlist file already)
+
+my_list = Songfile::Playlist.new("Jamie's Pink Floyd Playlist")
+default_player_file = File.join(File.dirname(__FILE__), "THE_WALL.csv") #plays an entered file OR the default (WALL.csv)
+my_list.load_songs(ARGV.shift || default_player_file)
+
+#Lines 28 and 29 can be uncommented to add a "classic song" from within the driving program file!
+#classic_song = Songfile::ClassicSong.new("Time") #default rank of 10000 assigned bc not specified, then halved bc it is a ClassicSong
+#my_list.add_song(classic_song)
+
+loop do
+    puts "\nHow many rounds? ('quit' to exit)"
+    ans = gets.chomp.downcase
+
+    case ans
+    when /^\d+$/
+        if ans.to_i > 20
+            puts "ERROR: Maximum number of rounds allowed: 20." # I will set a limit to 20 rounds
+        else
+        my_list.play(ans.to_i) # converts to integer
+        end
+    when 'quit', 'exit', 'q', 'e', 'ex'
+        my_list.print_stats # currently, this must be called SEPARATELY, not from within the "play" method to get the tests to pass
+        break
+    else
+        puts "Please enter a number or 'quit'"
+    end
+end
+
+my_list.save_output #this goes after the loop
+
+# my_list.show_titles 
+# ^ shows titles in the "array" format using "p"
+
+
+

data/lib/songfile/classic_song.rb

@@ -0,0 +1,18 @@
+require_relative 'song'
+module Songfile
+    class ClassicSong < Song
+        attr_reader :initial_rank
+        def initialize(title, rank=10000)
+            @initial_rank = rank
+            @title = titleize(title)
+            @rank = (rank.abs()) / 2
+            puts "New song '#{@title}' (classic) with rank of #{@rank} was created."
+            # puts "The classic song '#{@title}' jumps the chart with a halved rank !"
+        end
+    end
+
+    if __FILE__ == $0
+        classic_song = ClassicSong.new("Time", 10000) 
+        # puts "The classic song '#{classic_song.title}' jumps the chart with a halved rank (#{classic_song.initial_rank}/2) of #{classic_song.rank}!"
+    end
+end

data/lib/songfile/council.rb

@@ -0,0 +1,22 @@
+module Songfile #< this line nested on TOP of Reviewer = Struct.new
+Reviewer = Struct.new(:name, :influence) #bigger number means more influence (I use them as multiplier values)
+    module Council
+        REVIEWERS = [
+            Reviewer.new(:Roger_Waters, 100),
+            Reviewer.new(:Nick_Mason, 50),
+            Reviewer.new(:David_Gilmour, 100),
+            Reviewer.new(:Richard_Wright, 50),
+            Reviewer.new(:Syd_Barrett, 25)
+        ]
+
+        def self.random
+            REVIEWERS.sample
+        end
+    end
+
+    if __FILE__ == $0
+        p Council::REVIEWERS.map(&:name)
+        person = Council.random
+        puts "#{person.name} is reviewing your playlist."
+    end
+end

data/lib/songfile/die.rb

@@ -0,0 +1,13 @@
+module Songfile
+        class Die 
+        attr_reader :number
+
+        def roll
+            @number = rand(1..6)
+        end
+
+        def initialize
+            roll #the new die object now initializes as soon as "roll" is called anywhere.
+        end
+    end
+end

data/lib/songfile/playlist.rb

@@ -0,0 +1,159 @@
+require_relative 'song'
+require_relative 'die'
+require_relative 'playlist_turn'
+require_relative 'council'
+require 'csv'
+module Songfile
+    class Playlist
+        attr_reader :name, :list          #you can read the title (name) of the playlist
+        def initialize(name)       #this method converts a Playlist.new specified title to the correct format when created
+            @name = name.upcase    #upcased all playlist titles for now
+            @list = []
+            puts "Playlist '#{@name}' was created."
+        end
+
+        def show_titles
+            p self.list.map(&:title) # p is used within the method to print the array properly, and it is only an array of titles
+        end
+
+        def show_reviewers
+            reviewers = Council::REVIEWERS
+            puts "\nThere are #{reviewers.size} playlist reviewers:"
+            reviewers.each do |r|
+            puts "#{r.name}, #{r.influence}"
+        end
+        end
+
+        def add_song(song) #when you add a song, the list re-sorts itself
+            @list << song 
+            @list = @list.sort { |a, b| a.rank <=> b.rank } #this line is critical to have so that original song order by rank is displayed by the text output!
+            @original_list = @list # whenever a song is added, the list is stored
+            # NOTE: ^^ I disabled the list sorting itself whenever a new song is added. All the responsibility is
+            # now handed over to the sort songs method which 1) sorts all songs in array by rank then 
+            # normalizes the rank values based on the amount of songs in the playlist!
+        end
+
+        def sort_songs #created this method... it looks very similar to the print_stats method
+            @list.each do |song| #sort by rank step 1
+                @list = @list.sort { |a, b| a.rank <=> b.rank }
+                end
+        end
+        def normalize_ranks
+            @list.each do |song| #step 2 (after ALL songs are sorted by rank)
+                song.rank = @list.index(song) + 1 # NOW you normalize rank once all songs are sorted
+                #song.rank = @list.index(song) + 1 # NOW you normalize rank once all songs are sorted
+                # puts "#{song.rank}) #{song.title}"
+            end 
+        end
+        def multiply_ranks
+            @list.each do |song| #step 2 (after ALL songs are sorted by rank)
+                song.rank *= 10 # multiplies each song's rank by 10. This method is used after "normalize ranks" in the play method 
+            end 
+        end
+
+
+        def play(rounds=1) #play one round by default
+            puts "\nThere are #{@list.size} songs in this playlist:"
+            sort_songs # use of SELF to call sort_songs on the applicable Playlist object from inside the play method
+            normalize_ranks # is now separate from sorting songs
+            @list.each do |song|
+                puts "#{song.rank}) #{song.title}"
+            end 
+
+            multiply_ranks
+
+            show_reviewers # this method is standalone, no reference to self is needed
+
+            1.upto(rounds) do |round|
+                puts "\nRound #{round}:"
+            # puts "number rolled is #{number_rolled}"
+                @list.each do |song|
+                    puts song
+                    PlaylistTurn.take_turn(song)
+                    puts song
+                end
+            end
+
+            #self.print_stats #activating this code will make two tests fail because sort/normalization is 
+                            #performed within the print stats method which, when enabled INSIDE the "play" method
+                            #makes the math check test fail! (activating this code sorts/normalizes the new ranks
+                            #before the math checker is run, aka after the "play" method is completed)
+        end
+
+        def print_stats
+            sort_songs # FIRST SORT FOR PREVIEW/DISPLAY
+            puts "\n#{@name} Final Rankings:"
+            @list.each do |song|
+                puts "#{song.title} (#{song.rank})"
+            end
+
+            puts "\nOriginal list order:"
+                    @original_list.each do |song|
+                    puts "#{@original_list.index(song) + 1}) #{song.title}"
+                end 
+
+            normalize_ranks # NOW NORMALIZE RANKINGS
+
+            top_ten_songs, average_songs = @list.partition { |song| song.top_ten? }
+        puts "\nNew list order:"
+        if @list.size > 10
+            puts "Top 10 Songs:" 
+            top_ten_songs.each do |song|
+            puts "#{song.rank}) #{song.title}"
+            end
+        puts "\nOther Songs:" 
+            average_songs.each do |song|
+            puts "#{song.rank}) #{song.title}"
+            end
+        else
+            puts "\nTop #{@list.size} Songs:" 
+            @list.each do |song|
+            puts "#{song.rank}) #{song.title}"
+            end
+        end
+        end
+
+        def load_songs(from_file)
+            CSV.foreach(from_file, 'r:bom|utf-8') do |row|
+                if row[1].to_i == 0
+                    song = Song.new(row[0], 10000) # THIS is the code that sets nil to 10000 by default so that sorted song is ranked last in playlist
+                else
+                    song = Song.new(row[0], row[1].to_i)# << this "index" stuff syntax allows for nil ranks to "pass/fly" (and get reassigned to default of 0) THIS is where default gets assigned.
+
+                end
+            add_song(song) 
+            end
+        end
+        def save_output(to_file="songfile_output.txt")
+            File.open(to_file, "w") do |file|
+                file.puts Time.new.strftime("File updated on %m/%d/%Y at %I:%M %p")
+                file.puts "\nOriginal list order:"
+                    @original_list.each do |song|
+                    file.puts "#{@original_list.index(song) + 1}) #{song.title}"
+                end 
+            file.puts "\nNew list order:"
+
+            top_ten_songs, average_songs = @list.partition { |song| song.top_ten? }
+
+                if @list.size > 10
+                    file.puts "Top 10 Songs:" # literally copied from print stats but with "file.puts" not "puts"
+                    top_ten_songs.each do |song|
+                    file.puts "#{song.rank}) #{song.title}"
+                end
+                file.puts "\nOther Songs:" 
+                    average_songs.each do |song|
+                    file.puts "#{song.rank}) #{song.title}"
+                    end
+                else
+                    file.puts "\nTop #{@list.size} Songs:" 
+                    @list.each do |song|
+                    file.puts "#{song.rank}) #{song.title}"
+                    end
+                end
+                
+            end     
+
+        end
+        
+    end
+end

data/lib/songfile/playlist_turn.rb

@@ -0,0 +1,26 @@
+require_relative 'song'
+require_relative 'die'
+require_relative 'council'
+module Songfile
+    module PlaylistTurn
+
+        def self.take_turn(song)
+
+            reviewer = Council.random
+            #puts reviewer
+            puts "'#{song.title}' was reviewed by #{reviewer.name} (#{reviewer.influence} influence)"
+
+            die = Die.new
+                number_rolled = die.roll
+                case number_rolled 
+                when 5..6
+                    song.thumbs_up(reviewer.influence)     
+                when 3..4     
+                    puts "'#{song.title}' was skipped."    
+                when 1..2
+                    song.thumbs_down(reviewer.influence)                
+                else # (nothing is added if die roll is 3 or 4... or 0 etc.)
+                end
+        end
+    end
+end

data/lib/songfile/song.rb

@@ -0,0 +1,78 @@
+require_relative 'playlist'
+# set Lowercase_words to be a global variable bc the warning was annoying! 
+# the warning in question: "warning: already initialized constant Lowercase_words"
+
+$Lowercase_words = %w{and as at but by for from 
+    if in into like near nor of off on once 
+    onto or over past so than that the till 
+    to up upon v. vs vs. with when yet}
+module Songfile
+    class Song
+        #attr_reader :rank                  # allows you to print the "rank" attribute outside the Song class (GETTER method)
+        # attr_writer :title, :rank         # allows you to write to the "title" and "rank" attributes outside the Song class (SETTER method)
+        attr_accessor :title, :rank         # allows you to read and write to "title" and "rank" attribute outside the Song class
+
+        def titleize(title) #the actual titleize method (only hangup is "Like" (as a verb) vs "like" (as a preposition))
+            title.downcase.split.each_with_index.map{ |x, index| $Lowercase_words.include?(x) && index > 0 ? x : x.capitalize }.join(" ")
+        end
+    
+        def initialize(title, rank=10000)       #this method converts a Song.new specified title to the correct format when created
+            @title = titleize(title)
+            @rank = rank.abs() # the absolute value prevents anyone from typing in a NEGATIVE rank
+            puts "New song '#{@title}' with rank of #{@rank} was created."
+        end
+
+        def title=(new_title)               #this method converts a Song.new specified title to the correct format when overwritten
+            @title = new_title
+            @title = titleize(@title)
+        end
+
+        def thumbs_up(value=1)
+            @rank -= value
+            puts "'#{@title}' received a thumbs up!"
+        end
+
+        def thumbs_down(value=1)
+            @rank += value
+            puts "'#{@title}' received a thumbs down!"
+        end
+
+        def describe 
+            puts "'#{@title}' has a rank of #{@rank}."
+        end
+
+        def top_ten?
+            result = case @rank
+            when 1..10 then true
+            end
+        end
+
+        def status
+            top_ten? ? "*Top 10*" : "*Not Top 10*"
+        end
+
+        def to_s #defines what happens when you use puts on an object of class "Song"
+            "#{@title} (#{@rank})"
+            #"#{@title} (#{@rank}) #{status}"
+            #^^REMOVING "top 10" classification while the score is still computing!
+        end
+    end
+
+    #code that only runs inside THIS file (songfile.rb relies only on the class code and ignores this if statement code)
+    if __FILE__ == $0
+        song1 = Song.new("Run like Hell", 4)
+        song2 = Song.new("The Trial", 1)
+        song3 = Song.new("Outside the Wall", 11)
+        array = [song1, song2, song3]
+        array.each do |song|
+            puts song
+            song.describe
+            song.thumbs_up
+            song.thumbs_up
+            song.thumbs_down
+            song.thumbs_up
+            puts song
+    end
+
+    end
+end

data/spec/songfile/council_spec.rb

@@ -0,0 +1,52 @@
+# require_relative "council"
+require 'songfile/council'
+module Songfile
+  describe Reviewer do
+
+    before do
+      @reviewer = Reviewer.new(:Tre_Cool, 49)
+    end
+
+    it "has a name attribute" do
+      @reviewer.name.should == :Tre_Cool
+    end
+
+    it "has a correct influence (age in this case) attribute" do
+      @reviewer.influence.should == 49
+    end
+
+  end
+
+  describe Council do
+
+    it "returns a random reviewer from the council" do
+      reviewer = Council.random
+      Council::REVIEWERS.should include(reviewer)
+    end
+
+    it "has five reviewers" do
+      Council::REVIEWERS.size.should == 5
+    end
+
+    it "has Roger Waters (100)" do
+      Council::REVIEWERS[0].should == Reviewer.new(:Roger_Waters, 100)
+    end
+
+    it "has Nick Mason (50)" do
+      Council::REVIEWERS[1].should == Reviewer.new(:Nick_Mason, 50)
+    end
+
+    it "has David_Gilmour (100)" do
+      Council::REVIEWERS[2].should == Reviewer.new(:David_Gilmour, 100)
+    end
+
+    it "has Richard_Wright (50)" do
+      Council::REVIEWERS[3].should == Reviewer.new(:Richard_Wright, 50)
+    end
+
+    it "Syd_Barrett (25)" do
+      Council::REVIEWERS[4].should == Reviewer.new(:Syd_Barrett, 25)
+    end
+
+  end
+end 

data/spec/songfile/playlist_spec.rb

@@ -0,0 +1,108 @@
+# require_relative "playlist"
+require 'songfile/playlist'
+# require_relative "die"
+require 'songfile/die'
+# require_relative "council"
+require 'songfile/council'
+module Songfile
+    describe Playlist do
+
+        before do
+            @playlist = Playlist.new("test playlist")
+        end
+
+        context "single song playlist" do
+
+            before do
+                @initial_rank = -10
+                @song = Song.new("the happiest days of our lives", @initial_rank)
+                @initial_rank = @song.rank #this line had to be added to update the @inital rank
+                #variable in the test file so that it is updated to reflect the initialization of the "rank" attribute
+                #of the project (which changes negative values to their absolute value versions!)
+                @playlist.add_song(@song)
+                @round_amount = 2 # you only need to change the test in one place (this line) 
+                # to run different number of rounds in the spec file!
+            end
+
+            it "initial rank gets converted to a positive value" do # kind of a "duplicate" test from the one in song_spec.rb
+                # expect(@song.rank).to eq(@initial_rank.abs())
+                expect(@song.rank).to eq(10)
+            end
+
+            it "initial rank gets normalized correctly" do # not a duplicate test, this tests the normalize and multiplier methods
+                # expect(@song.rank).to eq(@initial_rank.abs())
+                @playlist.sort_songs
+                @playlist.normalize_ranks
+                expect(@song.rank).to eq(1)
+            end
+            
+            it "initial rank gets normalized and multiplied correctly" do # not a duplicate test, this tests the normalize and multiplier methods
+                # expect(@song.rank).to eq(@initial_rank.abs())
+                @playlist.sort_songs
+                @playlist.normalize_ranks
+                @playlist.multiply_ranks
+                expect(@song.rank).to eq(10)
+            end
+
+            it "thumbs up on high number (5-6)" do
+                Die.any_instance.stub(:roll).and_return(5)
+                allow(Council).to receive(:random).and_return(Council::REVIEWERS[0]) # FINALLY got the right code to retrieve roger each roll!
+                @playlist.play(@round_amount)
+                expect(@song.rank).to eq((10) - (100 * @round_amount)) # the (100) represents the new ranking (normalized and multiplied) of the only song in the list
+            end                              # thumbs down makes rank number smaller therefore higher on list!
+
+            it "no change on medium number (3-4)" do
+                Die.any_instance.stub(:roll).and_return(3)
+                @playlist.play(@round_amount)
+                expect(@song.rank).to eq((10))  # 10: The one song in the playlist gets a normalized rank of 1 which gets multiplied to 10.
+            end
+
+            it "thumbs down on low number (1-2)" do
+                Die.any_instance.stub(:roll).and_return(1)
+                allow(Council).to receive(:random).and_return(Council::REVIEWERS[0])
+                @playlist.play(@round_amount)
+                expect(@song.rank).to eq((10) + (100 * @round_amount)) # the (10) represents the new ranking (normalized and multiplied) of the only song in the list
+            end                              # thumbs down makes rank bigger therefore lower on list!
+        end
+
+        context "multiple song playlist" do
+            before do 
+            @song1 = Song.new("In the Flesh?", 500) # middle song, should come out to rank = 2
+            @song2 = Song.new("Vera", 1000) # last song, should come out to rank = 3
+            @song3 = Song.new("Comfortably Numb", 25) # top song, should come out to rank = 1
+
+            @playlist.add_song(@song1)
+            @playlist.add_song(@song2)
+            @playlist.add_song(@song3)
+
+            @playlist.sort_songs #this method sorts before running the game!
+            @playlist.normalize_ranks #this normalizes the ranks to the array size
+            end
+
+            it "all three songs are correctly sorted in the playlist" do
+                expect(@playlist.show_titles).to eq(["Comfortably Numb", "In the Flesh?", "Vera"])
+            end
+
+            it "all three songs are correctly ranked" do
+                expect(@song1.rank).to eq(2)
+                expect(@song2.rank).to eq(3)
+                expect(@song3.rank).to eq(1)
+            end
+
+        end
+
+        context "default values replacing nils (multiple song playlist)" do
+            before do
+            @my_list = Playlist.new("Jamie's Pink Floyd Playlist")
+
+            default_player_file = File.join(File.dirname(__FILE__), "../../bin/THE_WALL.csv") #plays an entered file OR the default (WALL.csv)
+            @my_list.load_songs(ARGV.shift || default_player_file)
+            end
+
+            it "replaces nil rank values with default value of 10000" do
+                expect(@my_list.list[11].rank).to eq(10000) # "young lust" correctly gets assigned default rank of 10000
+            end
+        end
+
+    end
+end

data/spec/songfile/song_spec.rb

@@ -0,0 +1,80 @@
+# ***** SONG TEST FILE *******
+# require_relative 'song' # calls the song class file 
+require 'songfile/song'
+
+module Songfile
+    describe Song do
+
+        context "song with a NEGATIVE ranking" do
+            before do
+                @song = Song.new("the happiest days of our lives", -10) # a user types in a negative rank (not ok)
+            end
+
+            it "automatically gets a negative rank # assigned to a positive rank #" do
+                expect(@song.rank).to eq(10) #rather than -10
+            end
+        end
+
+        context "default ranking song" do
+            before do
+                @initial_rank = 0
+                @song = Song.new("the happiest days of our lives")
+            end
+
+            it "has a default rank of 10000" do
+                #song.rank.should == 10000
+                @song = Song.new("the happiest days of our lives")
+                expect(@song.rank).to eq(10000) #Changed default to 10000 so UNRANKED songs are listed lowest in the playlist (assuming other RANKED songs are < 10000)
+            end
+
+            it "IS NOT a top 10 song" do
+                expect(@song.status).to eq("*Not Top 10*")
+            end
+        end
+
+        before do
+            @initial_rank = 10
+            @song = Song.new("the happiest days of our lives", @initial_rank)
+        end
+
+        it "has a capitalized title" do
+            #song.title.should == "The Happiest Days of Our Lives"
+            expect(@song.title).to eq("The Happiest Days of Our Lives") #better, new syntax
+        end
+
+        it "has an initial rank" do
+            #song.title.should == "The Happiest Days of Our Lives"
+            expect(@song.rank).to eq(10) #better, new syntax
+            expect(@initial_rank).to eq(10) #better, new syntax
+        end
+
+        it "has correct description" do
+            expect do
+                @song.describe
+            end.to output("'#{@song.title}' has a rank of #{@song.rank}.\n").to_stdout
+        end
+
+        it "has correct display with 'to_s' (Song)" do
+            expect(@song.to_s).to eq("The Happiest Days of Our Lives (10)") #removed *top 10* display from to_s method
+        end
+
+        it "has correct status" do
+            expect(@song.status).to eq("*Top 10*")
+        end
+
+        it "has correct rank after thumbs up" do
+            @song.thumbs_up 
+            expect(@song.rank).to eq(9)
+        end
+
+        it "has correct rank after thumbs down" do
+            @song.thumbs_down
+            expect(@song.rank).to eq(11)
+        end
+
+        it "IS a top 10 song" do
+            expect(@song.status).to eq("*Top 10*")
+        end
+
+    end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: songfile
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jamie Clark
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+description: |
+  ************************************** BASIC INSTRUCTIONS **************************************
+  TO RUN DEFAULT CSV SHEET (THE WALL)):
+  ruby bin/songfile
+
+  TO RUN DARK SIDE OF THE MOON ALBUM SONGS
+  ruby bin/songfile bin/DSOTM.csv
+
+  TO RUN SPECS:
+  rspec (not "rspec .")
+email: clarkcjamie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.txt
+- bin/DSOTM.csv
+- bin/THE_WALL.csv
+- bin/songfile
+- lib/songfile/classic_song.rb
+- lib/songfile/council.rb
+- lib/songfile/die.rb
+- lib/songfile/playlist.rb
+- lib/songfile/playlist_turn.rb
+- lib/songfile/song.rb
+- spec/songfile/council_spec.rb
+- spec/songfile/playlist_spec.rb
+- spec/songfile/song_spec.rb
+homepage: http://pragmaticstudio.com
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Text based game for ranking music playlists featuring multiple rounds, a
+  panel of reviewers from Pink Floyd, and output of the newly ranked playlist.
+test_files:
+- spec/songfile/council_spec.rb
+- spec/songfile/playlist_spec.rb
+- spec/songfile/song_spec.rb