ampt 0.2.0.pre1

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,31 @@
+Copyright (c) 2009 The Board of Trustees of the University of Illinois.  
+All rights reserved.
+
+Developed by: ACM@UIUC
+              University of Illinois at Urbana-Champaign
+              www.acm.uiuc.edu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal with 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:
+  1. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimers.
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimers in the
+     documentation and/or other materials provided with the distribution.
+  3. Neither the names of ACM@UIUC, University of Illinois at Urbana-
+     Champaign, nor the names of its contributors may be used to endorse
+     or promote products derived from this Software without specific prior
+     written permission.
+
+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
+CONTRIBUTORS 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
+WITH THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,75 @@
+= ampt
+
+http://www.interhacktive.com/ampt
+
+== DESCRIPTION:
+
+This is a command line client for the Acoustics Media Player (amp).
+Amp is available here: http://www.github.com/avuserow/amp
+
+This is a work in progress.
+
+== FEATURES:
+
+* Control things from the command line!
+* Extremely scriptable!
+
+== SYNOPSIS:
+
+    $ ampt --help
+    Usage ampt [command] [options] [args]
+
+    Commands include:
+     new              Get [num] newest songs. Defaults to 50.
+     list             List all songs with the specified parameter. This
+                      is less fuzzy than search. One of the flags must
+                      be specified.
+     add              Vote for a song. Provide a song id, or one of the
+                      flags.
+     history          Get [num] last-played songs. Defaults to 25.
+     stop             Stop Acoustics.
+     volume           Set the current volume level. If run without an
+                      arg, returns the current volume.
+     start            Start Acoustics.
+     remove           Remove your votes from songs in the playlist.
+                      Provide a song id or one of the
+                      flags.
+     random           Get [num] random songs. Defaults to 20.
+     show             Show more info about a song. Takes a song id as
+                      the single parameter.
+     reset            Clear all of your votes.
+     skip             Skip the currently playing song.
+     status           Prints the currently playing song and playlist.
+     search           Search the database for songs. Defaults to
+                      searching by any parameter.
+
+       --version, -v:   Print version and exit
+       --help, -h:   Show this message
+    $ ampt status
+    Now Playing:
+      [  14871] Let There Be Light by Justice 
+      Voted up by rotap2
+
+    Playlist:
+      [  14881] Newjack by Justice 
+      Voted up by rotap2
+    ...
+      25 songs queued for a total time of 2:13:51
+      You have 20 songs queued for a total time of 1:49:20
+
+== REQUIREMENTS:
+
+* libopenssl bindings for ruby 
+* libcurl-dev
+
+== INSTALL:
+
+    $ sudo gem install ampt
+
+== TODO:
+* Add an option to change default flags of a command
+* Make aliases more powerful (eg, be able to handle options tacked on)
+
+== LICENSE:
+
+See LICENSE.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+require File.dirname(__FILE__) + "/lib/ampt.rb"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ampt"
+    gem.version = Ampt::VERSION
+    gem.summary = %Q{Ampt is a command line client for the Acoustics Media Player (amp).}
+    gem.description = %Q{This is a command line client for the Acoustics Media Player (amp).
+Amp is available here: http://www.github.com/avuserow/amp
+
+This is a work in progress.}
+    gem.email = "rich@interhacktive.com"
+    gem.homepage = "http://github.com/capslock/ampt"
+    gem.authors = ["Rich"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ampt #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/ampt.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ampt}
+  s.version = "0.2.0.pre1"
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Rich"]
+  s.date = %q{2010-01-08}
+  s.default_executable = %q{ampt}
+  s.description = %q{This is a command line client for the Acoustics Media Player (amp).
+Amp is available here: http://www.github.com/avuserow/amp
+
+This is a work in progress.}
+  s.email = %q{rich@interhacktive.com}
+  s.executables = ["ampt"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".autotest",
+     ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "ampt.gemspec",
+     "bin/ampt",
+     "lib/ampt.rb",
+     "lib/ampt_api/acoustics.rb",
+     "lib/ampt_cfg/default.rb",
+     "test/helper.rb",
+     "test/test_ampt.rb"
+  ]
+  s.homepage = %q{http://github.com/capslock/ampt}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Ampt is a command line client for the Acoustics Media Player (amp).}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_ampt.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/bin/ampt

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'ampt'
+
+# You CAN specify configs over here... or you can just load them from your .amptrc.
+Ampt.init do
+  load_config "#{ENV['HOME']}/.amptrc"
+  load_config 'ampt_cfg/default.rb'
+end
+

data/lib/ampt.rb

@@ -0,0 +1,353 @@
+require 'rubygems'
+require 'trollop'
+
+module Ampt
+    VERSION = '0.2.0.pre1'
+    # This is the module that holds the API for the current music player. Defined in
+    # ampt_api/acoustics.rb
+    module API
+    end
+
+    # The typical entry point for an Ampt app. Configures a new instance of ampt
+    # using the specified block, and runs that configuration.
+    def self.init args = ARGV, *a, &b
+        @c = Config.new(*a, &b)
+        @c.run(ARGV)
+    end
+
+    # Class containing all of the configuration details for Ampt.
+    class Config
+        # Create a new configuration. Optionally takes a parameter, and
+        # a block with which to set up configuration options.
+        def initialize(*a, &b)
+            @commands = {}
+            @alias    = {}
+            @default  = nil
+            @api      = nil
+            cloaker(&b).bind(self).call(*a) if b
+        end
+
+        def extras s, *a, &b
+            @extras.send(s, *a, &b)
+        end
+
+        # Specify a file path from which to load the config from. If a relative path 
+        # is provided, the path is taken as relative to the Ampt library directory.
+        def load_config file
+            # If we got a relative path, take it as relative to the lib path.
+            # Otherwise, just use the absolute path.
+            name = if file[0...1] != '/'
+                File.dirname(__FILE__) + '/' + file
+            else
+                file
+            end
+            # Try to open the file. It may fail, as by default, we try to read
+            # from the user's .amptrc, which may not exist.
+            begin
+                File.open(name, 'r') do |f|
+                    # There used to be more code here, and it used to be more of a hack.
+                    # Now, it's robust to multiple instances of Ampt, and doesn't require
+                    # that ugly Ampt::Config::Extra nonsense; neither here, nor in the
+                    # config file. Yes, I am an hero.
+                    # This is the heart of the operation. It reads the config file into
+                    # an anonymous object of anonymous class (what kind of trickery...).
+                    # From there, it saves that object into this configuration object
+                    # that we're in, also passing a reference to itself into the object,
+                    # so that we can continue our trickery from there.
+                    unless @extras
+                        @extras = Class.new.new
+                        @extras.instance_variable_set '@__p__', self
+                    end
+                    # Now that we have an object, we can use it to store any user-defined
+                    # functions in the config, and have it forward to us anything that it
+                    # isn't aware of (i.e., all of those pesky command definitions).
+                    @extras.class.send(:define_method, :method_missing) do |s, *a, &b|
+                        begin
+                            @__p__.send(s, *a, &b)
+                        rescue e
+                            super
+                        end
+                    end
+                    # Finally, we can read in the configuration file.
+                    @extras.instance_eval(f.read)
+                end
+            rescue Errno::ENOENT => e
+            end
+            # If the user has configured an API, try to require it in.
+            # Otherwise, use the default acoustics API.
+            if @api
+                begin
+                    require @api
+                rescue
+                    puts "Couldn't load API #{@api}"
+                    exit
+                end
+            else
+                require 'ampt_api/acoustics'
+            end
+            # Include that API in the command class.
+            Command.class_eval do
+                include Ampt::API
+            end
+        end
+
+        # Select an API to use. Defaults to the acoustics API. The path should
+        # be an absolute path.
+        def api path
+            @api = path
+        end
+
+        # Alias a command. Takes a hash of 'new command' => 'previous command'.
+        def alias_cmd cmd
+            @alias.merge! cmd
+        end
+
+        # Set as the default command to run if Ampt is run with no arguments.
+        def default cmd
+            @default = cmd
+        end
+
+        # Define a new Ampt command. Must specify a name, and a block containing
+        # the configuration for the command.
+        # The configuration should contain one or more desc and opt's, plus an on_run
+        # block. See Ampt::Command for the on_run block.
+        def command name, &b
+            # If the command already exists, reconfigure it. Else, create a new
+            # instance of Ampt::Command.
+            if @commands[name]
+                @commands[name].reconfig &b
+            else
+                @commands[name] = Ampt::Command.new self, name, &b
+            end
+        end
+
+        # Run the config. Usually not called manually.
+        def run args
+            Trollop::options args, [@commands, @alias] do |cmds, *args|
+                commands, aliases = cmds
+                banner "Usage ampt [command] [options] [args]"
+                banner "\nCommands include:\n"
+                # Print out a nice listing of each command
+                commands.each do |name, command|
+                    banner sprintf("  %-16.16s %s", name, command.desc)
+                end
+                banner ""
+                version "ampt version #{Ampt::VERSION}"
+                # Stop parsing if we reach a command
+                stop_on(commands.keys + aliases.keys)
+            end
+            cmd = ARGV.shift
+            # Try to figure out if it's an alias or a command or nothing or invalid
+            if @commands[cmd]
+                @commands[cmd].run(ARGV)
+            elsif @alias[cmd]
+                until @alias[cmd].nil?
+                    cmd = @alias[cmd]
+                end
+                @commands[cmd].run(ARGV)
+            elsif cmd.nil? and not @default.nil?
+                @commands[@default].run(ARGV)
+            else
+                Trollop::die "#{cmd} is not an ampt command"
+            end
+        end
+
+        private
+        # Magic
+        def cloaker &b
+            (class << self; self; end).class_eval do
+                define_method :cloaker_, &b
+                meth = instance_method :cloaker_
+                remove_method :cloaker_
+                meth
+            end
+        end
+    end
+
+    # Class that is created to hold each Ampt command.
+    class Command
+        include Ampt::API
+
+        # Create a new command. This is usually not called directly; it is invoked by
+        # Ampt::Config::on_run.
+        def initialize config, name, &b
+            @config    = config
+            @name      = name
+            @desc      = []
+            @arg       = ['']
+            @opts      = []
+            @conflicts = []
+            @depends   = []
+            @on_run    = lambda {}
+            cloaker(&b).bind(self).call
+        end
+
+        def method_missing s, *a, &b
+            begin
+                @config.extras(s, *a, &b)
+            rescue
+                super
+            end
+        end
+
+        # Specify that a command takes an argument without flags. This is only used
+        # for nicely formatting the help command.
+        def arg str
+            @arg << '[' + str + ']'
+        end
+
+        # Called if you define a command twice in a configuration file. It will 
+        # reconfigure the command. This is usually not called manually.
+        def reconfig &b
+            cloaker(&b).bind(self).call
+        end
+
+        # Specify that a command takes an opt with the given name and description,
+        # and possibly some options. See Trollop::Opt.
+        def opt name, desc, options = {}
+            @opts << [name, desc, options]
+        end
+
+        # Specify that one or more options conflict with each other.
+        def conflicts *opts
+            @conflicts << opts
+        end
+
+        # Specify that one or more options depend on each other.
+        def depends *opts
+            @depends << opts
+        end
+
+        # Specify the behavior of the command when it is executed. Takes a block.
+        def on_run &b
+            @on_run = b
+        end
+
+        # If for any reason you need Ampt to quit (error, invalid args), call this.
+        def die message
+            Trollop::die "ampt #{@name}: #{message}"
+        end
+
+        # Executed when a command is run. Usually not called manually.
+        def run args
+            opts = Trollop::options args,
+                [@name, @desc, @arg, @opts, @conflicts, @depends] do |params, *args|
+                name, description, arg, opts, conflicts, depends = params
+                banner "ampt #{name}#{arg.join(' ')}: #{description.join " "}"
+                banner ""
+                # Parse each of the specified opts
+                opts.each do |o|
+                    name, desc, options = o
+                    opt name, desc, options
+                end
+                # Parse each of the conflicts
+                conflicts.each do |c|
+                    conflicts(*c)
+                end
+                # Parse each of the depends'
+                depends.each do |d|
+                    depends(*d)
+                end
+            end
+            # Call the on_run block with the options and arguments.
+            @on_run.call(opts, ARGV)
+        end
+
+        # Provide a description for the command. If called with no arguments,
+        # returns the current description.
+        # Can be called multiple times, and will append the the previous call.
+        # Specify :overwrite => true if you want to overwrite all of the previous
+        # text.
+        def desc description = nil, options = {}
+            if description
+                if options[:overwrite]
+                    @desc = [description]
+                else
+                    @desc << description
+                end
+            else
+                @desc
+            end
+        end
+
+        private
+        # Magic
+        def cloaker &b
+            (class << self; self; end).class_eval do
+                define_method :cloaker_, &b
+                meth = instance_method :cloaker_
+                remove_method :cloaker_
+                meth
+            end
+        end
+    end
+    class Song
+        # Create from json
+        def self.json_create o
+            new o['data'] if o['data']
+        end
+        # Serialize to json
+        def to_json(*a)
+            {
+                'json_class' => self.class.name,
+                'data' => [self.instance_variables.reduce({}) do |d,v|
+                    d[v[1..-1]] = self.instance_variable_get v
+                    d
+                end]
+            }.to_json(*a)
+        end
+
+        # Takes a hash to set up the object
+        def initialize h
+            h.each do |k,v|
+                (class << self; self; end).instance_eval do
+                    attr_reader k
+                end
+                instance_variable_set '@'+k, v
+            end
+        end
+    end
+
+    class Status
+        attr_reader :playlist, :now_playing, :who
+        def self.json_create(o)
+            o = o['data']
+            playlist = if o['playlist']
+                playlist = o['playlist'].collect do |s|
+                    Song.json_create('data' => s)
+                end
+            else
+                []
+            end
+            now_playing= Song.json_create('data' => o['now_playing'])
+            new o['player'], o['can_skip'], o['who'], now_playing, playlist
+        end
+
+        def initialize player, can_skip, whoami, now_playing, playlist
+            if player
+                player.each do |k,v|
+                    meta_eval do
+                        attr_reader k
+                    end
+                    instance_variable_set '@'+k, v
+                end
+            end
+            @can_skip = can_skip
+            @who = whoami
+            @playlist = playlist
+            @now_playing = now_playing
+        end
+
+        def can_skip?
+            @can_skip
+        end
+
+        private
+        def metaclass
+            (class << self; self; end)
+        end
+        def meta_eval &b
+            metaclass.instance_eval &b
+        end
+    end
+end

data/lib/ampt_api/acoustics.rb

@@ -0,0 +1,155 @@
+require 'json'
+require 'curb'
+require 'uri'
+
+module Ampt
+    # Provides the API for Acoustics
+    module API
+        # The base url which all of our requests will be relative to.
+        BASEURL = "https://www-s.acm.uiuc.edu/acoustics"
+
+        # Request the player's status. gets the session first so we can tell
+        # whether or not we can skip the current song, which songs are ours, etc.
+        def status
+            auth do
+                player_status req
+            end
+        end
+
+        # Unvotes a song. Takes a song_id (string)
+        def unvote song_id
+            auth do
+                player_status req 'unvote', 'song_id' => song_id
+            end
+        end
+
+        # Votes up a song. Takes a song_id (string)
+        def vote song_id
+            auth do
+                player_status req 'vote', 'song_id' => song_id
+            end
+        end
+
+        # Searches the database for the specified value in the given field.
+        def search value, field = 'any'
+            song_list req 'search', {'field' => field, 'value' => value}
+        end
+
+        # Clears all of your votes.
+        def reset
+            player_status unvote '0'
+        end
+
+        # Gets the most recently added songs. Takes a string count.
+        def recent cnt = '50'
+            song_list req 'recent', 'amount' => cnt || '50'
+        end
+
+        # Gets the most recently played songs. Takes a string count.
+        def history cnt = '25'
+            song_list req 'history', 'amount' => cnt || '25'
+        end
+
+        # Sets the volume to the specified level. level should be a string.
+        def volume level
+            auth do
+                player_status req 'volume', 'value' => level
+            end
+        end
+
+        # Start the player.
+        def start
+            auth do
+                player_status req 'start'
+            end
+        end
+
+        # Skip the current song. Will probably fail horribly if you aren't allowed to skip.
+        def skip
+            auth do
+                player_status req 'skip'
+            end
+        end
+
+        # Stop the player.
+        def stop
+            auth do
+                player_status req 'stop'
+            end
+        end
+
+        # takes field => value pair of what to list. Only one of the given pairs is used.
+        def list options
+            field = options.keys[0]
+            value = options[field]
+            song_list req 'select', {'field' => field, 'value' => value}
+        end
+
+        # Returns amt random songs.
+        def random amt='20'
+            song_list req 'random', 'amount' => amt || '20'
+        end
+
+        # Performs a request with given mode and params.
+        def req mode=nil, params = nil
+            c = Curl::Easy.new
+            c.cookies = @sess
+            if params
+                param_str = params.collect do |key, value|
+                    if value.instance_of? Array
+                        value.collect {|v| "#{URI::escape key}=#{URI::escape v}"}.join(';')
+                    else
+                    "#{URI::escape key}=#{URI::escape value}"
+                    end
+                end
+                c.url = "#{BASEURL}/json.pl?mode=#{mode};" + param_str.join(';')
+            elsif mode
+                c.url = "#{BASEURL}/json.pl?mode=#{mode};"
+            else
+                c.url = "#{BASEURL}/json.pl"
+            end
+            c.perform
+            c.body_str
+        end
+
+        def song_list json
+            begin
+                JSON.parse(json).collect do |s|
+                    Ampt::Song.json_create('data' => s)
+                end
+            rescue JSON::ParserError => e
+                puts "Got invalid JSON!"
+                p json
+                abort
+            end
+        end
+
+        def player_status json
+            begin
+                JSON.parse "{\"json_class\": \"Ampt::Status\", \"data\": " + json + "}"
+            rescue JSON::ParserError => e
+                puts "Got invalid JSON!"
+                p json
+                abort
+            end
+        end
+
+        # Perform an authenticated request
+        def auth &b
+            unless @sess
+                c = Curl::Easy.new
+                c.http_auth_types = Curl::CURLAUTH_GSSNEGOTIATE
+                c.userpwd = ":"
+                c.url = "#{BASEURL}/www-data/auth/"
+                c.perform
+                sessid = c.header_str[/CGISESSID=(.+);/]
+                if sessid.nil?
+                    puts "Could not authenticate -- maybe you should kinit?"
+                    abort
+                end
+                @sess = sessid.chop
+            end
+            (yield) if b
+        end
+    end
+end

data/lib/ampt_cfg/default.rb

@@ -0,0 +1,423 @@
+require 'tempfile'
+
+def colorize(text, color_code)
+  if @no_colorize
+      text
+  else
+      "#{color_code}#{text}\e[0m"
+  end
+end
+
+def red(text); colorize(text, "\e[31m"); end
+def green(text); colorize(text, "\e[32m"); end
+def bold(text); colorize(text, "\e[1m"); end
+def under(text); colorize(text, "\e[4m"); end
+def bggreen(text); colorize(text, "\e[42m"); end
+
+def pp_song song, options={:title => true, :artist => true, :album => false, :track => false}
+    song_id = song.song_id
+    if song_id.nil?
+        puts "  Nothing."
+        raise "Not playing."
+    end
+    artist  = song.artist
+    path    = song.path
+    title   = song.title
+    title   = path.split('/')[-1].rpartition('.')[0] if title.empty?
+    track   = song.track
+    album   = song.album
+    who     = if song.respond_to? :who
+                song.who
+              else
+                []
+              end
+    str = ["[#{green(song_id.rjust(7))}]"]
+    if options[:track]
+        str <<= "#{track.rjust(3)}."
+    end
+    if options[:title]
+        str <<= "#{under(title[0...40].strip)}"
+    end
+    if options[:artist] and not artist.empty?
+        str <<= "by #{(artist[0..20].strip)}"
+    end
+    if options[:album] and not album.empty?
+        str <<= "on #{(album[0..20].strip)}"
+    end
+    unless who.empty?
+        str <<= "\nVoted up by"
+        if who.size > 1 and (not options[:show_all_voters])
+            str <<= "#{who[0]} (and #{who.length - 1} other#{'s' if who.length > 2})"
+        elsif who.size > 1 and options[:show_all_voters]
+            str <<= who.join(', ')
+        else
+            str <<= who[0]
+        end
+    end
+    str.join(' ')
+end
+
+def pp_songs songs
+    songs.each do |song|
+        pp_song(song).lines.each {|l| puts "  " + l}
+    end
+end
+
+def songs_to_file songs, file
+    songs.uniq!
+    s = [sprintf("#\t%7s %3s   %20s   %20s   %20s", 'song_id', '#', 'title', 'artist',
+        'album')]
+    s += songs.collect do |song|
+        sprintf("#\t%7s %3s   %20.20s   %20.20s   %20.20s", song.song_id, song.track,
+                song.title, song.artist, song.album)
+    end
+    file.write(s.join("\n"))
+end
+
+def pp_songs_full songs, options = {}
+    opts = {:title => true, :artist => true, :album => true, :track => true}.merge(options)
+    songs.each do |song|
+        pp_song(song, opts).lines.each {|l| puts "  " + l}
+    end
+end
+
+def pp_time len
+    len = len.to_i
+    str = if len > 3600
+              format("%d:%02d", len/3600, (len/60)%60)
+          else
+              (len / 60).to_s
+          end
+    str << format(":%02d", len % 60)
+end
+
+alias_cmd 'st' => 'status'
+default 'status'
+
+command 'status' do 
+    desc "Prints the currently playing song and playlist."
+    opt :colorize, "Colorize the output", :short => '-c', :default => true
+    opt :no_colorize, "Disable color"
+    on_run do |opts, args|
+        if opts[:no_colorize]
+          @no_colorize = true
+        end
+        st = status
+        puts bold("Now Playing:") + "\n"
+        begin
+            pp_song(st.now_playing).lines.each {|l| puts "  " + l}
+        rescue => e
+            puts "  Ampt isn't currently playing anything."
+        end
+        unless st.playlist.empty?
+            puts bold("\nPlaylist:")
+            pp_songs st.playlist
+            totaltime = st.playlist.reduce(0) do |t, s|
+                t + s.length.to_i
+            end
+            print "\n  #{st.playlist.size} songs queued for a total time of "
+            puts pp_time totaltime
+            me = st.who
+            mine = st.playlist.select do |s|
+                s.who.include? me
+            end
+            mytime = mine.reduce(0) do |t, s|
+                t + s.length.to_i
+            end
+            print "  You have #{mine.size} songs queued for a total time of "
+            puts pp_time mytime
+        end
+    end
+end
+
+alias_cmd 'rm' => 'remove', 'unvote' => 'remove'
+command 'remove' do
+    desc 'Remove your votes from songs in the playlist. Provide a song id ' +
+        'or one of the flags.'
+    arg 'song_id'
+    opt :all, "Remove all of your queued songs (identical to ampt clear)", :short => '-a'
+    opt :interactive, "Interactively remove songs", :short => '-i'
+    conflicts :all, :interactive
+    on_run do |opts, args|
+        if (opts[:all] || opts[:interactive]) && (not args.empty?)
+            die "Unknown argument #{args.join(' ')}"
+        end
+        if opts[:all]
+            reset
+        elsif opts[:interactive]
+            st = status
+            me = st.who
+            list = st.playlist.select do |s|
+                s.who.include? me
+            end
+            s = []
+            Tempfile.open("ampt") do |tempfile|
+                songs_to_file(list, tempfile)
+                tempfile.fsync
+                tempfile.flush
+                path = tempfile.path
+                tempfile.close
+                system(ENV['EDITOR'], path)
+                File.open(path) do |f|
+                    s = f.readlines
+                end
+            end
+            arr = s.inject([]) do |a,line|
+                a + ((line.scan(/\s(\d+)\s/)[0] unless(line =~ /^\#/)) || [])
+            end
+            unless arr.empty?
+                arr.each_slice(40) do |a|
+                    unvote a
+                end
+            end
+        else
+            unvote args
+        end
+    end
+end
+
+alias_cmd 'up' => 'add'
+alias_cmd 'upvote' => 'add'
+command 'add' do
+    desc "Vote for a song. Provide a song id, or one of the flags."
+    arg 'song_id'
+    opt :artist, "Interactively add songs by artist", :type => :string, :multi => true
+    opt :album, "Interactively add songs by album", :type => :string, :multi => true
+    opt :title, "Interactively add songs by title", :type => :string, :multi => true
+    opt :search, "Interactively add songs, searching across all fields", :type => :string, :multi => true
+    opt :randomize, "Randomize order of newly queued songs", :short => '-r'
+    conflicts :search, :artist, :album, :title
+    on_run do |opts, args|
+        if(opts[:artist_given]||opts[:album_given]||opts[:title_given]||opts[:search_given])&&(not args.empty?)
+            die "Unknown argument #{args.join(' ')}"
+        end
+        if opts[:artist_given] || opts[:album_given] || opts[:title_given] || opts[:search_given]
+            randomize = opts.delete(:randomize)
+            list_of = {}
+            list_of[:artist] = opts[:artist]
+            list_of[:album]  = opts[:album]
+            list_of[:title]  = opts[:title]
+            list_of[:search] = opts[:search]
+            list = if opts[:search_given]
+                       list_of.collect do |k,v|
+                           v.collect do |v|
+                               search(v)
+                           end
+                       end
+                   else
+                       list_of.collect do |k,v|
+                           v.collect do |v|
+                               list k.to_s => v
+                           end
+                       end
+                   end
+            list = list.flatten
+            s = []
+            Tempfile.open("ampt") do |tempfile|
+                songs_to_file(list, tempfile)
+                tempfile.fsync
+                tempfile.flush
+                path = tempfile.path
+                tempfile.close
+                system(ENV['EDITOR'], path)
+                File.open(path) do |f|
+                    s = f.readlines
+                end
+            end
+            arr = s.inject([]) do |a,line|
+                a + ((line.scan(/\s(\d+)\s/)[0] unless(line =~ /^\#/)) || [])
+            end
+
+            unless arr.empty?
+                if randomize
+                    arr = arr.shuffle
+                end
+                arr.each_slice(40) do |a|
+                    vote a
+                end
+            end
+        else
+            vote args
+        end
+    end
+end
+
+command 'search' do
+    desc 'Search the database for songs. Defaults to searching by any parameter.'
+    arg 'query'
+    opt :artist, "Search by artist", :type => :string
+    opt :album, "Search by album", :type => :string
+    opt :title, "Search by title", :type => :string
+    opt :path, "Search by path", :type => :string
+    opt :any, "Search by any parameter. This is the default", :type => :string
+    opt :colorize, "Colorize the output", :short => '-c', :default => true
+    opt :no_colorize, "Disable color"
+    conflicts :artist, :album, :title, :path, :any
+    on_run do |opts, args|
+        if opts[:no_colorize]
+            @no_colorize = true
+        end
+        if opts[:artist_given]||opts[:album_given]||opts[:title_given]
+            list_of = {}
+            list_of[:artist] = opts[:artist]
+            list_of[:album]  = opts[:album]
+            list_of[:title]  = opts[:title]
+            list_of[:path]  = opts[:path]
+            list_of[:any]  = opts[:any]
+            list_of.each do |k,v|
+                next if v.nil?
+                puts "Results for #{k.to_s} #{bold(v)}:"
+                pp_songs_full search(v,k.to_s)
+            end
+        else
+            puts "Results for any #{bold(args.join(' '))}:"
+            pp_songs_full search(args)
+        end
+    end
+end
+
+alias_cmd 'clear' => 'reset'
+command 'reset' do
+    desc "Clear all of your votes."
+    on_run do |opts, args|
+        reset
+    end
+end
+
+command 'start' do
+    desc "Start Acoustics."
+    on_run do |opts, args|
+        start
+    end
+end
+
+command 'stop' do
+    desc "Stop Acoustics."
+    on_run do |opts, args|
+        stop
+    end
+end
+
+command 'skip' do
+    desc "Skip the currently playing song."
+    on_run do |opts, args|
+        st = status
+        if st.can_skip?
+            skip
+        else
+            puts "Not allowed to skip!"
+        end
+    end
+end
+
+alias_cmd 'vol' => 'volume'
+command 'volume' do
+    desc 'Set the current volume level. If run without an arg, returns ' + 
+        "the current volume."
+    arg 'num'
+    on_run do |opts,args|
+        if args[0]
+            volume args[0]
+        else
+            st = status
+            puts "Volume is currently set to #{(st.volume)}."
+        end
+    end
+end
+
+alias_cmd 'ls' => 'list'
+command 'list' do
+    desc 'List all songs with the specified parameter. This is ' +
+        'less fuzzy than search. One of the flags must be specified.'
+    opt :artist, "List by artist", :type => :string
+    opt :album, "List by album", :type => :string
+    opt :title, "List by title", :type => :string
+    opt :colorize, "Colorize the output", :short => '-c', :default => true
+    opt :no_colorize, "Disable color"
+    conflicts :artist, :album, :title
+    on_run do |opts, args|
+        if opts[:no_colorize]
+            @no_colorize = true
+        end
+        if not (opts[:artist_given]||opts[:album_given]||opts[:title_given])
+            die "You must specify one of the options"
+        else
+            list_of = {}
+            list_of[:artist] = opts[:artist]
+            list_of[:album]  = opts[:album]
+            list_of[:title]  = opts[:title]
+            list_of.each do |k,v|
+                next if v.nil?
+                puts "Results for #{k.to_s} #{bold(v)}:"
+                pp_songs_full list(k.to_s => v)
+            end
+        end
+    end
+end
+
+command 'show' do
+    desc 'Show more info about a song. Takes a song id as the single ' +
+        'parameter.'
+    opt :colorize, "Colorize the output", :short => '-c', :default => true
+    opt :no_colorize, "Disable color"
+    arg 'song_id'
+    on_run do |opts,args|
+        if opts[:no_colorize]
+            @no_colorize = true
+        end
+        (die "Not enough arguments") unless args[0]
+        song_id = args[0]
+        song = (list 'song_id' => song_id)[0]
+        puts <<-SONGINFO
+  #{under(song.title)} by #{song.artist}
+  Track #{song.track} on album #{song.album}
+  #{song.path}
+        SONGINFO
+        len = song.length.to_i
+        print "  "
+        puts pp_time len
+    end
+end
+
+alias_cmd 'rand' => 'random'
+command 'random' do
+    desc 'Get [num] random songs. Defaults to 20.'
+    opt :colorize, "Colorize the output", :short => '-c', :default => true
+    opt :no_colorize, "Disable color"
+    arg 'num'
+    on_run do |opts,args|
+        if opts[:no_colorize]
+            @no_colorize = true
+        end
+        puts "#{args[0]||20} random songs:"
+        pp_songs_full random args[0]
+    end
+end
+
+command 'new' do
+    desc 'Get [num] newest songs. Defaults to 50.'
+    opt :colorize, "Colorize the output", :short => '-c', :default => true
+    opt :no_colorize, "Disable color"
+    arg 'num'
+    on_run do |opts,args|
+        if opts[:no_colorize]
+            @no_colorize = true
+        end
+        puts "#{args[0]||'50'} newest songs:"
+        pp_songs_full recent args[0]
+    end
+end
+
+command 'history' do
+    desc 'Get [num] last-played songs. Defaults to 25.'
+    opt :colorize, "Colorize the output", :short => '-c', :default => true
+    opt :no_colorize, "Disable color"
+    arg 'num'
+    on_run do |opts,args|
+        if opts[:no_colorize]
+            @no_colorize = true
+        end
+        puts "#{args[0]||'25'} last-played:"
+        pp_songs_full history(args[0]), :show_all_voters => true
+    end
+end

data/test/helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ampt'
+
+class Test::Unit::TestCase
+end

data/test/test_ampt.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestAmpt < Test::Unit::TestCase
+  def test_something_for_real
+    #flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: ampt
+version: !ruby/object:Gem::Version 
+  version: 0.2.0.pre1
+platform: ruby
+authors: 
+- Rich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-08 00:00:00 -06:00
+default_executable: ampt
+dependencies: []
+
+description: |-
+  This is a command line client for the Acoustics Media Player (amp).
+  Amp is available here: http://www.github.com/avuserow/amp
+  
+  This is a work in progress.
+email: rich@interhacktive.com
+executables: 
+- ampt
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .autotest
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- ampt.gemspec
+- bin/ampt
+- lib/ampt.rb
+- lib/ampt_api/acoustics.rb
+- lib/ampt_cfg/default.rb
+- test/helper.rb
+- test/test_ampt.rb
+has_rdoc: true
+homepage: http://github.com/capslock/ampt
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ampt is a command line client for the Acoustics Media Player (amp).
+test_files: 
+- test/helper.rb
+- test/test_ampt.rb