mumbletune 0.1.0

data/lib/mumbletune/resolver.rb

@@ -0,0 +1,148 @@
+require 'uri'
+require 'meta-spotify'
+require 'text'
+
+
+module Mumbletune
+	def self.resolve(argument)
+		Resolvers.workers.each do |r|
+			if r.matches?(argument)
+				return r.resolve(argument)
+			end
+		end
+		return false
+	end
+
+	module Resolvers
+		class << self
+			attr_accessor :workers
+		end
+
+		@workers = []
+
+		class Resolver
+			def matches?(arg); end
+			def resolve(arg); end
+			def self.inherited(subcl)
+				Resolvers.workers.push(subcl.new)
+			end
+		end
+
+		class SpotifyURIResolver < Resolver
+			def matches?(uri)
+				http_uris = URI.extract(uri, ['http', 'https'])
+				sp_uris = URI.extract(uri, 'spotify')
+				if http_uris.any?
+					parsed_uri = URI.parse(http_uris.join)
+					if parsed_uri.hostname =~ /(?:open|play)\.spotify\.com/i
+						true
+					else
+						false
+					end
+				elsif sp_uris.any?
+					true
+				else
+					false
+				end
+			end
+			def resolve(uri)
+				raise "Not a Spotify URI." unless matches?(uri)
+				regexp = /(?<type>track|artist|album)[\/|:](?<id>\w+)/i
+				matched = regexp.match(uri)
+				type = matched[:type]
+				id = matched[:id]
+				sp_uri = "spotify:#{type}:#{id}"
+
+				# behave according to URI type
+				case type
+				when "track" # Return this track
+					SpotifyTrack::track_from_uri(sp_uri)
+				when "album" # Return all tracks of the album to queue
+					SpotifyTrack::tracks_from_album(sp_uri)
+				when "artist" # Return 10 tracks for this artist
+					SpotifyTrack::tracks_from_artist(sp_uri)
+				end
+			end
+		end
+
+		class SpotifySearchResolver < Resolver
+			def matches?(query)
+				# basically we will search for anything that's not a URL
+				if URI.extract(query).any?
+					return false
+				else
+					return true
+				end
+			end
+			def resolve(query)
+				first_word = query.split.first
+
+				# if first word is a type to search for, it needs to be stripped
+				#    from the query so we don't search for it (e.g. "track starships")
+				if first_word =~ /^(artist|album|track)$/i
+					query_a = query.split
+					query_a.delete_at 0
+					query = query_a.join(" ")
+				end
+
+				# used to check if tracks are playable in in region
+				region = Mumbletune.config["spotify"]["region"]
+
+				# determine result based on a type in the first word
+				if first_word =~ /^artist$/i
+					artist = Mumbletune.handle_sp_error { MetaSpotify::Artist.search(query) }
+					result = artist[:artists].first
+
+				elsif first_word =~ /^album$/i
+					album = Mumbletune.handle_sp_error { MetaSpotify::Album.search(query) }
+					album[:albums].select! { |a| a.available_territories.include? region }
+					result = album[:albums].first
+
+				elsif first_word =~ /^track$/i
+					track = Mumbletune.handle_sp_error { MetaSpotify::Track.search(query) }
+					track[:tracks].select! { |t| t.album.available_territories.include? region }
+					result = track[:tracks].first
+
+				else # determine intended result by similarity to the query
+					artist = Mumbletune.handle_sp_error { MetaSpotify::Artist.search(query) }
+					album = Mumbletune.handle_sp_error { MetaSpotify::Album.search(query) }
+					track = Mumbletune.handle_sp_error { MetaSpotify::Track.search(query) }
+
+					# searches now finished
+
+					# remove anything out-of-region
+					album[:albums].select! { |a| a.available_territories.include? region } if album[:albums].any?
+					track[:tracks].select! { |t| t.album.available_territories.include? region } if track[:tracks].any?
+
+					compare = []
+					compare.push track[:tracks].first if track[:tracks].any?
+					compare.push album[:albums].first if album[:albums].any?
+					compare.push artist[:artists].first if artist[:artists].any?
+					
+					white = Text::WhiteSimilarity.new
+					compare.sort! do |a, b|
+						a_sim = white.similarity(query, a.name)
+						b_sim = white.similarity(query, b.name)
+						if a_sim > b_sim
+							-1
+						elsif b_sim > a_sim
+							1
+						else
+							0
+						end
+					end
+					result = compare.first
+				end
+
+				if result.class == MetaSpotify::Artist
+					SpotifyTrack.tracks_from_artist(result)
+				elsif result.class == MetaSpotify::Album
+					SpotifyTrack.tracks_from_album(result)
+				elsif result.class == MetaSpotify::Track
+					SpotifyTrack.track_from_uri(result)
+				end
+
+			end
+		end
+	end
+end

data/lib/mumbletune/sp_uri_server.rb

@@ -0,0 +1,42 @@
+require 'sinatra/base'
+
+module Mumbletune
+
+	module SPURIServer
+
+		class Server < Sinatra::Base
+			set :run, true
+			set :server, :thin
+			set :logging, false
+			set :app_file, __FILE__
+			set :bind, 'localhost'
+			set :port, 8081
+
+			get '/play/:uri' do
+				cred = Mumbletune.config['spotify']
+				sp = Mumbletune::Spotify.new(cred['username'], cred['password'])
+
+				track = sp.objectFromURI(params[:uri])
+				halt 404, "Could not find a track with that URI." if track == nil
+
+				url = track.getFileURL().to_s
+				halt 404, "Could not find a track URL for that URI." if track == nil
+
+				sp.logout
+				redirect url, 303
+			end
+		end
+
+		def self.url_for(uri)
+			bind = Server::bind
+			port = Server::port
+			"http://#{bind}:#{port}/play/#{uri}"
+		end
+
+		def self.sp_uri_for(url)
+			regexp = /(.+)(<sp_uri>spotify:\w+:\w+)/i
+			matched = regexp.match(url)
+			matched[:sp_uri]
+		end
+	end
+end

data/lib/mumbletune/spotify_track.rb

@@ -0,0 +1,90 @@
+require 'uri'
+
+module Mumbletune
+
+	class SpotifyTrack < Track
+		def initialize(params)
+			super
+
+			@uri = params[:uri]
+			@url = SPURIServer.url_for(@uri)
+		end
+
+		def self.track_from_uri(track)
+			track = MetaSpotify::Track.lookup(track) unless track.class == MetaSpotify::Track
+
+			# force track to be playable within region
+			unless track.album.available_territories.include? Mumbletune.config["spotify"]["region"]
+				raise "#{track.name}: Not available in this region."
+			end
+
+			song = SpotifyTrack.new({
+				:name => track.name,
+				:artist => track.artists.first.name,
+				:album => track.album.name,
+				:uri => track.uri
+			})
+
+			# Technically, a collection of one.
+			Collection.new(
+				:TRACK,
+				song,
+				"<b>#{song.name}</b> by <b>#{song.artist}</b>"
+				)
+		end
+
+		def self.tracks_from_album(album_ref)	
+			album_uri = album_ref.uri if album_ref.class == MetaSpotify::Album
+			album = MetaSpotify::Album.lookup(album_uri, {:extras => "track"})
+
+			# force album to be playable in region
+			unless album.available_territories.include? Mumbletune.config["spotify"]["region"]
+				raise "#{album.name}: Not available in this region."
+			end
+
+			tracks = []
+			album.tracks.each do |track|
+				tracks.push SpotifyTrack.new({
+					:name => track.name,
+					:artist => track.artists.first.name,
+					:album => album.name,
+					:uri => track.uri
+				})
+			end
+
+			Collection.new(
+				:ALBUM,
+				tracks,
+				"the album <b>#{album.name}</b> by <b>#{album.artists.first.name}</b>"
+				)
+		end
+
+		def self.tracks_from_artist(artist)
+			artist = MetaSpotify::Artist.lookup(artist) unless artist.class == MetaSpotify::Artist
+
+			# spotify metadata api still error-prone
+			search_result = Mumbletune.handle_sp_error { MetaSpotify::Track.search("artist:\"#{artist.name}\"") }
+
+			# filter out tracks outside region
+			search_result[:tracks].select! do |track|
+				track.album.available_territories.include? Mumbletune.config["spotify"]["region"]
+			end
+
+			tracks = []
+			search_result[:tracks][0...10].each do |track|
+				tracks.push SpotifyTrack.new({
+					:name => track.name,
+					:artist => track.artists.first.name,
+					:album => track.album.name,
+					:uri => track.uri
+				})
+			end
+
+			Collection.new(
+				:ARTIST_TOP,
+				tracks,
+				"#{tracks.length} tracks by <b>#{artist.name}</b>"
+				)
+		end
+	end
+end

data/lib/mumbletune/templates/commands.mustache

@@ -0,0 +1,100 @@
+{{#unknown}}
+<p>
+	I've got literally no idea what "{{command}}" means. Try one of these commands:
+</p>
+{{/unknown}}
+
+<table>
+	<thead>
+		<tr class="header">
+			<th align="left">
+				Command
+			</th>
+			<th align="left">
+				Action
+			</th>
+		</tr>
+	</thead>
+	<tbody>
+		<tr class="odd">
+			<td align="left">
+				play &lt;track&gt;
+			</td>
+			<td align="left">
+				Queue this song.
+			</td>
+		</tr>
+		<tr class="even">
+			<td align="left">
+				play &lt;artist&gt;
+			</td>
+			<td align="left">
+				Queue 10 tracks by this artist.
+			</td>
+		</tr>
+		<tr class="odd">
+			<td align="left">
+				play &lt;album&gt;
+			</td>
+			<td align="left">
+				Queue this entire album.
+			</td>
+		</tr>
+		<tr class="even">
+			<td align="left">
+				play &lt;something&gt; now
+			</td>
+			<td align="left">
+				Play this shit right now!
+			</td>
+		</tr>
+		<tr class="odd">
+			<td align="left">
+				what
+			</td>
+			<td align="left">
+				Gets what is playing, and what is queued.
+			</td>
+		</tr>
+		<tr class="even">
+			<td align="left">
+				next
+			</td>
+			<td align="left">
+				Jump to the next song in the queue.
+			</td>
+		</tr>
+		<tr class="odd">
+			<td align="left">
+				clear
+			</td>
+			<td align="left">
+				Clears the current queue.
+			</td>
+		</tr>
+		<tr class="even">
+			<td align="left">
+				volume?
+			</td>
+			<td align="left">
+				Get the current volume level.
+			</td>
+		</tr>
+		<tr class="odd">
+			<td align="left">
+				volume [0-100]
+			</td>
+			<td align="left">
+				Set the volume.
+			</td>
+		</tr>
+		<tr class="even">
+			<td align="left">
+				wisdom
+			</td>
+			<td align="left">
+				Obtain it.
+			</td>
+		</tr>
+	</tbody>
+</table>

data/lib/mumbletune/templates/queue.mustache

@@ -0,0 +1,41 @@
+{{#anything?}}
+<table>
+	<col width="29%">
+	<col width="13%">
+	<col width="19%">
+	<thead>
+		<tr class="header">
+			<th align="left"></th>
+			<th align="left">
+				Track
+			</th>
+			<th align="left">
+				Artist
+			</th>
+		</tr>
+	</thead>
+	<tbody>
+{{/anything?}}
+
+		{{#queue}}
+		<tr class="odd">
+			<td align="left">
+				{{#playing?}} &#9658; {{/playing?}}
+			</td>
+			<td align="left">
+				{{name}}
+			</td>
+			<td align="left">
+				{{artist}}
+			</td>
+		</tr>
+		{{/queue}}
+
+{{#anything?}}
+	</tbody>
+</table>
+{{/anything?}}
+
+{{^anything?}}
+	Nothing is playing. :c
+{{/anything?}}

data/lib/mumbletune/track.rb

@@ -0,0 +1,32 @@
+module Mumbletune
+	class Track
+		attr_accessor :name, :artist, :album, :url, :mpd_id, :queue_pos
+
+		class << self
+			attr_accessor :store
+		end
+		self.store = []
+
+		def initialize(params)
+			@name = params[:name]
+			@artist = params[:artist]
+			@album = params[:album]
+			@url = params[:url]
+
+			Track.store.push self
+		end
+
+		def playing?
+			if self == Mumbletune.player.current_song
+				true
+			else
+				false
+			end
+		end
+
+		def self.retreive_from_mpd_id(id)
+			Track.store.select { |t| t.mpd_id == id }.first
+		end
+
+	end
+end

data/lib/mumbletune/version.rb

@@ -0,0 +1,3 @@
+module Mumbletune
+  VERSION = "0.1.0"
+end

data/lib/mumbletune.rb

@@ -0,0 +1,79 @@
+require 'mumbletune/mumble_client'
+require 'mumbletune/mpd_client'
+require 'mumbletune/messages'
+require 'mumbletune/track'
+require 'mumbletune/collection'
+require 'mumbletune/sp_uri_server'
+require 'mumbletune/spotify_track'
+require 'mumbletune/resolver'
+require 'mumbletune/handle_sp_error'
+
+require 'optparse'
+require 'yaml'
+require 'eventmachine'
+require 'rubypython'
+
+module Mumbletune
+	class << self
+		attr_reader :player, :mumble, :uri_server, :config
+	end
+
+	# parse command line options
+	config_file = nil
+	OptionParser.new do |opts|
+		opts.banner = "Usage: mumbletune.rb [options]"
+		opts.on("-c", "--config FILE", "=MANDATORY", "Path to configuration file") do |file|
+			config_file = file
+		end
+		opts.on("-h", "--help", "This help message") do
+			puts opts.help()
+			exit
+		end
+	end.parse!
+	raise OptionParser::MissingArgument unless config_file
+
+	# load configuration file
+	@config = YAML.load_file(config_file)
+
+	# load spotify-websocket-api
+	puts ">> Loading Spotify APIs..."
+	RubyPython.start(:python_exe => 'python2.7')
+	Spotify = RubyPython.import('spotify_web.friendly').Spotify
+
+	# open URI server
+	uri_thread = Thread.new do
+		SPURIServer::Server.run!
+	end
+
+	# initialize player
+	play_thread = Thread.new do
+		@player = Player.new
+	end
+
+	# connect to mumble & start streaming
+	mumble_thread = Thread.new do
+		@mumble = MumbleClient.new
+		@mumble.connect
+		@mumble.stream
+	end
+
+	# shutdown code
+	def self.shutdown
+		puts "\nGoodbye forever. Exiting..."
+	 	exit
+	end
+
+	# exit when Ctrl-C pressed
+	EventMachine.schedule do
+		trap("INT") { Mumbletune.shutdown }
+	end
+
+	# testing
+	# sleep 3
+	# @player.command_test_load
+	# @player.command_play
+
+	Thread.stop # wake up to shut down
+	self.shutdown
+
+end

data/mumbletune.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mumbletune/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mumbletune"
+  spec.version       = Mumbletune::VERSION
+  spec.authors       = ["Elliott Williams"]
+  spec.email         = ["e@elliottwillia.ms"]
+  spec.description   = "Mumbletune connects to a mumble server and allows users to"\
+                       " interact with and play a queue of music. Currently plays"\
+                       " from Spotify alone."
+  spec.summary       = "A mumble server bot that plays music"
+  spec.homepage      = "http://github.com/elliottwilliams/mumbletune"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency "mumble-ruby"
+  spec.add_runtime_dependency "ruby-mpd"
+  spec.add_runtime_dependency "sinatra"
+  spec.add_runtime_dependency "meta-spotify"
+  spec.add_runtime_dependency "rubypython"
+
+  spec.add_runtime_dependency "thin"
+  spec.add_runtime_dependency "eventmachine"
+  spec.add_runtime_dependency "text"
+  spec.add_runtime_dependency "mustache"
+end