rms_flicks 1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 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:
+
+- You may not use this Software in other training contexts.
+  
+- 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

@@ -0,0 +1,6 @@
+This is an example application used in The Pragmatic Studio's 
+Ruby Programming course, as described at
+
+  http://pragmaticstudio.com
+
+This code is Copyright 2012 The Pragmatic Studio. See the LICENSE file.

data/bin/flicks

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+# above says to find the ruby environment to get the ruby interpretor
+# also we ran the following from reviewRuby: 'chmod +x bin/flicks'
+# this makes it executable.
+# so we can run it from reviewRuby with: 'bin/flicks'
+# if installed as a gem, they said it would just run as flicks. - ??? we'll see!
+ 
+
+
+# used to test code.
+
+# this file is now in the bin directory
+# we can run it from the terminal in the top directory ('reviewRuby')  with 'ruby bin/flicks.rb'
+# so the playlist is up one then back down  to the lib directory
+require_relative '../lib/playlist'
+
+# ?? i think that since movie3d requires_relative movie - and it is relative to movie3d - this works
+require_relative '../lib/movie3d'
+
+# movie1 = Movie.new("goonies", 10)
+# movie2 = Movie.new("ghostbusters", 9)
+# movie3 = Movie.new("goldfinger")
+
+playlist1 = Flicks::Playlist.new("Kermit")
+
+
+# playlist1.add_movie(movie1)
+# playlist1.add_movie(movie2)
+# playlist1.add_movie(movie3)
+# removed above and added below in files video - after changes (add load method) to playlist
+
+# make movies.csv the default
+# but allow user to enter file
+# command line arguments are stored in a global varible called ARGV
+# also we call shift which will remove the passed in varible and shift all other elements down one.
+# the 'or' operator allows for a default.
+
+
+# we need to do something about the directory for movies.csv
+# we'll make a default file varible using the File class 
+# -> which will give it an 'absolute path'
+default_movie_file =
+  File.join(File.dirname(__FILE__), 'movies.csv')
+
+
+playlist1.load(ARGV.shift || default_movie_file)
+
+# here we add some movie3d stuff to demonstrate polymorphism
+# we are going to co-mingle movies and 3d movies in our playlist code
+
+movie3d = Flicks::Movie3D.new('glee', 5, 20)
+playlist1.add_movie(movie3d)
+
+# without changing anything else - 'glee' will get added in to the playlist activities - yeah!
+
+
+loop do
+  puts "How many viewings? 'quit' to exit"
+  answer = gets.chomp.downcase
+  case answer
+  when /^\d+$/ # 1 or more numbers and end with numbers???
+    playlist1.play(answer.to_i)  
+  when 'quit', 'exit'
+    playlist1.print_stats
+    break
+  else
+    puts "Please enter a number or 'quit'."
+  end  
+end
+
+# the save methods runs after viewings and creates a file of the the lastest rankings
+# movie_rankings.csv
+
+playlist1.save
+

data/bin/movie_rankings.csv

@@ -0,0 +1,4 @@
+Glee, 25
+Goonies, 10
+Ghostbuster, 9
+Goldfinger, 0

data/bin/movies.csv

@@ -0,0 +1,3 @@
+Goonies, 10
+Ghostbuster, 9
+Goldfinger, 0

data/lib/movie.rb

@@ -0,0 +1,165 @@
+require_relative 'rankable'
+require_relative 'snack_bar'
+
+module Flicks
+  class Movie
+    include Rankable
+    # changed :rank to an accessor in mixins
+    attr_accessor :rank
+  # attr_accessor does a reader and a writer as described below
+    attr_accessor :title
+
+  # attributes have the possiblility to expose date to the outside world
+  # having rank as only a reader means that it can only be changed by the 
+  #=> outside world through behaviour methods such as thumbs_up thumbs_down
+  # on the other hand - we will allow someone to change attr_accessor varibles
+
+  #  attr_reader :title, :rank
+    # the above line of code is a short cut for the code commented out below
+
+    # def title
+    #   @title
+    # end
+  # in programming this is commonly know as a getter method - attr_reader is a short cut to that.
+
+  #  attr_writer :title
+  #### does not do the capitalization
+    # the above line of code is a short cut for the code commented out below
+
+    # def title=(new_title)
+    #   @title = new_title
+    # end
+  # in programming this is commonly know as a writer method - attr_writer is a short cut to that.
+
+   
+
+
+    def initialize(title, rank=0)
+      # the new method expects there to be an initialize method
+      # this method accepts the passed in varibles
+      # if you want these varibles to be available you need make them instance varibles
+      # they don't have to be the same name as the parameters - but it often makes sense
+      # these instance varibles live for the life of the object and can be accessed.
+      @title = title.capitalize
+      @rank = rank
+  # added with Hashes
+  # there will of coursee be a set of these for every instance of movie.
+      @snack_carbs = Hash.new(0)
+    end
+
+  # added with input/output video
+
+    def self.from_csv(line) # we don't have a movie object to call here - s0 we call from self
+      title, rank = line.split(',')
+      # we changed this so it will raise an exception instead of bomb with an error -  rank.to_i)
+      Movie.new(title, Integer(rank)) 
+    end
+
+    def to_csv
+      "#{@title}, #{@rank}"
+    end
+
+
+
+  # added with iterators
+    def each_snack
+  # take the @snack_cards hash we added in hashes video
+      @snack_carbs.each do |name, carbs|
+  # create 'snack' object from our Struct with the name and carbs from each element
+        snack = Snack.new(name, carbs)
+  # then 'yield' that snack object over to block in playlist.print_status
+        yield snack
+
+      end
+
+
+    end
+
+
+
+  # added with Hashes
+    def carbs_consumed # total
+      @snack_carbs.values.reduce(0, :+)
+    end
+
+    def ate_snack(snack)
+  # we want to accumulate the carbs for each type snack consumed in this Hash instance for a movie.
+      @snack_carbs[snack.name] += snack.carbs
+      puts "#{@title} let to #{snack.carbs} #{snack.name} carbs being consumed."
+      puts "#{@title}'s snacks: #{@snack_carbs}" # just so we can see the accumulation.
+
+    end
+
+
+    # the initialize method has to do with state.
+    # below methods has to do with behaviour expressed as instance methods.
+
+    # below is a virtualized attribute - or attribute that is derived from instance varibles.
+    # can be called from within class
+    # when it's called from the class, the receiver object that's calling
+    # => turns out to be "self" which in the case below is movie3 object. that's why it's cool that
+    # "self", since the next time we call it may be from movie2 object. 
+    # see the call below in the to_s method.
+
+  # in the mixin video, we removed methods below and put them in rankable.rb 
+  # this encapsulates the notion of rankable and makes it geneic
+
+    # def hit?
+    #   @rank >= 10
+    # end
+
+    # def status
+    #   hit? ? "Hit" : "Flop"
+      
+    # end
+
+    # def normalized_rank
+    #   normalized_rank = @rank / 1.0
+    # end
+
+
+
+    # # below we are going to override the spaceship comparison method.
+    # def <=>(other_movie)
+    #   # this will compare the passed in movie with the rank of the current movie.?? see sorting.rb
+    #   other_movie.rank <=> @rank
+    # end
+
+
+    # what if i wanted to be able to run the listing method by just saying "puts movie3"
+    # well - with no method on call to the object, the default is to run
+    #=> the to_s method - which isn't particularly useful.
+    # so let's create another method called to_s which will override the default to_
+    #=> and make it do they same thing as our listing method.
+    # we could of course just get rid of the listing method - but lets leave it for now
+    #=> just to show the idea.
+
+    def listing
+      "#{@title} initialized with rank of #{@rank}."
+    end
+
+
+    def to_s
+      # - "Just to confirm, this is run when we call movies."
+      "#{@title} initialized with rank of #{normalized_rank} (#{status})."
+    end
+
+
+
+    # an old programming axiom is "Tell - Don't Ask"
+    # meaning - don't ask an object for it's state - rather just Tell it.
+
+  # removed these in mixin video to put in separate mixin module called 'rankable.rb' 
+    # def thumbs_up
+    #   @rank += 1
+    # end
+
+    # def thumbs_down
+    #   @rank -= 1
+    # end
+
+  end # of Movie class
+end # of Flicks module
+
+
+

data/lib/movie3d.rb

@@ -0,0 +1,56 @@
+require_relative 'movie'
+
+module Flicks 
+
+  class Movie3D < Movie
+
+  # this new initialize is necessary because we want to add wow_factor
+  # but we don't want to mess up title & rank
+  # therefore the line super(title, rank) which says - let movie handle setting up these instance vars.
+  # then we set up @wow_factor. 
+  # now - initalizing a movie requires 3 parameters
+
+
+# added this in after realizing movie3d_spec wasn't working - ?? see where i missed it
+    attr_reader :wow_factor
+
+    def initialize(title, rank, wow_factor)
+      super(title, rank)
+      @wow_factor = wow_factor
+    end
+  # specialized traits
+    def thumbs_up
+      # wow_factor = 10
+
+      # instead of doing the line below
+      # let's make so that it does whatever 'movie class' is doing times 10
+      # that way, if thumbs up in movie changes, the effect here will be more predictable
+      # @rank += ( 1 * @wow_factor)
+      @wow_factor.times { super }
+
+    end
+
+
+  # new traits
+    def show_effect
+      # wow_factor = 10
+      puts "Wow!" * @wow_factor
+
+    end
+
+  end # of Movie3d class
+
+end # of Flicks module
+
+if __FILE__ == $0
+# the following can be run before anything is added. it behaves just like movie.rb class
+
+  movie3d = Flicks::Movie3D.new('glee', 5, 10)
+  puts movie3d.title
+  puts movie3d.rank
+  puts movie3d
+  movie3d.show_effect
+  movie3d.thumbs_up
+  puts movie3d
+
+end  

data/lib/playlist.rb

@@ -0,0 +1,173 @@
+require_relative 'movie'
+require_relative 'movie3d'
+require_relative 'waldorf_and_statler'
+require_relative 'snack_bar'
+
+module Flicks
+  class Playlist
+
+# added this after seeing it in their code - don't know how i missed it ???    
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      @movies = [] # empty array
+    end
+
+    def load(from_file)
+      # copied from files.rb - changed to accept parameter
+      File.readlines(from_file).each do |line|
+
+  # removed to add better code
+        # title, rank = line.split(',')
+        # movie = Movie.new(title, rank.to_i)
+        # # removed after copy from files to add line below ->puts movie
+        #  add_movie(movie)
+        add_movie(Movie.from_csv(line))
+      end
+    end
+
+    def save(to_file="movie_rankings.csv")
+     File.open(to_file, "w") do |file|
+        @movies.sort.each do |movie|
+  # removed & replace with csv method implemented in movie class
+  # ->  file.puts "#{movie.title}, #{movie.rank}"
+        file.puts movie.to_csv
+        end
+      end   
+    end
+
+    def add_movie(movie)
+      @movies << movie  # append the 'movie' passed to the method to array
+    end
+
+  # added parameter 'viewings' as example for blocks. viewings being the number of times to play.
+    def play(viewings)
+      puts "#{@name}'s playlist:"
+  # this sort will use our spaceship override method (<=>) in movie
+      puts @movies.sort
+
+  # the following added after the Symbols&Structs video - see snack_bar.rb
+      snacks = SnackBar::SNACKS
+      puts  "\nThere are #{snacks.size} snacks available in the Snack Bar."
+  # now, iterate through the snacks array and print them out as a menu.
+      snacks.each do |snack|
+        puts "#{snack.name} has #{snack.carbs} carbs."
+      end
+
+      1.upto(viewings) do |count|
+        puts "\nViewing #{count}:"
+        @movies.each do |movie|
+          WaldorfAndStatler.review(movie)
+  # added after Symbols&Struts - get a random snace with a movie viewing.
+          snack = SnackBar.random
+  # added with Hashes        
+          movie.ate_snack(snack)
+
+
+   # took out on Hashes ->puts "#{movie.title} led to #{snack.carbs} #{snack.name} carbs being consumed."
+
+          puts movie
+        end
+      end    
+    end
+
+    def total_carbs_consumed
+
+      @movies.reduce(0) do |sum, movie|
+        sum + movie.carbs_consumed
+      end
+        
+    end
+
+
+    def print_stats
+        puts "\n#{@name}'s Stats:"
+
+        puts "#{total_carbs_consumed} total cards consumed."
+
+        @movies.sort.each do |movie|
+          puts "\n#{movie.title}'s snack totals:"
+  # added in iterators - add a method 'each_snack' in movie class        
+          movie.each_snack do |snack|
+            puts "#{snack.carbs} total #{snack.name} carbs"
+          end 
+
+
+          puts "#{movie.carbs_consumed} grand total carbs."
+        end
+
+        hits, flops = @movies.partition { |movie| movie.hit? }
+
+        puts "\nHits:"
+        puts hits.sort 
+
+        # when we call puts on an array it will call to_s on each of those elements
+        # => so the to_s method in movie will be called.
+
+        puts "\nFlops:"
+        puts flops.sort
+    end
+
+  end # -> of playlist class
+
+
+
+
+end # -> of Flicks module
+
+
+
+
+
+# below is tester code for the Movie & Playlist class
+# '__FILE__' is the varible that holds the file name for this file
+# '$0' is the varible that holds the file that is running.
+# so this code only gets run when we run this file
+# if this class is getting called from another program - it does not run
+
+if __FILE__ == $0
+
+  # the .new method expects there to be an initialize method
+  movie1 = Flicks::Movie.new("goonies",10)
+  movie1.thumbs_down
+  puts movie1.listing
+  movie2 = Flicks::Movie.new("ghostbusters",9)
+  puts movie2.listing
+  movie3 = Flicks::Movie.new("goldfinger",100)
+  # below runs method that affects behaviour
+  movie3.thumbs_up
+  # allows access to current state.
+  puts movie3
+  # below made possible by attr_reader
+  puts movie3.title
+  puts movie3.rank
+  movie3.title = ("goonies 2.0")
+  puts movie3.title
+  puts movie3.normalized_rank
+
+
+  puts "begin object_interact code"
+  playlist1 = Flicks::Playlist.new("Kermit")
+  playlist1.add_movie(movie1)
+  playlist1.add_movie(movie2)
+  playlist1.add_movie(movie3)
+  playlist1.play(1)
+
+  # add another playlist
+  playlist2 = Flicks::Playlist.new("Fozzie")
+  # put a movie in that playlist
+  playlist2.add_movie(movie3)
+
+  # add a new move using the Movie class
+  movie4 = Flicks::Movie.new("Gremlins", 15)
+
+  # now add that movie to playlist2
+  playlist2.add_movie(movie4)
+
+  # and now play - which actually just displays the playlist
+  playlist2.play(1)
+
+end
+
+

data/lib/rankable.rb

@@ -0,0 +1,40 @@
+module Flicks
+  module Rankable
+
+    # changed all the '@rank' to rank
+    # it is considered better to depend 
+    # => on a method or an attribute rather than an instance varible in the host class.
+
+    def thumbs_up
+      self.rank += 1
+    end
+
+    def thumbs_down
+      self.rank -= 1
+    end
+    def hit?
+      self.rank >= 10
+    end
+
+
+    def status
+      hit? ? "Hit" : "Flop"
+      
+    end
+
+    def normalized_rank
+      normalized_rank = self.rank / 1.0
+    end
+
+
+
+    # below we are going to override the spaceship comparison method.
+    # we changed the spaceship to just 'other' to make it more generic
+    def <=>(other)
+      # this will compare the passed in movie with the rank of the current movie.?? see sorting.rb
+      other.rank <=> self.rank
+    end
+
+
+  end # of module Rankable
+end # of module Flicks

data/lib/snack_bar.rb

@@ -0,0 +1,68 @@
+
+# we could do the following class - but it may be overkill - we can just use a struct
+
+# class Snack
+#   attr_reader :name, :carbs
+
+#   def initialize(name, carbs)
+#     @name = name
+#     @carbs = carbs
+#   end
+
+# end
+
+# the struct below will do the same thing
+module Flicks
+
+  Snack = Struct.new(:name, :carbs)
+
+
+
+  # the Struct above could be in module but leave out for now
+  module SnackBar
+
+  # constant SNACKS array of Struct instances...
+    SNACKS = [
+      Snack.new(:popcorn, 20),
+      Snack.new(:candy, 15),
+      Snack.new(:nachos, 40),
+      Snack.new(:pretzel, 10),
+      Snack.new(:soda, 5)
+    ]
+
+  # now we can add a method to our module that gets a random snack
+  # module methods start with self.
+    def self.random
+
+      # sample is a ruby method that gets a random element from an array.??? cool...
+      SNACKS.sample
+    end
+
+  end # of Snack Struct
+end # of module Flicks
+
+
+
+
+
+
+if __FILE__ == $0
+
+
+# to get access, we use our module name, then the 'scope resolution operator' (::) then the constant.
+
+  popcorn = Snack.new('popcorn', 20)
+  puts popcorn.name
+  puts popcorn.carbs
+
+  candy = Snack.new('candy', 15)
+  puts candy.name
+  puts candy.carbs
+
+  puts SnackBar::SNACKS
+
+  snack = SnackBar.random
+  puts snack
+  puts "Enjoy your #{snack.name} (#{snack.carbs} carbs)."
+
+end

data/lib/waldorf_and_statler.rb

@@ -0,0 +1,43 @@
+require_relative 'movie'
+
+module Flicks
+
+  module WaldorfAndStatler
+
+  # use modules when you don't need objects or state but rather 
+  # -> methods that takes parameters such as objects
+  # use as a bucket of related methods
+  # also use as mixins and namespaces
+
+  # you can't instanstiate a module
+
+  # a method can be called from a class as an instance of the class
+  # but in a module, we can instanctiate so we have to add "self" to the method to be to call it.
+  # the self allows us to call it directely as below.
+
+    def self.review(movie)
+      number_rolled = roll_die
+      # in the playlist_spec file, we'll stub the number_rolled for testing
+      case number_rolled 
+      when 1..2
+        movie.thumbs_down
+        puts "#{movie.title} got a thumbs down for a low roll."
+      when 3..4
+        puts "#{movie.title} was skipped."
+      else
+        movie.thumbs_up  # reward for rolling 5 or better
+        puts "#{movie.title} got a thumbs up for rolling 5 or better!"
+      end
+
+    end
+
+    def self.roll_die
+      rand(1..6)
+    end
+
+
+  end # of module WaldorfAndStatler
+end # of module Flicks
+
+
+  # WaldorfAndStatler.review

data/spec/movie3d_spec.rb

@@ -0,0 +1,35 @@
+require 'movie3d'
+
+module Flicks
+  describe Movie3D do
+    before do
+      @initial_rank = 10
+      @wow_factor = 5
+      @movie = Movie3D.new('Glee', @initial_rank, @wow_factor)
+    end
+  
+    it "has a title" do
+      @movie.title.should == "Glee"
+    end
+  
+    it "has a rank" do
+      @movie.rank.should == 10
+    end
+  
+    it "has a wow factor" do
+      @movie.wow_factor.should == 5
+    end
+  
+    it "increases rank by 1 times the wow factor when given a thumbs up" do
+      @movie.thumbs_up
+  
+      @movie.rank.should == @initial_rank + (1 * @wow_factor)
+    end
+
+    it "decreases rank by 1 when given a thumbs down" do
+      @movie.thumbs_down
+  
+      @movie.rank.should == @initial_rank - 1
+    end
+  end
+end

data/spec/movie_spec.rb

@@ -0,0 +1,153 @@
+# rspec convenction is to test class with file called "ClassName_spec.rb"
+
+
+#  the following will run all files in the current directory with _spec from the command line
+#  rspec .  --color --format doc
+
+
+# first thing is to requre class
+
+require 'movie'
+
+module Flicks
+
+  describe Movie do
+
+    before do
+
+  # we add the '@' to these varibles makeing them instance varibles so we can call them in the code.    
+      @initial_rank = 10
+      @movie = Movie.new("goonies", @initial_rank) 
+    end
+
+    it "has a capitalized title" do
+
+      @movie.title.should == "Goonies"
+
+    end
+
+    it "has a rank of 10" do
+
+      @movie.rank.should == @initial_rank
+    
+    end
+    
+    it "has a string representation" do 
+
+      @movie.to_s.should == "Goonies initialized with rank of #{@initial_rank/1.0} (Hit)."
+
+
+    end
+
+
+
+    it "increased rank by 1 when given a thumbs up" do 
+
+      @movie.thumbs_up
+
+      @movie.rank.should == @initial_rank + 1
+    end
+
+    it "decreased rank by 1 when given a thumbs down" do
+
+      @movie.thumbs_down
+
+      @movie.rank.should == @initial_rank - 1
+    end
+
+    context "created with a default rank" do
+      before do
+        @movie = Movie.new("goonies")
+      end
+
+      it "has a rank of 0" do
+        @movie.rank.should == 0
+      end
+
+    end
+
+    context "with a rank of at least 10" do
+      before do
+        @movie = Movie.new("goonies", 10)
+      end
+
+      it "is a hit" do
+        @movie.should be_hit # took out the .hit? - was be_true or == true
+      end
+
+      it "is a hit status" do
+        @movie.status.should == "Hit"
+      end
+
+    end
+
+     context "with a rank of less than 10" do
+      before do
+        @movie = Movie.new("goonies", 9)
+      end
+
+      it "is NOT a hit" do
+        @movie.should_not be_hit # took out the .hit? without the _not - was be_false or == false
+      end
+
+      it "has a flop status" do
+        @movie.status.should == "Flop"
+      end
+  
+    it "is sorted by decreasing rank" do
+      movie1 = Movie.new("goonies", 100)
+      movie2 = Movie.new("ghostbusters", 200)
+      movie3 = Movie.new("goldfinger", 300)
+    
+      movies = [movie1, movie2, movie3]
+    
+      movies.sort.should == [movie3, movie2, movie1]
+    end
+  
+    it "computes carbs consumed as the sum of all snack carbs consumed" do
+      @movie.carbs_consumed.should == 0
+
+      @movie.ate_snack(Snack.new(:popcorn, 10))
+
+      @movie.carbs_consumed.should == 10
+
+      @movie.ate_snack(Snack.new(:popcorn, 10))
+
+      @movie.carbs_consumed.should == 20
+
+      @movie.ate_snack(Snack.new(:soda, 5))
+    
+      @movie.carbs_consumed.should == 25
+    end
+  
+    it "yields each snack" do    
+      @movie.ate_snack(Snack.new(:popcorn, 10))
+      @movie.ate_snack(Snack.new(:popcorn, 10))
+      @movie.ate_snack(Snack.new(:soda, 5))
+    
+      yielded = []
+      @movie.each_snack do |snack|
+        yielded << snack
+      end
+    
+      yielded.should == [Snack.new(:popcorn, 20), Snack.new(:soda, 5)]
+    end
+  
+    it "can be instantiated from a CSV string" do
+      movie = Movie.from_csv("goonies,10")
+    
+      movie.title.should == "Goonies"
+      movie.rank.should == 10
+    end
+  
+    it "can be serialized to a CSV string" do  
+      movie = Movie.new("Goonies", 10)
+    
+      movie.to_csv.should == "Goonies, 10" 
+    end
+
+  end 
+
+  end # of describe
+
+end # of Flicks module

data/spec/playlist_spec.rb

@@ -0,0 +1,64 @@
+require 'playlist'
+
+module Flicks
+
+  #  the following will run all files in the current directory with _spec from the command line
+  #  rspec .  --color --format doc
+
+  describe Playlist do 
+    before do
+      @playlist = Playlist.new("Bobby")
+
+    end
+
+    it "has a name" do 
+      @playlist.name.should == "Bobby"
+    end
+
+    context "being played with one movie" do
+      before do
+        @initial_rank = 10
+        @movie = Movie.new("goonies", @initial_rank)
+        @playlist.add_movie(@movie)
+      end
+
+      it "gives the movie a thumbs up if a high number is rolled" do
+  # stub the roll_die method for testing since we don't want the random number for the test.
+        WaldorfAndStatler.stub(:roll_die).and_return(6)
+      
+        @playlist.play(2)
+    
+        @movie.rank.should == @initial_rank + 2 
+
+        WaldorfAndStatler.stub(:roll_die).and_return(5)
+        @playlist.play(2)
+        @movie.rank.should == @initial_rank + 4
+      end
+
+      it "skips the movie if a medium number is rolled" do
+        WaldorfAndStatler.stub(:roll_die).and_return(4)
+      
+        @playlist.play(2)
+    
+        @movie.rank.should == @initial_rank        
+        WaldorfAndStatler.stub(:roll_die).and_return(3)
+        @playlist.play(2)
+        @movie.rank.should == @initial_rank
+      end
+
+      it "gives the movie a thumbs down if a low number is rolled" do
+        WaldorfAndStatler.stub(:roll_die).and_return(2)
+        @playlist.play(2)
+        @movie.rank.should == @initial_rank - 2
+
+        WaldorfAndStatler.stub(:roll_die).and_return(1)
+        @playlist.play(2)
+        @movie.rank.should == @initial_rank - 4
+      end
+
+    end
+
+    
+  end # -> of Describe Playlist
+
+end # -> of Flicks module

data/spec/snack_bar_spec.rb

@@ -0,0 +1,32 @@
+require 'snack_bar'
+
+module Flicks
+  describe Snack do
+    before do
+      @snack = Snack.new(:pretzel, 10)
+    end
+  
+    it "has a name attribute" do
+      @snack.name.should == :pretzel
+    end
+  
+    it "has a carbs attribute" do
+      @snack.carbs.should == 10
+    end
+  
+  end
+end
+
+module Flicks
+  describe SnackBar do
+    it "has a trove of treasures" do
+      SnackBar::SNACKS.should_not be_empty
+    end
+  
+    it "returns a random treasure" do
+      snack = SnackBar.random
+    
+      SnackBar::SNACKS.should include(snack)
+    end
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: rms_flicks
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Pragmatic Studio student
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "This is an example application used in The Pragmatic Studio's \nRuby
+  Programming course, as described at\n\n  http://pragmaticstudio.com\n\nThis code
+  is Copyright 2012 The Pragmatic Studio. See the LICENSE file."
+email: rmckinleys@gmail.com
+executables:
+- flicks
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/flicks
+- bin/movie_rankings.csv
+- bin/movies.csv
+- lib/movie.rb
+- lib/movie3d.rb
+- lib/playlist.rb
+- lib/rankable.rb
+- lib/snack_bar.rb
+- lib/waldorf_and_statler.rb
+- spec/movie3d_spec.rb
+- spec/movie_spec.rb
+- spec/playlist_spec.rb
+- spec/snack_bar_spec.rb
+- LICENSE
+- README
+homepage: http://pragmaticstudio.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Plays and reviews movies
+test_files:
+- spec/movie3d_spec.rb
+- spec/movie_spec.rb
+- spec/playlist_spec.rb
+- spec/snack_bar_spec.rb