jimmy_jukebox 0.3.7 → 0.4.1

data/lib/jimmy_jukebox/songs/Ragtime.yml

@@ -0,0 +1,15 @@
+---
+- http://archive.org/download/EDIS-SRP-0092-03/EDIS-SRP-0092-03.mp3
+- http://archive.org/download/AlexandersRagtimeBand/AlexandersRagtimeBand.mp3
+- http://archive.org/download/ScottJoplinRagtime/ScottJoplinMapleLeaf.mp3
+- http://archive.org/download/ScottJoplinRagtime/ScottJoplinTheEntertainer.mp3
+- http://archive.org/download/ScottJoplinRagtime/ScottJoplinTheSycamore.mp3
+- http://archive.org/download/Eck_Robertson_Ragtime_Annie/Eck_Robertson-Ragtime_Annie_vbr.mp3
+- http://archive.org/download/BlackAndWhiteRagtime1909/VictorOrchestra-BlackAndWhiteRagtime1909.mp3
+- http://archive.org/download/WinnerRagtimeBand-TheTurkeyTrot1912/WinnerRagtimeBand-TurkeyTrot1912.mp3
+- http://archive.org/download/MugsySpannerAndHisRagtimeBand-Relaxin/MugsySpannerAndHisRagtimeBand-Relaxin.mp3
+- http://archive.org/download/ArthurCollinsByronHarlan-AlexandersRagtimeBand/ArthurCollinsByronHarlan-AlexandersRagtimeBand.mp3
+- http://archive.org/download/FowlerStreetFiveAlexandersRagtimeBand/Fs5-1954-betaHouseAtlanta-alexandersRagtimeBand.mp3
+- http://archive.org/download/DollyConnolly-TheRagtimeMockingbird1912/DollyConnolly-TheRagtimeMockingbird1912.mp3
+- http://archive.org/download/OleMissRag/W.c.Handy-oleMissRag_1917_64kb.mp3
+- http://archive.org/download/Dempsey_Jacks_Pig_Ankle_Rag/Dempsey_Jacks_Pig_Ankle_Rag.mp3

data/lib/jimmy_jukebox/user_config.rb

@@ -7,7 +7,8 @@ module JimmyJukebox
     require 'jimmy_jukebox/artists'
     include Artists
 
-    attr_reader :mp3_player, :ogg_player, :songs, :music_directories
+    attr_writer   :music_directories
+    attr_accessor :songs, :ogg_player, :mp3_player
 
     DEFAULT_PLAYLIST_DIR = File.expand_path(File.join("~",".jimmy_jukebox"))
 
@@ -19,6 +20,7 @@ module JimmyJukebox
     end
 
     def initialize
+      self.songs = []
       set_music_players
       generate_directories_list
       generate_song_list
@@ -31,8 +33,8 @@ module JimmyJukebox
     def set_music_players
       set_ogg_player
       set_mp3_player
-      no_player_configured if !@ogg_player && !@mp3_player
-      warn_about_partial_functionality if !@ogg_player || !@mp3_player
+      no_player_configured unless ogg_player || mp3_player
+      warn_about_partial_functionality if !ogg_player || !mp3_player
     end
 
     def no_player_configured
@@ -41,57 +43,61 @@ module JimmyJukebox
     end
 
     def warn_about_partial_functionality
-      if @ogg_player && !@mp3_player
+      if ogg_player && !mp3_player
         puts "*** YOU CANNOT PLAY MP3S -- YOU MIGHT WANT TO INSTALL MPG123 OR MPG321 ***"
-      elsif @mp3_player && !@ogg_player
+      elsif mp3_player && !ogg_player
         puts "*** YOU CANNOT PLAY OGG FILES -- YOU MIGHT WANT TO INSTALL OGG123 ***"
       end
     end
 
     def set_ogg_player
       if ogg123_exists?
-        @ogg_player = "ogg123"
+        self.ogg_player = "ogg123"
         return
       elsif music123_exists?
-        @ogg_player = "music123"
+        self.ogg_player = "music123"
         return
       elsif afplay_exists?
-        @ogg_player = "afplay"
+        self.ogg_player = "afplay"
         return
       elsif mplayer_exists?
-        @ogg_player = "mplayer -nolirc -noconfig all"
+        self.ogg_player = "mplayer -nolirc -noconfig all"
       elsif play_exists?
-        @ogg_player = "play"
+        self.ogg_player = "play"
       #elsif RUBY_PLATFORM.downcase.include?('mac') || RUBY_PLATFORM.downcase.include?('darwin')
-      #  @ogg_player = "afplay"
+      #  ogg_player = "afplay"
       #  return
       #elsif (require 'rbconfig') && ['mac','darwin'].include?(RbConfig::CONFIG['host_os'])
-      #  @ogg_player = "afplay"
+      #  ogg_player = "afplay"
+      else
+        raise NoOggPlayerFoundException, "Could not find an Ogg Vorbis player"
       end
     end
 
     def set_mp3_player
       if mpg123_exists?
-        @mp3_player = "mpg123"
+        self.mp3_player = "mpg123"
         return
       elsif mpg321_exists?
-        @mp3_player = "mpg321"
+        self.mp3_player = "mpg321"
         return
       elsif music123_exists?
-        @mp3_player = "music123"
+        self.mp3_player = "music123"
         return
       elsif afplay_exists?
-        @mp3_player = "afplay"
+        self.mp3_player = "afplay"
         return
       elsif mplayer_exists?
-        @mp3_player = "mplayer -nolirc -noconfig all"
+        self.mp3_player = "mplayer -nolirc -noconfig all"
       elsif play_exists?
-        @mp3_player = "play"
+        self.mp3_player = "play"
       #elsif RUBY_PLATFORM.downcase.include?('mac') || RUBY_PLATFORM.downcase.include?('darwin')
-      #  @mp3_player = "afplay"
+      #  mp3_player = "afplay"
       #  return
       #elsif (require 'rbconfig') && ['mac','darwin'].include?(RbConfig::CONFIG['host_os'])
-      #  @mp3_player = "afplay"
+      #  mp3_player = "afplay"
+      else
+        raise NoMP3PlayerFoundException, "Could not find an MP3 player"
       end
     end
 
@@ -132,27 +138,30 @@ module JimmyJukebox
       load_top_level_directories_from_file
     end
 
+    def music_directories
+      @music_directories ||= []
+    end
+
     def generate_directories_list
-      @music_directories = []
       # ARGV[0] can be "jazz.txt" (a file holding directory names), "~/Music/JAZZ" (a directory path) or nil
       # puts "ARGV: " + ARGV.inspect + " (" + ARGV.class.to_s + ")"
       if ARGV.empty?
-        @music_directories << default_music_dir
+        music_directories << default_music_dir
       elsif JAZZ_ARTISTS.keys.include?(ARGV[0].to_sym)
-        @music_directories << default_music_dir + key_to_subdir_name(ARGV[0].to_sym)
+        music_directories << default_music_dir + key_to_subdir_name(ARGV[0].to_sym)
       elsif is_a_txt_file?(ARGV[0])
         set_music_directories_from_file
       elsif is_a_directory?(ARGV[0])
-        @music_directories << File.expand_path(ARGV[0])
+        music_directories << File.expand_path(ARGV[0])
       else
-        @music_directories << default_music_dir
+        music_directories << default_music_dir
       end
       create_nonexistent_music_directories
       add_all_subdirectories
     end
 
     def create_nonexistent_music_directories
-      @music_directories.each do |md|
+      music_directories.each do |md|
         FileUtils.mkdir_p(md) unless Dir.exists?(md)
       end
     end
@@ -171,32 +180,30 @@ module JimmyJukebox
       File.open(@music_directories_file, "r") do |inf|
         while (line = inf.gets)
           line.strip!
-          @music_directories << File.expand_path(line)
+          music_directories << File.expand_path(line)
         end
       end
     end
 
     def add_all_subdirectories
       new_dirs = []
-      @music_directories.each do |dir|
-        Dir.chdir(dir)
-        new_dirs = new_dirs + Dir.glob("**/").map { |dir_name| File.expand_path(dir_name) }
+      music_directories.each do |dir|
+        new_dirs = new_dirs + Dir.glob(File.join(dir,"**/")).map { |dir_name| File.expand_path(dir_name) }
       end
-      @music_directories = @music_directories + new_dirs
+      self.music_directories = music_directories + new_dirs
     end
 
     def generate_song_list
-      @songs = []
-      @music_directories.each do |music_dir|
+      music_directories.each do |music_dir|
         files = Dir.entries(File.expand_path(music_dir))
         if "".respond_to?(:force_encoding)                                  # Ruby 1.8 doesn't have string encoding or String#force_encoding
          files.delete_if { |f| !f.force_encoding("UTF-8").valid_encoding? } # avoid "invalid byte sequence in UTF-8 (ArgumentError)"
         end
         files.delete_if { |f| !f.match(/.*\.mp3/i) && !f.match(/.*\.ogg/i) }
         files.map! { |f| File.expand_path(music_dir) + '/' + f }
-        @songs = @songs + files
+        files.each { |f| songs << f }
       end
-      puts "WARNING: JimmyJukebox could not find any songs" unless @songs.length > 0
+      puts "WARNING: JimmyJukebox could not find any songs" unless songs.length > 0
       #songs = ["~/Music/Artie_Shaw/Georgia On My Mind 1941.mp3",
       #         "~/Music/Jelly_Roll_Morton/High Society 1939.mp3"]
     end

data/lib/jimmy_jukebox/user_interface.rb

@@ -1,43 +1,61 @@
 require 'readline'
 
-jj = Jukebox
+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
+user_input_thread = Thread.new do
+  
+  stty_save = `stty -g`.chomp   # Store state of the terminal
+
+  def display_options
+    p "Press 'p' to (un)pause, 'q' to quit, 'r' for replay previous song, or 's' to skip this song"
+  end
+
+  def display_options_after_delay
+    sleep 0.2
+    display_options
+  end
+
+  class NoPlayLoopThreadException < Exception; end
+
+  begin
+    loop do
+      display_options_after_delay
+      line = Readline.readline('> ', true)
+      case line.strip
+      when "q", "Q"
+        raise Interrupt
+      when "p", "P"
+        raise NoPlayLoopThreadException, "Can't find play_loop_thread" unless play_loop_thread
+        if jj.current_song.paused?
+          p "Unpause requested"
+          jj.unpause_current_song
+        else
+          p "Pause requested"
+          p "To unpause, enter 'p' again"
+          jj.pause_current_song
+        end
+      when "r", "R"
+        p "Replay previous song requested"
+        jj.replay_previous_song
+      when "s", "S"
+        p "Skip song requested"
+        jj.skip_song
       else
-        raise "Can't find play_loop_thread"
+        p "#{line.strip} is not a valid response"
       end
-      puts display_string
-    when "s"
-      puts "Skip song requested"
-      jj.skip_song
-    else
-      puts display_string
     end
+  rescue Interrupt, SystemExit => e
+    p "JimmyJukebox closed by user request. Bye!"
+    jj.quit
+    system('stty', stty_save) unless RUBY_ENGINE == 'jruby' # Restore original terminal state
+    exit
   end
-rescue Interrupt => e
-  puts "\nMusic terminated by user"
-  exit
 end
 
 play_loop_thread.join
+user_input_thread.join
 

data/lib/jimmy_jukebox/version.rb

@@ -1,3 +1,4 @@
 module JimmyJukebox
-  VERSION = '0.3.7'
+  VERSION = '0.4.1'
+  DATE = '2013-02-22'
 end

data/spec/jimmy_jukebox_spec.rb

@@ -1,191 +1,214 @@
 require 'spec_helper'
-require 'fakefs/safe'
-require 'jimmy_jukebox'
+require_relative '../lib/jimmy_jukebox/jukebox'
 include JimmyJukebox
 
 describe Jukebox do
 
+  include FakeFS::SpecHelpers
+
   before(:all) do
     ARGV.clear
-    #ARGV.pop
   end
 
+  let(:jb) { Jukebox.new }
+
   let(:uc) { double('user_config').as_null_object }
  
+
   context "with no command line parameter" do
 
     it "exists" do
-      Jukebox.should_not be_nil
-      Jukebox.quit
+      jb.should_not be_nil
+      jb.quit
     end
 
-    #it "raises exception when no songs available"
-    #  lambda do
-    #    jj = Jukebox.new
-    #  end.should raise_error
-    #end
-
-    it "has a user_config method" do
-      Jukebox.user_config.is_a?(UserConfig)
+    it "calls play_random_song" do
+      jb.stub(:play_random_song).and_return(nil)
+      jb.should_receive(:play_once)
+      jb.play_once
+      jb.quit
     end
 
-    it "has a @user_config instance variable" do
-      Jukebox.instance_variable_get(:@user_config).is_a?(UserConfig)
+    it "raises exception when no songs available" do
+      expect { jb.play_once }.to raise_error(Jukebox::NoSongException)
     end
 
-    it "generates a non-empty song list" do
-      Jukebox.user_config.songs.should_not be_nil
-      Jukebox.user_config.songs.should_not be_empty
-      Jukebox.user_config.songs.length.should be > 0
+    it "has a user_config method" do
+      jb.user_config.is_a?(UserConfig)
     end
 
-    it "generates a non-empty song list with only mp3 & ogg files" do
-      Jukebox.user_config.songs.each do |song|
-        song.should match(/.*\.mp3|.*\.ogg/i)
-      end
+    it "generates an empty song list" do
+      jb.user_config.songs.should be_empty
+      jb.user_config.songs.length.should == 0
     end
 
-    describe "#play_once" do
+    context "when songs exist" do
 
-      it "should call play_random_song" do
-        Jukebox.should_receive(:play_random_song)
-        Jukebox.play_once
-      end
+      let(:song1) { '/home/xavier/Music/Rock/Beatles/Abbey_Road.mp3' }
+      let(:song2) { '/home/xavier/Music/Rock/Beatles/Sgt_Pepper.mp3' }
+      let(:song3) { '/home/xavier/Music/Rock/Eagles/Hotel_California.ogg' }
 
-      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
+      before do
+        [song1, song2, song3].each do |song|
+          FileUtils.mkdir_p(File.dirname(song))
+          FileUtils.touch(song)
+          Dir.chdir('/home/xavier')
         end
-        sleep 0.1
-        jj.current_song.is_a?(Song)
-        thread.exit
       end
 
-      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
+      it "generates a non-empty song list" do
+        jb.user_config.songs.should_not be_nil
+        jb.user_config.songs.should_not be_empty
+        jb.user_config.songs.length.should == 3
+        jb.user_config.songs.should include(/Abbey_Road.mp3/)
       end
 
-      it "should have a player" do
-        jj = Jukebox
-        thread = Thread.new do
-          Jukebox.play_once
+=begin
+      xit "generates a non-empty song list with only mp3 & ogg files" do
+        jb.user_config.songs.each do |song|
+          song.should match(/.*\.mp3|.*\.ogg/i)
         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
+      describe "#play_once" do
+
+        xit "should call play_random_song" do
+          jb.should_receive(:play_random_song)
+          jb.play_once
         end
-        sleep 0.3
-        jj.current_song.should be_nil
-        thread.exit
-      end
 
-      it "should have a current_song with a playing_pid" do
-        jj = Jukebox
-        thread = Thread.new do
-          jj.play_once
+        xit "should have a current_song" do
+          uc.stub(:mp3_player) {"play"}
+          uc.stub(:ogg_player) {"play"}
+          thread = Thread.new do
+            jb.play_once
+          end
+          sleep 0.1
+          jb.current_song.is_a?(Song)
+          thread.exit
         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
+        xit "should have a current_song with a music_file" do
+          uc.stub(:mp3_player) {"play"}
+          uc.stub(:ogg_player) {"play"}
+          thread = Thread.new do
+            jb.play_once
+          end
+          sleep 0.1
+          jb.current_song.music_file.should match /\.mp3$|\.ogg$/
+          thread.exit
+        xend
+
+        xit "should have a player" do
+          thread = Thread.new do
+            jb.play_once
+          end
+          sleep 0.1
+          jb.current_song.player.should_not be_nil
+          thread.exit
+        end
 
-      it "can pause the current song" do
-        thread = Thread.new do
-          Jukebox.play_once
+        xit "should not have a current_song after song finishes" do
+          thread = Thread.new do
+            jb.play_once
+          end
+          sleep 0.3
+          jb.current_song.should be_nil
+          thread.exit
         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
+        xit "should have a current_song with a playing_pid" do
+          thread = Thread.new do
+            jb.play_once
+          end
+          sleep 0.1
+          jb.current_song.playing_pid.should_not be_nil
+          #jb.should_receive(:terminate_current_song)
+          jb.quit
+          thread.exit
+        end
+
+        xit "triggers play_random_song" do
+          jb.should_receive(:play_random_song)
+          jb.play_once
+        end
+
+        xit "can pause the current song" do
+          thread = Thread.new do
+            jb.play_once
+          end
+          sleep 0.1
+          song_1 = jb.current_song.playing_pid
+          jb.pause_current_song
+          song_2 = jb.current_song.playing_pid
+          song_1.should == song_2
+          jb.current_song.paused?.should be_true
+          jb.quit
+          thread.exit
+        end
+
+        xit "can unpause a paused song" do
+          thread = Thread.new do
+            jb.play_once
+          end
+          sleep 0.05
+          song_1 = jb.current_song
+          jb.current_song.paused?.should be_false
+          jb.pause_current_song
+          song_2 = jb.current_song
+          jb.current_song.paused?.should be_true
+          song_2.should == song_1
+          jb.unpause_current_song
+          jb.current_song.paused?.should be_false
+          song_3 = jb.current_song
+          jb.current_song.paused?.should be_false
+          jb.pause_current_song
+          song_4 = jb.current_song
+          jb.current_song.paused?.should be_true
+          song_4.should == song_3
+          jb.unpause_current_song
+          jb.current_song.paused?.should be_false
+          jb.quit
+          thread.exit
         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
     end
 
+  end
+=begin
     describe "#play_loop" do
 
-      it "plays multiple songs" do
+      xit "plays multiple songs" do
         thread = Thread.new do
-          Jukebox.play_loop
+          jb.play_loop
         end
         sleep 0.1
-        song1 = Jukebox.current_song.playing_pid
+        song1 = jb.current_song.playing_pid
         song1.should_not be_nil
-        Jukebox.continuous_play.should be_true
+        jb.continuous_play.should be_true
         sleep 0.2
-        song2 = Jukebox.current_song.playing_pid
+        song2 = jb.current_song.playing_pid
         song2.should_not be_nil
         song2.should_not == song1
-        Jukebox.quit
+        jb.quit
         thread.exit
       end
 
-      it "can skip a song" do
+      xit "can skip a song" do
         thread = Thread.new do
-          Jukebox.play_loop
+          jb.play_loop
         end
         sleep 0.2
-        song_1 = Jukebox.current_song
-        Jukebox.skip_song
+        song_1 = jb.current_song
+        jb.skip_song
         sleep 0.2
-        song_2 = Jukebox.current_song
-        Jukebox.skip_song
+        song_2 = jb.current_song
+        jb.skip_song
         sleep 0.2
-        song_3 = Jukebox.current_song
+        song_3 = jb.current_song
         song_1.should_not == song_2 || song_2.should_not == song_3
-        Jukebox.quit
+        jb.quit
         thread.exit
       end
 
@@ -200,23 +223,25 @@ describe Jukebox do
       ARGV << File.expand_path("~/Music")
     end
 
-    it "can skip a song" do
+    xit "can skip a song" do
       thread = Thread.new do
-        Jukebox.play_loop
+        jb.play_loop
       end
       sleep 0.2
-      song_1 = Jukebox.current_song
-      Jukebox.skip_song
+      song_1 = jb.current_song
+      jb.skip_song
       sleep 0.2
-      song_2 = Jukebox.current_song
-      Jukebox.skip_song
+      song_2 = jb.current_song
+      jb.skip_song
       sleep 0.2
-      song_3 = Jukebox.current_song
+      song_3 = jb.current_song
       song_1.should_not == song_2 || song_2.should_not == song_3
-      Jukebox.quit
+      jb.quit
       thread.exit
     end
 
   end
 
+=end
+
 end

data/spec/song_loader_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'rubygems'
 require 'rspec/mocks'
 require 'fakeweb' # apparently must be required before fakefs
 FakeWeb.allow_net_connect = false