anyplayer 1.1.1 → 1.2.0

data/lib/anyplayer/players/xmms2.rb

@@ -1,77 +1,87 @@
 class Anyplayer::Xmms2 < Anyplayer::Player
   def playpause
-    xmms2 'toggle'
+    xmms2 "toggle"
   end
 
   def play
-    xmms2 'play'
+    xmms2 "play"
   end
 
   def pause
-    xmms2 'pause'
+    xmms2 "pause"
   end
 
   def prev
-    xmms2 'prev'
+    xmms2 "prev"
     super
   end
 
   def next
-    xmms2 'next'
+    xmms2 "next"
     super
   end
 
   def voldown
-    current = volume.to_i
-    new_volume = (current < 11 ? 0 : current - 10)
-    xmms2 "server volume #{new_volume}"
+    set_volume volume - 10
   end
 
   def volup
-    current = volume.to_i
-    new_volume = (current > 89 ? 100 : current + 10)
-    xmms2 "server volume #{new_volume}"
+    set_volume volume + 10
   end
 
   def volume
     # currently just the first (left?) channel
-    xmms2('server volume').split("\n").first.sub(/([^0-9]*)/, '')
-    $1
+    xmms2("server volume").split("\n").first.sub(/([^0-9]*)/, "").to_i
   end
 
   def track
-    xmms2 "status -f '${title}'"
+    xmms2 "current -f '${title}'"
   end
 
   def artist
-    xmms2 "status -f '${artist}'"
+    xmms2 "current -f '${artist}'"
   end
 
   def album
-    xmms2 "status -f '${album}'"
+    xmms2 "current -f '${album}'"
   end
 
   def playing?
-    xmms2("status -f '${playback_status}'") == "Playing"
+    xmms2("current -f '${playback_status}'") == "Playing"
   end
 
   def paused?
-    xmms2("status -f '${playback_status}'") == "Paused"
+    xmms2("current -f '${playback_status}'") == "Paused"
   end
 
   def launched?
     # xmms2 autolaunches the daemon, so this should always be true
-    %x(xmms2 status 2> /dev/null)
+    %x(xmms2 current 2> /dev/null)
     $? == 0
   end
 
   def host
-    ENV['XMMS_PATH'] || super
+    ENV["XMMS_PATH"] || super
+  end
+
+  def platforms
+    [:unix, :linux]
   end
 
   private
-    def xmms2(command)
-      %x(xmms2 #{command}).split("\n").first.strip
-    end
-end
 
+  def xmms2(command)
+    ret = %x(xmms2 #{command}).split("\n").first
+    ret ? ret.strip : ""
+  end
+
+  def set_volume(num)
+    num = if num < 0
+            0
+          elsif num > 100
+            100
+          end
+
+    xmms2 "server volume #{num}"
+  end
+end

data/lib/anyplayer/selector.rb

@@ -1,4 +1,7 @@
-# The Selector is the tool that will find you the currently running player on your platform
+require "rbconfig"
+
+# The Selector is the tool that will find you the currently running player
+# on your platform.
 #
 # Example:
 #
@@ -7,62 +10,90 @@
 #   player = selector.player
 #
 # Needs the PLAYERS constant to contain a list of players.
+module Anyplayer
+  class Selector
+    attr_accessor :verbose
+    attr_reader :errors
 
-class Anyplayer::Selector
-  attr_accessor :verbose
-  attr_reader :errors
+    def initialize
+      @verbose = false
+      @errors = []
+    end
 
-  def initialize
-    @verbose = false
-    @errors = []
-  end
+    # Returns an instance of the first music player that's launched
+    def player
+      PLAYERS.each do |player|
+        player_load(player) || next
 
-  # Returns an instance of the first music player that's launched
-  def player
-    players_for_this_platform.each { |player|
-      player_load(player) or next
-      instance = player_class(player).new
-      return instance if player_launched(instance)
-    }
-    nil
-  end
+        instance = player_class(player).new
+        player_on_platform?(instance) || next
 
+        return instance if player_launched?(instance)
+      end
+      nil
+    end
 
-  private
+    private
 
-    def players_for_this_platform
-      players = Anyplayer::PLAYERS
-      players.reject! { |player| player =~ /_mac$/ } if RUBY_PLATFORM !~ /darwin/
-      players.reject! { |player| player =~ /_windows$/ } if RUBY_PLATFORM !~ /cygwin|mswin|mingw|bccwin|wince|emx/
-      players
+    def platform
+      @platform ||= begin
+        host_os = RbConfig::CONFIG["host_os"]
+        case host_os
+        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+          :windows
+        when /darwin|mac os/
+          :mac
+        when /linux/
+          :linux
+        when /solaris|bsd/
+          :unix
+        else
+          @errors << "Unknown operating system #{host_os.inspect}"
+          nil
+        end
+      end
     end
 
     def player_load(player)
+      log "#{player}:"
       begin
         require "anyplayer/players/#{player}"
-        $stderr.puts "Loaded #{player}" if verbose
+        log "  loaded"
         true
       rescue LoadError => e
-        $stderr.puts "Could not load #{player}" if verbose
+        log "  #{e.message}"
         @errors << "Error loading #{player}: #{e.message}"
         false
       end
     end
 
-    def player_class(player)
-      camelized = player.to_s.split(/_/).map{ |word| word.capitalize }.join
-      Anyplayer::const_get(camelized)
+    def player_on_platform?(player)
+      result = player.platforms.include?(platform)
+      log "  not on platform" unless result
+      result
     end
 
-    def player_launched(player)
-      $stderr.puts "#{player.name} launched?" if verbose
+    def player_class(player)
+      camelized = player.to_s.split(/_/).map(&:capitalize).join
+      Anyplayer.const_get(camelized)
+    end
 
+    def player_launched?(player)
       seconds = 5
       begin
-        Timeout::timeout(seconds) { player.launched? }
+        Timeout.timeout(seconds) do
+          launched = player.launched?
+          log launched ? "  launched" : "  not launched"
+          launched
+        end
       rescue Timeout::Error
-        $stderr.puts "Timed out after #{seconds} seconds" if verbose
+        log "  timed out after #{seconds} seconds"
         false
       end
     end
+
+    def log(text)
+      $stderr.puts text if verbose
+    end
+  end
 end

data/lib/anyplayer/version.rb

@@ -1,3 +1,3 @@
 module Anyplayer
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/test/anyplayer_test.rb

@@ -1,9 +1,15 @@
 require "test_helper"
 
-class AnyplayerTest < MiniTest::Unit::TestCase
-  # def test_loading_all_players_does_not_explode
-  #   PLAYERS.each do |player|
-  #     require "anyplayer/players/#{player}"
-  #   end
-  # end
+class AnyplayerTest < Minitest::Test
+  def test_loading_all_players_does_not_explode
+    PLAYERS.each do |player|
+      require "anyplayer/players/#{player}"
+    end
+  rescue LoadError
+    # Allow LoadErrors that depend on Windows
+  end
+
+  def test_launched
+    assert_kind_of Anyplayer::Player, Anyplayer.launched
+  end
 end

data/test/command_line_test.rb

@@ -0,0 +1,150 @@
+require "test_helper"
+require "anyplayer/command_line"
+
+class CommandLineTest < Minitest::Test
+  USAGE = "Usage: anyplayer [-v] [command]
+
+Where command is one of: playpause, play, pause, next, prev, voldown, volup, volume, track, artist, album, vote, name, launched, paused, playing.
+
+Player connected: Fake Player.
+"
+
+  def setup
+    @player = flexmock(:player)
+    @selector = flexmock(:selector)
+    @selector.should_receive(:player).and_return(@player)
+    flexmock(Anyplayer::Selector).should_receive(:new).and_return(@selector)
+  end
+
+  def test_no_command
+    flexmock(@player).should_receive(:name).once.and_return("Fake Player")
+    flexmock($stderr).should_receive(:puts).once.with(USAGE)
+    flexmock(Anyplayer::CommandLine).should_receive(:exit).once.with(1)
+    Anyplayer::CommandLine.parse(%w())
+  end
+
+  def test_wrong_command
+    flexmock(@player).should_receive(:name).once.and_return("Fake Player")
+    flexmock($stderr).should_receive(:puts).once.with(USAGE)
+    flexmock(Anyplayer::CommandLine).should_receive(:exit).once.with(1)
+    Anyplayer::CommandLine.parse(%w(err))
+  end
+
+  def test_verbose
+    # flexmock(@player).should_receive(:name).once.and_return("Foo")
+    flexmock(@player).should_receive(:play).once
+    flexmock(@selector).should_receive(:verbose=).once.with(true)
+    flexmock($stderr).should_receive(:puts).once.with(/^anyplayer v[0-9.]+$/)
+    Anyplayer::CommandLine.parse(%w(-v play))
+  end
+
+  # Actions
+
+  def test_playpause
+    flexmock(@player).should_receive(:playpause).once
+    Anyplayer::CommandLine.parse(%w(playpause))
+  end
+
+  def test_play
+    flexmock(@player).should_receive(:play).once
+    Anyplayer::CommandLine.parse(%w(play))
+  end
+
+  def test_pause
+    flexmock(@player).should_receive(:pause).once
+    Anyplayer::CommandLine.parse(%w(pause))
+  end
+
+  def test_next
+    flexmock(@player).should_receive(:next).once
+    Anyplayer::CommandLine.parse(%w(next))
+  end
+
+  def test_prev
+    flexmock(@player).should_receive(:prev).once
+    Anyplayer::CommandLine.parse(%w(prev))
+  end
+
+  def test_voldown
+    flexmock(@player).should_receive(:voldown).once
+    Anyplayer::CommandLine.parse(%w(voldown))
+  end
+
+  def test_volup
+    flexmock(@player).should_receive(:volup).once
+    Anyplayer::CommandLine.parse(%w(volup))
+  end
+
+  def test_vote
+    flexmock(@player).should_receive(:vote).once
+    Anyplayer::CommandLine.parse(%w(vote))
+  end
+
+  def test_volume
+    flexmock(@player).should_receive(:volume).once.and_return(42)
+    flexmock($stdout).should_receive(:puts).once.with(42)
+    Anyplayer::CommandLine.parse(%w(volume))
+  end
+
+  def test_track
+    flexmock(@player).should_receive(:track).once.and_return("Foo")
+    flexmock($stdout).should_receive(:puts).once.with("Foo")
+    Anyplayer::CommandLine.parse(%w(track))
+  end
+
+  def test_artist
+    flexmock(@player).should_receive(:artist).once.and_return("Foo")
+    flexmock($stdout).should_receive(:puts).once.with("Foo")
+    Anyplayer::CommandLine.parse(%w(artist))
+  end
+
+  def test_album
+    flexmock(@player).should_receive(:album).once.and_return("Foo")
+    flexmock($stdout).should_receive(:puts).once.with("Foo")
+    Anyplayer::CommandLine.parse(%w(album))
+  end
+
+  def test_name
+    flexmock(@player).should_receive(:name).once.and_return("Foo")
+    flexmock($stdout).should_receive(:puts).once.with("Foo")
+    Anyplayer::CommandLine.parse(%w(name))
+  end
+
+  # Booleans
+
+  def test_launched_true
+    flexmock(Anyplayer::CommandLine).should_receive(:exit) # .with(1)
+    flexmock(@player).should_receive(:launched?).once.and_return(true)
+    Anyplayer::CommandLine.parse(%w(launched))
+  end
+
+  def test_launched_false
+    flexmock(Anyplayer::CommandLine).should_receive(:exit) # .with(0)
+    flexmock(@player).should_receive(:launched?).once.and_return(false)
+    Anyplayer::CommandLine.parse(%w(launched))
+  end
+
+  def test_playing_true
+    flexmock(Anyplayer::CommandLine).should_receive(:exit).once # .with(1)
+    flexmock(@player).should_receive(:playing?).once.and_return(true)
+    Anyplayer::CommandLine.parse(%w(playing))
+  end
+
+  def test_playing_false
+    flexmock(Anyplayer::CommandLine).should_receive(:exit).once # .with(0)
+    flexmock(@player).should_receive(:playing?).once.and_return(false)
+    Anyplayer::CommandLine.parse(%w(playing))
+  end
+
+  def test_paused_true
+    flexmock(Anyplayer::CommandLine).should_receive(:exit).once # .with(1)
+    flexmock(@player).should_receive(:paused?).once.and_return(true)
+    Anyplayer::CommandLine.parse(%w(paused))
+  end
+
+  def test_paused_false
+    flexmock(Anyplayer::CommandLine).should_receive(:exit).once # .with(0)
+    flexmock(@player).should_receive(:paused?).once.and_return(false)
+    Anyplayer::CommandLine.parse(%w(paused))
+  end
+end

data/test/player_test.rb

@@ -1,12 +1,51 @@
 require "test_helper"
 
-class PlayerTest < MiniTest::Unit::TestCase
-  include FlexMock::TestCase
-
+class PlayerTest < Minitest::Test
   def setup
     @player = Noplayer.new
   end
 
+  # Default name
+
+  def test_default_name
+    assert_equal "Noplayer", @player.name
+  end
+
+  def test_default_name_should_remove_namespace
+    flexmock(@player).should_receive(:class).and_return("Foo::Bar")
+    assert_equal "Bar", @player.name
+  end
+
+  # Default paused?
+
+  def test_paused_is_false_if_not_playing
+    flexmock(@player).should_receive(:playing?).once.and_return(false)
+    assert @player.paused?
+  end
+
+  def test_paused_is_true_if_not_paused
+    flexmock(@player).should_receive(:playing?).once.and_return(true)
+    assert !@player.paused?
+  end
+
+  # Default playpause
+
+  def test_playpause_toggles_play
+    flexmock(@player).should_receive(:paused?).once.and_return(true)
+    flexmock(@player).should_receive(:play).once
+
+    @player.playpause
+  end
+
+  def test_playpause_toggles_pause
+    flexmock(@player).should_receive(:paused?).once.and_return(false)
+    flexmock(@player).should_receive(:pause).once
+
+    @player.playpause
+  end
+
+  # Votes
+
   def test_votes
     Player::DEFAULT_VOTES_TO_SKIP.times do |i|
       @player.vote
@@ -16,7 +55,7 @@ class PlayerTest < MiniTest::Unit::TestCase
         assert_equal @player.votes, 0
       else
         assert_equal @player.votes, i + 1
-     end
+      end
     end
   end
 
@@ -45,9 +84,7 @@ class PlayerTest < MiniTest::Unit::TestCase
         assert_equal @player.votes, 0
       else
         assert_equal @player.votes, i + 1
-     end
+      end
     end
   end
-
-
 end