jimmy_jukebox 0.4.1 → 0.4.2

data/bin/play_jukebox

@@ -1,12 +1,14 @@
 #!/usr/bin/env ruby
 
-if RUBY_ENGINE =~ /jruby/
+$running_jruby = defined?(JRUBY_VERSION) || (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby') || RUBY_PLATFORM == 'java'
+
+if $running_jruby
   begin
     require 'spoon'
     require 'readline'
   rescue LoadError => e
     if e.message =~ /spoon/
-      p "*** You must install the 'spoon' gem to use JimmyJukebox on JRuby ***"
+      p "*** You must run 'gem install spoon' before using JimmyJukebox on JRuby ***"
       exit
     elsif e.message =~ /readline/
       p "*** You must install 'readline' to use JimmyJukebox on JRuby ***"
@@ -24,7 +26,7 @@ else
       p "*** You must install 'readline' or the 'rb-readline' gem to use JimmyJukebox in Ruby ***"
       exit
     elsif e.message =~ /posix/ || e.message =~ /spawn/
-      p "*** You must install the 'posix-spawn' gem to use JimmyJukebox in Ruby ***"
+      p "*** You must run 'gem install posix-spawn' before using JimmyJukebox in Ruby ***"
       exit
     else
       raise

data/lib/jimmy_jukebox/artists.rb

@@ -26,6 +26,7 @@ module Artists
   :lh   => "lionel_hampton",
   :md   => "miles_davis",
   :odjb => "original_dixieland_jazz_band",
+  :rt   => "ragtime",
   :rn   => "red_norvo",
   :sb   => "sidney_bechet"
   }
@@ -44,5 +45,4 @@ module Artists
     value.to_s.split("_").map! { |name_component| name_component.capitalize }.join("") + '.yml'
   end
 
-
 end

data/lib/jimmy_jukebox/jukebox.rb

@@ -8,8 +8,8 @@ module JimmyJukebox
     class NoCurrentSongException < Exception; end
     class NoPreviousSongException < Exception; end
 
-    attr_accessor :current_song, :continuous_play
-    attr_writer   :user_config, :previous_song, :next_song, :playing
+    attr_accessor :current_song, :continuous_play, :songs_played
+    attr_writer   :user_config, :next_song, :playing
 
     def initialize(new_user_config = UserConfig.new, continuous_play = true)
       self.user_config = new_user_config
@@ -19,7 +19,7 @@ module JimmyJukebox
     def play_loop
       loop do
         if continuous_play && !playing?
-          p "Playing random song"
+          p "Playing next song"
           play_next_song
         else
           sleep 0.1
@@ -28,7 +28,10 @@ module JimmyJukebox
     end
 
     def next_song
-      @next_song ? @next_song : random_song
+      # reset @next_song each time it's accessed
+      current_next_song = @next_song ? @next_song : random_song
+      @next_song = random_song
+      current_next_song
     end
 
     def play_next_song
@@ -45,27 +48,37 @@ module JimmyJukebox
     end
 
     def previous_song
-      @previous_song || nil
+      if songs_played.length >= 2
+        songs_played[songs_played.length-2]
+      else
+        nil
+      end
+    end
+
+    def songs_played
+      @songs_played ||= []
     end
 
     def replay_previous_song
-      if previous_song
+      if previous_song && current_song
+        enable_continuous_play
+        self.next_song = previous_song
         p "Replaying #{previous_song.music_file}"
-        #terminate_current_song
-        play_song(previous_song)
+        current_song.terminate
+        self.current_song = nil
+        self.playing = false
       else
         raise NoPreviousSongException, "No previous song"
       end
     end
 
     def skip_song
-      enable_continuous_play
       if current_song
+        enable_continuous_play
         p "Skipping #{current_song.music_file}"
         #play_random_song
-        self.previous_song = current_song
+        current_song.terminate
         self.current_song = nil
-        previous_song.terminate
         self.playing = false
       else
         raise NoCurrentSongException, "No current_song"
@@ -90,41 +103,39 @@ module JimmyJukebox
     end
 
     def play_random_song
-      p "Inside play_random_song"
       play_song(random_song)
     end
 
     def enable_continuous_play
       self.continuous_play = true
-      p "Enabled continuous_play"
     end
 
     def disable_continuous_play
       self.continuous_play = false
-      p "Disabled continuous_play"
     end
 
     def play_song(song)
-      terminate_current_song if current_song
       self.playing = true
-      p "Setting current_song = #{song.music_file}"
+      terminate_current_song(play_another: false) if current_song
       self.current_song = song
+      self.songs_played << song
       current_song.play(user_config, self)
       p "Finished playing"
-      self.previous_song = current_song
+      p "Songs played: " + songs_played.to_s
       self.current_song = nil
       self.playing = false
     rescue Song::SongTerminatedPrematurelyException
       p "Song ended prematurely"
     end
 
-    def terminate_current_song
+    def terminate_current_song(opts=nil)
+      # By default, stops song and lets a new song play automatically
+      # To prevent another song from playing automatically, pass "play_another: false"
       if current_song
         p "Terminating #{current_song.music_file}"
         current_song.terminate
-        self.previous_song = current_song
         self.current_song = nil
-        self.playing = false
+        self.playing = (opts && opts[:play_another]) ? !play_another : false
       else
         raise NoCurrentSongException, "No current_song"
       end

data/lib/jimmy_jukebox/song.rb

@@ -37,16 +37,15 @@ module JimmyJukebox
       gpid == 0 ? nil : gpid
     end
 
+    def process_group_id
+      Process.getpgid(playing_pid)
+    end
+
     def pause
       self.paused = true
-      # jruby doesn't seem to handle system() correctly
-      # trying backticks
-      # system("kill -s STOP #{playing_pid}") if playing_pid
       if grandchild_pid
-        p "Pausing"
         `kill -s STOP #{grandchild_pid}`
       elsif playing_pid
-        p "Pausing"
         `kill -s STOP #{playing_pid}`
       else
         raise NoPlayingPidException, "*** Can't pause song because can't find playing_pid #{playing_pid} ***"
@@ -55,14 +54,9 @@ module JimmyJukebox
 
     def unpause
       self.paused = false
-      # jruby doesn't seem to handle system() correctly
-      # trying backticks
-      #system("kill -s CONT #{playing_pid}") if playing_pid
       if grandchild_pid
-        p "Unpausing"
         `kill -s CONT #{grandchild_pid}`
       elsif playing_pid
-        p "Unpausing"
         `kill -s CONT #{playing_pid}`
       else
         raise NoPlayingPidException, "*** Can't unpause song because can't find playing_pid #{playing_pid} ***"
@@ -77,17 +71,11 @@ module JimmyJukebox
         p "killed #{grandpid}"
       end
       `kill #{playpid}`
-      p "killed #{playpid}"
     end
 
     def terminate
       self.paused = false
-      #`killall #{player}`
       self.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
       if playing_pid
         kill_playing_pid_and_children
         self.playing_pid = nil
@@ -118,38 +106,24 @@ module JimmyJukebox
       music_file_path = File.expand_path(music_file)
       run_command(player, music_file_path)
       p "playing_pid = " + playing_pid.to_s
-      #system_yield_pid(player, music_file_path) do |pid|
-      #  self.playing_pid = pid 
-      #end
-      #if running_jruby?
-        Process.waitpid(playing_pid) # Waits for a child process to exit, returns its process id, and sets $? to a Process::Status object
-      #else
-      #  Process::waitpid(playing_pid)
-      #end
-      p "Stopped waiting"
+      Process.waitpid(playing_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
     end
 
   end
 
-  def running_jruby?
-    defined?(JRUBY_VERSION) || RUBY_ENGINE == 'jruby' || RUBY_PLATFORM == 'java'
-  end
-
   def run_command(command, arg)
-    if running_jruby?
+    # make system call and get pid so you can pause/terminate process
+    if $running_jruby
       pid = Spoon.spawnp(command,arg)
     else
       begin
         pid = POSIX::Spawn::spawn(command + ' ' + arg)
-        #pgid = Process.getpgid(pid)
-        #child = POSIX::Spawn::Child.new(command + ' ' + arg)
-        #pid = child.status.pid
         
-        # create and run block in subprocess (which will terminate with status 0), capture subprocess pid
+        # posix/spawn is much faster than fork-exec
         #pid = Process.fork do
-        #  exec(command + ' ' + arg)  # replace new process with system call
-        #  exit! 127                  # exit process and return exit status 127; should never be reached
+        #  exec(command + ' ' + arg)
+        #  exit! 127                  # should never be reached
         #end
       rescue NotImplementedError
         raise CannotSpawnProcessException, "*** Cannot play music because we found neither Spoon.spawnp (for JRuby) nor Process.fork (for MRI) ***"
@@ -158,26 +132,4 @@ module JimmyJukebox
     self.playing_pid = pid
   end
 
-  # make system call and get pid so you can terminate process
-  def system_yield_pid(command,arg)
-    # would like to use Process.respond_to?(:fork) but JRuby mistakenly returns true
-    if running_jruby?
-      pid = Spoon.spawnp(command,arg)
-    else
-      begin
-        #spawn(command + ' ' + arg)
-        #pid = POSIX::Spawn::spawn(command + ' ' + arg)
-        
-        # create and run block in subprocess (which will terminate with status 0), capture subprocess pid
-        pid = Process.fork do
-          exec(command + ' ' + arg)  # replace new process with system call
-          exit! 127                  # exit process and return exit status 127; should never be reached
-        end
-      rescue NotImplementedError
-        raise CannotSpawnProcessException, "*** Cannot play music because we found neither Spoon.spawnp (for JRuby) nor Process.fork (for MRI) ***"
-      end
-    end
-    yield pid if block_given? # call block, passing in the subprocess pid
-  end
-
 end

data/lib/jimmy_jukebox/user_interface.rb

@@ -51,7 +51,7 @@ user_input_thread = Thread.new do
   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
+    system('stty', stty_save) unless $running_jruby # Restore original terminal state
     exit
   end
 end

data/lib/jimmy_jukebox/version.rb

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

metadata

@@ -2,7 +2,7 @@
 name: jimmy_jukebox
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - James Lavin