ruby-mpd 0.1.4

data/lib/ruby-mpd.rb

@@ -0,0 +1,310 @@
+require 'socket'
+require 'thread'
+
+require 'ruby-mpd/song'
+require 'ruby-mpd/parser'
+require 'ruby-mpd/playlist'
+
+require 'ruby-mpd/plugins/information'
+require 'ruby-mpd/plugins/playback_options'
+require 'ruby-mpd/plugins/controls'
+require 'ruby-mpd/plugins/queue'
+require 'ruby-mpd/plugins/playlists'
+require 'ruby-mpd/plugins/database'
+require 'ruby-mpd/plugins/stickers'
+require 'ruby-mpd/plugins/outputs'
+require 'ruby-mpd/plugins/reflection'
+require 'ruby-mpd/plugins/channels'
+
+# TODO: object oriented: song commands and dir commands
+# in MPD::Song, MPD::Directory.
+# Make stickers a mixin for Playlist, Song, Directory...
+# TODO: Namespace queue?
+# TODO: fix parser to use build_group also
+
+# command list as a do block
+# mpd.command_list do
+#   volume 10
+#   play xyz
+# end
+
+# Playlist#rename -> Playlist#name= ?
+#   MPD::Playlist.new(mpd, 'name')  no mpd?
+
+# make it possible to use MPD::Song objects instead of filepath strings
+
+# error codes stored in ack.h
+
+# @!macro [new] error_raise
+#   @raise (see #send_command)
+# @!macro [new] returnraise
+#   @return [Boolean] returns true if successful.
+#   @macro error_raise
+
+# The main class/namespace of the MPD client.
+class MPD
+
+  # Standard MPD error.
+  class MPDError < StandardError; end
+
+  include Parser
+
+  include Plugins::Information
+  include Plugins::PlaybackOptions
+  include Plugins::Controls
+  include Plugins::Queue
+  include Plugins::Playlists
+  include Plugins::Database
+  include Plugins::Stickers
+  include Plugins::Outputs
+  include Plugins::Reflection
+  include Plugins::Channels
+
+  # The version of the MPD protocol the server is using.
+  attr_reader :version
+  # A list of tags MPD accepts.
+  attr_reader :tags
+
+  # Initialize an MPD object with the specified hostname and port.
+  # When called without arguments, 'localhost' and 6600 are used.
+  def initialize(hostname = 'localhost', port = 6600)
+    @hostname = hostname
+    @port = port
+    @socket = nil
+    @version = nil
+
+    @stop_cb_thread = false
+    @mutex = Mutex.new
+    @cb_thread = nil
+    @callbacks = {}
+  end
+
+  # This will register a block callback that will trigger whenever
+  # that specific event happens.
+  #
+  #   mpd.on :volume do |volume|
+  #     puts "Volume was set to #{volume}"!
+  #   end
+  #
+  # One can also define separate methods or Procs and whatnot,
+  # just pass them in as a parameter.
+  #
+  #  method = Proc.new {|volume| puts "Volume was set to #{volume}"! }
+  #  mpd.on :volume, &method
+  #
+  def on(event, &block)
+    @callbacks[event] ||= []
+    @callbacks[event].push block
+  end
+
+  # Triggers an event, running it's callbacks.
+  # @param [Symbol] event The event that happened.
+  def emit(event, *args)
+    @callbacks[event] ||= []
+    @callbacks[event].each do |handle|
+      handle.call *args
+    end
+  end
+
+  # Connect to the daemon.
+  #
+  # When called without any arguments, this will just connect to the server
+  # and wait for your commands.
+  #
+  # When called with true as an argument, this will enable callbacks by starting
+  # a seperate polling thread, which will also automatically reconnect if disconnected
+  # for whatever reason.
+  #
+  # @return [true] Successfully connected.
+  # @raise [MPDError] If connect is called on an already connected instance.
+  def connect(callbacks = false)
+    raise MPDError, 'Already Connected!' if self.connected?
+
+    @socket = File.exists?(@hostname) ? UNIXSocket.new(@hostname) : TCPSocket.new(@hostname, @port)
+    @version = @socket.gets.chomp.gsub('OK MPD ', '') # Read the version
+
+    if callbacks and (@cb_thread.nil? or !@cb_thread.alive?)
+      @stop_cb_thread = false
+      @cb_thread = Thread.new(self) { |mpd|
+        old_status = {}
+        connected = ''
+        while !@stop_cb_thread
+          status = mpd.status rescue {}
+          c = mpd.connected?
+
+          # @todo Move into status[:connection]?
+          if connected != c
+            connected = c
+            emit(:connection, connected)
+          end
+
+          status[:time] = [nil, nil] if !status[:time] # elapsed, total
+          status[:audio] = [nil, nil, nil] if !status[:audio] # samp, bits, chans
+
+          status.each do |key, val|
+            next if val == old_status[key] # skip unchanged keys
+
+            if key == :song
+              emit(:song, mpd.current_song)
+            else # convert arrays to splat arguments
+              val.is_a?(Array) ? emit(key, *val) : emit(key, val)
+            end
+          end
+
+          old_status = status
+          sleep 0.1
+
+          if !connected
+            sleep 2
+            unless @stop_cb_thread
+              mpd.connect rescue nil
+            end
+          end
+        end
+      }
+    end
+
+    return true
+  end
+
+  # Check if the client is connected.
+  #
+  # @return [Boolean] True only if the server responds otherwise false.
+  def connected?
+    return false if !@socket
+
+    ret = send_command(:ping) rescue false
+    return ret
+  end
+
+  # Disconnect from the MPD daemon. This has no effect if the client is not
+  # connected. Reconnect using the {#connect} method. This will also stop
+  # the callback thread, thus disabling callbacks.
+  def disconnect
+    @stop_cb_thread = true
+
+    return if @socket.nil?
+
+    @socket.puts 'close'
+    @socket.close
+    @socket = nil
+  end
+
+  # Kills the MPD process.
+  # @macro returnraise
+  def kill
+    send_command :kill
+  end
+
+  # Used for authentication with the server
+  # @param [String] pass Plaintext password
+  def password(pass)
+    send_command :password, pass
+  end
+
+  # Ping the server.
+  # @macro returnraise
+  def ping
+    send_command :ping
+  end
+
+  ###--- OTHER ---###
+
+  # Lists all of the albums in the database.
+  # The optional argument is for specifying an artist to list
+  # the albums for
+  #
+  # @return [Array<String>] An array of album names.
+  def albums(artist = nil)
+    list :album, artist
+  end
+
+  # Lists all of the artists in the database.
+  #
+  # @return [Array<String>] An array of artist names.
+  def artists
+    list :artist
+  end
+
+  # List all of the directories in the database, starting at path.
+  # If path isn't specified, the root of the database is used
+  #
+  # @return [Array<String>] Array of directory names
+  def directories(path = nil)
+    response = send_command :listall, path
+    return response[:directory]
+  end
+
+  # List all of the files in the database, starting at path.
+  # If path isn't specified, the root of the database is used
+  #
+  # @return [Array<String>] Array of file names
+  def files(path = nil)
+    response = send_command(:listall, path)
+    return response[:file]
+  end
+
+  # List all of the songs by an artist.
+  #
+  # @return [Array<MPD::Song>]
+  def songs_by_artist(artist)
+    find :artist, artist
+  end
+
+  # Used to send a command to the server. This synchronizes
+  # on a mutex to be thread safe
+  #
+  # @return (see #handle_server_response)
+  # @raise [MPDError] if the command failed.
+  def send_command(command, *args)
+    raise MPDError, "Not Connected to the Server" if @socket.nil?
+
+    @mutex.synchronize do
+      begin
+        @socket.puts convert_command(command, *args)
+        return handle_server_response
+      rescue Errno::EPIPE
+        @socket = nil
+        raise MPDError, 'Broken Pipe (Disconnected)'
+      end
+    end
+  end
+
+  private
+
+  # Handles the server's response (called inside {#send_command}).
+  # Repeatedly reads the server's response from the socket and
+  # processes the output.
+  #
+  # @return (see Parser#build_response)
+  # @return [true] If "OK" is returned.
+  # @raise [MPDError] If an "ACK" is returned.
+  def handle_server_response
+    return if @socket.nil?
+
+    msg = ''
+    reading = true
+    error = nil
+    while reading
+      line = @socket.gets
+      case line
+      when "OK\n", nil
+        reading = false
+      when /^ACK/
+        error = line
+        reading = false
+      else
+        msg += line
+      end
+    end
+
+    if !error
+      return true if msg.empty?
+      return build_response(msg)
+    else
+      err = error.match(/^ACK \[(?<code>\d+)\@(?<pos>\d+)\] \{(?<command>.*)\} (?<message>.+)$/)
+      raise MPDError, "#{err[:code]}: #{err[:command]}: #{err[:message]}"
+    end
+  end
+
+end

data/lib/ruby-mpd/parser.rb

@@ -0,0 +1,151 @@
+require 'time' # required for Time.iso8601
+
+class MPD
+  # Parser module, being able to parse messages to and from the MPD daemon format.
+  module Parser
+    private
+
+    # Parses the command into MPD format.
+    def convert_command(command, *args)
+      args.map! do |word|
+        if word.is_a?(TrueClass) || word.is_a?(FalseClass)
+          word ? '1' : '0' # convert bool to 1 or 0
+        elsif word.is_a?(Range)
+          if word.end == -1 #negative means to end of range
+            "#{word.begin}:"
+          else
+            "#{word.begin}:#{word.end + (word.exclude_end? ? 0 : 1)}"
+          end
+        else
+          # escape any strings with space (wrap in double quotes)
+          word = word.to_s
+          word.match(/\s|'/) ? %Q["#{word}"] : word
+        end
+      end
+      return [command, args].join(' ').strip
+    end
+
+    INT_KEYS = [
+      :song, :artists, :albums, :songs, :uptime, :playtime, :db_playtime, :volume,
+      :playlistlength, :xfade, :pos, :id, :date, :track, :disc, :outputid, :mixrampdelay,
+      :bitrate, :nextsong, :nextsongid, :songid, :updating_db,
+      :musicbrainz_trackid, :musicbrainz_artistid, :musicbrainz_albumid, :musicbrainz_albumartistid
+    ]
+
+    SYM_KEYS = [:command, :state, :changed, :replay_gain_mode, :tagtype]
+    FLOAT_KEYS = [:mixrampdb, :elapsed]
+    BOOL_KEYS = [:repeat, :random, :single, :consume, :outputenabled]
+
+    # Parses key-value pairs into correct class
+    # @todo special parsing of playlist, it's a int in :status and a string in :listplaylists
+
+    def parse_key key, value
+      if INT_KEYS.include? key
+        value.to_i
+      elsif FLOAT_KEYS.include? key
+        value == 'nan' ? Float::NAN : value.to_f
+      elsif BOOL_KEYS.include? key
+        value != '0'
+      elsif SYM_KEYS.include? key
+        value.to_sym
+      elsif key == :playlist && !value.to_i.zero?
+        # doc states it's an unsigned int, meaning if we get 0,
+        # then it's a name string. HAXX! what if playlist name is '123'?
+        # @todo HAXX
+        value.to_i
+      elsif key == :db_update
+        Time.at(value.to_i)
+      elsif key == :"last-modified"
+        Time.iso8601(value)
+      elsif [:time, :audio].include? key
+        value.split(':').map(&:to_i)
+      else
+        value.force_encoding('UTF-8')
+      end
+    end
+
+    # Parses a single response line into an object.
+    def parse_line(string)
+      return nil if string.nil?
+      key, value = string.split(': ', 2)
+      key = key.downcase.to_sym
+      value ||= '' # no nil values please ("album: ")
+      return parse_key(key, value.chomp)
+    end
+
+    # This builds a hash out of lines returned from the server,
+    # elements parsed into the correct type.
+    #
+    # The end result is a hash containing the proper key/value pairs
+    def build_hash(string)
+      return {} if string.nil?
+
+      string.split("\n").each_with_object({}) do |line, hash|
+        key, value = line.split(': ', 2)
+        key = key.downcase.to_sym
+        value ||= '' # no nil values please ("album: ")
+
+        # if val appears more than once, make an array of vals.
+        if hash.include? key
+          hash[key] = [hash[key]] if !hash[key].is_a?(Array) # if necessary
+          hash[key] << parse_key(key, value.chomp) # add new val to array
+        else # val hasn't appeared yet, map it.
+          hash[key] = parse_key(key, value.chomp) # map val to key
+        end
+      end
+    end
+
+    # Converts the response to MPD::Song objects.
+    # @return [Array<MPD::Song>] An array of songs.
+    def build_songs_list(array)
+      return [] if !array.is_a?(Array)
+      return array.map {|hash| Song.new(hash) }
+    end
+
+    # Make chunks from string.
+    # @return [Array<String>]
+    def make_chunks(string)
+      first_key = string.match(/\A(.+?): /)[1]
+
+      chunks = string.split(/\n(?=#{first_key})/)
+      chunks.inject([]) do |result, chunk|
+        result << chunk.strip
+      end
+    end
+
+    # Parses the response into appropriate objects (either a single object,
+    # or an array of objects or an array of hashes).
+    #
+    # @return [Array<Hash>, Array<String>, String, Integer] Parsed response.
+    def build_response(string)
+      return [] if string.nil? || !string.is_a?(String)
+
+      chunks = make_chunks(string)
+      # if there are any new lines (more than one data piece), it's a hash, else an object.
+      is_hash = chunks.any? {|chunk| chunk.include? "\n"}
+
+      list = chunks.inject([]) do |result, chunk|
+        result << (is_hash ? build_hash(chunk) : parse_line(chunk))
+      end
+
+      # if list has only one element, return it, else return array
+      result = list.length == 1 ? list.first : list
+      return result
+    end
+
+    # Parse the response into groups that have the same key (used for file lists,
+    # groups together files, directories and playlists).
+    # @return [Hash<Array>] A hash of key groups.
+    def build_groups(string)
+      return [] if string.nil? || !string.is_a?(String)
+
+      string.split("\n").each_with_object({}) do |line, hash|
+        key, value = line.split(': ', 2)
+        key = key.downcase.to_sym
+        hash[key] ||= []
+        hash[key] << parse_key(key, value.chomp) # map val to key
+      end
+    end
+
+  end
+end