mpc 0.8 → 0.9

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mpc.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler"
+require "rake/testtask"
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+desc "Test the library"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+end

data/lib/mpc.rb

@@ -1,226 +1,125 @@
+require "socket"
 class Mpc
+
   @@regexps = {
-    "ACK"  => /\AACK \[(\d+)\@(\d+)\] \{(.*)\} (.+)\Z/,
-    "OK"   => /\AOK\n\Z/,
-    "FILE" => /\Afile\:(.*)\Z/,
+    "ACK"     => /\AACK \[(\d+)\@(\d+)\] \{(.*)\} (.+)\Z/,
+    "OK"      => /\AOK\n\Z/,
+    "FILE"    => /\Afile\:(.*)\Z/,
+    "CONNECT" => /\AOK MPD (\d+)\.(\d+).(\d+)\n\Z/
   }
 
+  attr_accessor :host, :port
   def initialize(host = "127.0.0.1", port = 6600)
-    @socket = TCPSocket.new(host, port)
+    @host = host
+    @port = port
+  end
+
+  def connect
+    @socket = socket
     @socket.gets
   end
 
-  def play(song = nil)
-    song.nil? ? command = "play" : command = "play #{song.to_s}"
-    puts(command)
+  def disconnect
+    @socket.close
+    @socket = nil
   end
 
-  def pause
-    puts("pause 1")
+  def play
+    send_command "play"
   end
 
-  def paused?
-    status_hash = status
-    status_hash[:state] == "pause"
+  def playing?
+    status[:state] == "play"
   end
 
   def stop
-    puts("stop")
+    send_command "stop"
   end
 
   def stopped?
-    status_hash = status
-    status_hash[:state] == "stop"
+    status[:state] == "stop"
+  end
+
+  def pause
+    send_command "pause 1"
+  end
+
+  def paused?
+    status[:state] == "pause"
   end
 
   def next
-    puts("next")
+    send_command "next"
   end
 
   def previous
-    puts("previous")
+    send_command "previous"
   end
 
   def random(state = nil)
-    if state.nil?
-      random? ? random_state = 0 : random_state = 1
-    else
-      random_state = state
-    end
-    puts("random #{random_state}")
+    state ||= bool_to_int(!random?)
+    send_command "random #{state}"
   end
 
   def random?
-    status_hash = status
-    status_hash[:random] == "1"
+    status[:random] == "1"
   end
 
   def repeat(state = nil)
-    if state.nil?
-      repeat? ? repeat_state = 0 : repeat_state = 1
-    else
-      repeat_state = state
-    end
-    puts("repeat #{repeat_state}")
+    state ||= bool_to_int(!repeat?)
+    send_command "repeat #{state}"
   end
 
   def repeat?
-    status_hash = status
-    status_hash[:repeat] == "1"
+    status[:repeat] == "1"
   end
 
-  def set_volume(volume)
-    begin
-      unless (0..100).include?(volume)
-        raise Exception.new("Volume should be between 0 (minimum) and 100 (maximum)")
-      end
-      puts("setvol #{volume.to_s}")
-    end
+  def volume(level = nil)
+    set_volume(level) if level
+    get_volume
   end
 
- def volume
-   status_hash = status
-   status_hash[:volume]
- end
-
- def volume_up
-  set_volume(volume.to_i + 20)
- end
-
- def volume_down
-  set_volume(volume.to_i - 20)
- end
-
- def seek(time, song = nil)
-  if song.nil?
-    song = current_song[:pos]
+  def volume_up
+    set_volume(volume.to_i + 20)
   end
-  puts("seek #{song.to_s} #{time.to_s}")
- end
 
- def find(type, what = "")
-  unless type.match(/\A(title|artist|album|filename)\Z/)
-    raise Exception.new("Wrong type: #{type}")
+  def volume_down
+    set_volume(volume.to_i - 20)
   end
-  if what == ""
-    raise Exception.new(" \"What\" can\"t be an empty string")
-  end
-  parse_song_list(puts("search #{type} #{what}"))
- end
-
- def current_playlist_songs
-  parse_song_list(puts("playlistid"))
- end
-
- def list_all_songs
-  parse_song_list(puts("listallinfo"))
- end
-
- def current_song
-   parse_song_list(puts("currentsong")).first
- end
-
- def stats
-   to_hash(puts("stats"))
- end
 
- def ping
-   unless status[:state] == "stop"
-     output = {:song_time=>current_song[:time],:time=>status[:time].split(":").first,:artist=>current_song[:artist],:title=>current_song[:title],:file=>current_song[:file],:album=>current_song[:album],:id=>current_song[:id]}
-   else
-     output = {:song_time=>0,:time=>0,:artist=>nil,:title=>nil,:file=>nil,:album=>nil,:id=>nil}
-   end
- end
+  private
 
- def list_playlists
-   output = Array.new
-   puts("listplaylists").each do |line|
-     if line.match(/\Aplaylist\:(.*)\n\Z/)
-       output << to_hash(line)
-     end
-   end
-   output
- end
-
- def list_playlist_info(name)
-   parse_song_list(puts("listplaylistinfo #{name}"))
- end
-
- def add_to_playlist(uri, name = nil)
-   if name.nil?
-     puts("add \"#{uri}\"")
-   else
-     puts("playlistadd \"#{name}\" \"#{uri}\"")
-   end
- end
-
- def rename_playlist(original_name, name)
-  puts("rename \"#{original_name}\" \"#{name}\"")
- end
-
- def create_playlist(name)
-  puts("save \"#{name}\"")
- end
-
- def destroy_playlist(name)
-  puts("rm \"#{name}\"")
- end
-
- def clear!(name = nil)
-   if name.nil?
-     puts("clear")
-   else
-     puts("playlistclear \"#{name}\"")
-   end
- end
-
- def get_paths
-  song_list(puts("listall"))
- end
+  def get_volume
+    status[:volume]
+  end
 
- def list_library
-   root = Tree::TreeNode.new("/")
-   # root = Hash.new
-   get_paths.each do |path|
-     segments = path.split("/")
-     if root[segments.first].nil?
-       root << Tree::TreeNode.new(segments.first,segments.first)
-       # root[segments.first] = {}
-     end
-     last_element = root[segments.first]
-     first_element = segments.delete_at(0)
-     segments.each_with_index do |element, index|
-        if last_element[element].nil?
-          last_element << Tree::TreeNode.new(element, first_element + "/" + segments[0...index+1].join("/") )
-          # last_element[element] = {}
-        end
-        last_element = last_element[element]
-     end
-   end
-   root
- end
+  def set_volume(level)
+    level = 0 if level < 0
+    level = 100 if level > 100
+    send_command "setvol #{level.to_s}"
+  end
 
- def delete_song(song)
-   puts("delete #{song.to_s}")
- end
+  def socket
+    TCPSocket.new(@host, @port)
+  end
 
- def move_song(from, to)
-  puts("move #{from.to_s} #{to.to_s}")
- end
- private
+  def gets_from_socket
+    @socket.gets
+  end
 
-  def puts(command)
+  def send_command(command)
+    raise StandardError unless @socket
     @socket.puts(command)
-    gets
+    get_response
   end
 
-  def gets
+  def get_response
     response = ""
-    while line = @socket.gets do
+    while line = gets_from_socket do
       if @@regexps["OK"].match(line)
         return response
       elsif error = @@regexps["ACK"].match(line)
-        raise Exception.new(line)
+        raise ArgumentError.new(line)
       else
         response << line
       end
@@ -228,45 +127,20 @@ class Mpc
     response
   end
 
-  def status
-    output = puts("status")
-    to_hash(output)
-  end
-
   def to_hash(string)
-    status_hash = Hash.new
-    string.each do |line|
-      key, value = line.chomp.split(": ", 2) 
-      status_hash[key.downcase.to_sym] = value
-    end 
-    status_hash
-  end
-
-  def parse_song_list(song_list)
-    output = Array.new
-    song_hash = Hash.new
-    song_list.each do |song|
-      if song.match(@@regexps["FILE"])
-        output << song_hash
-        song_hash = Hash.new
-      end
-      song_hash.merge!(to_hash(song))
+    output = Hash.new
+    string.each_line do |line|
+      key, value = line.chomp.split(": ", 2)
+      output[key.to_sym] = value
     end
-    output << song_hash
-    output.delete_at(0)
     output
   end
 
-  def song_list(list)
-    output = Array.new
-    list.each do |song|
-      if song.match(@@regexps["FILE"])
-        output << song.split(": ",2).second.gsub!("\n","")
-      end
-    end
-    output
+  def status
+    to_hash(send_command("status"))
   end
 
-  class Exception < StandardError  
+  def bool_to_int(bool)
+    bool == true ? 1 : 0
   end
-end
+end

data/lib/mpc/version.rb

@@ -0,0 +1,3 @@
+module Mpc
+  VERSION = "0.9"
+end

data/mpc.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mpc/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mpc"
+  s.version     = Mpc::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michał Krzyżanowski"]
+  s.email       = ["michal.krzyzanowski+github@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{MPD client}
+  s.description = %q{Ruby MPD client}
+
+  s.rubyforge_project = "mpc"
+
+  s.add_dependency("rubytree")
+
+  s.add_development_dependency("mocha")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/mpc_test.rb

@@ -1,189 +1,35 @@
-require "rubygems"
-require "mocha"
+require "test_helper"
 
-gem "test-unit"
+class MpcTest < MiniTest::Unit::TestCase
 
-require "test/unit"
-require "lib/mpc"
-require "tree"
-
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-class MpcTest < Test::Unit::TestCase
-  
   def setup
+    @socket_mock = stub("TCPSocket", :puts => nil, :gets => nil, :close => nil)
     @mpc = Mpc.new
-    TCPSocket.any_instance.stubs(:puts).returns(nil)
-  end
-  
-  test "gets raises an exception on ACK response" do
-    TCPSocket.any_instance.stubs(:gets).returns("ACK [5@0] {} unknown command \"asd\"\n")
-    assert_raise(Mpc::Exception) do 
-      @mpc.send(:puts,'asd')
-    end
-  end
-  
-  test "gets outputs empty string on OK response " do
-    TCPSocket.any_instance.stubs(:gets).returns("OK\n")
-    assert_equal("",@mpc.stop )
-  end
-
-  test "status outputs propper hash" do
-    @mpc.stubs(:gets).returns("volume: -1\nrepeat: 0\nrandom: 0\nsingle: 0\nconsume: 0\nplaylist: 43\nplaylistlength: 41\nxfade: 0\nstate: stop\nsong: 17\nsongid: 17\nnextsong: 18\nnextsongid: 18\n")
-    assert_equal({:songid=>"17", :state=>"stop", :single=>"0", :volume=>"-1", :nextsong=>"18", :consume=>"0", :nextsongid=>"18", :playlist=>"43", :repeat=>"0", :song=>"17", :playlistlength=>"41", :random=>"0", :xfade=>"0"},@mpc.send(:status) )
-  end
-
-  test "random without state should send request with opposite value" do
-    @mpc.stubs(:status).returns({:songid=>"17", :state=>"stop", :single=>"0", :volume=>"-1", :nextsong=>"18", :consume=>"0", :nextsongid=>"18", :playlist=>"43", :repeat=>"0", :song=>"17", :playlistlength=>"41", :random=>"0", :xfade=>"0"})
-    @mpc.expects(:puts).with('random 1')
-    @mpc.random
-  end
-
-  test "random with state should send request with given value" do
-    @mpc.stubs(:status).returns({:songid=>"17", :state=>"stop", :single=>"0", :volume=>"-1", :nextsong=>"18", :consume=>"0", :nextsongid=>"18", :playlist=>"43", :repeat=>"0", :song=>"17", :playlistlength=>"41", :random=>"0", :xfade=>"0"})
-    @mpc.expects(:puts).with('random 0')
-    @mpc.random(0)
-  end
-
-  test "repeat without state should send request with opposite value" do
-    @mpc.stubs(:status).returns({:songid=>"17", :state=>"stop", :single=>"0", :volume=>"-1", :nextsong=>"18", :consume=>"0", :nextsongid=>"18", :playlist=>"43", :repeat=>"0", :song=>"17", :playlistlength=>"41", :random=>"0", :xfade=>"0"})
-    @mpc.expects(:puts).with('repeat 1')
-    @mpc.repeat
-  end
-
-  test "repeat with state should send request with given value" do
-    @mpc.stubs(:status).returns({:songid=>"17", :state=>"stop", :single=>"0", :volume=>"-1", :nextsong=>"18", :consume=>"0", :nextsongid=>"18", :playlist=>"43", :repeat=>"0", :song=>"17", :playlistlength=>"41", :random=>"0", :xfade=>"0"})
-    @mpc.expects(:puts).with('repeat 0')
-    @mpc.repeat(0)
-  end
-
-  test "set_volume with volume in propper range should not raise exception" do
-    @mpc.expects(:puts).with('setvol 100')
-    @mpc.set_volume(100)
-  end
-
-  test "setvol with volume out of range should raise exception" do
-    assert_raise(Mpc::Exception) do
-      @mpc.set_volume(200)
-    end
-  end
-
-  test "seek without song_position seeks current song" do
-    @mpc.stubs(:current_song).returns({:date=>"2008", :track=>"4", :album=>"One Kind Favor", :genre=>"Blues", :time=>"190", :file=>"Kuba's Music/B.B. King - One Kind Favor/04. B.B. King - How Many More Years.mp3", :pos=>"3", :title=>"How Many More Years", :id=>"3", :albumartist=>"B.B. King", :artist=>"B.B. King"})
-    @mpc.expects(:puts).with('seek 3 130')
-    @mpc.seek(130)
-  end
-
-  test "seek with song_position seeks given song" do
-    @mpc.stubs(:current_song).returns({:date=>"2008", :track=>"4", :album=>"One Kind Favor", :genre=>"Blues", :time=>"190", :file=>"Kuba's Music/B.B. King - One Kind Favor/04. B.B. King - How Many More Years.mp3", :pos=>"3", :title=>"How Many More Years", :id=>"3", :albumartist=>"B.B. King", :artist=>"B.B. King"})
-    @mpc.expects(:puts).with('seek 11 20')
-    @mpc.seek(20,11)
-  end
-
-  test "find with wrong type should raise exception" do
-    assert_raise(Mpc::Exception) do
-      @mpc.find('wrong_type')
-    end
-  end
-
-  test "find with correct type but with empty string should raise exception" do
-    assert_raise(Mpc::Exception) do
-      @mpc.find('artist',"")
-    end
-  end
-
-  test "find with correct type and with string should return hash with songs" do
-
+    @mpc.stubs(:socket).returns(@socket_mock)
+    @mpc.connect
   end
 
-  test "list_library should return tree" do
-    @mpc.stubs(:get_paths).returns(["Abra Dab/Miasto Jest Nasze/ABRADAB - Bezposrednio.mp3",
-    "Abra Dab/Miasto Jest Nasze/miasto jest nasze (3).mp3",
-    "iTunes/iTunes Music/02. Aaliyah/Romeo must die/06 Are You Feelin Me.mp3",
-    "iTunes/iTunes Music/07. Dave Bing ft. Lil' Mo/Romeo must die/12 Someone Gonna Die Tonight.mp3"])
-    @root = Tree::TreeNode.new('/')
-    @first_node = Tree::TreeNode.new('Abra Dab')
-    
-    @folder = Tree::TreeNode.new('Miasto Jest Nasze')
-    @folder << Tree::TreeNode.new('ABRADAB - Bezposrednio.mp3')
-    @folder << Tree::TreeNode.new('miasto jest nasze (3).mp3') 
-    
-    @first_node << @folder
-    @root << @first_node
-    
-    @second_node = Tree::TreeNode.new('iTunes')
-    @folder = Tree::TreeNode.new('iTunes Music')
-    @first_subfolder = Tree::TreeNode.new('02. Aaliyah')
-    @element = Tree::TreeNode.new('Romeo must die')
-    @mp3 = Tree::TreeNode.new('06 Are You Feelin Me.mp3')
-    @element << @mp3
-    @first_subfolder << @element
-    @second_subfolder = Tree::TreeNode.new("07. Dave Bing ft Lil' Mo")
-    @element = Tree::TreeNode.new('Romeo must die')
-    @mp3 = Tree::TreeNode.new('12 Someone Gonna Die Tonight.mp3')
-    @element << @mp3
-    @second_subfolder << @element
-    
-    @folder << @first_subfolder
-    @folder << @second_subfolder
-    @second_node << @folder
-    @root << @second_node
-    
-    assert_equal(@root.to_s,@mpc.list_library.to_s)
+  def test_library_raises_error_if_there_is_no_connection
+    @mpc.disconnect
+    assert_raises(StandardError){
+      @mpc.play
+    }    
   end
 
-  test "move_song should send move command" do
-    @mpc.expects(:puts).with("move 1 3")
-    @mpc.move_song(1,3)
+  def test_gets_raises_an_exception_on_ACK_response
+    @mpc.stubs(:gets_from_socket).returns("ACK [5@0] {} unknown command \"asd\"\n")
+    assert_raises(ArgumentError){
+      @mpc.send(:send_command, "asd")
+    }
   end
 
-  test "list_playlists should return array with playlists" do
-    @mpc.stubs(:puts).returns("playlist: asd\nLast-Modified: 2010-08-02T08:39:28Z\nplaylist: foo\nLast-Modified: 2010-08-11T07:35:43Z\nplaylist: nowa\nLast-Modified: 2010-08-02T07:39:52Z\n")
-    expected_output = Array.new
-    expected_output << {:playlist => "asd"}
-    expected_output << {:playlist => "foo"}
-    expected_output << {:playlist => "nowa"}
-    assert_equal(expected_output,@mpc.list_playlists)
+  def test_gets_outputs_empty_string_on_OK_response
+    @mpc.stubs(:gets_from_socket).returns("OK\n")
+    assert_equal("", @mpc.stop )
   end
 
-  test "ping method should return hash with informations about song" do
-    @mpc.stubs(:current_song).returns({
-        :date=> "2001",
-        :id=> "23",
-        :title=> "ToNieMy",
-        :file=> "Paktofonika - Kinematografia/ToNieMy.mp3",
-        :time=> "227",
-        :album=> "Kinematografia",
-        :track=> "6",
-        :pos=> "5",
-        :genre=> "Hip-Hop",
-        :artist=> "Paktofonika"} )
-    @mpc.stubs(:status).returns({
-             :bitrate=> "128",
-             :song=> "5",
-             :volume=> "-1",
-             :audio=> "44100:24:2",
-             :consume=> "0",
-             :repeat=> "0",
-             :nextsong=> "6",
-             :time=> "102:227",
-             :playlist=> "54",
-             :state=> "play",
-             :playlistlength=> "23",
-             :nextsongid=> "24",
-             :xfade=> "0",
-             :random=> "0",
-             :songid=> "23",
-             :single=> "0"})
-    expected_output = {
-              :title=>"ToNieMy",
-              :file=>"Paktofonika - Kinematografia/ToNieMy.mp3",
-              :artist=>"Paktofonika",
-              :album=>"Kinematografia",
-              :song_time=>"227",
-              :id=>"23",
-              :time=>"102"}
-    assert_equal(expected_output,@mpc.ping)
+  def test_status_outputs_propper_hash
+    @mpc.stubs(:get_response).returns("volume: -1\nrepeat: 0\nrandom: 0\nsingle: 0\nconsume: 0\nplaylist: 43\nplaylistlength: 41\nxfade: 0\nstate: stop\nsong: 17\nsongid: 17\nnextsong: 18\nnextsongid: 18\n")
+    assert_equal({:songid=>"17", :state=>"stop", :single=>"0", :volume=>"-1", :nextsong=>"18", :consume=>"0", :nextsongid=>"18", :playlist=>"43", :repeat=>"0", :song=>"17", :playlistlength=>"41", :random=>"0", :xfade=>"0"}, @mpc.send(:status) )
   end
 end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require "minitest/unit"
+require "minitest/autorun"
+require "mocha"
+require "mpc"

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: mpc
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 8
-  version: "0.8"
+  prerelease: 
+  version: "0.9"
 platform: ruby
 authors: 
 - "Micha\xC5\x82 Krzy\xC5\xBCanowski"
@@ -14,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-12 00:00:00 +02:00
+date: 2011-08-04 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,14 +21,23 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
         version: "0"
   type: :runtime
   version_requirements: *id001
-description: Ruby MPD client gem
-email: michal.krzyzanowski+mpc@gmail.com
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Ruby MPD client
+email: 
+- michal.krzyzanowski+github@gmail.com
 executables: []
 
 extensions: []
@@ -40,10 +45,16 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .gitignore
+- Gemfile
+- Rakefile
 - lib/mpc.rb
+- lib/mpc/version.rb
+- mpc.gemspec
 - test/mpc_test.rb
+- test/test_helper.rb
 has_rdoc: true
-homepage: 
+homepage: ""
 licenses: []
 
 post_install_message: 
@@ -56,25 +67,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.7
+rubyforge_project: mpc
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
-summary: MPD client gem
+summary: MPD client
 test_files: 
 - test/mpc_test.rb
+- test/test_helper.rb