mpd_client 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Anton Maminov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# MPDClient
+
+Yet another Music Player Daemon (MPD) client library written entirely in Ruby.
+`mpd_client` is a Ruby port of the [python-mpd](https://github.com/Mic92/python-mpd2) library.
+
+## Installation
+
+Add this line to your application `Gemfile`:
+
+```ruby
+gem 'mpd_client'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+Or install it yourself as:
+
+```
+$ gem install mpd_client
+```
+
+## Usage
+All functionality is contained in the `MPDClient` class. Creating an instance of this class is as simple as:
+
+```ruby
+client = MPDClient.new
+```
+
+Once you have an instance of the `MPDClient` class, start by connecting to the server:
+
+```ruby
+client.connect('localhost', 6600)
+```
+
+The client library can be used as follows:
+
+```ruby
+puts client.mpd_version             # print the mpd version
+puts client.search('title', 'ruby') # print the result of the command 'search title ruby'
+client.close                        # send the close command
+client.disconect                    # disconnect from the server
+```
+
+Command lists are also supported using `command_list_ok_begin` and `command_list_end`:
+
+```ruby
+client.command_list_ok_begin # start a command list
+client.update                # insert the update command into the list
+client.status                # insert the status command into the list
+client.command_list_end      # result will be a Array with the results
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/mpd_client/version.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+class MPDClient
+  VERSION = "0.0.1"
+end

data/lib/mpd_client.rb

@@ -0,0 +1,329 @@
+# -*- encoding: utf-8 -*-
+
+require 'socket'
+require "mpd_client/version"
+
+HELLO_PREFIX = "OK MPD "
+ERROR_PREFIX = "ACK "
+SUCCESS = "OK"
+NEXT = "list_OK"
+
+# http://mpd.wikia.com/wiki/MusicPlayerDaemonCommands
+COMMANDS = {
+  # Status Commands
+  "clearerror"         => "fetch_nothing",
+  "currentsong"        => "fetch_object",
+  "idle"               => "fetch_list",
+  "noidle"             => "",
+  "status"             => "fetch_object",
+  "stats"              => "fetch_object",
+  # Playback Option Commands
+  "consume"            => "fetch_nothing",
+  "crossfade"          => "fetch_nothing",
+  "mixrampdb"          => "fetch_nothing",
+  "mixrampdelay"       => "fetch_nothing",
+  "random"             => "fetch_nothing",
+  "repeat"             => "fetch_nothing",
+  "setvol"             => "fetch_nothing",
+  "single"             => "fetch_nothing",
+  "replay_gain_mode"   => "fetch_nothing",
+  "replay_gain_status" => "fetch_item",
+  # Playback Control Commands
+  "next"               => "fetch_nothing",
+  "pause"              => "fetch_nothing",
+  "play"               => "fetch_nothing",
+  "playid"             => "fetch_nothing",
+  "previous"           => "fetch_nothing",
+  "seek"               => "fetch_nothing",
+  "seekid"             => "fetch_nothing",
+  "seekcur"            => "fetch_nothing",
+  "stop"               => "fetch_nothing",
+  # Playlist Commands
+  "add"                => "fetch_nothing",
+  "addid"              => "fetch_item",
+  "clear"              => "fetch_nothing",
+  "delete"             => "fetch_nothing",
+  "deleteid"           => "fetch_nothing",
+  "move"               => "fetch_nothing",
+  "moveid"             => "fetch_nothing",
+  "playlist"           => "fetch_playlist",
+  "playlistfind"       => "fetch_songs",
+  "playlistid"         => "fetch_songs",
+  "playlistinfo"       => "fetch_songs",
+  "playlistsearch"     => "fetch_songs",
+  "plchanges"          => "fetch_songs",
+  "plchangesposid"     => "fetch_changes",
+  "prio"               => "fetch_nothing",
+  "prioid"             => "fetch_nothing",
+  "shuffle"            => "fetch_nothing",
+  "swap"               => "fetch_nothing",
+  "swapid"             => "fetch_nothing",
+  # Stored Playlist Commands
+  "listplaylist"       => "fetch_list",
+  "listplaylistinfo"   => "fetch_songs",
+  "listplaylists"      => "fetch_playlists",
+  "load"               => "fetch_nothing",
+  "playlistadd"        => "fetch_nothing",
+  "playlistclear"      => "fetch_nothing",
+  "playlistdelete"     => "fetch_nothing",
+  "playlistmove"       => "fetch_nothing",
+  "rename"             => "fetch_nothing",
+  "rm"                 => "fetch_nothing",
+  "save"               => "fetch_nothing",
+  # Database Commands
+  "count"              => "fetch_object",
+  "find"               => "fetch_songs",
+  "findadd"            => "fetch_nothing",
+  "list"               => "fetch_list",
+  "listall"            => "fetch_database",
+  "listallinfo"        => "fetch_database",
+  "lsinfo"             => "fetch_database",
+  "search"             => "fetch_songs",
+  "update"             => "fetch_item",
+  "rescan"             => "fetch_item",
+  # Sticker Commands
+  "sticker get"        => "fetch_item",
+  "sticker set"        => "fetch_nothing",
+  "sticker delete"     => "fetch_nothing",
+  "sticker list"       => "fetch_list",
+  "sticker find"       => "fetch_songs",
+  # Connection Commands
+  "close"              => "",
+  "kill"               => "",
+  "password"           => "fetch_nothing",
+  "ping"               => "fetch_nothing",
+  # Audio Output Commands
+  "disableoutput"      => "fetch_nothing",
+  "enableoutput"       => "fetch_nothing",
+  "outputs"            => "fetch_outputs",
+  # Reflection Commands
+  "config"             => "fetch_item",
+  "commands"           => "fetch_list",
+  "notcommands"        => "fetch_list",
+  "tagtypes"           => "fetch_list",
+  "urlhandlers"        => "fetch_list",
+  "decoders"           => "fetch_plugins",
+  # Client To Client
+  "subscribe"          => "fetch_nothing",
+  "unsubscribe"        => "fetch_nothing",
+  "channels"           => "fetch_list",
+  "readmessages"       => "fetch_messages",
+  "sendmessage"        => "fetch_nothing"
+}
+
+class MPDClient
+  attr_reader :mpd_version
+
+  def initialize
+    reset
+  end
+
+  def connect(host = 'localhost', port = 6600)
+    @socket = TCPSocket.new(host, port)
+    hello
+  end
+
+  def disconnect
+    @socket.close
+    reset
+  end
+
+  # http://www.musicpd.org/doc/protocol/ch01s04.html
+  def command_list_ok_begin
+    raise "Already in command list" unless @command_list.nil?
+    write_command('command_list_ok_begin')
+    @command_list = []
+  end
+
+  def command_list_end
+    raise "Not in command list" if @command_list.nil?
+    write_command('command_list_end')
+    
+    return fetch_command_list
+  end
+
+  class << self
+    def add_command(name, retval)
+      define_method name.to_sym do |*args|
+        execute(name, *args, retval)
+      end
+    end
+
+    def remove_command(name)
+      raise "Can't remove not existent '#{name}' command" unless method_defined? name.to_sym
+      remove_method name.to_sym
+    end
+  end
+
+  private
+
+  def execute(command, *args, retval)
+    if !@command_list.nil?
+      write_command(command, *args)
+      @command_list << retval
+    else
+      write_command(command, *args)
+      eval retval
+    end
+  end
+
+  def write_line(line)
+    @socket.puts line
+    @socket.flush
+  end
+
+  def write_command(command, *args)
+    parts = [command]
+    args.each{|arg| parts << "\"#{escape(arg)}\""}
+    write_line(parts.join(' '))
+  end
+
+  def read_line
+    line = @socket.gets.force_encoding('utf-8')
+    raise "Connection lost while reading line" unless line.end_with?("\n")
+    line.chomp!
+    if line.start_with?(ERROR_PREFIX)
+      error = line[/#{ERROR_PREFIX}(.*)/, 1].strip
+      raise error
+    end
+
+    if !@command_list.nil?
+      return if line == NEXT
+      raise "Got unexpected '#{SUCCESS}'" if line == SUCCESS
+    elsif line == SUCCESS
+      return
+    end
+
+    return line
+  end
+
+  def read_pair(separator)
+    line = read_line
+    return if line.nil?
+    pair = line.split(separator)
+    raise "Could now parse pair: '#{line}'" if pair.size < 2
+
+    return pair #Array
+  end
+
+  def read_pairs(separator = ': ')
+    result = []
+    pair = read_pair(separator)
+    while pair
+      result << pair
+      pair = read_pair(separator)
+    end
+
+    return result
+  end
+
+  def fetch_item
+    pairs = read_pairs
+    return nil if pairs.size != 1
+    return pairs[0][1]
+  end
+
+  def fetch_nothing
+    line = read_line
+    raise "Got unexpected return value: #{line}" unless line.nil?
+  end
+
+  def fetch_list
+    result = []
+    seen = nil
+    read_pairs.each do |key, value|
+      if key != seen
+        if seen != nil
+          raise "Expected key '#{seen}', got '#{key}'"
+        end
+        seen = key
+      end
+      result << value
+    end
+  end
+
+  def fetch_objects(delimeters = [])
+    result = []
+    obj = {}
+    read_pairs.each do |key, value|
+      key = key.downcase
+      if delimeters.include?(key)
+        result << obj unless obj.empty?
+        obj = {}
+      elsif obj.include?(key)
+        obj[key] << value
+      end
+      obj[key] = value
+    end
+
+    result << obj unless obj.empty?
+
+    return result
+  end
+
+  def fetch_object
+    objs = fetch_objects
+    return objs ? objs[0] : {}
+  end
+
+  def fetch_changes; fetch_objects(['cpos']); end
+  
+  def fetch_songs; fetch_objects(['file']); end
+
+  def fetch_messages; fetch_objects('channel'); end
+
+  def fetch_outputs; fetch_objects(['outputid']); end
+  
+  def fetch_plugins; fetch_objects(['plugin']); end
+
+  def fetch_database; fetch_objects(['file', 'directory', 'playlist']); end
+  
+  def fetch_playlists; fetch_objects(['playlist']); end
+  
+  def fetch_playlist
+    result = []
+    read_pairs(':').each do |key, value|
+      result << value
+    end
+
+    return result
+  end
+
+  def fetch_command_list
+    result = []
+    begin
+      @command_list.each do |retval|
+        result << (eval retval)
+      end
+    ensure
+      @command_list = nil
+    end
+  
+    return result
+  end
+
+
+  def hello
+    line = @socket.gets
+    raise "Connection lost while reading MPD hello" unless line.end_with?("\n")
+    line.chomp!
+    raise "Got invalid MPD hello: #{line}" unless line.start_with?(HELLO_PREFIX)
+    @mpd_version = line[/#{HELLO_PREFIX}(.*)/, 1]
+  end
+
+  def reset
+    @mpd_version = nil
+    @command_list = nil
+    @socket = nil
+  end
+
+  def escape(text)
+    text.gsub("\\", "\\\\").gsub('"', '\\"')
+  end
+
+end
+
+COMMANDS.each_pair do |name, callback|
+  MPDClient.add_command(name, callback)
+end
+

data/mpd_client.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/mpd_client/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Anton Maminov"]
+  gem.email         = ["anton.linux@gmail.com"]
+  gem.description   = %q{Yet another Ruby MPD client library}
+  gem.summary       = %q{Simple Music Player Daemon library written entirely in Ruby}
+  gem.homepage      = "https://github.com/mamantoha/mpd_client"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "mpd_client"
+  gem.require_paths = ["lib"]
+  gem.version       = MPDClient::VERSION
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: mpd_client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Anton Maminov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-30 00:00:00.000000000 Z
+dependencies: []
+description: Yet another Ruby MPD client library
+email:
+- anton.linux@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/mpd_client.rb
+- lib/mpd_client/version.rb
+- mpd_client.gemspec
+homepage: https://github.com/mamantoha/mpd_client
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Simple Music Player Daemon library written entirely in Ruby
+test_files: []