subcl 1.0.1 → 1.1.0

data/lib/Configs.rb

@@ -1,67 +0,0 @@
-class Configs
-
-	attr_reader :server
-	attr_reader :uname
-	attr_reader :pword
-	attr_reader :proto_version
-	attr_reader :max_search_results
-	attr_reader :notifyMethod
-	attr_reader :appname
-	attr_reader :app_version
-	attr_reader :randomSongCount
-
-	def initialize
-		@app_version = '1.0'
-		#subsonic API protocol version
-		@proto_version = '1.9.0'
-		@appname = 'subcl'
-		@max_search_results = 20 #default value
-		@notifyMethod = "auto"
-		@randomSongCount = 10
-
-		@filename = File.expand_path("~/.subcl")
-		unless File.file?(@filename)
-			raise "Config file not found"
-		end
-
-		readConfigs
-		#TODO optimally don't ping here - do this when the notification system is initialized
-		ping
-	end
-
-	def readConfigs
-
-		file = File.new(@filename, "r")
-		while (line = file.gets) do
-			spl = line.split(' ')
-			if spl[0].eql? "server"
-				@server = spl[1]
-			elsif spl[0].eql? "username"
-				@uname = spl[1]
-			elsif spl[0].eql? "password"
-				@pword = spl[1]
-			elsif spl[0].eql? "max_search_results"
-				@max_search_results = spl[1]
-			elsif spl[0].eql? "notify_method"
-				@notifyMethod = spl[1]
-			elsif spl[0].eql? "random_song_count"
-				@randomSongCount = spl[1]
-			end
-		end
-
-		if @server == nil or @uname == nil or @pword == nil
-			raise "Incorrect configuration file"
-		end
-	end
-
-	#check to see if the server is reachable
-	def ping
-		url = @server + "/rest/ping.view"
-		begin
-			Net::HTTP.get_response(URI.parse(url))
-		rescue
-			raise "Couldn't connect to server: #{@server}"
-		end
-	end
-
-end

data/lib/Mpc.rb

@@ -1,68 +0,0 @@
-
-class Mpc
-	attr_accessor :debug
-
-	def initialize
-		@debug = false
-	end
-
-	def mpccall(cmd, quiet = true)
-		call = "mpc #{cmd}"
-		call << " > /dev/null" if quiet
-
-		unless system(call)
-			$stderr.puts "MPC call error: #{$?}"
-		end
-
-	end
-
-	#insert: whether to add the song after the currently playing one
-	#instead of the end of the queue
-	def add(song, insert = false)
-		unless song.respond_to? 'url'
-			p song
-			raise ArgumentError, "parameter does not have an #url method"
-		end
-		if @debug
-			action = insert ? "insert" : "add"
-			puts "would #{action} #{song['title']}: #{song.url}"
-		else
-			if insert then
-				mpccall("insert '#{song.url}'")
-			else
-				mpccall("add '#{song.url}'")
-			end
-		end
-	end
-
-	def play
-		if @debug
-			puts "would play"
-		else
-			mpccall("play")
-		end
-	end
-
-	#stops the player and clears the playlist
-	def clear
-		if @debug
-			puts "would clear"
-		else
-			mpccall("stop")
-			mpccall("clear")
-		end
-	end
-
-	#returns info about the currently playing file
-	def current(info = :url)
-		filter =case info
-		when :url
-			'%file%'
-		when :album
-			'%album%'
-		when :artist
-			'%artist%'
-		end
-		`mpc --format '#{filter}' current`
-	end
-end

data/lib/Notify.rb

@@ -1,66 +0,0 @@
-class Notify
-
-	SupportedMethods = %w{notify-send growlnotify awesome-client}
-	Icon = File.dirname(__FILE__) + "/../share/icon.png"
-
-	def initialize(notifyMethod)
-		@method = nil
-
-		case notifyMethod
-		when nil
-			#do nothing
-		when "none"
-			#do nothing
-		when "auto"
-			#auto detect notifier lib
-			SupportedMethods.each do |method|
-				@binary = getBinary(method)
-				unless @binary.nil?
-					@method = method
-					break
-				end
-			end
-		else
-			#use specified binary
-			unless SupportedMethods.include? notifyMethod
-				raise ArgumentError, "Notification method #{notifyMethod} is not supported"
-			end
-			@binary = getBinary(notifyMethod) 
-			@method = notifyMethod
-			raise ArgumentError, "No binary found for #{notifyMethod} in PATH" if @binary.nil?
-		end
-	end
-
-	def getBinary(name)
-		binary = `which #{name}`.chomp
-		if $?.success?
-			binary
-		else
-			nil
-		end
-	end
-
-	def notify(message)
-		case @method
-		when nil
-			#great, do nothing
-		when "notify-send"
-			system("notify-send --icon #{Icon} --urgency critical Subcl '#{message}'")
-		when "growlnotify"
-			system("growlnotify --image #{Icon} --title Subcl --message '#{message}'")
-		when "awesome-client"
-			naughtyCmd = %Q{
-				naughty.notify({
-					title='subcl',
-					text='#{message}',
-					icon='#{Icon}',
-					timeout = 10
-				}) 
-			}
-			naughtyCmd.gsub! "\n" " "
-
-			system(%Q{echo "#{naughtyCmd}" | awesome-client})
-		end
-	end
-end
-

data/lib/Picker.rb

@@ -1,63 +0,0 @@
-class Picker
-	def initialize(ary)
-		@available = ary
-		if ary.empty? then
-			raise ArgumentError, "Cannot initialize Picker with an empty array!"
-		end
-	end
-
-	def pick
-		choices = {}
-
-		i = 1
-		@available.each do |elem|
-			choices[i] = elem
-			$stderr.print "[#{i}] " 
-			$stderr.puts yield(elem)
-			i = i + 1
-		end
-
-
-		begin
-			picks = []
-			valid = true
-			$stderr.print "Pick any: "
-
-			choice = $stdin.gets
-
-			return @available if choice.chomp == 'all'
-
-			choice.split(/[ ,]+/).each do |part|
-				possibleRange = part.split(/\.\.|-/)
-				if possibleRange.length == 2
-					start = possibleRange[0].to_i
-					stop = possibleRange[1].to_i
-					[start, stop].each do |num|
-						valid = validate(num)
-					end
-					(start..stop).each do |num|
-						picks << choices[num]
-					end
-
-				elsif validate(num = part.to_i)
-					picks << choices[num]
-				else
-					valid == false
-				end
-			end
-		end while !valid
-
-		return picks
-	end
-
-	def validate(pickNum)
-		#no -1, we start filling choices{} at 1
-		if pickNum > 0 and pickNum <= @available.length
-			true
-		else
-			$stderr.puts "Invalid pick. Try again."
-			false
-		end
-	end
-
-end

data/lib/Song.rb

@@ -1,14 +0,0 @@
-class Song < Hash
-	def initialize(subsonic, attributes)
-		@subsonic = subsonic
-		self['type'] = 'song'
-		attributes.each do |key, val|
-			self[key] = val
-		end
-	end
-
-	#returns the streaming url for a song
-	def url
-		@subsonic.songUrl(self['id'])
-	end
-end

data/lib/Subcl.rb

@@ -1,159 +0,0 @@
-require_relative 'Mpc'
-require_relative 'Subsonic'
-require_relative 'Configs'
-require_relative 'Notify'
-
-class Subcl
-	attr_reader :player, :subsonic, :notifier
-
-	def initialize(options = {})
-		#default options
-		@options = {
-			:interactive => true,
-			:tty => true,
-			:insert => false
-		}
-
-		#overwrite defaults with given options
-		@options.merge! options
-
-		begin
-		@configs = Configs.new
-		rescue => e
-			$stderr.puts "Error initializing config"
-			$stderr.puts e.message
-			exit
-		end
-
-		@player = Mpc.new
-		@player.debug = @options[:debug]
-
-		@notifier = Notify.new @configs.notifyMethod
-
-		@display = {
-			:song => proc { |song|
-				"#{song['title']} by #{song['artist']} on #{song['album']} (#{song['year']})"
-			},
-			:album => proc { |album|
-				"#{album['name']} by #{album['artist']} in #{album['year']}"
-			},
-			:artist => proc { |artist|
-				"#{artist['name']}"
-			},
-			:playlist => proc { |playlist|
-				"#{playlist[:name]} by #{playlist[:owner]}"
-			},
-		}
-
-		@subsonic = Subsonic.new(@configs, @display)
-		@subsonic.interactive = @options[:interactive]
-
-	end
-
-	def albumartUrl(size = nil)
-		current = @player.current
-		puts @subsonic.albumartUrl(current, size) unless current.empty?
-	end
-
-	def queue(query, type, inArgs = {})
-		args = {
-			:clear => false, #whether to clear the playlist prior to adding songs
-			:play => false, #whether to start the player after adding the songs
-			:insert => false #whether to insert the songs after the current instead of the last one
-		}
-		args.merge! inArgs
-
-		if @options[:current]
-			unless [:album, :artist].include? type
-				raise ArgumentError, "'current' option can only be used with albums or artists."
-			end
-			query = @player.current type
-		end
-
-		songs = case type
-						when :song
-							@subsonic.song(query)
-						when :album
-							@subsonic.albumSongs(query)
-						when :artist
-							@subsonic.artistSongs(query)
-						when :playlist
-							@subsonic.playlistSongs(query)
-						when :randomSong
-							begin
-								@subsonic.randomSongs(query)
-							rescue ArgumentError
-								raise ArgumentError, "random-songs takes an integer as argument"
-							end
-						end
-
-		if songs.empty?
-			noMatches
-		end
-
-		@player.clear if args[:clear]
-
-		songs.shuffle! if @options[:shuffle]
-
-		songs.each do |song|
-			@player.add(song, args[:insert])
-		end
-
-		@player.play if args[:play]
-	end
-
-	def searchSong(name)
-		songs = @subsonic.songs(name)
-		if(songs.size == 0)
-			noMatches("song")
-		else
-			songs.each do |song|
-				puts @display[:song].call(song)
-			end
-		end
-	end
-
-	def searchAlbum(name)
-		albums = @subsonic.albums(name)
-		if(albums.size == 0)
-			noMatches("album")
-		else
-			albums.each do |album|
-				puts @display[:album].call(album)
-			end
-		end
-	end
-
-	def searchArtist(name)
-		artists = @subsonic.artists(name)
-		if(artists.size == 0)
-			noMatches("artist")
-		else
-			artists.each do |artist|
-				puts @display[:artist].call(artist)
-			end
-		end
-	end
-
-	#print an error that no matches were found, then exit with code 2
-	def noMatches(what = nil)
-		if what
-			message = "No matching #{what}"
-		else
-			message = "No matches"
-		end
-
-		if @options[:tty]
-			$stderr.puts message
-		else
-			@notifier.notify(message) 
-		end
-		exit 2 
-	end
-
-	def testNotify
-		@notifier.notify("Hi!")
-	end
-
-
-end

data/lib/Subsonic.rb

@@ -1,297 +0,0 @@
-require 'net/http'
-require 'rexml/document'
-require 'thread'
-require 'cgi'
-include REXML
-
-require_relative 'Configs'
-require_relative 'Song'
-require_relative 'Picker'
-
-#TODO remove puts from this class; Subcl should handle this
-class Subsonic
-
-	attr_accessor :interactive
-
-	def initialize(configs, display)
-		@configs = configs
-		#hash containing procs for displaying songs, artists, albums
-		@display = display
-		@interactive = true
-	end
-
-	#returns an array of songs for the given album name
-	#on multiple matches, the user is asked interactively for the wanted match
-	def song(name)
-		searchResults = search(name, :song)
-
-		if searchResults.length.zero?
-			return []
-		end
-
-		return whichDidYouMean(searchResults, &@display[:song])
-
-	end
-
-	#returns an array of songs for the given album name
-	#on multiple matches, the user is asked interactively for the wanted match
-	def albumSongs(name)
-
-		searchResults = search(name, :album)
-
-		if searchResults.length.zero?
-			return []
-		end
-
-		picks = whichDidYouMean(searchResults, &@display[:album])
-		songs = []
-		picks.each do |album|
-			doc = query('getAlbum.view', {:id => album['id']})
-			doc.elements.each('subsonic-response/album/song') do |element|
-				songs << Song.new(self, element.attributes)
-			end
-		end
-
-		songs
-	end
-
-	#returns an array of song streaming urls for the given artist name
-	#on multiple matches, the user is asked interactively for the wanted match
-	def artistSongs(name)
-		searchResults = search(name, :artist)
-
-		if searchResults.length.zero?
-			return []
-		end
-
-		picks = whichDidYouMean(searchResults, &@display[:artist])
-		songs = []
-		picks.each do |artist|
-			doc = query('getArtist.view', {:id => artist['id']})
-			doc.elements.each('subsonic-response/artist/album') do |album|
-				doc = query('getAlbum.view', {:id => album.attributes['id']})
-				doc.elements.each('subsonic-response/album/song') do |element|
-					songs << Song.new(self, element.attributes)
-				end
-			end
-		end
-
-		songs
-	end
-
-	def whichDidYouMean(array, &displayProc)
-		if array.empty? or array.length == 1
-			return array
-		end
-
-		if !@interactive
-			return [array.first]
-		end
-
-		return Picker.new(array).pick(&displayProc)
-
-	end
-
-	#returns all artists matching the pattern
-	def artists(name)
-		search(name, :artist)
-	end
-
-	#returns all albums matching the pattern
-	def albums(name)
-		search(name, :album)
-	end
-
-	#returns all songs matching the pattern
-	def songs(name)
-		search(name, :song)
-	end
-
-	#returns all playlists
-	def allPlaylists
-		out = []
-		doc = query('getPlaylists.view')
-		doc.elements.each('subsonic-response/playlists/playlist') do |playlist|
-			item = {
-				:id => playlist.attributes['id'],
-				:name => playlist.attributes['name'],
-				:owner => playlist.attributes['owner']
-			}
-			out << item
-		end
-		out
-	end
-	
-
-	#returns all playlists matching name
-	def playlists(name = nil)
-		all = allPlaylists
-		out = []
-
-		if name
-			name.downcase!
-			all.each do |playlist|
-				if playlist[:name].downcase.include? name
-					out << playlist
-				end
-			end
-		end
-
-		whichDidYouMean(out, &@display[:playlist])
-	end
-
-	#returns all songs from playlist(s) matching the name
-	def playlistSongs(playListName)
-		out = []
-		playlists(playListName).each do |playlist|
-			doc = query('getPlaylist.view', {:id => playlist[:id]})
-			doc.elements.each('subsonic-response/playlist/entry') do |entry|
-				out << Song.new(self, entry.attributes)
-			end
-		end
-		out
-	end
-
-	#returns the streaming URL for the song, including basic auth
-	def songUrl(songid)
-		uri = buildUrl('stream.view', {:id => songid})
-		addBasicAuth(uri)
-	end
-
-	#returns the albumart URL for the song
-	def albumartUrl(streamUrl, size = nil)
-		raise ArgumentError if streamUrl.empty?
-		id = CGI.parse(URI.parse(streamUrl).query)['id'][0]
-		params = {:id => id};
-		params[:size] = size unless size.nil?
-		addBasicAuth(
-			buildUrl('getCoverArt.view', params)
-		)
-	end
-
-	#should the need arise, this outputs the album art as binary
-	def albumart
-		$stderr.puts "Not yet implemented"
-	end
-
-	def albumlist
-		doc = query('getAlbumList2.view', {:type => 'random'})
-		doc.elements.each('subsonic-response/albumList2/album') do |album|
-			puts "#{album.attributes['name']} by #{album.attributes['artist']}"
-		end
-	end
-
-	def randomSongs(count)
-		if count.empty?
-			count = @configs.randomSongCount
-		else
-			#throw an exception if it's not an int
-			count = Integer(count)
-		end
-		out = []
-		doc = query('getRandomSongs.view', {:size => count})
-		doc.elements.each('subsonic-response/randomSongs/song') do |song|
-			out << Song.new(self, song.attributes)
-		end
-		out
-	end
-
-	private
-		def search(query, type)
-			out = []
-
-			params = {
-				:query => query, 
-				:songCount => 0, 
-				:albumCount => 0, 
-				:artistCount => 0,
-			}
-
-			case type
-			when :artist
-				params[:artistCount] = @configs.max_search_results
-			when :album
-				params[:albumCount] = @configs.max_search_results
-			when :song
-				params[:songCount] = @configs.max_search_results
-			when :any
-				#XXX or do we now use max/3 for each?
-				params[:songCount] = @configs.max_search_results
-				params[:albumCount] = @configs.max_search_results
-				params[:artistCount] = @configs.max_search_results
-			end
-
-			doc = query('search3.view', params)
-
-			#TODO find proper variable names. seriously.
-			['artist','album','song'].each do |entityName|
-				doc.elements.each("subsonic-response/searchResult3/#{entityName}") do |entity|
-					ob = nil
-					if entityName == 'song'
-						ob = Song.new self, entity.attributes
-					else
-						ob = entity.attributes
-						ob['type'] = entityName
-					end
-					out << ob
-				end
-			end
-
-			out
-		end
-
-		def query(method, params = {})
-			uri = buildUrl(method, params)
-			req = Net::HTTP::Get.new(uri.request_uri)
-			req.basic_auth(@configs.uname, @configs.pword)
-			res = Net::HTTP.start(uri.hostname, uri.port) do |http|
-				http.request(req)
-			end
-
-			doc = Document.new(res.body)
-
-			#handle error response
-			doc.elements.each('subsonic-response/error') do |error|
-				$stderr.puts "query: #{uri} (basic auth sent per HTTP header)"
-				$stderr.print "Error communicating with the Subsonic server: "
-				$stderr.puts  "#{error.attributes["message"]} (#{error.attributes["code"]})"
-				exit 1
-			end
-
-			#handle http error
-			case res.code
-			when '200'
-				doc
-			else
-				$stderr.puts "query: #{uri} (basic auth sent per HTTP header)"
-				$stderr.print "Error communicating with the Subsonic server: "
-				case res.code
-				when '401'
-					$stderr.puts "HTTP 401. Might be an incorrect username/password"
-				else
-					$stderr.puts "HTTP #{res.code}"
-				end
-				exit 1
-			end
-		end
-
-		def buildUrl(method, params)
-			#params[:u] = @configs.uname
-			#params[:p] = @configs.pword
-			params[:v] = @configs.proto_version
-			params[:c] = @configs.appname
-			query = params.map {|k,v| "#{k}=#{URI.escape(v.to_s)}"}.join('&')
-
-			uri = URI("#{@configs.server}/rest/#{method}?#{query}")
-			#puts "url2: #{uri}"
-			uri
-		end
-
-		#adds the basic auth parameters from the config to the URI
-		def addBasicAuth(uri)
-			uri.user = @configs.uname
-			uri.password = @configs.pword
-			return uri
-		end
-
-end