plllayer 0.0.3 → 0.0.4

data/README.md

@@ -0,0 +1,89 @@
+# plllayer
+
+`plllayer` provides a Ruby interface to an external media player, such as `mplayer`.
+
+It takes a playlist to play (which may just be an `Array` of `String`s containing the paths to the audio files), and lets you control playback as the playlist plays, with commands such as `pause`, `resume`, `seek`, `skip`, and so on.
+
+## Install
+
+    $ gem install plllayer
+
+## Example
+
+Here's how to play your music library in random order:
+
+    $ irb
+    irb> require "plllayer"
+      => true
+    irb> player = Plllayer.new(Dir["Music/**/*.{mp3,m4a,ogg}"])
+      => #<Plllayer: ... >
+    irb> player.shuffle
+      => true
+    irb> player.play
+      => true
+    irb>
+
+Then, while it's playing, you can type `player.track` to see what song it's playing, `player.skip` to skip to the next song, and so on.
+
+## Usage
+
+Make a `Plllayer` like this:
+
+    player = Plllayer.new
+
+This initializes a `Plllayer` with an empty playlist, and will use whatever external audio player is available on the system. You can also pass in an initial playlist, or specify what external audio player you want to use:
+
+    player = Plllayer.new(playlist)
+    player = Plllayer.new(external_player: :mplayer)
+
+Only `mplayer` is supported at the moment.
+
+### Playlists
+
+A playlist is just an `Array` of tracks. A track is either a `String` containing the path to an audio file, or an object with a `#location` attribute that returns the path.
+
+A singleton playlist, with only one track, doesn't need to be in an `Array`. That's ugly. You can just pass a track object to any method that expects a playlist and it'll understand.
+
+To tell the `Plllayer` what playlist to play, either initialize the `Plllayer` with the playlist or use `Plllayer#append`:
+
+    player = Plllayer.new
+    player.append(playlist)
+    player << more_tracks    # the << operator is an alias for append
+
+The playlist can be accessed by `Plllayer#playlist`.
+
+The playlist can be shuffled using `Plllayer#shuffle`:
+
+    player.shuffle
+
+If one of the tracks is currently playing, it will be kept at the top of the playlist while the rest of the tracks will be shuffled.
+
+The playlist can also be sorted:
+
+    player.sort
+
+This delegates to Ruby's `Array#sort`, which sorts the tracks using their `<=>` method. This also means you can pass a block to compare tracks by, like this:
+
+    player.sort { |a, b| [a.artist, a.album, a.track_number] <=> [b.artist, b.album, b.track_number] }
+
+This is safe to do when a track is currently playing, and then the next track that plays will be whatever comes next in the sorted playlist.
+
+Lastly, the player's playlist can be reset to an empty playlist using `Plllayer#clear`:
+
+    player.clear
+
+This stops playback if it's currently playing.
+
+### Playback commands
+
+There are many commands that influence playback. Think of them as buttons on a physical media player: you can push them even when they don't apply to the state of the player. They always return false if this is the case, otherwise they return a truthy value.
+
+See `lib/plllayer.rb` for all the available commands, with documentation.
+
+## Todo
+
+* Support multiple external players
+* Work around mplayer's bug where it reports the length of the track totally wrong
+* Fix bug with mplayer returning weird answers sometimes
+* Write tests
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+

data/lib/plllayer/synchronize.rb

@@ -0,0 +1,11 @@
+class Module
+  def synchronize(method, mutex_name)
+    alias_method :"_unsynchronized_#{method}", method.to_sym
+    define_method(method.to_sym) do |*args, &blk|
+      instance_variable_get(mutex_name.to_sym).synchronize do
+        send(:"_unsynchronized_#{method}", *args, &blk)
+      end
+    end
+  end
+end
+

data/lib/plllayer.rb

@@ -1,6 +1,8 @@
 require "open4"
 
-require "plllayer/time_helpers.rb"
+require "plllayer/time_helpers"
+require "plllayer/synchronize"
+
 require "plllayer/single_player"
 require "plllayer/single_players/mplayer"
 require "plllayer/single_players/nop"
@@ -49,6 +51,8 @@ class Plllayer
     @paused = false
     @playing = false
     @repeat_mode = nil
+
+    @index_mutex = Mutex.new
   end
 
   # Append tracks to the playlist. Can be done while the playlist is playing.
@@ -57,8 +61,8 @@ class Plllayer
   # An ArgumentError is raised when you try to pass a non-track.
   #
   # This method is aliased as the << operator.
-  def append(tracks)
-    tracks = Array(tracks)
+  def append(*tracks)
+    tracks = tracks.flatten
     tracks.each do |track|
       if !track.is_a?(String) && !track.respond_to?(:location)
         raise ArgumentError, "a #{track.class} is not a track (try adding a #location method)"
@@ -67,8 +71,74 @@ class Plllayer
     @playlist += tracks
     @playlist.dup
   end
+  synchronize :append, :@index_mutex
   alias :<< :append
 
+  # Insert one or more tracks in the playlist, right after the currently-playing
+  # track. If no track is playing, insert to the head of the playlist.
+  def insert(*tracks)
+    after = @index || -1
+    _unsynchronized_insert_at(after + 1, *tracks)
+    @playlist.dup
+  end
+  synchronize :insert, :@index_mutex
+
+  # Insert one or more tracks anywhere in the playlist. A negative index may be
+  # given to refer to the end of the playlist.
+  def insert_at(index, *tracks)
+    index = @playlist.length + index + 1 if index < 0
+    unless (0..@playlist.length).include? index
+      raise IndexError, "index is out of range"
+    end
+    @playlist.insert(index, *tracks)
+    @index += tracks.length if @index && index < @index
+    @playlist.dup
+  end
+  synchronize :insert_at, :@index_mutex
+
+  # Remove one or more tracks from the playlist by value. If the currently-playing
+  # track is removed, it will start playing the next track in the playlist.
+  def remove(*tracks)
+    n = nil
+    n = tracks.pop if tracks.last.is_a?(Fixnum)
+    index = 0
+    current_track_removed = false
+    @playlist = @playlist.inject([]) do |playlist, track|
+      if tracks.include?(track) && (n.nil? || n > 0)
+        n &&= n - 1
+        @index -= 1 if @index && index < @index
+        current_track_removed = true if index == @index
+      else
+        playlist << track
+      end
+      index += 1
+      playlist
+    end
+    _unsynchronized_change_track(0) if current_track_removed
+    @playlist.dup
+  end
+  synchronize :remove, :@index_mutex
+
+  # Remove one or more tracks from the playlist at a particular index. A negative
+  # index may be given to refer to the end of the playlist. If the currently-playing
+  # track is removed, it will start playing the next track in the playlist.
+  def remove_at(index, n = 1)
+    index = @playlist.length + index if index < 0
+    if @playlist.empty? || index < 0 || index + n > @playlist.length
+      raise IndexError, "index is out of range"
+    end
+    @playlist.slice!(index, n)
+    if @index && @index > index
+      if @index < index + n
+        _unsynchronized_change_track(index - @index)
+      else
+        @index -= n
+      end
+    end
+    @playlist.dup
+  end
+  synchronize :remove_at, :@index_mutex
+
   # Returns a copy of the playlist.
   def playlist
     @playlist.dup
@@ -142,6 +212,7 @@ class Plllayer
       false
     end
   end
+  synchronize :stop, :@index_mutex
 
   # Pause playback.
   def pause
@@ -342,9 +413,6 @@ class Plllayer
 
   def change_track(by = 1, options = {})
     if playing?
-      if options[:auto] && track.respond_to?(:increment_play_count)
-        track.increment_play_count
-      end
       @index += by
       if @repeat_mode
         case @repeat_mode
@@ -358,13 +426,14 @@ class Plllayer
         @single_player.stop if paused? && @single_player.active?
         play_track if not paused?
       else
-        stop
+        _unsynchronized_stop
       end
       true
     else
       false
     end
   end
+  synchronize :change_track, :@index_mutex
 
   def play_track
     @single_player.play(track_path) do

data/plllayer.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name = "plllayer"
-  s.version = "0.0.3"
-  s.date = "2013-02-05"
+  s.version = "0.0.4"
+  s.date = "2013-02-12"
   s.summary = "An audio playback library for Ruby."
   s.description = "plllayer is an audio playback library for Ruby. It is a Ruby interface to some external media player, such as mplayer."
   s.author = "Jeremy Ruten"
@@ -10,8 +10,9 @@ Gem::Specification.new do |s|
   s.license = "MIT"
   s.required_ruby_version = ">= 1.9.2"
 
-  s.files = ["Gemfile", "Gemfile.lock", "LICENSE", "plllayer.gemspec"]
+  s.files = ["Rakefile", "Gemfile", "Gemfile.lock", "LICENSE", "plllayer.gemspec", "README.md"]
   s.files += Dir["lib/**/*.rb"]
+  s.files += Dir["spec/**/*.{rb,mp3}"]
 
   %w(bundler open4).each do |gem_name|
     s.add_runtime_dependency gem_name

data/spec/invalid.mp3

@@ -0,0 +1 @@
+this is an invalid mp3 file. let's see what mplayer does with it.

data/spec/mplayer_spec.rb

@@ -0,0 +1,185 @@
+require "spec_helper"
+
+PATH_3000MS = "spec/3000ms.mp3"
+PATH_10000MS = "spec/10000ms.mp3"
+NONEXISTANT_PATH = "spec/not_here.mp3"
+INVALID_AUDIO_FILE = "spec/invalid.mp3"
+
+describe Plllayer::SinglePlayers::MPlayer do
+  before(:each) do
+    @player = Plllayer::SinglePlayers::MPlayer.new
+  end
+
+  after(:each) do
+    @player.stop
+  end
+
+  it "is not playing by default" do
+    @player.should_not be_playing
+  end
+
+  it "starts playing a single audio file" do
+    @player.play(PATH_3000MS)
+    @player.should be_playing
+    sleep 3.1
+    @player.should_not be_playing
+  end
+
+  it "executes a callback when the track is done playing" do
+    done_playing = false
+    @player.play(PATH_3000MS) { done_playing = true }
+    done_playing.should be_false
+    sleep 3.1
+    done_playing.should be_true
+  end
+
+  it "doesn't play non-existant files" do
+    expect { @player.play NONEXISTANT_PATH }.to raise_error(Plllayer::FileNotFoundError)
+  end
+
+  it "doesn't play invalid audio files" do
+    expect { @player.play INVALID_AUDIO_FILE }.to raise_error(Plllayer::InvalidAudioFileError)
+  end
+
+  it "stops playback" do
+    callback_called = false
+    @player.play(PATH_3000MS) { callback_called = true }
+    @player.stop
+    @player.should_not be_playing
+    sleep 3.1
+    callback_called.should be_false
+  end
+
+  it "pauses and resumes playback" do
+    @player.play(PATH_3000MS)
+    @player.should_not be_paused
+    @player.pause
+    @player.should be_paused
+    position = @player.position
+    sleep 0.3
+    @player.position.should be_within(100).of(position)
+    @player.resume
+    @player.should_not be_paused
+    sleep 0.3
+    @player.position.should_not be_within(100).of(position)
+  end
+
+  it "seeks to an absolute position" do
+    @player.play(PATH_3000MS)
+    @player.pause
+    @player.seek(2000)
+    @player.position.should be_within(100).of(2000)
+  end
+
+  it "seeks to a relative position" do
+    @player.play(PATH_10000MS)
+    @player.pause
+    position = @player.position
+    @player.seek(5000, :relative)
+    @player.position.should be_within(2500).of(position + 5000)
+    @player.seek(-4000, :relative)
+    @player.position.should be_within(2500).of(position + 1000)
+  end
+
+  it "seeks to a percentage position" do
+    @player.play(PATH_3000MS)
+    @player.pause
+    @player.seek(50, :percent)
+    @player.position.should be_within(100).of(1500)
+  end
+
+  it "has a default speed of 1" do
+    @player.speed.should eq(1.0)
+  end
+
+  it "speeds up playback" do
+    @player.speed = 2.0
+    @player.play(PATH_3000MS)
+    @player.should be_playing
+    sleep 2.5
+    @player.should_not be_playing
+  end
+
+  it "slows down playback" do
+    @player.speed = 0.5
+    @player.play(PATH_3000MS)
+    @player.should be_playing
+    sleep 3.1
+    @player.should be_playing
+    sleep 3
+    @player.should_not be_playing
+  end
+
+  it "is not initially muted" do
+    @player.should_not be_muted
+  end
+
+  it "mutes the volume" do
+    @player.mute
+    @player.should be_muted
+  end
+
+  it "unmutes the volume" do
+    @player.mute
+    @player.unmute
+    @player.should_not be_muted
+  end
+
+  it "has a default volume of 50%" do
+    @player.volume.should eq(50)
+  end
+
+  it "changes the volume" do
+    @player.volume = 100
+    @player.volume.should eq(100)
+  end
+
+  it "unmutes when changing the volume" do
+    @player.mute
+    @player.volume = 50
+    @player.should_not be_muted
+  end
+
+  it "keeps track of the position of playback" do
+    @player.play(PATH_3000MS)
+    @player.position.should be_within(100).of(100)
+    sleep 0.5
+    @player.position.should be_within(200).of(600)
+  end
+
+  it "tells you the length of the track in milliseconds" do
+    @player.play(PATH_3000MS)
+    @player.track_length.should be_within(100).of(3000)
+  end
+
+  it "persists speed, volume, and mute settings from track to track" do
+    @player.play(PATH_3000MS)
+    @player.speed = 2.0
+    @player.volume = 5
+    @player.mute
+    @player.stop
+
+    @player.play(PATH_3000MS)
+    @player.speed.should eq(2.0)
+    @player.volume.should eq(5)
+    @player.should be_muted
+  end
+
+  it "returns false for most commands when playback is stopped" do
+    @player.stop.should eq(false)
+    @player.pause.should eq(false)
+    @player.resume.should eq(false)
+    @player.seek(0).should eq(false)
+    @player.position.should eq(false)
+    @player.track_length.should eq(false)
+  end
+
+  it "returns false when double pausing resuming" do
+    @player.play(PATH_3000MS)
+    @player.pause.should be_true
+    @player.pause.should eq(false)
+    @player.resume.should be_true
+    @player.resume.should eq(false)
+  end
+end
+

data/spec/nop_spec.rb

@@ -0,0 +1,162 @@
+require "spec_helper"
+
+PATH = "spec/250ms.mp3"
+NONEXISTANT_PATH = "spec/not_here.mp3"
+
+describe Plllayer::SinglePlayers::Nop do
+  before(:each) do
+    @player = Plllayer::SinglePlayers::Nop.new
+  end
+
+  it "is not playing by default" do
+    @player.should_not be_playing
+  end
+
+  it "starts playing a single audio file" do
+    @player.play PATH
+    @player.should be_playing
+    sleep 0.5
+    @player.should_not be_playing
+  end
+
+  it "executes a callback when the track is done playing" do
+    done_playing = false
+    @player.play(PATH) { done_playing = true }
+    done_playing.should be_false
+    sleep 0.5
+    done_playing.should be_true
+  end
+
+  it "doesn't play non-existant files" do
+    expect { @player.play NONEXISTANT_PATH }.to raise_error(Plllayer::FileNotFoundError)
+  end
+
+  it "stops playback" do
+    callback_called = false
+    @player.play(PATH) { callback_called = true }
+    @player.stop
+    @player.should_not be_playing
+    sleep 0.5
+    callback_called.should be_false
+  end
+
+  it "pauses and resumes playback" do
+    @player.play(PATH)
+    @player.should_not be_paused
+    @player.pause
+    @player.should be_paused
+    position = @player.position
+    sleep 0.2
+    @player.position.should eq(position)
+    @player.resume
+    @player.should_not be_paused
+    sleep 0.2
+    @player.position.should_not eq(position)
+  end
+
+  it "seeks to an absolute position" do
+    @player.play(PATH)
+    @player.pause
+    @player.seek(100)
+    @player.position.should eq(100)
+  end
+
+  it "seeks to a relative position" do
+    @player.play(PATH)
+    @player.pause
+    position = @player.position
+    @player.seek(10, :relative)
+    @player.position.should eq(position + 10)
+    @player.seek(-10, :relative)
+    @player.position.should eq(position)
+  end
+
+  it "seeks to a percentage position" do
+    @player.play(PATH)
+    @player.pause
+    @player.seek(50, :percent)
+    @player.position.should be_within(1).of(125)
+  end
+
+  it "has a default speed of 1" do
+    @player.speed.should eq(1.0)
+  end
+
+  it "speeds up playback" do
+    @player.speed = 2.0
+    @player.play(PATH)
+    @player.should be_playing
+    sleep 0.15
+    @player.should_not be_playing
+  end
+
+  it "slows down playback" do
+    @player.speed = 0.5
+    @player.play(PATH)
+    @player.should be_playing
+    sleep 0.3
+    @player.should be_playing
+    sleep 0.3
+    @player.should_not be_playing
+  end
+
+  it "is not initially muted" do
+    @player.should_not be_muted
+  end
+
+  it "mutes the volume" do
+    @player.mute
+    @player.should be_muted
+  end
+
+  it "unmutes the volume" do
+    @player.mute
+    @player.unmute
+    @player.should_not be_muted
+  end
+
+  it "has a default volume of 50%" do
+    @player.volume.should eq(50)
+  end
+
+  it "changes the volume" do
+    @player.volume = 100
+    @player.volume.should eq(100)
+  end
+
+  it "unmutes when changing the volume" do
+    @player.mute
+    @player.volume = 50
+    @player.should_not be_muted
+  end
+
+  it "keeps track of the position of playback" do
+    @player.play(PATH)
+    @player.position.should be_within(5).of(5)
+    sleep 0.1
+    @player.position.should be_within(10).of(105)
+  end
+
+  it "tells you the length of the track in milliseconds" do
+    @player.play(PATH)
+    @player.track_length.should eq(250)
+  end
+
+  it "returns false for most commands when playback is stopped" do
+    @player.stop.should eq(false)
+    @player.pause.should eq(false)
+    @player.resume.should eq(false)
+    @player.seek(0).should eq(false)
+    @player.position.should eq(false)
+    @player.track_length.should eq(false)
+  end
+
+  it "returns false when double pausing resuming" do
+    @player.play(PATH)
+    @player.pause.should be_true
+    @player.pause.should eq(false)
+    @player.resume.should be_true
+    @player.resume.should eq(false)
+  end
+end
+

data/spec/playback.mp3

@@ -0,0 +1 @@
+this is an invalid mp3 file. let's see what mplayer does with it.

data/spec/plllayer_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+TRACK_1 = "spec/250ms.mp3"
+TRACK_2 = "spec/3000ms.mp3"
+TRACK_3 = "spec/10000ms.mp3"
+
+describe Plllayer do
+  before(:each) do
+    @player = Plllayer.new(external_player: :nop)
+  end
+
+  after(:each) do
+    @player.stop
+  end
+
+  describe "playlist control" do
+    it "appends tracks to the end of the playlist" do
+      @player.append(TRACK_1, TRACK_2)
+      @player << [TRACK_2, TRACK_3]
+      @player.playlist.should eq([TRACK_1, TRACK_2, TRACK_2, TRACK_3])
+    end
+
+    it "inserts tracks anywhere in the playlist" do
+      @player.insert_at(0, TRACK_1)
+      @player.playlist.should eq([TRACK_1])
+      @player.insert_at(0, TRACK_2)
+      @player.playlist.should eq([TRACK_2, TRACK_1])
+      @player.insert_at(1, TRACK_3)
+      @player.playlist.should eq([TRACK_2, TRACK_3, TRACK_1])
+      @player.insert_at(3, TRACK_1, TRACK_2, TRACK_3)
+      @player.playlist.should eq([TRACK_2, TRACK_3, TRACK_1, TRACK_1, TRACK_2, TRACK_3])
+    end
+
+    it "inserts tracks after the currently playing track" do
+      @player.insert(TRACK_1)
+      @player.playlist.should eq([TRACK_1])
+      @player.insert(TRACK_2)
+      @player.playlist.should eq([TRACK_2, TRACK_1])
+      @player.play
+      @player.insert(TRACK_3)
+      @player.playlist.should eq([TRACK_2, TRACK_3, TRACK_1])
+    end
+
+    it "removes tracks by object comparison" do
+      @player << [TRACK_1, TRACK_2, TRACK_1, TRACK_3, TRACK_1]
+      @player.remove(TRACK_1)
+      @player.playlist.should eq([TRACK_2, TRACK_3])
+      @player << [TRACK_1, TRACK_1, TRACK_1]
+      @player.remove(TRACK_1, 2)
+      @player.playlist.should eq([TRACK_2, TRACK_3, TRACK_1])
+      @player.remove(TRACK_1, TRACK_2, TRACK_3)
+      @player.playlist.should be_empty
+    end
+
+    it "removes one or more tracks anywhere in the playlist" do
+      @player << [TRACK_1, TRACK_2, TRACK_3]
+      @player.remove_at(1)
+      @player.playlist.should eq([TRACK_1, TRACK_3])
+      @player.remove_at(0, 2)
+      @player.playlist.should be_empty
+    end
+
+    it "continues playing while playlist is modified" do
+      @player << [TRACK_3, TRACK_2, TRACK_1]
+      @player.play
+      @player << TRACK_1
+      @player.playlist.should eq([TRACK_3, TRACK_2, TRACK_1, TRACK_1])
+      @player.track.should eq(TRACK_3)
+      @player.remove(TRACK_3)
+      @player.playlist.should eq([TRACK_2, TRACK_1, TRACK_1])
+      @player.track.should eq(TRACK_2)
+      @player.remove(TRACK_2, TRACK_1)
+      @player.should_not be_playing
+    end
+
+    it "raises index error when inserting or removing out of the playlist's bounds" do
+      expect { @player.insert_at(-3, TRACK_1) }.to raise_error(IndexError)
+      expect { @player.insert_at(2, TRACK_1) }.to raise_error(IndexError)
+      expect { @player.remove_at(-3) }.to raise_error(IndexError)
+      expect { @player.remove_at(0) }.to raise_error(IndexError)
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require "plllayer"
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/time_helpers_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+describe Plllayer::TimeHelpers do
+  describe :format_time do
+    it "formats a time of zero milliseconds" do
+      Plllayer.format_time(0).should eq("0:00")
+    end
+
+    it "formats a time of one millisecond" do
+      Plllayer.format_time(1).should eq("0:00.001")
+    end
+
+    it "formats a time of one second" do
+      Plllayer.format_time(1000).should eq("0:01")
+    end
+
+    it "formats a time of one second plus a millisecond" do
+      Plllayer.format_time(1001).should eq("0:01.001")
+    end
+
+    it "formats a time of one minute and thirty seconds" do
+      Plllayer.format_time(90000).should eq("1:30")
+    end
+
+    it "formats times of an hour" do
+      Plllayer.format_time(3600000).should eq("1:00:00")
+    end
+
+    it "formats times with multiple components" do
+      Plllayer.format_time(7200000 + 120000 + 2000 + 2).should eq("2:02:02.002")
+    end
+
+    it "can exclude milliseconds from the output" do
+      Plllayer.format_time(1500).should eq("0:01.500")
+      Plllayer.format_time(1500, include_milliseconds: false).should eq("0:01")
+    end
+
+    it "can't format negative times" do
+      expect { Plllayer.format_time(-1) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe :parse_time do
+    it "parses times of zero" do
+      Plllayer.parse_time("0").should eq(0)
+      Plllayer.parse_time("0:00").should eq(0)
+      Plllayer.parse_time("0:00.000").should eq(0)
+      Plllayer.parse_time("0:00:00.000").should eq(0)
+    end
+
+    it "parses milliseconds" do
+      Plllayer.parse_time("0.001").should eq(1)
+      Plllayer.parse_time("0:00.999").should eq(999)
+      Plllayer.parse_time("0:00:00.5").should eq(500)
+    end
+
+    it "parses seconds" do
+      Plllayer.parse_time("1").should eq(1000)
+      Plllayer.parse_time("0:05").should eq(5000)
+      Plllayer.parse_time("0:00:09.500").should eq(9500)
+    end
+
+    it "parses minutes" do
+      Plllayer.parse_time("2:30").should eq(150000)
+    end
+
+    it "parses hours" do
+      Plllayer.parse_time("1:00:00").should eq(3600000)
+      Plllayer.parse_time("2:02:02.002").should eq(7200000 + 120000 + 2000 + 2)
+      Plllayer.parse_time("1000:00:00").should eq(1000 * 3600000)
+    end
+
+    it "assumes empty components are zero" do
+      Plllayer.parse_time("1:").should eq(60000)
+      Plllayer.parse_time("1::.5").should eq(3600000 + 500)
+      Plllayer.parse_time("::.001").should eq(1)
+      Plllayer.parse_time("::6.").should eq(6000)
+      Plllayer.parse_time("").should eq(0)
+    end
+
+    it "can't parse invalid strings" do
+      expect { Plllayer.parse_time("-1") }.to raise_error(ArgumentError)
+      expect { Plllayer.parse_time("1:00:00:00") }.to raise_error(ArgumentError)
+    end
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plllayer
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-05 00:00:00.000000000 Z
+date: 2013-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,15 +82,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- Rakefile
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - plllayer.gemspec
+- README.md
 - lib/plllayer/single_player.rb
 - lib/plllayer/single_players/mplayer.rb
 - lib/plllayer/single_players/nop.rb
+- lib/plllayer/synchronize.rb
 - lib/plllayer/time_helpers.rb
 - lib/plllayer.rb
+- spec/mplayer_spec.rb
+- spec/nop_spec.rb
+- spec/plllayer_spec.rb
+- spec/spec_helper.rb
+- spec/time_helpers_spec.rb
+- spec/10000ms.mp3
+- spec/250ms.mp3
+- spec/3000ms.mp3
+- spec/invalid.mp3
+- spec/playback.mp3
 homepage: http://github.com/yjerem/plllayer
 licenses:
 - MIT