subcl 1.0.0

data/bin/subcl

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/Subcl'
+require 'optparse'
+
+#don't throw a huge stacktrace
+trap("INT") {
+	puts "\n"
+	exit
+}
+
+options = { :tty => true }
+
+if File.exist?('debug')
+	puts "DEBUGGING"
+	options[:debug] = true
+end
+
+#no idea how to get this variable from outside, so we'll just set it in the loop
+usage = nil
+OptionParser.new do |opts|
+	opts.banner = "Usage: subcl [options] command"
+	opts.separator %{
+Commands
+  list to terminal
+      search[-song|-album|-artist] <pattern>
+      ss|sl|sr <pattern>
+  clear queue and immediately start playing
+      play[-song|-album|-artist|-playlist] <pattern>
+      ps|pl|pr|pp <pattern>
+  clear queue and immediately start playing random songs
+			play-random <count, default 10>
+			r <count, default 10>
+  add to end of queue
+      queue-last[-song|-album|-artist|-playlist] <pattern>
+      ls|ll|lr|lp <pattern>
+  add after the current song
+      queue-next[-song|-album|-artist|-playlist] <pattern>
+      ns|nl|nr|np <pattern>
+  albumart-url [size] - print url of albumart to terminal, 
+      optionally with a specified image size
+
+Options }
+
+	usage = opts
+
+	opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+		options[:verbose] = v
+	end
+	opts.on('-1', '--use-first', 'On multiple matches, use the first match instead of asking interactively') do
+		options[:interactive] = false
+	end
+	opts.on('-s', '--shuffle', "Shuffle playlist before queueing") do
+		options[:shuffle] = true
+	end
+	opts.on('-c', '--current', 'Use info currently playing song instead of commandline argument') do
+		options[:current] = true
+	end
+	opts.on('-h', '--help', 'Display this screen') do
+		puts opts
+		exit
+	end
+	opts.on("--version", "Print version information") do
+		puts Configs.new.app_version
+		exit
+	end
+
+end.parse!
+
+unless ARGV.size >= 1
+	puts usage
+	exit
+end
+
+unless system('tty -s')
+	#not running in a tty, so no use for interactivity
+	options[:tty] = false
+	options[:interactive] = false
+end
+
+subcl = Subcl.new options
+
+arg = ARGV[1,ARGV.length-1].join(" ") #put rest of args together so no quotes are required
+
+
+case ARGV[0].downcase
+when /^play-song$|^ps$/
+	subcl.queue(arg, :song, {:play => true, :clear => true})
+when /^play-artist$|^pr$/
+	subcl.queue(arg, :artist, {:play => true, :clear => true})
+when /^play-album$|^pl$/
+	subcl.queue(arg, :album, {:play => true, :clear => true})
+when /^play-playlist$|^pp$/
+	subcl.queue(arg, :playlist, {:play => true, :clear => true})
+when /^play-random$|^r$/
+	subcl.queue(arg, :randomSong, {:play => true, :clear => true})
+when /^queue-next-song$|^ns$/
+	subcl.queue(arg, :song, {:insert => true})
+when /^queue-next-artist$|^nr$/
+	subcl.queue(arg, :artist, {:insert => true})
+when /^queue-next-album$|^nl$/
+	subcl.queue(arg, :album, {:insert => true})
+when /^queue-next-playlist$|^np$/
+	subcl.queue(arg, :playlist, {:insert => true})
+when /^queue-last-song$|^ls$/
+	subcl.queue(arg, :song)
+when /^queue-last-artist$|^lr$/
+	subcl.queue(arg, :artist)
+when /^queue-last-album$|^ll$/
+	subcl.queue(arg, :album)
+when /^queue-last-playlist$|^lp$/
+	subcl.queue(arg, :playlist)
+when /^search-song$|^ss$/
+	subcl.searchSong(arg)
+when /^search-artist$|^sr$/
+	subcl.searchArtist(arg)
+when /^search-album$|^sl$/
+	subcl.searchAlbum(arg)
+when "albumart-url"
+	arg = nil if arg.empty?
+	puts subcl.albumartUrl(arg)
+when /^album-list$|^al$/
+	subcl.subsonic.albumlist
+when "test-notify"
+	subcl.testNotify
+else
+	if options[:tty] then
+		puts usage
+	else
+		subcl.notifier.notify "Unrecognized command"
+	end
+end

data/lib/Configs.rb

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,68 @@
+
+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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,297 @@
+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

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: subcl
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Latzer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-03 00:00:00.000000000 Z
+dependencies: []
+description: ! ' This is a commandline client for the subsonic music server (www.subsonic.org).
+  It relies on mpd and mpc. '
+email: latzer.daniel@gmail.com
+executables:
+- subcl
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/Picker.rb
+- lib/Configs.rb
+- lib/Subcl.rb
+- lib/Subsonic.rb
+- lib/Mpc.rb
+- lib/Notify.rb
+- lib/Song.rb
+- bin/subcl
+- share/icon.png
+homepage: https://github.com/Tourniquet/subcl
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A commandline client for the subsonic music server
+test_files: []