r21174 - in /branches/upstream/libaudio-moosic-perl: ./ current/ current/Changes current/MANIFEST current/META.yml current/Makefile.PL current/README current/lib/ current/lib/Audio/ current/lib/Audio/Moosic.pm current/t/ current/t/Audio-Moosic.t
gregoa at users.alioth.debian.org
gregoa at users.alioth.debian.org
Sun Jun 15 13:18:16 UTC 2008
Author: gregoa
Date: Sun Jun 15 13:18:15 2008
New Revision: 21174
URL: http://svn.debian.org/wsvn/?sc=1&rev=21174
Log:
[svn-inject] Installing original source of libaudio-moosic-perl
Added:
branches/upstream/libaudio-moosic-perl/
branches/upstream/libaudio-moosic-perl/current/
branches/upstream/libaudio-moosic-perl/current/Changes
branches/upstream/libaudio-moosic-perl/current/MANIFEST
branches/upstream/libaudio-moosic-perl/current/META.yml
branches/upstream/libaudio-moosic-perl/current/Makefile.PL
branches/upstream/libaudio-moosic-perl/current/README
branches/upstream/libaudio-moosic-perl/current/lib/
branches/upstream/libaudio-moosic-perl/current/lib/Audio/
branches/upstream/libaudio-moosic-perl/current/lib/Audio/Moosic.pm
branches/upstream/libaudio-moosic-perl/current/t/
branches/upstream/libaudio-moosic-perl/current/t/Audio-Moosic.t
Added: branches/upstream/libaudio-moosic-perl/current/Changes
URL: http://svn.debian.org/wsvn/branches/upstream/libaudio-moosic-perl/current/Changes?rev=21174&op=file
==============================================================================
--- branches/upstream/libaudio-moosic-perl/current/Changes (added)
+++ branches/upstream/libaudio-moosic-perl/current/Changes Sun Jun 15 13:18:15 2008
@@ -1,0 +1,35 @@
+Revision history for Perl extension Audio::Moosic.
+
+0.09 Mon Mar 21 20:45:33 2005
+ - Makefile.PL: Added RPC::XML to PREREQ_PM.
+
+0.08 Wed Dez 15 15:10:03 2004
+ - Documentation fix.
+ - Fixed fatal bugs in move() and move_list().
+ - Removed 'use 5.008004;' from Makefile.PL.
+
+0.07 Tue Sep 14 21:23:08 2004
+ - Added can_play().
+
+0.06 Mon Sep 13 12:48:22 2004
+ - Fixed bug with set_loop_mode().
+ - Added play().
+
+0.05 Fri Aug 20 12:41:03 2004
+ - Don't croak anymore if the connect failed. Simply set $@ and return an
+ undefined value.
+
+0.04 Thu Aug 19 13:26:12 2004
+ - Added swap method introduced by moosic 1.5.1 (api version 1.8).
+
+0.03 Thu Jul 15 09:35:34 2004
+ - LWP::Protocol::http::SocketUnix is the new name included in the module
+ list.
+
+0.02 Thu Jul 15 04:18:20 2004
+ - LWP::Protocol::http::UNIX is now known as LWP::Protocol::http::UnixSocket
+
+0.01 Sun Jun 6 19:21:53 2004
+ - original version; created by h2xs 1.23 with options
+ -AXO -n Audio::Moosic
+
Added: branches/upstream/libaudio-moosic-perl/current/MANIFEST
URL: http://svn.debian.org/wsvn/branches/upstream/libaudio-moosic-perl/current/MANIFEST?rev=21174&op=file
==============================================================================
--- branches/upstream/libaudio-moosic-perl/current/MANIFEST (added)
+++ branches/upstream/libaudio-moosic-perl/current/MANIFEST Sun Jun 15 13:18:15 2008
@@ -1,0 +1,7 @@
+Changes
+Makefile.PL
+MANIFEST
+README
+t/Audio-Moosic.t
+lib/Audio/Moosic.pm
+META.yml Module meta-data (added by MakeMaker)
Added: branches/upstream/libaudio-moosic-perl/current/META.yml
URL: http://svn.debian.org/wsvn/branches/upstream/libaudio-moosic-perl/current/META.yml?rev=21174&op=file
==============================================================================
--- branches/upstream/libaudio-moosic-perl/current/META.yml (added)
+++ branches/upstream/libaudio-moosic-perl/current/META.yml Sun Jun 15 13:18:15 2008
@@ -1,0 +1,11 @@
+# http://module-build.sourceforge.net/META-spec.html
+#XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX#
+name: Audio-Moosic
+version: 0.09
+version_from: lib/Audio/Moosic.pm
+installdirs: site
+requires:
+ RPC::XML: 0
+
+distribution_type: module
+generated_by: ExtUtils::MakeMaker version 6.17
Added: branches/upstream/libaudio-moosic-perl/current/Makefile.PL
URL: http://svn.debian.org/wsvn/branches/upstream/libaudio-moosic-perl/current/Makefile.PL?rev=21174&op=file
==============================================================================
--- branches/upstream/libaudio-moosic-perl/current/Makefile.PL (added)
+++ branches/upstream/libaudio-moosic-perl/current/Makefile.PL Sun Jun 15 13:18:15 2008
@@ -1,0 +1,14 @@
+use 5.008004;
+use ExtUtils::MakeMaker;
+# See lib/ExtUtils/MakeMaker.pm for details of how to influence
+# the contents of the Makefile that is written.
+WriteMakefile(
+ NAME => 'Audio::Moosic',
+ VERSION_FROM => 'lib/Audio/Moosic.pm', # finds $VERSION
+ PREREQ_PM => {
+ 'RPC::XML' => 0
+ }, # e.g., Module::Name => 1.1
+ ($] >= 5.005 ? ## Add these new keywords supported since 5.005
+ (ABSTRACT_FROM => 'lib/Audio/Moosic.pm', # retrieve abstract from module
+ AUTHOR => 'Florian Ragwitz <flora at cpan.org>') : ()),
+);
Added: branches/upstream/libaudio-moosic-perl/current/README
URL: http://svn.debian.org/wsvn/branches/upstream/libaudio-moosic-perl/current/README?rev=21174&op=file
==============================================================================
--- branches/upstream/libaudio-moosic-perl/current/README (added)
+++ branches/upstream/libaudio-moosic-perl/current/README Sun Jun 15 13:18:15 2008
@@ -1,0 +1,28 @@
+Audio-Moosic version 0.09
+=========================
+
+INSTALLATION
+
+To install this module type the following:
+
+ perl Makefile.PL
+ make
+ make test
+ make install
+
+DEPENDENCIES
+
+This module requires these other modules and libraries:
+
+LWP::Protocol::http::SocketUnix (only if you need to communicate with a local
+moosic server over an UNIX socket.
+
+COPYRIGHT AND LICENCE
+
+Copyright (C) 2004 by Florian Ragwitz
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself, either Perl version 5.8.4 or,
+at your option, any later version of Perl 5 you may have available.
+
+
Added: branches/upstream/libaudio-moosic-perl/current/lib/Audio/Moosic.pm
URL: http://svn.debian.org/wsvn/branches/upstream/libaudio-moosic-perl/current/lib/Audio/Moosic.pm?rev=21174&op=file
==============================================================================
--- branches/upstream/libaudio-moosic-perl/current/lib/Audio/Moosic.pm (added)
+++ branches/upstream/libaudio-moosic-perl/current/lib/Audio/Moosic.pm Sun Jun 15 13:18:15 2008
@@ -1,0 +1,1309 @@
+package Audio::Moosic;
+
+use strict;
+use warnings;
+use vars qw( $VERSION );
+use RPC::XML;
+use RPC::XML::Client;
+
+$VERSION = 0.09;
+
+=head1 NAME
+
+Audio::Moosic - Moosic client library for Perl
+
+=head1 SYNOPSIS
+
+ use Audio::Moosic;
+
+ $moo = Audio::Moosic::Unix->new();
+
+ $moosic->append('/home/me/somewhat.ogg');
+ $moosic->play;
+ print $moosic->current, "\n";
+ $moosic->pause;
+ ...
+
+=head1 DESCRIPTION
+
+Audio::Moosic acts as a client for the musical jukebox programm Moosic
+(http://nanoo.org/~daniel/moosic/) by Daniel Pearson <daniel at nanoo.org>.
+
+Using Audio::Moosic you can connect to a moosic server either via an UNIX socket
+or an INET socket.
+
+=head1 METHODS
+
+=head2 new
+
+ $moo = Audio::Moosic::Unix->new();
+ $moo = Audio::Moosic::Unix->new('/tmp/moosic/socket');
+ $moo = Audio::Moosic::Inet->new('localhost', 8765);
+
+Constructor. Initializes the class and invokes the connect method. If you're
+creating a Audio::Moosic::Unix object you can give the location of your moosic
+socket as parameter. If not ~/.moosic/socket is used. If you're creating a
+Audio::Moosic::Inet instance you need to pass host and port as arguments.
+
+You can't create an instance of Audio::Moosic itself. Use Unix or Inet subclass.
+
+If the object was able to connect to the moosic server a reference to the object
+instance is returned. If the connection failed $@ is set and undef returned.
+
+=cut
+
+sub new {
+ my ($class, @args) = @_;
+ $class = ref($class) || $class;
+
+ my $self = { __errors => [ ] };
+ bless $self, $class;
+
+ unless( $self->connect(@args) ) {
+ $@ = "Can't connect to moosic server: $!";
+ return;
+ }
+
+ return $self;
+}
+
+=head2 connect
+
+ $moo->connect('foobar.com', 9876);
+
+Connect to the moosic server. You normally don't need to run this method in your
+moosic client.
+
+=cut
+
+sub connect {
+ require Carp;
+ Carp::croak('This method should never be called. Please create an instance'.
+ ' of Audio::Moosic::Inet or Audio::Moosic::Unix.');
+}
+
+=head2 disconnect
+
+ $moo->disconnect;
+
+Disconnect from the moosic daemon. No more calls will be sent to the server
+after calling this method. You'll need to reconnect() first.
+
+=cut
+
+sub disconnect {
+ my $self = shift;
+ $self->{__connected} = 0;
+ delete $self->{__rpc_xml_client}
+}
+
+=head2 reconnect
+
+ $moo->reconnect;
+
+Disconnects from the server if you're connected and tries to reconnect.
+
+=cut
+
+sub reconnect {
+ my $self = shift;
+ $self->disconnect if $self->connected;
+ return $self->connect;
+}
+
+=head2 connected
+
+ $moo->reconnect unless $moo->connected;
+
+Check whether you're connected to the moosic server or not.
+
+=cut
+
+sub connected {
+ my $self = shift;
+ return $self->{__connected};
+}
+
+=head2 client_config
+
+ print $moo->client_config('location');
+ $conf = $moo->client_config();
+
+Reads the moosic clients config. If a $key argument is given it returns only the
+value associated with that key, if not the whole config hash.
+
+Would it be a good idea to make the user able to edit the client_config here?
+Suggestions or maybe patches are welcome.
+
+=cut
+
+sub client_config {
+ my ($self, $key) = @_;
+ if($key) {
+ return $self->{__client_config}{$key};
+ } else {
+ return $self->{__client_config};
+ }
+}
+
+=head2 ping
+
+ die unless $moo->ping;
+
+Checks if we're still connected. This method checks the connection explicitly by
+calling the no_op server method. connected() only checks the value of the
+'connected' object property.
+
+=cut
+
+sub ping {
+ my $self = shift;
+
+ my $resp = $self->{__rpc_xml_client}->send_request('no_op');
+
+ if( ref $resp ) {
+ $self->{__connected} = 1;
+ } else {
+ $self->{__connected} = 0;
+ }
+
+ return $self->connected;
+}
+
+=head2 error
+
+ my $error = $moo->error;
+ $moo->error('Whaaa!');
+
+If an argument is given it adds the error string to the internal error array. If
+called in scalar context it returns the last error occured. If you call error()
+in list context the whole error array of the Audio::Moosic instance is returned.
+
+=cut
+
+sub error {
+ my ($self, $error) = @_;
+
+ if($error) {
+ push(@{$self->{__errors}}, $error);
+ } else {
+ return wantarray ?
+ @{$self->{__errors}} :
+ @{$self->{__errors}}[@{$self->{__errors}} - 1];
+ }
+}
+
+=head2 call
+
+ $moo->call('foo');
+ $moo->call('bar', RPC::XML::int->new(3));
+
+This method calls a xml-rpc method on the moosic server. The first argument
+should be the method name. The arguments of that method should follow behind.
+
+If the request to the moosic server could not be sent the Audio::Moosic instance
+disconnects from the server and puts the error message into the internal error
+array. Access it via error(). The object won't send any calls anymore if such an
+error occured. You should try to reconnect.
+
+If the request could be sent, but returned an error the error message is added
+to the error array accessable via error().
+
+If any error occured call() returns undef. If everything went fine the value of
+the response is returned.
+
+Normally you don't need to call this method. It is only used by other moosic
+methods to send their calls more easily. If a new moosic method is not supported
+by this library yet you'll maybe need to use call() manually. Please notice me
+if that happens so I'll add the new method.
+
+=cut
+
+sub call {
+ my ($self, $method, @args) = @_;
+ return unless $self->connected;
+ my $resp = $self->{__rpc_xml_client}->send_request($method, @args);
+
+ unless( ref $resp ) {
+ my $error = qq/Lost connection to moosic server: "$resp"/;
+ if( my $function = (caller(1))[3]) { $error .= " in $function()"; }
+ $self->error($error);
+ $self->{__connected} = 0;
+ return;
+ }
+
+ if( $resp->is_fault ) {
+ my $error = 'Error: '. $resp->code .': "'. $resp->string .'"';
+ if( my $function = (caller(1))[3]) { $error .= " in $function()"; }
+ $self->error($error);
+ return;
+ }
+
+ return $resp->value;
+}
+
+=head2 api_version
+
+ @api = $moo->api_version;
+ $api = $moo->api_version;
+
+Return the moosic servers API version. If called in scalar context a version
+string like '1.3' is returned. In list context the mayor and minor numbers of
+the API version are returned.
+
+=cut
+
+sub api_version {
+ my $self = shift;
+ my $resp = $self->call('api_version') or return;
+ return wantarray ? @{$resp} : join('.', @{$resp});
+}
+
+=head2 append
+
+ $moo->append('/home/florian/whatever.ogg');
+ $moo->append('/home/florian/foo.ogg', '/home/florian/bar.mp3');
+
+Add songs to the moosic queue. The files to add should be the arguments for the
+append method. append() returns 1 if there were no errors or something false if
+there were some.
+
+=cut
+
+sub append {
+ my ($self, @items) = @_;
+ return $self->call('append', RPC::XML::array->new(
+ map { RPC::XML::base64->new($_) } @items
+ ));
+}
+
+=head2 clear
+
+ $moo->clear;
+
+Clears the moosic queue. Only the current song remains playing.
+
+=cut
+
+sub clear {
+ my $self = shift;
+ return $self->call('clear');
+}
+
+=head2 crop
+
+ $moo->crop(4);
+ $moo->crop(3, 4);
+
+Remove all playlist items that don't fall within a given range. If the range is
+represented by one integer all items whose index is greater than or equal to the
+value will be removed. Two intergers represent all items whose index is greater
+than or equal to the value of first integer and less than the value of the
+second integer.
+
+=cut
+
+sub crop {
+ my ($self, @range) = @_;
+ return $self->call('crop', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 crop_list
+
+ $moo->crop_list(1, 4, 3);
+
+Remove all queued items exept those referenced by a list of positions.
+
+=cut
+
+sub crop_list {
+ my ($self, @range) = @_;
+ return $self->call('crop_list', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 current
+
+ print $moo->current;
+
+Return the name of the current playing song.
+
+=cut
+
+sub current {
+ my $self = shift;
+ return $self->call('current');
+}
+
+=head2 current_time
+
+ print $moo->current_time;
+
+Return the amount of time the current song has been playing.
+
+=cut
+
+sub current_time {
+ my $self = shift;
+ return $self->call('current_time');
+}
+
+=head2 cut
+
+ $moo->cut(3);
+ $moo->cut(4, 10);
+
+Remove all queued items that fall within a given range. See crop() for details
+on how that range should look like.
+
+=cut
+
+sub cut {
+ my ($self, @range) = @_;
+ return $self->call('cut', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 cut_list
+
+ $moo->cut_list(3, 7, 9);
+
+Remove all queued items referenced by list of positions.
+
+=cut
+
+sub cut_list {
+ my ($self, @range) = @_;
+ return $self->call('cut_list', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 die
+
+ $moo->die;
+
+Tell the server to terminate itself.
+
+=cut
+
+sub die {
+ my $self = shift;
+ ($self->call('die') and $self->disconnect) or return;
+}
+
+=head2 filter
+
+ $moo->filter('foo');
+ $moo->filter('bar', 4);
+ $moo->filter('moo', 7, 11);
+
+Remove all items that don't match the given regular expression. You may limit
+this operation to a specific range which is described in crop().
+
+=cut
+
+sub filter {
+ my ($self, $regex, @range) = @_;
+ return $self->call('filter',
+ RPC::XML::base64->new($regex),
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @range )
+ );
+}
+
+=head2 get_history_limit
+
+ $limit = $moo->get_history_limit;
+
+Get the limit on the size of the history list stored in servers memory.
+
+=cut
+
+sub get_history_limit {
+ my $self = shift;
+ return $self->call('get_history_limit');
+}
+
+=head2 getconfig
+
+ @config = $moo->getconfig;
+
+Return a list of the server's filetype-player associations.
+
+=cut
+
+sub getconfig {
+ my ($self, $key) = @_;
+ my $resp = $self->call('getconfig');
+ return @{$resp};
+ #TODO support $key to read single config options
+}
+
+=head2 halt_queue
+
+ $moo->halt_queue;
+
+Stop any new songs from being played. Use run_queue() to reverse this state.
+
+=cut
+
+sub halt_queue {
+ my $self = shift;
+ return $self->call('halt_queue');
+}
+
+=head2 haltqueue
+
+See halt_queue().
+
+=cut
+
+sub haltqueue {
+ my $self = shift;
+ $self->halt_queue;
+}
+
+=head2 history
+
+ %hist = $moo->history;
+
+Return a list of items that has been recently played. If a positive integer
+argument is given than no more than number of items will be returned. Otherwise
+the entire history is printed.
+
+history() returns an array of hashrefs like that:
+ @history = (
+ { title => 'foo', start => 123.45, stop => 543.21 },
+ { title => 'bar', start => 234.56, stop => 654.32 },
+ ...
+ );
+
+=cut
+
+sub history {
+ my ($self, $num) = @_;
+
+ return map {
+ title => $_->[0],
+ start => $_->[1],
+ stop => $_->[2] }, @{$self->call('history',
+ RPC::XML::int->new( $num || 0 )) };
+}
+
+=head2 indexed_list
+
+ %list = $moo->indexed_list;
+ %list = $moo->indexed_list(1);
+ %list = $moo->indexed_list(2, 5);
+
+List the song queue's contents. If a range is specified, only the items that
+fall within that range are listed.
+
+indexed_list() returns a hash like that:
+ %list = (
+ list => [ 'foo', 'bar', 'moo', ... ],
+ start => 4
+ );
+
+=cut
+
+sub indexed_list {
+ my ($self, @range) = @_;
+
+ return $self->call('indexed_list', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 insert
+
+ $moo->insert(4, 'foo.ogg', 'bar.mp3');
+
+Insert items at a given position in the queue.
+
+=cut
+
+sub insert {
+ my $self = shift;
+ my $num = pop;
+ my @items = @_;
+
+ return $self->call('insert',
+ RPC::XML::array->new( map { RPC::XML::base64->new($_) } @items ),
+ RPC::XML::int->new( $num )
+ );
+}
+
+=head2 is_looping
+
+ $moo->toggle_loop_mode if $moo->is_looping;
+
+Check whether the loop mode is on or not.
+
+=cut
+
+sub is_looping {
+ my $self = shift;
+ return $self->call('is_looping');
+}
+
+=head2 is_paused
+
+ $moo->toggle_pause if $moo->is_paused;
+
+Check whether the current song is paused or not.
+
+=cut
+
+sub is_paused {
+ my $self = shift;
+ return $self->call('is_paused');
+}
+
+=head2 is_queue_running
+
+ if($moo->is_queue_running) {
+ ...;
+ }
+
+Check whether the queue consumption (advancement) is activated.
+
+=cut
+
+sub is_queue_running {
+ my $self = shift;
+ return $self->call('is_queue_running');
+}
+
+=head2 last_queue_update
+
+ $time = $moo->last_queue_update
+
+Return the time at which the song queue was last modified.
+
+=cut
+
+sub last_queue_update {
+ my $self = shift;
+ return $self->call('last_queue_update');
+}
+
+=head2 length
+
+ $length = $moo->length
+
+Return the number of items in the song queue.
+
+=cut
+
+sub length {
+ my $self = shift;
+ return $self->call('length');
+}
+
+=head2 list
+
+ @list = $moo->list();
+ @list = $moo->list(2);
+ @list = $moo->list(4, 8);
+ $list_ref = $moo->list()
+
+List the song queue's contents. If a range is specified, only the items that
+fall within that range are listed. Returns an array if called in list context
+or an array reference if it's called in scalar context.
+
+=cut
+
+sub list {
+ my ($self, @range) = @_;
+
+ my $list = $self->call('list', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+
+ return wantarray ?
+ @{$list} :
+ $list;
+}
+
+=head2 move
+
+ $moo->move(10, 4);
+ $moo->move(4, 7, 1);
+
+Move a range of items to a new position within the queue.
+
+=cut
+
+sub move {
+ my $self = shift;
+ my $num = pop;
+ my @range = @_;
+
+ return $self->call('move',
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @range ),
+ RPC::XML::int->new( $num )
+ );
+}
+
+=head2 move_list
+
+ $moo->move(3, 5, 7, 11);
+
+Move the items referenced by a list of positions to a new position.
+
+=cut
+
+sub move_list {
+ my $self = shift;
+ my $num = pop;
+ my @range = @_;
+
+ return $self->call('move_list',
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @range ),
+ RPC::XML::int->new( $num )
+ );
+}
+
+=head2 next
+
+ $moo->next;
+ $moo->next(5);
+
+Stop the current song (if any), and jumps ahead to a song that is currently in
+the queue. The skipped songs are recorded in the history as if they had been
+played. When called without arguments, this behaves very much like the skip()
+method, except that it will have an effect even if nothing is currently playing.
+
+=cut
+
+sub next {
+ my ($self, $num) = @_;
+
+ return $self->call('next', RPC::XML::int->new( $num || 1 ));
+}
+
+=head2 no_op
+
+ $moo->no_op
+
+Do nothing, successfully.
+
+=cut
+
+sub no_op {
+ my $self = shift;
+ return $self->call('no_op');
+}
+
+=head2 pause
+
+ $moo->pause;
+
+Pause the currently playing song.
+
+=cut
+
+sub pause {
+ my $self = shift;
+ return $self->call('pause');
+}
+
+=head2 prepend
+
+ $moo->prepend('foo.ogg', 'bar.mp3');
+
+Add items to the beginning of the queue.
+
+=cut
+
+sub prepend {
+ my ($self, @items) = @_;
+
+ return $self->call('prepend', RPC::XML::array->new(
+ map { RPC::XML::base64->new($_) } @items
+ ));
+}
+
+=head2 previous
+
+ $moo->previous;
+ $moo->previous(3);
+
+Stops the current song (if any), removes the most recently played song from the
+history, and puts these songs at the head of the queue. When loop mode is on,
+the songs at the tail of the song queue are used instead of the most recently
+played songs in the history.
+
+=cut
+
+sub previous {
+ my ($self, $num) = @_;
+
+ return $self->call('previous', RPC::XML::int->new( $num || 1 ));
+}
+
+=head2 putback
+
+ $moo->putback;
+
+Place the currently playing song at the beginning of the queue.
+
+=cut
+
+sub putback {
+ my $self = shift;
+ return $self->call('putback');
+}
+
+=head2 queue_length
+
+ $length = $moo->queue_length;
+
+Return the number of items in the song queue.
+
+=cut
+
+sub queue_length {
+ my $self = shift;
+ return $self->call('queue_length');
+}
+
+=head2 reconfigure
+
+ $moo->reconfigure;
+
+Tell the server to reread its player configuration file.
+
+=cut
+
+sub reconfigure {
+ my $self = shift;
+ return $self->call('reconfigure');
+}
+
+=head2 remove
+
+ $moo->remove('regex');
+ $moo->remove('regex', 4);
+ $moo->remove('regex', 1, 3);
+
+Remove all items that match the given regular expression. You can limit this
+operation by giving a range as described in crop() as last argument.
+
+=cut
+
+sub remove {
+ my ($self, $regex, @range) = @_;
+
+ return $self->call('remove',
+ RPC::XML::base64->new( $regex ),
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @range )
+ );
+}
+
+=head2 replace
+
+ $moo->replace('foo.ogg', 'bar.mp3');
+
+Replace the contents of the queue with the given items. This is equivalent to
+calling clear() and prepend() in succession, except that this operation is
+atomic.
+
+=cut
+
+sub replace {
+ my ($self, @items) = @_;
+
+ return $self->call('replace', RPC::XML::array->new(
+ map { RPC::XML::base64->new($_) } @items
+ ));
+}
+
+=head2 reverse
+
+ $moo->reverse;
+ $moo->reverse(2);
+ $moo->reverse(5, 7);
+
+Reverse the order of the items in the queue. You can limit this operation by
+giving a range as described in crop() as last argument.
+
+=cut
+
+sub reverse {
+ my ($self, @range) = @_;
+
+ return $self->call('reverse', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 run_queue
+
+ $moo->run_queue;
+
+Allows new songs to be played again after halt_queue() has been called.
+
+=cut
+
+sub run_queue {
+ my $self = shift;
+ return $self->call('run_queue');
+}
+
+=head2 runqueue
+
+See run_queue().
+
+=cut
+
+sub runqueue {
+ my $self = shift;
+ return $self->run_queue;
+}
+
+=head2 set_history_limit
+
+ $moo->set_history_limit(44);
+
+Set the limit on the size of the history list stored in memory.
+
+=cut
+
+sub set_history_limit {
+ my ($self, $limit) = @_;
+
+ return $self->call('set_history_limit', RPC::XML::int->new( $limit ));
+}
+
+=head2 set_loop_mode
+
+ $moo->set_loop_mode(0);
+ $moo->set_loop_mode(1);
+
+Turn loop mode on or off.
+
+=cut
+
+sub set_loop_mode {
+ my ($self, $mode) = @_;
+
+ return $self->call('set_loop_mode', RPC::XML::boolean->new( $mode ));
+}
+
+=head2 showconfig
+
+ my $config = $moo->showconfig;
+ my %config = $moo->showconfig;
+
+Return the server's player configuration. If showconfig() is called in scalar
+context a scalar containing the textual description of the configuration is
+returned. If you call showconfig() in list context a hash which maps the
+configuration regular expression to the player commands is returned.
+
+=cut
+
+sub showconfig {
+ my $self = shift;
+
+ my $config = $self->call('showconfig');
+ return unless $config;
+ return $config unless wantarray;
+
+ my @config;
+ foreach(split("\n", $config)) {
+ s/^\s+//;
+ chomp;
+ push(@config, $_);
+ }
+
+ return @config;
+}
+
+=head2 shuffle
+
+ $moo->shuffle;
+ $moo->shuffle(2);
+ $moo->shuffle(4, 6);
+
+Rearrange the contents of the queue into a random order. You can limit this
+operation by giving a range as described for crop() as last argument.
+
+=cut
+
+sub shuffle {
+ my ($self, @range) = @_;
+
+ return $self->call('shuffle', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 skip
+
+ $moo->skip;
+
+Skips the rest of the current song to play the next song in the queue. This only
+has an effect if there actually is a current song.
+
+=cut
+
+sub skip {
+ my $self = shift;
+ return $self->call('skip');
+}
+
+=head2 sort
+
+ $moo->sort;
+ $moo->sort(2);
+ $moo->sort(4, 6);
+
+Arrange the contents of the queue into sorted order.
+
+=cut
+
+sub sort {
+ my ($self, @range) = @_;
+
+ return $self->call('sort', RPC::XML::array->new(
+ map { RPC::XML::int->new($_) } @range
+ ));
+}
+
+=head2 stop
+
+ $moo->stop;
+
+Stop playing the current song and stops new songs from playing. The current
+song is returned to the head of the song queue and is not recorded in the
+history list. If loop mode is on, the current song won't be placed at the end of
+the song queue when it is stopped.
+
+=cut
+
+sub stop {
+ my $self = shift;
+ return $self->call('stop');
+}
+
+=head2 sub
+
+ $moo->sub('regex', 'substitition');
+ $moo->sub('regex', 'substitition', 2);
+ $moo->sub('regex', 'substitition', 1, 7);
+
+Perform a regular expression substitution on the items in the queue. You can
+limit this operation by giving a range as described for crop() as last argument.
+
+=cut
+
+sub sub {
+ my ($self, $regex, $subst, @range) = @_;
+
+ return $self->call('sub',
+ RPC::XML::base64->new( $regex ),
+ RPC::XML::base64->new( $subst ),
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @range )
+ );
+}
+
+=head2 sub_all
+
+ $moo->sub_all('regex', 'substition');
+ $moo->sub_all('regex', 'substition', 2);
+ $moo->sub_all('regex', 'substition', 1, 7);
+
+Performs a global regular expression substitution on the items in the queue.
+
+=cut
+
+sub sub_all {
+ my ($self, $regex, $subst, @range) = @_;
+
+ return $self->call('sub_all',
+ RPC::XML::base64->new( $regex ),
+ RPC::XML::base64->new( $subst ),
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @range )
+ );
+}
+
+=head2 swap
+
+ $moo->swap( [7, 10], [ 5 ] );
+
+Swap the items contained in one range with the items contained in the other
+range. The ranges for the swap() method needs to be passed as array references
+in contrast to other methods that use ranges.
+
+=cut
+
+sub swap {
+ my ($self, $range1, $range2) = @_;
+
+ return $self->call('swap',
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @{$range1} ),
+ RPC::XML::array->new( map { RPC::XML::int->new($_) } @{$range2} )
+ );
+}
+
+=head2 listMethods
+
+ @methods = $moo->listMethods;
+
+Return an array of all available XML-RPC methods on this server.
+
+=cut
+
+sub listMethods {
+ my $self = shift;
+ return $self->call('system.listMethods');
+}
+
+=head2 methodHelp
+
+ $help = $moo->methodHelp('sub');
+
+Given the name of a method, return a help string.
+
+=cut
+
+sub methodHelp {
+ my ($self, $method) = @_;
+
+ return $self->call('syste.methodHelp',
+ RPC::XML::string->new( $method )
+ );
+}
+
+=head2 methodSignature
+
+ $signature = $moo->methodSignature;
+
+Given the name of a method, return an array of legal signatures. Each signature
+is an array of scalars. The first item of each signature is the return type, and
+any others items are parameter types. =cut
+
+=cut
+
+sub methodSignature {
+ my ($self, $method) = @_;
+
+ return $self->call('system.methodSignature',
+ RPC::XML::string->new( $method )
+ );
+}
+
+=head2 multicall
+
+ $moo->multicall(...);
+
+Process an array of calls, and return an array of results. This is not
+implemented yet.
+
+=cut
+
+sub multicall {
+ my ($self, @cmds) = @_;
+ require Carp;
+ Carp::carp(__PACKAGE__."::multicall() isn't implemented yet."); #TODO
+}
+
+=head2 toggle_loop_mode
+
+ $moo->toggle_loop_mode;
+
+Turn loop mode on if it is off, and turns it off if it is on.
+
+=cut
+
+sub toggle_loop_mode {
+ my $self = shift;
+ return $self->call('toggle_loop_mode');
+}
+
+=head2 toggle_pause
+
+ $moo->toggle_pause;
+
+Pause the current song if it is playing, and unpauses if it is paused.
+
+=cut
+
+sub toggle_pause {
+ my $self = shift;
+ return $self->call('toggle_pause');
+}
+
+=head2 unpause
+
+ $moo->unpause;
+
+Unpauses the current song.
+
+=cut
+
+sub unpause {
+ my $self = shift;
+ return $self->call('unpause');
+}
+
+=head2 version
+
+ $version = $moo->version;
+
+Return the Moosic server's version string.
+
+=cut
+
+sub version {
+ my $self = shift;
+ return $self->call('version');
+}
+
+=head1 HELPER METHODS
+
+The following methods aren't methods defined by the moosic API but should be
+usefull when dealing with a moosic server.
+
+=head2 play
+
+ $moo->play();
+
+Start playing. If the playback is paused it will be unpaused. If the queue is
+stopped it will be started.
+
+=cut
+
+sub play {
+ my $self = shift;
+
+ return $self->unpause() if $self->is_paused();
+ return $self->run_queue();
+}
+
+=head2 can_play
+
+ $moo->append( $song ) if $moo->can_play( $song );
+
+Takes a list of songs as argument and returns all items that can be played by
+the moosic daemon.
+
+=cut
+
+sub can_play {
+ my $self = shift;
+ my @can_play;
+
+ my @config = $self->getconfig();
+ for my $track ( @_ ) {
+ for( @config ) {
+ push @can_play, $track if $track =~ qr/$_->[0]/;
+ }
+ }
+
+ return @can_play;
+}
+
+package Audio::Moosic::Inet;
+
+use strict;
+use warnings;
+use base qw( Audio::Moosic );
+
+sub connect {
+ my ($self, $host, $port) = @_;
+ return if $self->connected;
+
+ my $location = "http://$host\:$port";
+ $self->disconnect;
+ $self->{__rpc_xml_client} = RPC::XML::Client->new($location);
+
+ $self->ping or return;
+ $self->{__client_config} = { location => $location };
+}
+
+package Audio::Moosic::Unix;
+
+use strict;
+use warnings;
+use base qw( Audio::Moosic );
+
+
+sub connect {
+ _init();
+
+ my ($self, $filename) = @_;
+ return if $self->connected;
+
+ $filename = ($ENV{HOME} || '/tmp') . '/.moosic/socket' unless $filename;
+ my $location = "http://$filename";
+ $self->disconnect;
+ $self->{__rpc_xml_client} = RPC::XML::Client->new($location);
+
+ $self->ping or return;
+ $self->{__client_config} = { location => $location };
+}
+
+sub _init {
+
+ unless( eval 'require LWP::Protocol::http::SocketUnix' ) {
+ require Carp;
+ Carp::croak('You need LWP::Protocol::http::SocketUnix to connect to a local'.
+ " moosic server using a UNIX socket.\nPlease install it!");
+ }
+
+ LWP::Protocol::implementor( http => 'LWP::Protocol::http::SocketUnix' );
+}
+
+1;
+
+=head1 BUGS
+
+=over 4
+
+=item * check arguments more strictly
+
+expecially for constructors.
+
+=back
+
+If you find some others please report them to Florian Ragwitz
+E<lt>flora at cpan.orgE<gt>
+
+=head1 TODO
+
+=over 4
+
+=item * implement system_multicall
+
+=item * improve client_config
+
+=item * maybe use autoloader to load subs on demand
+
+create the method arguments from methodSignature.
+
+=back
+
+=head1 SEE ALSO
+
+moosic(1), moosicd(1), http://nanoo.org/~daniel/moosic/
+
+=head1 AUTHOR
+
+Florian Ragwitz, E<lt>flora at cpan.orgE<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2004 by Florian Ragwitz
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself, either Perl version 5.8.4 or,
+at your option, any later version of Perl 5 you may have available.
+
+=cut
Added: branches/upstream/libaudio-moosic-perl/current/t/Audio-Moosic.t
URL: http://svn.debian.org/wsvn/branches/upstream/libaudio-moosic-perl/current/t/Audio-Moosic.t?rev=21174&op=file
==============================================================================
--- branches/upstream/libaudio-moosic-perl/current/t/Audio-Moosic.t (added)
+++ branches/upstream/libaudio-moosic-perl/current/t/Audio-Moosic.t Sun Jun 15 13:18:15 2008
@@ -1,0 +1,15 @@
+# Before `make install' is performed this script should be runnable with
+# `make test'. After `make install' it should work as `perl Audio-Moosic.t'
+
+#########################
+
+# change 'tests => 1' to 'tests => last_test_to_print';
+
+use Test::More tests => 1;
+BEGIN { use_ok('Audio::Moosic') };
+
+#########################
+
+# Insert your test code below, the Test::More module is use()ed here so read
+# its man page ( perldoc Test::More ) for help writing this test script.
+
More information about the Pkg-perl-cvs-commits
mailing list