mpg321 0.4.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 11c12e85e497f78a257b911218d636a6c9c0f796
-  data.tar.gz: de65fc5363ed72e636dca7d84ea04fc5f9081a7f
+  metadata.gz: 945d500d8a3ca04c58284f2456ba90ace17c8f60
+  data.tar.gz: b4d8b06747ad4c9457902093fe76ff50a27ead0b
 SHA512:
-  metadata.gz: 17ecfe4f4e8a21c17af1b8690dd76f2807083badb4420ad8a419948c0dc737df56e45d23478818dc96f13979560052d27907cdca9f0d2c386b4e4c050df1b111
-  data.tar.gz: 29b170b7b75dab7fa7cef5124ec95b47719d3909db57639c573a5b4cae90640713dba5128907f878e980db9679f13c176f417a31385d0669353c642ddb06fbb1
+  metadata.gz: f5742b2ae1a0d8201dc512fde5567f01332733095c8eaec29cdfc8ef9f7608ba4d1ef6a7a2ce2a0cbd3b31551e983454309f3e42bd4813b2ced3709355e0cb1a
+  data.tar.gz: 04900df45afc40372adced49111df5563e3f6dbf2a185e7404469c44b0c1cdd695e8918e4db3c08d0b603b60bcdd302dc696c8f5641a06161dba97134e5d5f5b

data/README.md

@@ -25,27 +25,16 @@ Here's how you can easily play an mp3:
 
 ```ruby
 require 'mpg321'
-mog321 = Mpg321.new
+mpg321 = Mpg321::Client.new
 
 mpg321.play('/some_path/song.mp3') #=> to play a song from a file
 
 mpg321.play('http://example.com/a_hosted_song.mp3') #=> to play a song from the web
 ```
-To play a list of songs:
-
-```ruby
-require 'mpg321'
-
-mog321 = Mpg321.new
-mpg321.play(['/some_path/song.mp3', '/another_path/another_song'])
-```
 
 Volume controls:
 
 ```ruby
-require 'mpg321'
-mog321 = Mpg321.new
-
 mpg321.volume #=> initialized to 50
 
 mpg321.volume = 10 #=> Set volume to a number between 0 and 100
@@ -53,15 +42,30 @@ mpg321.volume = 10 #=> Set volume to a number between 0 and 100
 mpg321.volume_up(10)   #=> Increase volume by 10
 mpg321.volume_down(10) #=> Decrease volume by 10
 ```
+
 Other controls:
 
 ```ruby
-require 'mpg321'
-mog321 = Mpg321.new
-
 mpg321.pause #=> Pause / unpause song
 
-mpg321.stop  #=> Stop playing song / song list
+mpg321.stop  #=> Stop playing song
+```
+
+Events:
+
+```ruby
+mpg321.on(:playback_finished) { } # Called when song ends.
+
+mpg321.on(:file_not_found) { }    # Called when song could not be found.
+
+mpg321.on(:error) { }             # Called in error case. Do not use object
+                                  # afterwards.
+```
+
+Stop the mpg321 process:
+
+```ruby
+mpg321.quit
 ```
 
 Contributing

data/history.rdoc

@@ -1,3 +1,10 @@
+== v1.0.0 (20 October 2015)
+
+* Add better namspacing for the gem
+* Add callback for 'file_not_found'
+* Add callback for 'playback_finished'
+* Add callback for 'error'
+
 == v0.4.0 (04 July 2015)
 
 * Add paused? mehod

data/lib/mpg321.rb

@@ -1,101 +1,6 @@
-require 'open3'
-require 'timeout'
-
-class Mpg321
-  attr_reader :volume
-
-  def initialize
-    @volume = 50
-    @paused = false
-    @music_input, @stdout, @stderr, _thread = Open3.popen3("mpg321 -R mpg321_ruby")
-    handle_stderr
-    handle_stdout
-    send_volume
-  end
-
-  def pause
-    @paused = !@paused
-    @music_input.puts "P"
-  end
-
-  def stop
-    @paused = !@paused
-    @music_input.puts "S"
-  end
-
-  def paused?
-    @paused
-  end
-
-  def play song_list
-    @paused = !@paused
-    @song_list = song_list
-    if song_list.class == Array
-      @list = true
-      play_song @song_list.shift
-    else
-      @list = false
-      play_song song_list
-    end
-  end
-
-  def volume_up volume
-    @volume += volume
-    @volume = [@volume, 100].min
-    send_volume
-  end
-
-  def volume_down volume
-    @volume -= volume
-    @volume = [@volume, 0].max
-    send_volume
-  end
-
-  def volume= volume
-    if volume < 0
-      @volume = 0
-    elsif volume > 100
-      @volume = 100
-    else
-      @volume = volume
-    end
-    send_volume
-  end
-
-  private
-
-  def play_song song
-    @music_input.puts "L #{song}"
-  end
-
-  def send_volume
-    @music_input.puts "G #{@volume}"
-  end
-
-  def handle_stderr
-    Thread.new do
-      loop do
-
-        #Not sure how to test this yet
-        begin
-          Timeout::timeout(1) { @stderr.readline }
-        rescue Timeout::Error
-          play @song_list if @list && !@paused
-        end
-
-      end
-    end
-  end
-
-  def handle_stdout
-    Thread.new do
-      loop do
-        #Not sure how to test this yet
-        @stout.readline
-        if @list && @line.match(/@P 3/)
-          play @song_list
-        end
-      end
-    end
-  end
-end
+require 'mpg321/control/playback'
+require 'mpg321/control/volume'
+require 'mpg321/client'
+require 'mpg321/playlist'
+require 'mpg321/process_wrapper'
+require 'mpg321/version'

data/lib/mpg321/client.rb

@@ -0,0 +1,16 @@
+module Mpg321
+  class Client
+    include Control::Playback
+    include Control::Volume
+
+    extend Forwardable
+    def_delegator :@process, :send_command
+    def_delegator :@process, :on
+    def_delegator :@process, :quit
+
+    def initialize
+      @process = ProcessWrapper.new
+      send :volume=, 50
+    end
+  end
+end

data/lib/mpg321/control/playback.rb

@@ -0,0 +1,34 @@
+module Mpg321
+  module Control
+    module Playback
+      def play song
+        @loaded = true
+        @paused = false
+        send_command 'L', song
+      end
+
+      def pause
+        @paused = !@paused
+        send_command 'P'
+      end
+
+      def stop
+        @loaded = false
+        @paused = false
+        send_command 'S'
+      end
+
+      def paused?
+        !!@paused
+      end
+
+      def loaded?
+        !!@loaded
+      end
+
+      def playing?
+        loaded? && !paused?
+      end
+    end
+  end
+end

data/lib/mpg321/control/volume.rb

@@ -0,0 +1,22 @@
+module Mpg321
+  module Control
+    module Volume
+      def volume
+        @volume
+      end
+
+      def volume= volume
+        @volume = [0, volume.to_i, 100].sort[1]
+        send_command 'G', @volume
+      end
+
+      def volume_up inc
+        send :volume=, @volume + inc
+      end
+
+      def volume_down dec
+        send :volume=, @volume - dec
+      end
+    end
+  end
+end

data/lib/mpg321/playlist.rb

@@ -0,0 +1,41 @@
+module Mpg321
+  class Playlist
+    include Enumerable
+
+    PLAYLIST_ADVANCE_EVENTS = [ :playback_finished, :file_not_found ]
+
+    def initialize autoplay = false, client = Client.new
+      @tracks   = Array.new
+      @access   = Mutex.new
+      @autoplay = autoplay
+      @client   = client
+
+      PLAYLIST_ADVANCE_EVENTS.each do |event|
+        @client.on(event) { advance }
+      end
+    end
+
+    def enqueue song
+      @access.synchronize { @tracks << song }
+      advance if @autoplay && !@client.loaded?
+    end
+
+    def advance
+      if song = dequeue
+        @client.play song
+      else
+        @client.stop if @client.loaded?
+      end
+    end
+
+    def each &block
+      @access.synchronize { @tracks.each &block }
+    end
+
+    private
+
+    def dequeue
+      @access.synchronize { @tracks.shift }
+    end
+  end
+end

data/lib/mpg321/process_wrapper.rb

@@ -0,0 +1,89 @@
+require 'open3'
+
+module Mpg321
+  class ProcessWrapper
+    def initialize
+      spawn_mpg321
+
+      @callbacks = Hash.new { |h, e| h[e] = Array.new }
+      @read_thr  = async_handle_stdoe
+    end
+
+    def send_command command, *args
+      @stdin.puts [command, *(args.map(&:to_s))].join(' ')
+    end
+
+    def on(event, &block)
+      @callbacks[event] << block
+    end
+
+    def quit
+      send_command 'Q'
+      @read_thr.join
+      @wait_thr.value
+    end
+
+    private
+
+    # This corresponds to the system-specific "No such file or directory" message.
+    # TODO: Would love to use strerror(3) instead, but Ruby doesn't expose that.
+    LOCALIZED_ENOENT_MESSAGE = SystemCallError.new('', Errno::ENOENT::Errno).message.gsub(' - ', '')
+
+    def spawn_mpg321
+      @stdin, @stdoe, @wait_thr = Open3.popen2e 'mpg321 -R mpg321_ruby'
+    end
+
+    def emit(event, *args)
+      @callbacks[event].each { |cb| cb.call *args }
+    end
+
+    # :nocov:
+    def async_handle_stdoe
+      Thread.new do
+        begin
+          loop { read_stdoe_line }
+        rescue EOFError
+          # Stream exhausted, ignore.
+        end
+      end
+    end
+
+    def read_stdoe_line
+      line = @stdoe.readline
+      case line[0..1]
+      when '@F'
+        parts = line.split(' ')
+        emit :status_update, {
+          current_frame:    parts[1].to_i,
+          frames_remaining: parts[2].to_i,
+          current_time:     parts[3].to_f,
+          time_remaining:   parts[4].to_f
+        }
+      when '@P'
+        # mpg321 sends '@P 3' when the song has finished playing.
+        if line[3] == '3'
+          emit :playback_finished
+        end
+      when '@E'
+        # This is sent in case of illegal syntax, e.g. an empty string
+        # as parameter to the LOAD command.
+        emit :error, line.strip
+      else
+        # Any critical error is sent to stderr and is not preprended
+        # by an @ character. mpg321 immediately exits afterwards.
+        if line[0] != '@'
+          if line.include? LOCALIZED_ENOENT_MESSAGE
+            # Handle file not found gracefully and restart mpg321.
+            @wait_thr.join
+            spawn_mpg321
+            emit :file_not_found
+          else
+            # TODO: This leaves the instance in a unusable state. Subsequent
+            # calls to #send_message etc. will respond with EPIPE.
+            emit :error, line.strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mpg321/version.rb

@@ -0,0 +1,3 @@
+module Mpg321
+  VERSION = '1.0.0'
+end

data/spec/client_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Mpg321::Client do
+  include_context 'fake_mpg321'
+
+  describe 'initialize' do
+    it 'sets the volume to 50' do
+      expect(subject.volume).to eq 50
+    end
+  end
+
+end

data/spec/playback_control_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Mpg321::Client do
+  include_context 'fake_mpg321'
+
+  describe '#play' do
+    it 'sends a message to play a song' do
+      subject.play example_file
+      expect(last_command).to be_a_load_command_for example_file
+    end
+
+    context '#when paused' do
+      before do
+        subject.pause
+      end
+
+      it 'unpauses' do
+        expect(subject.paused?).to be_truthy
+        subject.stop
+        expect(subject.paused?).to be_falsy
+      end
+    end
+  end
+
+  describe '#pause' do
+    it 'sends a message to pause / unpause the song' do
+      subject.pause
+      expect(last_command).to be_a_pause_command
+    end
+
+    context '#when paused' do
+      before do
+        subject.pause
+      end
+
+      it 'unpauses' do
+        expect(subject.paused?).to be_truthy
+        subject.pause
+        expect(subject.paused?).to be_falsy
+      end
+    end
+  end
+
+  describe '#stop' do
+    it 'sends a message to stop the song' do
+      subject.stop
+      expect(last_command).to be_a_stop_command
+    end
+
+    context '#when paused' do
+      before do
+        subject.pause
+      end
+
+      it 'unpauses' do
+        expect(subject.paused?).to be_truthy
+        subject.stop
+        expect(subject.paused?).to be_falsy
+      end
+    end
+  end
+
+  describe '#paused?' do
+    it 'returns false if it is not paused' do
+      expect(subject.paused?).to be_falsy
+    end
+
+    it 'returns false if it is not paused' do
+      expect(subject.paused?).to be_falsy
+      subject.pause
+      expect(subject.paused?).to be_truthy
+    end
+  end
+
+  describe '#loaded?' do
+    it 'returns false if no file has been loaded for playback' do
+      expect(subject.loaded?).to be_falsy
+    end
+
+    it 'returns true if a file has been loaded for playback' do
+      subject.play '/some_path/file_name'
+      expect(subject.loaded?).to be_truthy
+    end
+  end
+
+  describe '#playing?' do
+    it 'returns false if no file has been loaded' do
+      expect(subject.playing?).to be_falsy
+    end
+
+    it 'returns true if a file has been loaded and playback is not paused' do
+      subject.play '/some_path/file_name'
+      expect(subject.playing?).to be_truthy
+    end
+
+    it 'returns false if a file has been loaded but playback is paused' do
+      subject.play '/some_path/file_name'
+      subject.pause
+      expect(subject.playing?).to be_falsy
+    end
+  end
+
+end

data/spec/playlist_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Mpg321::Playlist do
+  include_context 'fake_mpg321'
+
+  let(:client) { subject.instance_variable_get(:@client) }
+  let(:process) { client.instance_variable_get(:@process) }
+  let(:fake_read_thread) { process.instance_variable_get(:@read_thr) }
+
+  let(:song) { 'song' }
+  let(:songs) { %w{ A B C } }
+
+  before(:each) do
+    songs.each { |s| subject.enqueue s }
+  end
+
+  after(:each) { subject.instance_variable_get(:@tracks).clear }
+
+  describe 'enqueue' do
+    it "adds a song to the playlist's back" do
+      expect { subject.enqueue song }.to change { subject.entries.size }.by 1
+      expect(subject.entries).to eq (songs + [song])
+    end
+
+    context 'when the autoplay flag is set' do
+      let(:client2) { Mpg321::Client.new }
+      subject { Mpg321::Playlist.new(true, client2) }
+
+      context 'and the player has not loaded a file' do
+        it 'automatically starts playback' do
+          expect(client2).to receive(:loaded?).and_return false
+          expect(subject).to receive :advance
+          subject.enqueue song
+        end
+      end
+
+      context 'and the player has loaded a file' do
+        it 'automatically starts playback' do
+          expect(client2).to receive(:loaded?).and_return true
+          expect(subject).to_not receive :advance
+          subject.enqueue song
+        end
+      end
+    end
+  end
+
+  describe 'advance' do
+    context 'when the playlist contains songs' do
+      it 'removes the first song from the playlist' do
+        expect { subject.advance }.to change { subject.entries.size }.by -1
+        expect(subject).to_not include songs.first
+      end
+
+      it 'starts playback of the next song' do
+        expect(client).to receive(:play).with songs.first
+        subject.advance
+      end
+    end
+
+    context 'when the playlist is empty' do
+      before { subject.instance_variable_get(:@tracks).clear }
+
+      it 'stops playback of the current song if the player is loaded' do
+        expect(client).to receive(:loaded?).and_return true
+        expect(client).to receive :stop
+        subject.advance
+      end
+    end
+  end
+
+  describe '(events)' do
+    context 'in case of a playback_finished event' do
+      it 'advances to the next track' do
+        expect(subject).to receive :advance
+
+        fake_mpg321.finish_playback
+        fake_read_thread.run_once
+      end
+    end
+
+    context 'in case of a file_not_found event' do
+      it 'advances to the next track' do
+        expect(subject).to receive :advance
+
+        fake_mpg321.send_file_not_found
+        fake_read_thread.run_once
+      end
+    end
+  end
+end

data/spec/process_wrapper_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Mpg321::ProcessWrapper do
+  include_context 'fake_mpg321'
+
+  let(:fake_read_thread) { subject.instance_variable_get(:@read_thr) }
+
+  describe 'quit' do
+    it 'sends a quit message' do
+      subject.quit
+      expect(last_command).to be_a_quit_command
+    end
+
+    it 'waits for completion of the reader thread' do
+      # We expect the main thread to wait for the reader threads termination.
+      expect(fake_read_thread).to receive :join
+      subject.quit
+    end
+
+    it 'collects the status of the mpg321 process (and does not leave zombies)' do
+      expect(fake_mpg321.wait_thr).to receive :value
+      subject.quit
+    end
+
+    it 'returns the exitstatus of the mpg321 process' do
+      expect(subject.quit).to respond_to :exitstatus
+    end
+  end
+
+  describe '(error handling)' do
+    context 'when a file can not be found' do
+      it 'notifies interested observers' do
+        callback = Proc.new {}
+        subject.on :file_not_found, &callback
+        expect(callback).to receive :call
+
+        fake_mpg321.send_file_not_found
+        fake_read_thread.run_once
+      end
+
+      it 'respawns the dead mpg321 process' do
+        expect(fake_mpg321.wait_thr).to receive(:join)
+        expect(subject).to receive(:spawn_mpg321).and_return(fake_mpg321)
+
+        fake_mpg321.send_file_not_found
+        fake_read_thread.run_once
+      end
+    end
+
+    context 'in case of a syntax error in a command' do
+      it 'notifies interested observers' do
+        callback = Proc.new {}
+        subject.on :error, &callback
+        expect(callback).to receive(:call)
+
+        fake_mpg321.send_command_syntax_error
+        fake_read_thread.run_once
+      end
+    end
+
+    context 'in any other error case (e.g., no sound card found)' do
+      it 'notifies interested observers' do
+        callback = Proc.new {}
+        subject.on :error, &callback
+        expect(callback).to receive(:call)
+
+        fake_mpg321.send_fatal_unknown_error
+        fake_read_thread.run_once
+      end
+
+      # TODO: ProcessWrapper should probably remember that mpg321 is dead
+      # and return some sane error message afterwards.
+      it 'puts itself into a sane state'
+    end
+  end
+
+  describe '(read thread)' do
+    it 'dies when mpg321 exits' do
+      # When mpg321 dies, the stdout pipe will go away, resulting
+      # in an exception in the reader thread. We simulate this
+      # here by closing the StringIO.
+      fake_mpg321.stdoe.close
+      expect { fake_read_thread.run_once }.to raise_error IOError
+    end
+  end
+
+  describe '(events)' do
+    context 'when playback of a file has finished' do
+      it 'notifies interested observers' do
+        callback = Proc.new {}
+        subject.on :playback_finished, &callback
+        expect(callback).to receive :call
+
+        fake_mpg321.finish_playback
+        fake_read_thread.run_once
+      end
+    end
+
+    context 'when frame decoding status update is received' do
+      let(:update_data) do
+        { current_frame: 1, frames_remaining: 10, current_time: 1.00, time_remaining: 10.00 }
+      end
+
+      it 'notifies interested observers' do
+        callback = Proc.new {}
+        subject.on :status_update, &callback
+        expect(callback).to receive(:call).with(update_data)
+
+        fake_mpg321.send_status_update update_data
+        fake_read_thread.run_once
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,9 +1,10 @@
-require 'bundler/setup'
 require 'simplecov'
+SimpleCov.add_filter '/spec/'
 SimpleCov.start
 
+require 'mpg321'
 
-Dir['./spec/support/*.rb'].map {|f| require f }
+Dir['./spec/support/*.rb'].each { |f| require f }
 
 RSpec.configure do |config|
   config.filter_run :focus => true

data/spec/support/context.rb

@@ -0,0 +1,13 @@
+RSpec.shared_context 'fake_mpg321' do
+  let(:fake_mpg321) { FakeMpg321.new }
+  let(:last_command) { fake_mpg321.last_command }
+  let(:example_file) { '/somepath/somefile.mp3' }
+
+  before do
+    allow(Open3).to receive(:popen2e).and_return(fake_mpg321.open2e_returns)
+
+    allow_any_instance_of(Mpg321::ProcessWrapper).to receive(:async_handle_stdoe) do |instance|
+      FakeReadThread.new(instance) { read_stdoe_line }
+    end
+  end
+end

data/spec/support/matcher.rb

@@ -0,0 +1,51 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :be_a_pause_command do
+  match do |actual|
+    actual[0] == 'P'
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be a mpg321 pause command ('P'/'PAUSE')"
+  end
+end
+
+RSpec::Matchers.define :be_a_stop_command do
+  match do |actual|
+    actual[0] == 'S'
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be a mpg321 stop command ('S'/'STOP')"
+  end
+end
+
+RSpec::Matchers.define :be_a_quit_command do
+  match do |actual|
+    actual[0] == 'Q'
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be a mpg321 quit command ('Q'/'QUIT')"
+  end
+end
+
+RSpec::Matchers.define :set_volume_to do |vol|
+  match do |actual|
+    actual == "G #{vol}"
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be a mpg321 gain command ('G'/'LOAD') with '#{vol}'"
+  end
+end
+
+RSpec::Matchers.define :be_a_load_command_for do |file|
+  match do |actual|
+    actual == "L #{file}"
+  end
+
+  failure_message do |actual|
+    "expected that #{actual} would be a mpg321 load command ('L'/'LOAD') for file '#{file}'"
+  end
+end

data/spec/support/mocks.rb

@@ -0,0 +1,76 @@
+require 'stringio'
+
+class FakeReadThread
+  def initialize(ctx, &block)
+    @ctx    = ctx
+    @action = block
+  end
+
+  def run_once
+    @ctx.instance_eval &@action
+  end
+
+  def join
+    self
+  end
+end
+
+class FakeWaitThread
+  FakeExitStatus = Struct.new(:exitstatus)
+
+  def join
+    self
+  end
+
+  def value
+    FakeExitStatus.new(0)
+  end
+end
+
+class FakeMpg321
+  attr_reader :stdin, :stdoe, :wait_thr
+
+  def initialize
+    @stdin    = StringIO.new
+    @stdoe    = StringIO.new
+    @wait_thr = FakeWaitThread.new
+  end
+
+  def open2e_returns
+    [@stdin, @stdoe, @wait_thr]
+  end
+
+  def last_command
+    @stdin.rewind
+    cmd = @stdin.gets.strip until @stdin.eof?
+    @stdin = StringIO.new
+    cmd
+  end
+
+  def send_status_update data
+    send_mpg321_output "@F #{data[:current_frame]} #{data[:frames_remaining]} #{data[:current_time]} #{data[:time_remaining]}"
+  end
+
+  def finish_playback
+    send_mpg321_output '@P 3'
+  end
+
+  def send_command_syntax_error
+    send_mpg321_output "@E Missing argument to 'L'"
+  end
+
+  def send_file_not_found
+    send_mpg321_output "foobar: #{Mpg321::ProcessWrapper::LOCALIZED_ENOENT_MESSAGE}"
+  end
+
+  def send_fatal_unknown_error
+    send_mpg321_output 'big boom'
+  end
+
+  def send_mpg321_output(line)
+    @stdoe.rewind
+    @stdoe.flush
+    @stdoe.puts line
+    @stdoe.rewind
+  end
+end

data/spec/volume_control_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Mpg321::Client do
+  include_context 'fake_mpg321'
+
+  describe '#volume_up' do
+    it 'sends a message to increase the volume' do
+      subject.volume_up 10
+      expect(last_command).to set_volume_to 60
+    end
+
+    it 'has a maximum volume of 100' do
+      subject.volume_up 55
+      expect(subject.volume).to eq 100
+      expect(last_command).to set_volume_to 100
+    end
+  end
+
+  describe '#volume_down' do
+    it 'sends a message to decrease the volume' do
+      subject.volume_down 10
+      expect(last_command).to set_volume_to 40
+    end
+
+    it 'has a minimum volume of 0' do
+      subject.volume_down 55
+      expect(subject.volume).to eq 0
+      expect(last_command).to set_volume_to 0
+    end
+  end
+
+  describe '#volume' do
+    it 'returns the current volume' do
+      expect(subject.volume).to eq 50
+      subject.volume_up 5
+      expect(subject.volume).to eq 55
+    end
+  end
+
+  describe '#volume=' do
+    it 'sets the volume' do
+      expect(subject.volume).to eq 50
+      subject.volume = 11
+      expect(subject.volume).to eq 11
+    end
+
+    it 'casts float arguments to integer' do
+      expect(subject.volume).to eq 50
+      subject.volume = 47.11
+      expect(subject.volume).to eq 47
+    end
+
+    it 'has a minimum of 0' do
+      subject.volume = -1
+      expect(subject.volume).to eq 0
+    end
+
+    it 'has a maximum of 100' do
+      subject.volume = 101
+      expect(subject.volume).to eq 100
+    end
+
+    it 'sends a message to set the volume' do
+      subject.volume = 11
+      expect(last_command).to set_volume_to 11
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mpg321
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Richard Vickerstaff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-04 00:00:00.000000000 Z
+date: 2015-10-20 00:00:00.000000000 Z
 dependencies: []
 description: A simple ruby wrapper around mpg321
 email:
@@ -17,22 +17,28 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".semver"
-- ".travis.yml"
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - history.rdoc
 - lib/mpg321.rb
-- lib/version.rb
-- mpg321.gemspec
-- spec/mpg321_spec.rb
+- lib/mpg321/client.rb
+- lib/mpg321/control/playback.rb
+- lib/mpg321/control/volume.rb
+- lib/mpg321/playlist.rb
+- lib/mpg321/process_wrapper.rb
+- lib/mpg321/version.rb
+- spec/client_spec.rb
+- spec/playback_control_spec.rb
+- spec/playlist_spec.rb
+- spec/process_wrapper_spec.rb
 - spec/spec_helper.rb
+- spec/support/context.rb
+- spec/support/matcher.rb
+- spec/support/mocks.rb
+- spec/volume_control_spec.rb
 homepage: https://github.com/RichardVickerstaff/mpg321
 licenses:
-- GNU GENERAL PUBLIC LICENSE
+- GPL-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -50,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Provides a ruby object to wrap the mpg321 'Remote control'

data/.gitignore

@@ -1,4 +0,0 @@
-/coverage/*
-*.gem
-*.sw?
-Gemfile.lock

data/.semver

@@ -1,6 +0,0 @@
----
-:major: 0
-:minor: 4
-:patch: 0
-:special: ''
-:metadata: ''

data/.travis.yml

@@ -1,19 +0,0 @@
-language: ruby
-rvm:
-- 2.1.0
-- 2.0.0
-- 1.9.3
-- jruby-1.7.12
-- ruby-head
-matrix:
-  allow_failures:
-    - rvm: ruby-head
-deploy:
-  provider: rubygems
-  api_key:
-    secure: RmGYn4yb1PPjZxdWxgwUWTENnRaqp/PXUMfieJoAE0Dw1JrwkjxI3qhy/I6p36KusLsrFxrh4UdATj78QsWdtZVLJ9tvjONOsrAUjIszBwRmOXDWRkH8eLGCCmIYfYMZaRYvlQhPR2t5CC6BwfHS6W1AU5YtU5SSpk0HT+SRzII=
-  gem: mpg321
-  on:
-    tags: true
-    repo: RichardVickerstaff/mpg321
-    all_branches: true

data/Gemfile

@@ -1,9 +0,0 @@
-source 'https://rubygems.org'
-
-group :test, :development do
-  gem 'simplecov'
-  gem 'semver2'
-  gem 'bundler-audit'
-  gem 'rake-n-bake'
-  gem 'rspec'
-end

data/Rakefile

@@ -1,10 +0,0 @@
-require'rake_n_bake'
-
-@external_dependencies = %w[ruby]
-
-task :default => [
-  :"bake:check_external_dependencies",
-  :"bake:code_quality:all",
-  :"bake:rspec",
-  :"bake:ok",
-]

data/lib/version.rb

@@ -1,3 +0,0 @@
-module Mpg321
-  VERSION = "0.4.0"
-end

data/mpg321.gemspec

@@ -1,17 +0,0 @@
-# coding: utf-8
-require File.expand_path('../lib/version', __FILE__)
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-Gem::Specification.new do |spec|
-  spec.name          = "mpg321"
-  spec.version       = Mpg321::VERSION
-  spec.authors       = ["Richard Vickerstaff"]
-  spec.email         = ["m3akq@btinternet.com"]
-  spec.description   = "A simple ruby wrapper around mpg321"
-  spec.summary       = "Provides a ruby object to wrap the mpg321 'Remote control'"
-  spec.homepage      = "https://github.com/RichardVickerstaff/mpg321"
-  spec.license       = "GNU GENERAL PUBLIC LICENSE"
-  spec.files         = `git ls-files`.split($/)
-  spec.require_paths = ["lib"]
-end

data/spec/mpg321_spec.rb

@@ -1,157 +0,0 @@
-require 'spec_helper'
-require 'mpg321'
-
-describe Mpg321 do
-
-  let(:thread) { double :thread }
-  let(:stderr) { double :stderr }
-  let(:stdout) { double :stdout }
-  let(:stdin)  { double :stdin  }
-
-  before do
-    allow(Open3).to receive(:popen3).and_return([stdin, stdout, stderr, thread])
-    allow(stdin).to receive(:puts)
-  end
-
-  describe 'initialize' do
-    it 'sets the volume to 50' do
-      expect(subject.volume).to eq 50
-    end
-  end
-
-  describe '#volume_up' do
-    it 'sends a message to increase the volume' do
-      expect(stdin).to receive(:puts).with "G 60"
-      subject.volume_up 10
-    end
-
-    it 'has a maximum volume of 100' do
-      expect(stdin).to receive(:puts).with "G 100"
-      subject.volume_up 55
-      expect(subject.volume).to eq 100
-    end
-  end
-
-  describe '#volume_down' do
-    it 'sends a message to decrease the volume' do
-      expect(stdin).to receive(:puts).with "G 40"
-      subject.volume_down 10
-    end
-
-    it 'has a minimum volume of 0' do
-      expect(stdin).to receive(:puts).with "G 0"
-      subject.volume_down 55
-      expect(subject.volume).to eq 0
-    end
-  end
-
-  describe '#volume' do
-    it 'returns the current volume' do
-      expect(subject.volume).to eq 50
-      subject.volume_up 5
-      expect(subject.volume).to eq 55
-    end
-  end
-
-  describe '#volume=' do
-    it 'sets the volume' do
-      expect(subject.volume).to eq 50
-      subject.volume = 11
-      expect(subject.volume).to eq 11
-    end
-
-    it 'has a minimum of 0' do
-      subject.volume = -1
-      expect(subject.volume).to eq 0
-    end
-
-    it 'has a maximum of 100' do
-      subject.volume = 101
-      expect(subject.volume).to eq 100
-    end
-
-    it 'sends a message to set the volume' do
-      expect(stdin).to receive(:puts).with "G 11"
-      subject.volume = 11
-    end
-  end
-
-  describe '#play' do
-    context 'when there is only one song' do
-      it 'sends a message to play a song' do
-        expect(stdin).to receive(:puts).with "L /some_path/file_name"
-        subject.play '/some_path/file_name'
-      end
-
-      context '#when paused' do
-        before do
-          subject.pause
-        end
-
-        it 'unpauses' do
-          expect(subject.paused?).to be_truthy
-          subject.stop
-          expect(subject.paused?).to be_falsy
-        end
-      end
-    end
-
-    context 'when there moer than one song' do
-      it 'sends a message to play the first song' do
-        expect(stdin).to receive(:puts).with "L /some_path/file_name"
-        subject.play ['/some_path/file_name', '/some_other_song']
-      end
-    end
-  end
-
-  describe '#pause' do
-    it 'sends a message to pause / unpause the song' do
-      expect(stdin).to receive(:puts).with "P"
-      subject.pause
-    end
-
-    context '#when paused' do
-      before do
-        subject.pause
-      end
-
-      it 'unpauses' do
-        expect(subject.paused?).to be_truthy
-        subject.pause
-        expect(subject.paused?).to be_falsy
-      end
-    end
-  end
-
-  describe '#stop' do
-    it 'sends a message to stop the song' do
-      expect(stdin).to receive(:puts).with "S"
-      subject.stop
-    end
-
-    context '#when paused' do
-      before do
-        subject.pause
-      end
-
-      it 'unpauses' do
-        expect(subject.paused?).to be_truthy
-        subject.stop
-        expect(subject.paused?).to be_falsy
-      end
-    end
-  end
-
-  describe '#paused?' do
-    it 'returns false if it is not paused' do
-      expect(subject.paused?).to be_falsy
-    end
-
-    it 'returns false if it is not paused' do
-      expect(subject.paused?).to be_falsy
-      subject.pause
-      expect(subject.paused?).to be_truthy
-    end
-  end
-
-end