ruby-mpd 0.1.4

data/lib/ruby-mpd/playlist.rb

@@ -0,0 +1,77 @@
+class MPD
+  # An object representing an .m3u playlist stored by MPD.
+  #
+  # Playlists are stored inside the configured playlist directory. They are
+  # addressed with their file name (without the directory and without the
+  # .m3u suffix).
+  #
+  # Some of the commands described in this section can be used to run playlist
+  # plugins instead of the hard-coded simple m3u parser. They can access
+  # playlists in the music directory (relative path including the suffix) or
+  # remote playlists (absolute URI with a supported scheme).
+  #
+  # Changes: rm -> destroy. listplaylistinfo -> songs. Playlist prefixes
+  # dropped also of course. Listplaylist not used, kinda inferior to listplaylistinfo
+  class Playlist
+
+    attr_accessor :name
+
+    def initialize(mpd, options)
+      @name = options[:playlist]
+      @mpd = mpd
+      #@last_modified = options[:'last-modified']
+    end
+
+    # Lists the songs in the playlist. Playlist plugins are supported.
+    # @return [Array<MPD::Song>] songs in the playlist.
+    def songs
+      mpd.build_songs_list @mpd.send_command(:listplaylistinfo, @name)
+    end
+
+    # Loads the playlist into the current queue. Playlist plugins are supported.
+    #
+    # Since 0.17, a range can be passed to load, to load only a part of the playlist.
+    # @macro returnraise
+    def load(range=nil)
+      @mpd.send_command :load, @name, range
+    end
+
+    # Adds URI to the playlist.
+    # @macro returnraise
+    def add(uri)
+      @mpd.send_command :playlistadd, @name, uri
+    end
+
+    # Clears the playlist.
+    # @macro returnraise
+    def clear
+      @mpd.send_command :playlistclear, @name
+    end
+
+    # Deletes song at position POS from the playlist.
+    # @macro returnraise
+    def delete(pos)
+      @mpd.send_command :playlistdelete, @name, pos
+    end
+
+    # Moves song with SONGID in the playlist to the position SONGPOS.
+    # @macro returnraise
+    def move(songid, songpos)
+      @mpd.send_command :playlistmove, @name
+    end
+
+    # Renames the playlist to +new_name+.
+    # @macro returnraise
+    def rename(new_name)
+      @mpd.send_command :rename, @name, new_name
+      @name = new_name
+    end
+
+    # Deletes the playlist from the disk.
+    # @macro returnraise
+    def destroy
+      @mpd.send_command :rm, @name
+    end
+
+  end
+end

data/lib/ruby-mpd/plugins/channels.rb

@@ -0,0 +1,58 @@
+class MPD
+  module Plugins
+    # = Client to client commands
+    #
+    # Clients can communicate with each others over "channels". A channel
+    # is created by a client subscribing to it. More than one client can be
+    # subscribed to a channel at a time; all of them will receive the messages
+    # which get sent to it.
+    #
+    # Each time a client subscribes or unsubscribes, the global idle event
+    # subscription is generated. In conjunction with the channels command, this
+    # may be used to auto-detect clients providing additional services.
+    #
+    # New messages are indicated by the message idle event.
+    module Channels
+
+      # Subscribe to a channel. The channel is created if it does not exist already.
+      # The name may consist of alphanumeric ASCII characters plus underscore, dash, dot and colon.
+      # @param [Symbol, String] channel The channel to subscribe to.
+      # @macro returnraise
+      def subscribe(channel)
+        send_command :subscribe, channel
+      end
+
+      # Unsubscribe from a channel.
+      # @param [Symbol, String] channel The channel to unsibscribe from.
+      # @macro returnraise
+      def unsubscribe(channel)
+        send_command :unsubscribe, channel
+      end
+
+      # Obtain a list of all channels.
+      # @return [Array<String>]
+      # @return [String] if only one channel exists.
+      # @return [true] if no channels exist.
+      def channels
+        send_command :channels
+      end
+
+      # Reads messages for this client. The response is an array of
+      # hashes with +:channel+ and +:message+ keys or true if no messages.
+      # @return [Array<Hash>] Messages recieved.
+      # @return [Hash] if only one message recieved
+      # @return [true] if no messages.
+      def readmessages
+        send_command :readmessages
+      end
+
+      # Send a message to the specified channel.
+      # @param [Symbol, String] channel The channel to send to.
+      # @param [String] message The message to send.
+      # @macro returnraise
+      def sendmessage(channel, message)
+        send_command :sendmessage, channel, message
+      end
+    end
+  end
+end

data/lib/ruby-mpd/plugins/controls.rb

@@ -0,0 +1,72 @@
+class MPD
+  module Plugins
+    # Commands for controlling playback. Changes have been made to {#seek},
+    # command maps to +seekcur+ from MPD and the original seek command is
+    # {#seekpos} here.
+    module Controls
+      # Plays the next song in the playlist.
+      # @macro returnraise
+      def next
+        send_command :next
+      end
+
+      # Resume/pause playback.
+      # @note The use of pause without an argument is deprecated in MPD.
+      # @macro returnraise
+      def pause=(toggle)
+        send_command :pause, toggle
+      end
+
+      # Begin playing the playist.
+      # @param [Integer] pos Position in the playlist to start playing.
+      # @macro returnraise
+      def play(pos = nil)
+        send_command :play, pos
+      end
+
+      # Begin playing the playlist.
+      # @param [Integer] songid ID of the song where to start playing.
+      # @macro returnraise
+      def playid(songid = nil)
+        send_command :playid, songid
+      end
+
+      # Plays the previous song in the playlist.
+      # @macro returnraise
+      def previous
+        send_command :previous
+      end
+
+      # Seeks to the position in seconds within the current song.
+      # If prefixed by '+' or '-', then the time is relative to the current
+      # playing position.
+      #
+      # @since MPD 0.17
+      # @param [Integer, String] time Position within the current song.
+      # Returns true if successful,
+      def seek(time)
+        send_command :seekcur, time
+      end
+
+      # Seeks to the position +time+ (in seconds) of the
+      # song at +pos+ in the playlist.
+      # @macro returnraise
+      def seekpos(pos, time)
+        send_command :seek, pos, time
+      end
+
+      # Seeks to the position +time+ (in seconds) of the song with
+      # the id of +songid+.
+      # @macro returnraise
+      def seekid(songid, time)
+        send_command :seekid, songid, time
+      end
+
+      # Stop playing.
+      # @macro returnraise
+      def stop
+        send_command :stop
+      end
+    end
+  end
+end

data/lib/ruby-mpd/plugins/database.rb

@@ -0,0 +1,79 @@
+class MPD
+  module Plugins
+    # Commands for interacting with the music database.
+    #
+    # Changes: listallinfo -> songs
+    module Database
+
+      # Counts the number of songs and their total playtime
+      # in the db matching, matching the searched tag exactly.
+      # @return [Hash] a hash with +songs+ and +playtime+ keys.
+      def count(type, what)
+        send_command :count, type, what
+      end
+
+      # Finds songs in the database that are *EXACTLY* matched by the what
+      # argument.
+      #
+      # @param [Symbol] type Can be any tag supported by MPD, or one of the two special
+      #   parameters: +:file+ to search by full path (relative to database root),
+      #   and +:any+ to match against all available tags.
+      # @return [Array<MPD::Song>] Songs that matched.
+      def find(type, what)
+        build_songs_list send_command(:find, type, what)
+      end
+
+      # findadd
+
+      # List all tags of the specified type.
+      # Type can be any tag supported by MPD or +:file+.
+      # If type is 'album' then arg can be a specific artist to list the albums for
+      #
+      # @return [Array<String>]
+      def list(type, arg = nil)
+        send_command :list, type, arg
+      end
+
+      # listall
+
+      # List all of the songs in the database starting at path.
+      # If path isn't specified, the root of the database is used
+      #
+      # @return [Array<MPD::Song>]
+      def songs(path = nil)
+        build_songs_list send_command(:listallinfo, path)
+      end
+
+      # lsinfo
+
+      # Searches for any song that contains +what+ in the +type+ field.
+      # Searches are *NOT* case sensitive.
+      #
+      # @param (see #find)
+      # @return [Array<MPD::Song>] Songs that matched.
+      def search(type, what)
+        build_songs_list(send_command(:search, type, what))
+      end
+
+      # searchadd
+
+      # searchaddpl
+
+      # Tell the server to update the database. Optionally,
+      # specify the path to update.
+      #
+      # @return [Integer] Update job ID
+      def update(path = nil)
+        send_command :update, path
+      end
+
+      # Same as {#update}, but also rescans unmodified files.
+      #
+      # @return [Integer] Update job ID
+      def rescan(path = nil)
+        send_command :rescan, path
+      end
+
+    end
+  end
+end

data/lib/ruby-mpd/plugins/information.rb

@@ -0,0 +1,146 @@
+class MPD
+  module Plugins
+    # Informational commands regarding MPD's current status.
+    module Information
+
+      # Clears the current error message reported in status
+      # (also accomplished by any command that starts playback).
+      #
+      # @macro returnraise
+      def clearerror
+        send_command :clearerror
+      end
+
+      # Get the currently playing song
+      #
+      # @return [MPD::Song]
+      def current_song
+        Song.new send_command :currentsong
+      end
+
+      # Waits until there is a noteworthy change in one or more of MPD's subsystems.
+      # As soon as there is one, it lists all changed systems in a line in the format
+      # 'changed: SUBSYSTEM', where SUBSYSTEM is one of the following:
+      #
+      # * *database*: the song database has been modified after update.
+      # * *update*: a database update has started or finished. If the database was modified
+      #   during the update, the database event is also emitted.
+      # * *stored_playlist*: a stored playlist has been modified, renamed, created or deleted
+      # * *playlist*: the current playlist has been modified
+      # * *player*: the player has been started, stopped or seeked
+      # * *mixer*: the volume has been changed
+      # * *output*: an audio output has been enabled or disabled
+      # * *options*: options like repeat, random, crossfade, replay gain
+      # * *sticker*: the sticker database has been modified.
+      # * *subscription*: a client has subscribed or unsubscribed to a channel
+      # * *message*: a message was received on a channel this client is subscribed to; this
+      #   event is only emitted when the queue is empty
+      #
+      # If the optional +masks+ argument is used, MPD will only send notifications
+      # when something changed in one of the specified subsytems.
+      #
+      # @since MPD 0.14
+      # @param [Symbol] masks A list of subsystems we want to be notified on.
+      def idle(*masks)
+        send_command(:idle, *masks)
+      end
+
+      # MPD status: volume, time, modes...
+      # * *volume*: 0-100
+      # * *repeat*: true or false
+      # * *random*: true or false
+      # * *single*: true or false
+      # * *consume*: true or false
+      # * *playlist*: 31-bit unsigned integer, the playlist version number
+      # * *playlistlength*: integer, the length of the playlist
+      # * *state*: :play, :stop, or :pause
+      # * *song*: playlist song number of the current song stopped on or playing
+      # * *songid*: playlist songid of the current song stopped on or playing
+      # * *nextsong*: playlist song number of the next song to be played
+      # * *nextsongid*: playlist songid of the next song to be played
+      # * *time*: total time elapsed (of current playing/paused song)
+      # * *elapsed*: Total time elapsed within the current song, but with higher resolution.
+      # * *bitrate*: instantaneous bitrate in kbps
+      # * *xfade*: crossfade in seconds
+      # * *mixrampdb*: mixramp threshold in dB
+      # * *mixrampdelay*: mixrampdelay in seconds
+      # * *audio*: [sampleRate, bits, channels]
+      # * *updating_db*: job id
+      # * *error*: if there is an error, returns message here
+      #
+      # @return [Hash] Current MPD status.
+      def status
+        send_command :status
+      end
+
+      # Statistics.
+      #
+      # * *artists*: number of artists
+      # * *songs*: number of albums
+      # * *uptime*: daemon uptime in seconds
+      # * *db_playtime*: sum of all song times in the db
+      # * *db_update*: last db update in a Time object
+      # * *playtime*: time length of music played
+      #
+      # @return [Hash] MPD statistics.
+      def stats
+        send_command :stats
+      end
+
+      # Unofficial additions below
+
+      # Is MPD paused?
+      # @return [Boolean]
+      def paused?
+        return status[:state] == :pause
+      end
+
+      # Is MPD playing?
+      # @return [Boolean]
+      def playing?
+        return status[:state] == :play
+      end
+
+      # @return [Boolean] Is MPD stopped?
+      def stopped?
+        return status[:state] == :stop
+      end
+
+      # Gets the volume level.
+      # @return [Integer]
+      def volume
+        return status[:volume]
+      end
+
+      # @return [Integer] Crossfade in seconds.
+      def crossfade
+        return status[:xfade]
+      end
+
+      # @return [Integer] Current playlist version number.
+      def playlist_version
+        return status[:playlist]
+      end
+
+      # Returns true if consume is enabled.
+      def consume?
+        return status[:consume]
+      end
+
+      # Returns true if single is enabled.
+      def single?
+        return status[:single]
+      end
+
+      # Returns true if random playback is currently enabled,
+      def random?
+        return status[:random]
+      end
+
+      # Returns true if repeat is enabled,
+      def repeat?
+        return status[:repeat]
+      end
+    end
+  end
+end

data/lib/ruby-mpd/plugins/outputs.rb

@@ -0,0 +1,26 @@
+class MPD
+  module Plugins
+    # Commands related to audio output devices.
+    module Outputs
+      # Gives a list of all outputs
+      # @return [Array<Hash>] An array of outputs.
+      def outputs
+        send_command :outputs
+      end
+
+      # Enables specified output.
+      # @param [Integer] num Number of the output to enable.
+      # @macro returnraise
+      def enableoutput(num)
+        send_command :enableoutput, num
+      end
+
+      # Disables specified output.
+      # @param [Integer] num Number of the output to disable.
+      # @macro returnraise
+      def disableoutput(num)
+        send_command :disableoutput, num
+      end
+    end
+  end
+end