jimmy_jukebox 0.2.6 → 0.3.6

data/bin/jload_jukebox

@@ -1,29 +1,3 @@
 #!/usr/bin/env jruby
 
-lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
-$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
-require 'jimmy_jukebox/song_loader'
-include JimmyJukebox
-
-require 'jimmy_jukebox/artists'
-include Artists
-
-def no_argv0
-  puts "You must select an artist to use 'load_jukebox'."
-  puts "For example: 'load_jukebox at' to load Art Tatum"
-  puts "Another example: 'load_jukebox dr' to load Django Reinhardt"
-  exit
-end
-
-def invalid_artist
-  puts "No action taken in response to your command 'load_jukebox #{ARGV[0]}'."
-  puts "JimmyJukebox does not recognize '#{ARGV[0]}'. You must select a valid artist."
-  puts "For example, valid artists include: 'bh' for Billie Holiday, 'cb' for Count Basie, and 'lh' for Lionel Hampton"
-  puts "Please see the README for a complete list of valid artists."
-  exit
-end
-
-no_argv0 unless ARGV[0]
-invalid_artist unless JAZZ_ARTISTS.has_key?(ARGV[0].to_sym)
-JimmyJukebox::SongLoader.send(JAZZ_ARTISTS[ARGV[0].to_sym])
-
+require File.dirname(__FILE__) + '/../lib/jimmy_jukebox/load_jukebox_code.rb'

data/bin/jplay_jukebox

@@ -1,49 +1,21 @@
 #!/usr/bin/env jruby
-require 'readline'
-
-lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
-$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
-require 'jimmy_jukebox'
-include JimmyJukebox
-
-jj = Jukebox.new
 
-play_loop_thread = Thread.new do
-  jj.play_loop
-end
+require 'readline'
 
-display_string = "Press 'p' to (un)pause, 'q' to quit, or 's' to skip the song"
 begin
-  while true do
-    puts display_string
-    line = Readline.readline('> ', true)
-    case line.strip
-    when "q"
-      puts "Quit requested"
-      jj.quit
-      Thread.main.exit
-    when "p"
-      if play_loop_thread && jj.current_song_paused
-        puts "Unpause requested"
-        jj.unpause_current_song
-      elsif play_loop_thread
-        puts "Pause requested"
-        jj.pause_current_song
-      else
-        raise "Can't find play_loop_thread"
-      end
-      puts display_string
-    when "s"
-      puts "Skip song requested"
-      jj.skip_song
-    else
-      puts display_string
-    end
+  #Gem::Specification.find_by_name('spoon') # Gem.available?('spoon')
+  #gem 'spoon'
+  if (defined?(JRUBY_VERSION) || RUBY_PLATFORM == 'java')
+    require 'rubygems'
+    require 'spoon'
   end
-rescue Interrupt => e
-  puts "\nMusic terminated by user"
+rescue LoadError
+  puts "*** You must install the 'spoon' gem to use JimmyJukebox on JRuby ***"
   exit
 end
 
-play_loop_thread.join
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+require 'jimmy_jukebox'
+include JimmyJukebox
 

data/bin/load_jukebox

@@ -1,29 +1,3 @@
 #!/usr/bin/env ruby
 
-lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
-$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
-require 'jimmy_jukebox/song_loader'
-include JimmyJukebox
-
-require 'jimmy_jukebox/artists'
-include Artists
-
-def no_argv0
-  puts "You must select an artist to use 'load_jukebox'."
-  puts "For example: 'load_jukebox at' to load Art Tatum"
-  puts "Another example: 'load_jukebox dr' to load Django Reinhardt"
-  exit
-end
-
-def invalid_artist
-  puts "No action taken in response to your command 'load_jukebox #{ARGV[0]}'."
-  puts "JimmyJukebox does not recognize '#{ARGV[0]}'. You must select a valid artist."
-  puts "For example, valid artists include: 'bh' for Billie Holiday, 'cb' for Count Basie, and 'lh' for Lionel Hampton"
-  puts "Please see the README for a complete list of valid artists."
-  exit
-end
-
-no_argv0 unless ARGV[0]
-invalid_artist unless JAZZ_ARTISTS.has_key?(ARGV[0].to_sym)
-JimmyJukebox::SongLoader.send(JAZZ_ARTISTS[ARGV[0].to_sym])
-
+require File.dirname(__FILE__) + '/../lib/jimmy_jukebox/load_jukebox_code.rb'

data/bin/play_jukebox

@@ -6,44 +6,3 @@ $LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
 require 'jimmy_jukebox'
 include JimmyJukebox
 
-jj = Jukebox.new
-
-play_loop_thread = Thread.new do
-  jj.play_loop
-end
-
-display_string = "Press 'p' to (un)pause, 'q' to quit, or 's' to skip the song"
-begin
-  while true do
-    puts display_string
-    line = Readline.readline('> ', true)
-    case line.strip
-    when "q"
-      puts "Quit requested"
-      jj.quit
-      Thread.main.exit
-    when "p"
-      if play_loop_thread && jj.current_song_paused
-        puts "Unpause requested"
-        jj.unpause_current_song
-      elsif play_loop_thread
-        puts "Pause requested"
-        jj.pause_current_song
-      else
-        raise "Can't find play_loop_thread"
-      end
-      puts display_string
-    when "s"
-      puts "Skip song requested"
-      jj.skip_song
-    else
-      puts display_string
-    end
-  end
-rescue Interrupt => e
-  puts "\nMusic terminated by user"
-  exit
-end
-
-play_loop_thread.join
-

data/lib/jimmy_jukebox/jukebox.rb

@@ -0,0 +1,83 @@
+module JimmyJukebox
+
+  module Jukebox
+
+    class << Jukebox
+
+      attr_accessor :current_song, :continuous_play
+
+    end
+
+    def self.play_loop
+      @continuous_play = true
+      while @continuous_play do
+        play_once
+      end
+    end
+
+    def self.play_once
+      begin
+        play_random_song
+      rescue SystemExit, Interrupt => e
+        terminate_current_song
+        puts "\nMusic terminated by user"
+        exit
+      end
+    end
+
+    def self.quit
+      stop_looping
+      terminate_current_song
+    end
+
+    def self.skip_song
+      if @current_song
+        puts "Terminating #{@current_song.music_file}"
+        terminate_current_song
+      else
+        raise "No @current_song"
+      end
+    end
+
+    def self.pause_current_song
+      @current_song.pause
+    end
+
+    def self.unpause_current_song
+      @current_song.unpause
+    end
+
+    def self.stop_looping
+      @continuous_play = false
+    end
+
+    def self.songs
+      user_config.songs
+    end
+
+    def self.play_random_song
+      #terminate_current_song
+      raise "JimmyJukebox has no songs to play!" if songs.length == 0
+      @current_song = Song.new( songs[rand(songs.length)] )
+      @current_song.play(user_config)
+      @current_song = nil # ????
+    end
+
+    def self.terminate_current_song
+      if @current_song
+        puts "Terminating #{@current_song.music_file}"
+        @current_song.terminate
+        #@current_song = nil
+      else
+        puts "No song is currently playing"
+      end
+    end
+
+    def self.user_config
+      @user_config = UserConfig.new unless @user_config
+      @user_config
+    end
+
+  end
+
+end

data/lib/jimmy_jukebox/load_jukebox_code.rb

@@ -0,0 +1,27 @@
+lib = File.expand_path(File.dirname(__FILE__) + '/..')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+require 'jimmy_jukebox/song_loader'
+include JimmyJukebox
+
+require 'jimmy_jukebox/artists'
+include Artists
+
+def no_argv0
+  puts "You must select an artist to use 'load_jukebox'."
+  puts "For example: 'load_jukebox at' to load Art Tatum"
+  puts "Another example: 'load_jukebox dr' to load Django Reinhardt"
+  exit
+end
+
+def invalid_artist
+  puts "No action taken in response to your command 'load_jukebox #{ARGV[0]}'."
+  puts "JimmyJukebox does not recognize '#{ARGV[0]}'. You must select a valid artist."
+  puts "For example, valid artists include: 'bh' for Billie Holiday, 'cb' for Count Basie, and 'lh' for Lionel Hampton"
+  puts "Please see the README for a complete list of valid artists."
+  exit
+end
+
+no_argv0 unless ARGV[0]
+invalid_artist unless JAZZ_ARTISTS.has_key?(ARGV[0].to_sym)
+JimmyJukebox::SongLoader.send(JAZZ_ARTISTS[ARGV[0].to_sym])
+

data/lib/jimmy_jukebox/song.rb

@@ -0,0 +1,111 @@
+module JimmyJukebox
+
+  class Song
+
+    attr_reader :paused, :music_file
+    attr_accessor :player, :playing_pid
+
+    def initialize(music_file)
+      set_music_file(music_file)
+      @paused = false
+      @playing_pid = nil
+    end
+
+    def set_music_file(music_file)
+      if music_file =~ /\.mp3$/i || music_file =~ /\.ogg$/i
+        @music_file = music_file
+      else
+        raise "You can create a song only with an .mp3 or .ogg file"
+      end
+    end
+
+    def pause
+      @paused = true
+      # jruby doesn't seem to handle system() correctly
+      # trying backticks
+      # system("kill -s STOP #{@playing_pid}") if @playing_pid
+      `kill -s STOP #{@playing_pid}` if @playing_pid
+    end
+
+    def unpause
+      @paused = false
+      # jruby doesn't seem to handle system() correctly
+      # trying backticks
+      #system("kill -s CONT #{@playing_pid}") if @playing_pid
+      `kill -s CONT #{@playing_pid}` if @playing_pid
+    end
+
+    def delete
+      # without temp var, next song could start playing
+      # in another thread and wrong file could be deleted
+      file_to_delete = @music_file
+      terminate
+      File.delete(file_to_delete)
+    end
+
+    def terminate
+      @paused = false
+      #`killall #{@player}`
+      @player = nil
+      # killing processes seems problematic in JRuby
+      # I've tried several approaches, and nothing seems reliable
+      #Process.kill("SIGKILL",@playing_pid) if @playing_pid
+      #Process.kill("SIGTERM",@playing_pid) if @playing_pid
+      `kill #{@playing_pid}` if @playing_pid
+      @playing_pid = nil
+    end
+
+    def set_player(user_config)
+      if @music_file =~ /\.mp3$/i
+        @player = user_config.mp3_player
+      elsif @music_file =~ /\.ogg$/i
+        @player = user_config.ogg_player
+      end
+      raise "Attempted to play a file format this program cannot play" unless @player
+    end
+
+    def play(user_config)
+      set_player(user_config)
+      process_status = play_with_player
+      process_status.exitstatus.to_i == 0 ? (@playing_pid = nil) : (raise "Experienced a problem playing a song")
+    end
+
+    def play_with_player
+      puts "Press Ctrl-C to stop the music and exit this program"
+      puts "Now playing '#{@music_file}'"
+      puts "#{@player} \"#{File.expand_path(@music_file)}\""
+      system_yield_pid(@player, File.expand_path(@music_file)) do |pid|
+        @playing_pid = pid 
+      end
+    end
+
+  end
+
+  # make system call and get pid so you can terminate process
+  def system_yield_pid(player, filename)
+    # would like to use Process.respond_to?(:fork) but JRuby mistakenly returns true
+    if (defined?(JRUBY_VERSION) || RUBY_PLATFORM == 'java')
+      pid = Spoon.spawnp("#{player}", "#{filename}")
+    else
+      begin
+        pid = fork do             # creates and runs block in subprocess (which will terminate with status 0), capture subprocess pid
+          exec(player,filename)   # replaces current process with system call
+          exit! 127               # exit process and return exit status 127; should never be reached
+        end
+      rescue NotImplementedError
+        raise "*** fork()...exec() not supported ***"
+      end
+    end
+    yield pid if block_given? # call block, passing in the subprocess pid
+    #if pid
+    #  puts "pid: #{pid}"
+    #  puts "current_song: #{Jukebox.current_song.inspect}"
+    #else
+    #  puts "No process id (pid)!"
+    #  raise "@current_song: #{Jukebox.current_song.inspect}"
+    #end
+    Process.waitpid(pid)      # Waits for a child process to exit, returns its process id, and sets $? to a Process::Status object
+    $?                        # return Process::Status object with instance methods .stopped?, .exited?, .exitstatus; see: http://www.ruby-doc.org/core/classes/Process/Status.html
+  end
+
+end

data/lib/jimmy_jukebox/user_interface.rb

@@ -0,0 +1,41 @@
+jj = Jukebox
+
+play_loop_thread = Thread.new do
+  jj.play_loop
+end
+
+display_string = "Press 'p' to (un)pause, 'q' to quit, or 's' to skip the song"
+begin
+  while true do
+    puts display_string
+    line = Readline.readline('> ', true)
+    case line.strip
+    when "q"
+      puts "Quit requested"
+      jj.quit
+      Thread.main.exit
+    when "p"
+      if play_loop_thread && jj.current_song.paused
+        puts "Unpause requested"
+        jj.unpause_current_song
+      elsif play_loop_thread
+        puts "Pause requested"
+        jj.pause_current_song
+      else
+        raise "Can't find play_loop_thread"
+      end
+      puts display_string
+    when "s"
+      puts "Skip song requested"
+      jj.skip_song
+    else
+      puts display_string
+    end
+  end
+rescue Interrupt => e
+  puts "\nMusic terminated by user"
+  exit
+end
+
+play_loop_thread.join
+

data/lib/jimmy_jukebox/version.rb

@@ -1,3 +1,3 @@
 module JimmyJukebox
-  VERSION = '0.2.6'
+  VERSION = '0.3.6'
 end

data/lib/jimmy_jukebox.rb

@@ -1,120 +1,7 @@
-module JimmyJukebox
+require 'jimmy_jukebox/user_config'
+require 'jimmy_jukebox/song'
+require 'jimmy_jukebox/jukebox'
 
-  # make system call and get pid so you can terminate process
-  def system_yield_pid(*cmd)
-    # would like to use Process.respond_to?(:fork) but JRuby mistakenly returns true
-    begin
-      pid = fork do             # creates and runs block in subprocess (which will terminate with status 0), capture subprocess pid
-        exec(*cmd)              # replaces current process with system call
-        exit! 127               # exit process and return exit status 127; should never be reached
-      end
-    rescue NotImplementedError
-      require 'rubygems'
-      require 'spoon'
-      pid = Spoon.spawnp(*cmd)
-      #raise "*** fork() not supported ***" unless Process.respond_to?(:fork)
-    end
-    yield pid if block_given? # call block, passing in the subprocess pid
-    Process.waitpid(pid)      # Waits for a child process to exit, returns its process id, and sets $? to a Process::Status object
-    $?                        # return Process::Status object with instance methods .stopped?, .exited?, .exitstatus; see: http://www.ruby-doc.org/core/classes/Process/Status.html
-  end
+include JimmyJukebox
 
-  class Jukebox
-
-    require 'jimmy_jukebox/user_config'
-
-    attr_reader :loop, :current_song_paused, :playing_pid
-
-    def initialize
-      @user_config = UserConfig.new
-    end
-
-    def play_loop
-      @loop = true
-      while @loop do
-        play
-      end
-    end
-
-    def play
-      begin
-        play_random_song(@user_config.songs)
-      rescue SystemExit, Interrupt => e
-        terminate_current_song
-        puts "\nMusic terminated by user"
-        exit
-      end
-    end
-
-    def quit
-      stop_looping
-      terminate_current_song
-    end
-
-    def skip_song
-      terminate_current_song
-    end
-
-    def pause_current_song
-      @current_song_paused = true
-      # jruby doesn't seem to handle system() correctly
-      # trying backticks
-      # system("kill -s STOP #{@playing_pid}") if @playing_pid
-      `kill -s STOP #{@playing_pid}` if @playing_pid
-    end
-
-    def unpause_current_song
-      @current_song_paused = false
-      # jruby doesn't seem to handle system() correctly
-      # trying backticks
-      #system("kill -s CONT #{@playing_pid}") if @playing_pid
-      `kill -s CONT #{@playing_pid}` if @playing_pid
-    end
-
-    private
-
-    def stop_looping
-      @loop = false
-    end
-
-    def play_random_song(songs)
-      terminate_current_song
-      raise "JimmyJukebox has no songs to play!" if songs.length == 0
-      music_file = songs[rand(songs.length)]
-      play_file(music_file)
-    end
-
-    def terminate_current_song
-      if @playing_pid
-        @current_song_paused = false
-        # killing processes seems problematic in JRuby
-        # I've tried several approaches, and nothing seems reliable
-        Process.kill("SIGKILL",@playing_pid)
-        #Process.kill("SIGTERM",@playing_pid)
-        #`kill #{@playing_pid}` if @playing_pid
-        @playing_pid = nil
-      end
-    end
-
-   def play_file(music_file)
-      # TODO: refactor the duplicate code below into a method
-      if music_file =~ /\.mp3$/i && @user_config.mp3_player
-        process_status = play_file_with(music_file, @user_config.mp3_player)
-      elsif music_file =~ /\.ogg$/i && @user_config.ogg_player
-        process_status = play_file_with(music_file, @user_config.ogg_player)
-      else
-        raise "Attempted to play a file format this program cannot play"
-      end
-      process_status.exitstatus.to_i == 0 ? (@playing_pid = nil) : (raise "Experienced a problem playing a song")
-    end
-
-    def play_file_with(music_file,player)
-      puts "Press Ctrl-C to stop the music and exit this program"
-      system_yield_pid(player, File.expand_path(music_file)) do |pid|
-        @playing_pid = pid 
-      end
-    end
-
-  end
-
-end
+require 'jimmy_jukebox/user_interface'

data/spec/jimmy_jukebox_spec.rb

@@ -3,29 +3,20 @@ require 'fakefs/safe'
 require 'jimmy_jukebox'
 include JimmyJukebox
 
-# Override exec() to prevent songs from actually playing
-# Instead, start a brief sleep process
-module Kernel
-  alias :real_exec :exec
-
-  def exec(*cmd)
-    real_exec("sleep 0.2")  
-  end
-end
-
 describe Jukebox do
 
   before(:all) do
-    #ARGV.clear
-    ARGV.pop
+    ARGV.clear
+    #ARGV.pop
   end
 
+  let(:uc) { double('user_config').as_null_object }
+ 
   context "with no command line parameter" do
 
-    it "can be instantiated" do
-      jj = Jukebox.new
-      jj.should_not be_nil
-      jj.quit
+    it "exists" do
+      Jukebox.should_not be_nil
+      Jukebox.quit
     end
 
     #it "raises exception when no songs available"
@@ -34,102 +25,172 @@ describe Jukebox do
     #  end.should raise_error
     #end
 
+    it "has a user_config method" do
+      Jukebox.user_config.is_a?(UserConfig)
+    end
+
+    it "has a @user_config instance variable" do
+      Jukebox.instance_variable_get(:@user_config).is_a?(UserConfig)
+    end
+
     it "generates a non-empty song list" do
-      jj = Jukebox.new
-      jj.instance_variable_get(:@user_config).songs.should_not be_nil
-      jj.instance_variable_get(:@user_config).songs.should_not be_empty
-      jj.instance_variable_get(:@user_config).songs.length.should be > 0
+      Jukebox.user_config.songs.should_not be_nil
+      Jukebox.user_config.songs.should_not be_empty
+      Jukebox.user_config.songs.length.should be > 0
     end
 
     it "generates a non-empty song list with only mp3 & ogg files" do
-      jj = Jukebox.new
-      jj.instance_variable_get(:@user_config).songs.each do |song|
+      Jukebox.user_config.songs.each do |song|
         song.should match(/.*\.mp3|.*\.ogg/i)
       end
     end
 
-    it "can play" do
-      jj = Jukebox.new
-      thread = Thread.new do
-        jj.play
+    describe "#play_once" do
+
+      it "should call play_random_song" do
+        Jukebox.should_receive(:play_random_song)
+        Jukebox.play_once
       end
-      sleep 0.2
-      jj.instance_variable_get(:@playing_pid).should_not be_nil
-      jj.should_receive(:terminate_current_song)
-      jj.quit
-    end
 
-    it "can play_loop" do
-      jj = Jukebox.new
-      thread = Thread.new do
-        jj.play_loop
+      it "should have a current_song" do
+        jj = Jukebox
+        uc.stub(:mp3_player) {"play"}
+        uc.stub(:ogg_player) {"play"}
+        thread = Thread.new do
+          Jukebox.play_once
+        end
+        sleep 0.1
+        jj.current_song.is_a?(Song)
+        thread.exit
       end
-      sleep 0.1
-      song1 = jj.playing_pid
-      song1.should_not be_nil
-      jj.loop.should be_true
-      sleep 0.2
-      song2 = jj.playing_pid
-      song2.should_not be_nil
-      song2.should_not == song1
-      jj.quit
-    end
 
-    it "can skip a song" do
-      jj = Jukebox.new
-      thread = Thread.new do
-        jj.play_loop
+      it "should have a current_song with a music_file" do
+        jj = Jukebox
+        uc.stub(:mp3_player) {"play"}
+        uc.stub(:ogg_player) {"play"}
+        thread = Thread.new do
+          Jukebox.play_once
+        end
+        sleep 0.1
+        jj.current_song.music_file.should match /\.mp3$|\.ogg$/
+        thread.exit
       end
-      sleep 0.2
-      song_1 = jj.playing_pid
-      jj.skip_song
-      sleep 0.2
-      song_2 = jj.playing_pid
-      jj.skip_song
-      sleep 0.2
-      song_3 = jj.playing_pid
-      song_1.should_not == song_2 || song_2.should_not == song_3
-      jj.quit
-    end
 
-    it "can pause the current song" do
-      jj = Jukebox.new
-      thread = Thread.new do
-        jj.play
+      it "should have a player" do
+        jj = Jukebox
+        thread = Thread.new do
+          Jukebox.play_once
+        end
+        sleep 0.1
+        jj.current_song.player.should_not be_nil
+        thread.exit
+      end
+
+      it "should not have a current_song after song finishes" do
+        jj = Jukebox
+        thread = Thread.new do
+          Jukebox.play_once
+        end
+        sleep 0.3
+        jj.current_song.should be_nil
+        thread.exit
       end
-      sleep 0.1
-      song_1 = jj.playing_pid
-      jj.pause_current_song
-      song_2 = jj.playing_pid
-      song_1.should == song_2
-      jj.current_song_paused.should be_true
-      jj.quit
+
+      it "should have a current_song with a playing_pid" do
+        jj = Jukebox
+        thread = Thread.new do
+          jj.play_once
+        end
+        sleep 0.1
+        jj.current_song.playing_pid.should_not be_nil
+        #jj.should_receive(:terminate_current_song)
+        jj.quit
+        thread.exit
+      end
+
+      it "triggers play_random_song" do
+        Jukebox.should_receive(:play_random_song)
+        Jukebox.play_once
+      end
+
+      it "can pause the current song" do
+        thread = Thread.new do
+          Jukebox.play_once
+        end
+        sleep 0.1
+        song_1 = Jukebox.current_song.playing_pid
+        Jukebox.pause_current_song
+        song_2 = Jukebox.current_song.playing_pid
+        song_1.should == song_2
+        Jukebox.current_song.paused.should be_true
+        Jukebox.quit
+        thread.exit
+      end
+
+      it "can unpause a paused song" do
+        thread = Thread.new do
+          Jukebox.play_once
+        end
+        sleep 0.05
+        song_1 = Jukebox.current_song
+        Jukebox.current_song.paused.should be_false
+        Jukebox.pause_current_song
+        song_2 = Jukebox.current_song
+        Jukebox.current_song.paused.should be_true
+        song_2.should == song_1
+        Jukebox.unpause_current_song
+        Jukebox.current_song.paused.should be_false
+        song_3 = Jukebox.current_song
+        Jukebox.current_song.paused.should be_false
+        Jukebox.pause_current_song
+        song_4 = Jukebox.current_song
+        Jukebox.current_song.paused.should be_true
+        song_4.should == song_3
+        Jukebox.unpause_current_song
+        Jukebox.current_song.paused.should be_false
+        Jukebox.quit
+        thread.exit
+      end
+
     end
 
-    it "can unpause a paused song" do
-      jj = Jukebox.new
-      thread = Thread.new do
-        jj.play
+    describe "#play_loop" do
+
+      it "plays multiple songs" do
+        thread = Thread.new do
+          Jukebox.play_loop
+        end
+        sleep 0.1
+        song1 = Jukebox.current_song.playing_pid
+        song1.should_not be_nil
+        Jukebox.continuous_play.should be_true
+        sleep 0.2
+        song2 = Jukebox.current_song.playing_pid
+        song2.should_not be_nil
+        song2.should_not == song1
+        Jukebox.quit
+        thread.exit
       end
-      sleep 0.05
-      song_1 = jj.playing_pid
-      jj.current_song_paused.should be_false
-      jj.pause_current_song
-      song_2 = jj.playing_pid
-      jj.current_song_paused.should be_true
-      song_2.should == song_1
-      jj.unpause_current_song
-      jj.current_song_paused.should be_false
-      song_3 = jj.playing_pid
-      jj.current_song_paused.should be_false
-      jj.pause_current_song
-      song_4 = jj.playing_pid
-      jj.current_song_paused.should be_true
-      song_4.should == song_3
-      jj.unpause_current_song
-      jj.current_song_paused.should be_false
-      jj.quit
+
+      it "can skip a song" do
+        thread = Thread.new do
+          Jukebox.play_loop
+        end
+        sleep 0.2
+        song_1 = Jukebox.current_song
+        Jukebox.skip_song
+        sleep 0.2
+        song_2 = Jukebox.current_song
+        Jukebox.skip_song
+        sleep 0.2
+        song_3 = Jukebox.current_song
+        song_1.should_not == song_2 || song_2.should_not == song_3
+        Jukebox.quit
+        thread.exit
+      end
+
     end
+
   end
 
   context "with valid music directory as command line parameter" do
@@ -140,20 +201,20 @@ describe Jukebox do
     end
 
     it "can skip a song" do
-      jj = Jukebox.new
       thread = Thread.new do
-        jj.play_loop
+        Jukebox.play_loop
       end
       sleep 0.2
-      song_1 = jj.playing_pid
-      jj.skip_song
+      song_1 = Jukebox.current_song
+      Jukebox.skip_song
       sleep 0.2
-      song_2 = jj.playing_pid
-      jj.skip_song
+      song_2 = Jukebox.current_song
+      Jukebox.skip_song
       sleep 0.2
-      song_3 = jj.playing_pid
+      song_3 = Jukebox.current_song
       song_1.should_not == song_2 || song_2.should_not == song_3
-      jj.quit
+      Jukebox.quit
+      thread.exit
     end
 
   end

data/spec/song_loader_spec.rb

@@ -16,8 +16,8 @@ describe JimmyJukebox::SongLoader do
 
   before(:all) do
     #ARGV.delete_if { |val| true }
-    #ARGV.clear
-    ARGV.pop
+    ARGV.clear
+    #ARGV.pop
   end
 
   before(:each) do

data/spec/song_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'jimmy_jukebox/song'
+require 'jimmy_jukebox/user_config'
+
+include JimmyJukebox
+
+describe Song do
+
+  before(:each) do
+  end
+
+  describe "#initialize" do
+
+    it "requires a parameter" do
+      expect {Song.new}.to raise_error
+    end
+
+    it "fails if parameter does not end in .mp3 or .ogg" do
+      expect {Song.new("/home/bill/music_file")}.to raise_error
+    end
+
+    it "accepts a parameter ending in .mp3" do
+      Song.new("/home/bill/music_file.mp3").is_a?(Song)
+    end
+
+    it "accepts a parameter ending in .ogg" do
+      Song.new("/home/bill/music_file.ogg").is_a?(Song)
+    end
+
+    it "sets a music file" do
+      mf = "/home/bill/Music/JAZZ/billie_holiday.ogg"
+      song = Song.new(mf)
+      song.music_file.should == mf
+    end
+
+  end
+
+  describe "#paused" do
+
+    before(:each) do
+      @song = Song.new("~/Music/JAZZ/art_tatum.mp3")
+    end
+
+    it "is initially not paused" do
+      @song.paused.should be_false
+    end
+
+    it "is paused after calling #pause" do
+      @song.pause
+      @song.paused.should be_true
+    end
+
+    it "is unpaused after calling #pause and #unpause" do
+      @song.pause
+      @song.unpause
+      @song.paused.should be_false
+    end
+
+  end
+
+  describe "#play" do
+
+    before(:each) do
+      @music_file = "~/Music/JAZZ/art_tatum.mp3"
+      @song = Song.new(@music_file)
+    end
+
+    let(:uc) { double('user_config').as_null_object }
+    let(:ps) { double('process_status').as_null_object}
+
+    it "calls #play_with_player" do
+      ps.stub(:exitstatus).and_return(0)
+      @song.should_receive(:play_with_player).and_return(ps)
+      uc.stub(:mp3_player) {"play"}
+      uc.stub(:ogg_player) {"play"}
+      @song.play(uc)
+    end
+
+    it "raises error when exitstatus != 0" do
+      ps.stub(:exitstatus).and_return(1)
+      @song.should_receive(:play_with_player).and_return(ps)
+      uc.stub(:mp3_player) {"play"}
+      uc.stub(:ogg_player) {"play"}
+      expect{@song.play(uc)}.to raise_error
+    end
+
+  end
+
+  describe "#play_with_player" do
+
+    before(:each) do
+      @music_file = "~/Music/JAZZ/art_tatum.mp3"
+      @song = Song.new(@music_file)
+    end
+
+    let(:uc) { double('user_config').as_null_object }
+    let(:ps) { double('process_status').as_null_object}
+
+    it "calls #system_yield_pid" do
+      uc.stub(:mp3_player) {"play"}
+      uc.stub(:ogg_player) {"play"}
+      @song.set_player(uc)
+      @song.should_receive(:system_yield_pid).with("play",File.expand_path(@music_file)).and_return(ps)
+      @song.play_with_player
+    end
+
+    it "calls #system_yield_pid and captures playing_pid" do
+      pending
+      uc.stub(:mp3_player) {"play"}
+      uc.stub(:ogg_player) {"play"}
+      @song.set_player(uc)
+      @song.should_receive(:system_yield_pid).with("play",File.expand_path(@music_file)).and_yield(1469)
+      @song.play_with_player
+      @song.playing_pid.should == 1469
+    end
+
+  end
+
+  describe "#playing_pid" do
+
+    before(:each) do
+      @song = Song.new("~/Music/JAZZ/art_tatum.mp3")
+    end
+
+    let(:uc) { double('user_config').as_null_object }
+
+    it "is initially nil" do
+      @song.playing_pid.should be_nil
+    end
+
+    it "is not nil after #play" do
+      uc.stub(:mp3_player) {"play"}
+      uc.stub(:ogg_player) {"play"}
+      thread = Thread.new do
+        @song.play(uc)
+      end
+      sleep 0.1
+      @song.playing_pid.should_not be_nil
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -3,3 +3,15 @@ RSpec.configure do |config|
     ARGV.clear
   end
 end
+
+# Override exec() to prevent songs from actually playing
+# Instead, start a brief sleep process
+module Kernel
+  alias :real_exec :exec
+
+  def exec(*cmd)
+    real_exec("sleep 0.2")  
+  end
+end
+
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: jimmy_jukebox
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 31
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 6
-  version: 0.2.6
+  version: 0.3.6
 platform: ruby
 authors: 
 - James Lavin
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-22 00:00:00 Z
+date: 2011-09-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -115,10 +115,14 @@ extra_rdoc_files: []
 files: 
 - roadmap.txt
 - LICENSE.txt
+- lib/jimmy_jukebox/load_jukebox_code.rb
+- lib/jimmy_jukebox/jukebox.rb
 - lib/jimmy_jukebox/song_loader.rb
 - lib/jimmy_jukebox/user_config.rb
 - lib/jimmy_jukebox/version.rb
+- lib/jimmy_jukebox/song.rb
 - lib/jimmy_jukebox/artists.rb
+- lib/jimmy_jukebox/user_interface.rb
 - lib/jimmy_jukebox.rb
 - lib/jimmy_jukebox/songs/BennieMoten.yml
 - lib/jimmy_jukebox/songs/MilesDavis.yml
@@ -148,6 +152,7 @@ files:
 - spec/user_config_spec.rb
 - spec/jimmy_jukebox_spec.rb
 - spec/song_loader_spec.rb
+- spec/song_spec.rb
 - bin/play_jukebox
 - bin/load_jukebox
 - bin/jplay_jukebox
@@ -178,10 +183,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       segments: 
       - 0
       version: "0"
-requirements: []
-
+requirements: 
+- spoon gem (JRuby only)
 rubyforge_project: jimmy_jukebox
-rubygems_version: 1.8.5
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: plays your MP3 & OGG files and lets you easily download music
@@ -190,3 +195,4 @@ test_files:
 - spec/user_config_spec.rb
 - spec/jimmy_jukebox_spec.rb
 - spec/song_loader_spec.rb
+- spec/song_spec.rb