mpd 0.17.0

data/lib/mpd/controller/config.rb

@@ -0,0 +1,35 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module MPD; class Controller
+
+class Config < Hash
+	attr_reader :controller
+
+	def initialize (controller)
+		@controller = controller
+
+		controller.do_and_raise_if_needed(:config).each {|name, value|
+			self[name] = value
+		}
+
+		freeze
+	end
+
+	def respond_to_missing? (id, include_private = false)
+		include? id
+	end
+
+	def method_missing (id, *)
+		self[id]
+	end
+end
+
+end; end

data/lib/mpd/controller/current_playlist.rb

@@ -0,0 +1,110 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module MPD; class Controller
+
+class CurrentPlaylist
+	include Enumerable
+
+	attr_reader :controller
+
+	def initialize (controller)
+		@controller = controller
+	end
+
+	def version
+		controller.status.playlist.version
+	end
+
+	def length
+		controller.status.playlist.length
+	end
+
+	def add (uri, position = nil)
+		controller.do_and_raise_if_needed(:addid, uri, *position).first.last
+	end
+
+	def delete (what)
+		if what.is_a?(Integer) || what.is_a?(Range)
+			controller.do_and_raise_if_needed :delete, what
+		else
+			controller.do_and_raise_if_needed :deleteid, what
+		end
+
+		self
+	end
+
+	def move (from, to)
+		if from.is_a?(Integer) || what.is_a?(Range)
+			controller.do_and_raise_if_needed :move, from, to
+		else
+			controller.do_and_raise_if_needed :moveid, from, to
+		end
+
+		self
+	end
+
+	def clear
+		controller.do_and_raise_if_needed :clear
+	end
+
+	def save_as (name, force = false)
+		if force
+			controller.playlists[name].delete!
+		end
+
+		controller.do_and_raise_if_needed :save, name
+
+		self
+	end
+
+	def search (pattern, options = { tag: :title, strict: false })
+		Database::Song.from_data(controller.do_and_raise_if_needed(options[:strict] ? :playlistfind : :playlistsearch, options[:tag], pattern))
+	end
+
+	def each
+		return to_enum unless block_given?
+
+		Database::Song.from_data(controller.do(:playlistinfo)).each {|song|
+			yield song
+		}
+
+		self
+	end
+
+	def [] (id)
+		Database::Song.from_data(controller.do_and_raise_if_needed(:playlistid, id))
+	end
+
+	def priority (priority, *args)
+		controller.do_and_raise_if_needed :prio, priority, *args.select { |o| o.is_a?(Range) }
+		controller.do_and_raise_if_needed :prioid, priority, *args.reject { |o| o.is_a?(Range) }
+
+		self
+	end
+
+	def shuffle (range = nil)
+		controller.do_and_raise_if_needed :shuffle, *range
+
+		self
+	end
+
+	def swap (a, b)
+		if a.is_a?(Integer) && b.is_a?(Integer)
+			controller.do_and_raise_if_needed :swap, a, b
+		else
+			controller.do_and_raise_if_needed :swapip, a, b
+		end
+
+		self
+	end
+end
+
+end; end

data/lib/mpd/controller/database.rb

@@ -0,0 +1,235 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module MPD; class Controller
+
+class Database
+	class Song
+		Tags = Struct.new(:track, :title, :artist, :album, :genre, :date, :composer, :performer, :disc, :id)
+
+		def self.from_data (data, controller = nil)
+			if data.count { |name, _| name == :file } > 1
+				result  = []
+				to_read = nil
+
+				data.each {|name, value|
+					if name == :file
+						if to_read
+							result << Song.from_data(to_read, controller)
+						end
+
+						to_read = [[name, value]]
+					else
+						to_read << [name, value]
+					end
+				}
+
+				result << Song.from_data(to_read, controller)
+
+				result
+			else
+				song = new(controller)
+
+				data.each {|name, value|
+					case name
+					when :file                then song.file           = value
+					when :Pos                 then song.position       = value
+					when :Time                then song.duration       = value
+					when :Track               then song.tags.track     = value
+					when :Title               then song.tags.title     = value
+					when :Artist              then song.tags.artist    = value
+					when :Album               then song.tags.album     = value
+					when :Genre               then song.tags.genre     = value
+					when :Date                then song.tags.date      = value
+					when :Composer            then song.tags.composer  = value
+					when :Performer           then song.tags.performer = value
+					when :Disc                then song.tags.disc      = value
+					when :MUSICBRAINZ_TRACKID then song.tags.id        = value
+					end
+				}
+
+				song
+			end
+		end
+
+		def self.from_uri (uri, controller = nil)
+			if controller
+				from_data(controller.do_and_raise_if_needed(:listallinfo, uri), controller)
+			else
+				Song.new.tap {|song|
+					song.file = uri
+				}
+			end
+		end
+
+		attr_reader   :controller, :tags
+		attr_accessor :file, :position, :duration
+
+		def initialize (controller = nil)
+			@controller = controller
+			@tags       = Tags.new
+		end
+
+		def add
+			raise 'no controller, cannot add to playlist' unless controller
+		end
+
+		def respond_to_missing (id, include_private = false)
+			@tags.respond_to?(id, include_private)
+		end
+
+		def method_missing (id, *)
+			if @tags.respond_to? id
+				return @tags.__send__ id
+			end
+
+			super
+		end
+
+		alias uri file
+
+		def inspect
+			"#<#{self.class.name}: #{file.inspect}>"
+		end
+	end
+
+	class Directory
+		include Enumerable
+
+		attr_reader :database, :uri
+
+		def initialize (database, uri = nil)
+			@database = database
+			@uri      = uri
+		end
+
+		def each
+			return enum_for :each unless block_given?
+
+			database.controller.do_and_raise_if_needed(:lsinfo, *uri).each {|name, value|
+				case name
+				when :file      then yield Song.from_uri(value, database.controller)
+				when :directory then yield Directory.new(database, value)
+				end
+			}
+
+			self
+		end
+
+		def [] (name)
+			each { |n| return n if n.uri == name }
+
+			nil
+		end
+
+		def inspect
+			"#<#{self.class.name}: #{uri.inspect}>"
+		end
+	end
+
+	class Artist
+		attr_reader :database, :name
+
+		def initialize (database, name)
+			@database = database
+			@name     = name
+		end
+
+		def nil?
+			name.empty?
+		end
+
+		def songs (strict = false)
+			database.search(name, tag: :artist, strict: strict)
+		end
+
+		def inspect
+			"#<#{self.class.name}: #{name.inspect}>"
+		end
+	end
+
+	class Element
+		attr_reader :database, :tag, :name
+
+		def initialize (database, tag, name)
+			@database = database
+			@tag      = tag
+			@name     = name
+		end
+
+		def nil?
+			name.empty?
+		end
+
+		def songs (strict = false)
+			database.search(name, tag: tag, strict: strict)
+		end
+
+		def inspect
+			"#<#{self.class.name.sub(/::Element$/, "::#{tag.capitalize}")}: #{name.inspect}>"
+		end
+	end
+
+	include Enumerable
+
+	attr_reader :controller, :root
+
+	def initialize (controller)
+		@controller = controller
+		@root       = Directory.new(self)
+	end
+
+	def tags (name, artist = nil)
+		return enum_for :tags, name, artist unless block_given?
+
+		controller.do_and_raise_if_needed(:list, name, *artist).each {|_, value|
+			yield value
+		}
+	end
+
+	%w[artists albums genres composers performers].each {|name|
+		tag = name[0 .. -2].to_sym
+
+		define_method name do |artist = nil|
+			tags(tag, artist).map { |n| Element.new(self, tag, n) }
+		end
+	}
+
+	def search (pattern, options = { tag: :title, strict: false })
+		Song.from_data(controller.do_and_raise_if_needed(options[:strict] ? :find : :search, options[:tag], pattern))
+	end
+
+	def each (&block)
+		return to_enum unless block_given?
+
+		@root.each(&block)
+
+		self
+	end
+
+	def [] (name)
+		@root[name]
+	end
+
+	def update (*args)
+		options = args.last.is_a?(Hash) ? args.pop : { force: false }
+		uri     = args.shift
+
+		if options[:force]
+			controller.do_and_raise_if_needed :rescan, *uri
+		else
+			controller.do_and_raise_if_needed :update, *uri
+		end
+
+		self
+	end
+end
+
+end; end

data/lib/mpd/controller/decoders.rb

@@ -0,0 +1,54 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module MPD; class Controller
+
+class Decoders
+	Decoder = Struct.new(:name, :suffixes, :mime_types)
+
+	include Enumerable
+
+	attr_reader :controller
+
+	def initialize (controller)
+		@controller = controller
+		@decoders   = []
+
+		name       = nil
+		suffixes   = nil
+		mime_types = nil
+
+		controller.do_and_raise_if_needed(:decoders).each {|type, value|
+			if type == :plugin
+				if name
+					@decoders << Decoder.new(name, suffixes, mime_types)
+				end
+
+				name       = value
+				suffixes   = []
+				mime_types = []
+			elsif type == :suffix
+				suffixes << value
+			elsif type == :mime_type
+				mime_types << value
+			end
+		}
+	end
+
+	def each (&block)
+		return to_enum unless block_given?
+
+		@decoders.each(&block)
+
+		self
+	end
+end
+
+end; end

data/lib/mpd/controller/do.rb

@@ -0,0 +1,42 @@
+#--
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#                    Version 2, December 2004
+#
+#            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+#   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+#
+#  0. You just DO WHAT THE FUCK YOU WANT TO.
+#++
+
+module MPD; class Controller
+
+class Do < BasicObject
+	attr_reader :controller
+
+	def initialize (controller, &block)
+		@controller = controller
+		@commands   = []
+
+		instance_exec &block if block
+	end
+
+	def method_missing (id, *args)
+		@commands << ::MPD::Protocol::Command.new(id, args)
+	end
+
+	def send
+		result = []
+
+		controller.puts ::MPD::Protocol::CommandList.new(@commands).to_s
+
+		@commands.each {|command|
+			result << ::MPD::Protocol::Response.read(controller, command)
+
+			break if result.last.is_a? ::MPD::Protocol::Error
+		} and controller.readline
+
+		result
+	end
+end
+
+end; end