mumbletune 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.DS_Store
+conf.yml
+conf.yaml

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mumbletune.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: .
+  specs:
+    mumbletune (0.1.0)
+      eventmachine
+      meta-spotify
+      mumble-ruby
+      mustache
+      ruby-mpd
+      rubypython
+      sinatra
+      text
+      thin
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    blankslate (3.1.2)
+    celt-ruby (0.0.1)
+      ffi
+    daemons (1.1.9)
+    eventmachine (1.0.3)
+    ffi (1.4.0)
+    httparty (0.10.2)
+      multi_json (~> 1.0)
+      multi_xml (>= 0.5.2)
+    i18n (0.6.4)
+    meta-spotify (0.3.0)
+      httparty (> 0.8)
+    multi_json (1.6.1)
+    multi_xml (0.5.3)
+    mumble-ruby (0.0.3)
+      activesupport
+      celt-ruby
+      ruby_protobuf
+    mustache (0.99.4)
+    rack (1.5.2)
+    rack-protection (1.5.0)
+      rack
+    rake (10.0.3)
+    ruby-mpd (0.2.1)
+    ruby_protobuf (0.4.11)
+    rubypython (0.6.3)
+      blankslate (>= 2.1.2.3)
+      ffi (>= 1.0.7)
+    sinatra (1.4.1)
+      rack (~> 1.5, >= 1.5.2)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    text (1.2.1)
+    thin (1.5.0)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    tilt (1.3.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  mumbletune!
+  rake

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Elliott Williams
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in 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:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 AUTHORS 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 IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Mumbletune
+
+MUMBLETUNE is an amiable bot that connects to a mumble server and allows users to interact with and play a queue of music. It currently plays music through Spotify.
+
+## Installation
+
+First, install Hexxeh's (spotify-websocket-api)[https://github.com/Hexxeh/spotify-websocket-api].
+
+    git clone git://github.com/Hexxeh/spotify-websocket-api.git
+    cd spotify-websocket-api
+    python setup.py build
+    puthon setup.py install
+
+Then, add this line to your application's Gemfile:
+
+    gem 'mumbletune'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mumbletune
+
+## Usage
+
+1. Create a configuration file. See `conf.example.yaml` for help.
+2. Start Mumbletune, passing your config with `-c`.
+
+		$ mumbletune -c config_file.yaml

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mumbletune

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+
+require 'mumbletune'

data/docs/commands.md

@@ -0,0 +1,13 @@
+Command									Action
+------									------
+play <track>					 	Queue this song.
+play <artist>						Queue 10 tracks by this artist.
+play <album>						Queue this entire album.
+play <something> now				Play this shit right now!
+what									Gets what is playing, and what is queued.
+next									Jump to the next song in the queue.
+clear									Clears the current queue.
+volume?									Get the current volume level.
+volume [0-100]							Set the volume.
+wisdom									Obtain it.
+------									------

data/lib/mumbletune/collection.rb

@@ -0,0 +1,17 @@
+module Mumbletune
+	class Collection
+		attr_accessor :type, :tracks, :description, :user
+
+		def initialize(type, tracks, description)
+			@type = type
+			@description = description
+
+			if tracks.class == Array
+				@tracks = tracks
+			else
+				@tracks = [tracks]
+			end
+		end
+
+	end
+end

data/lib/mumbletune/handle_sp_error.rb

@@ -0,0 +1,23 @@
+module Mumbletune
+
+	# The Spotify Metadata API seems to throw 502 (Bad Gateway) errors *a lot*.
+	# 	There's some complaint about this online, and I can reproduce it with
+	# 	plenty of REST clients, so I am sure it's Spotify's problem. But they
+	# 	don't seem too interested in fixing what appears to be a long-standing
+	# 	issue. Ho hum.
+	def self.handle_sp_error
+		begin
+			yield
+		rescue MetaSpotify::ServerError => err
+			puts "Caught ServerError: #{err}"
+			failed ||= 0
+			failed += 1
+			if failed < 4
+				sleep 1
+				retry
+			else
+				raise
+			end
+		end
+	end
+end

data/lib/mumbletune/messages.rb

@@ -0,0 +1,163 @@
+require 'uri'
+require 'text'
+require 'mustache'
+
+Thread.abort_on_exception=true # development only
+
+module Mumbletune
+
+	class Message
+
+		# class methods
+
+		class << self
+			attr_accessor :template
+		end
+		self.template = Hash.new
+
+		def self.parse(client, data)
+			message = Message.new(client, data)
+
+			begin
+				case message.text
+
+				when /^play/i
+					if message.argument.length > 0 # user wants to play something
+						if message.words.last =~ /now/i
+							play_now = true 
+							message.argument = message.words[1...message.words.length-1].join(" ")
+						else
+							play_now = false
+						end
+
+						# reassurance that it's working
+						message.respond "I'm searching. Hang tight."
+						
+						collection = Mumbletune.resolve(message.argument)
+
+						# handle unknown argument
+						return message.respond "I couldn't find what you wanted me to play. :'(" unless collection
+
+						# associate the collection with a user
+						collection.user = message.sender.name
+
+						# add these tracks to the queue
+						Mumbletune.player.add_collection collection, (play_now) ? true : false
+
+						if play_now
+							message.respond_all "#{message.sender.name} is playing #{collection.description} RIGHT NOW."
+						else
+							message.respond_all "#{message.sender.name} added #{collection.description} to the queue."
+						end
+
+						Mumbletune.player.play unless Mumbletune.player.playing?
+
+						
+					else # user wants to unpause
+						if Mumbletune.player.paused?
+							Mumbletune.player.play
+							message.respond "Unpaused."
+						else
+							message.respond "Not paused."
+						end
+					end
+
+				when /^pause$/i
+					paused = Mumbletune.player.pause
+					response = (paused) ? "Paused." : "Unpaused."
+					message.respond response
+
+				when /^unpause$/i
+					if Mumbletune.player.paused?
+						Mumbletune.player.play
+						message.respond "Unpaused."
+					else
+						message.respond "Not paused."
+					end
+
+
+				when /^next$/i
+					Mumbletune.player.next
+					current = Mumbletune.player.current_song
+					message.respond "OK, now playing #{current.artist} - #{current.name}"
+
+				when /^clear$/i
+					Mumbletune.player.clear_queue
+					message.respond "#{message.sender.name} cleared the queue."
+
+				when /^undo$/i
+					removed = Mumbletune.player.undo
+					message.respond_all "#{message.sender.name} removed #{removed.description} that #{removed.user} added."
+
+
+				when /^(what|queue)$/i
+					queue = Mumbletune.player.queue
+
+					# Now, a template.
+					rendered = Mustache.render Message.template[:queue],
+						:queue => queue,
+						:anything? => (queue.empty?) ? false : true
+					message.respond rendered
+
+				when /^volume\?$/i
+					message.respond "The volume is #{Mumbletune.player.volume?}."
+
+				when /^volume/i
+					if message.argument.length == 0
+						message.respond "The volume is #{Mumbletune.player.volume?}."
+					else
+						Mumbletune.player.volume(message.argument)
+						message.respond "Now the volume is #{Mumbletune.player.volume?}."
+					end
+
+				when /^wisdom$/i
+					message.respond `fortune`
+
+				when /^help$/i
+					rendered = Mustache.render Message.template[:commands]
+					message.respond rendered
+					
+				else # Unknown command was given.
+					rendered = Mustache.render Message.template[:commands],
+						:unknown => { :command => message.text }
+					message.respond rendered
+				end
+
+			rescue => err # Catch any command that errored.
+				message.respond "Woah, an error occurred: #{err.message}"
+				puts "#{err.class}: #{err.message}"
+				puts err.backtrace
+			end
+		end
+
+
+		# instance methods
+
+		attr_accessor :client, :sender, :text, :command, :argument, :words
+
+		def initialize(client, data)
+			@client = client
+			@sender = client.users[data[:actor]] # users are stored by their session ID
+			@me = client.me
+			@text = data[:message]
+
+			@words = @text.split
+			@command = words[0]
+			@argument = words[1...words.length].join(" ")
+		end
+
+		def respond(message)
+			@client.text_user(@sender.session, message)
+		end
+
+		def respond_all(message) # send to entire channel
+			@client.text_channel(@me.channel_id, message)
+		end
+	end
+
+	# load templates
+	Dir.glob(File.dirname(__FILE__) + "/templates/*.mustache").each do |f_path|
+		f = File.open(f_path)
+		Message.template[File.basename(f_path, ".mustache").to_sym] = f.read
+	end
+end

data/lib/mumbletune/mpd_client.rb

@@ -0,0 +1,180 @@
+require 'ruby-mpd'
+
+module Mumbletune
+
+	class Player
+
+		attr_accessor :history
+
+		def initialize(host=Mumbletune.config['mpd']['host'], port=Mumbletune.config['mpd']['port'])
+			@mpd = MPD.new(host, port)
+			@mpd.connect true # 'true' enables callbacks
+			@mpd.clear
+
+			@history = Array.new
+			@prev_id = 0
+
+			self.default_volume
+			self.establish_callbacks
+		end
+
+		# Setup
+
+		def default_volume
+			@mpd.volume = Mumbletune.config["mpd"]["default_volume"] || 100
+		end
+
+		def establish_callbacks
+			@mpd.on :connection do |status|
+				if status == false
+					@mpd.connect true
+				else
+					puts ">> MPD happens to be connected."
+				end
+			end
+
+			# Fires when currently playing song changes.
+			@mpd.on :songid do |id|
+				
+				# Clear old tracks from the store.
+				Track.store.delete_if { |t| t.mpd_id == @prev_id }
+
+				@prev_id = id
+			end
+		end
+
+		# Status methods
+
+		def playing?
+			state = @mpd.status[:state]
+			if state =~ /^(play|pause)$/i
+				true
+			else
+				false
+			end
+		end
+
+		def paused?
+			state = @mpd.status[:state]
+			if state == :pause
+				true
+			else
+				false
+			end
+		end
+
+
+		# MPD Settings
+
+		def volume?
+			@mpd.volume
+		end
+
+		def volume(percent)
+			@mpd.volume = percent
+		end
+
+
+
+		# Queue
+
+		def add_collection(col, now=false)
+			col.tracks.each do |t|
+				id = @mpd.addid t.url,
+					 (now) ? col.tracks.index(t)+1 : nil
+				t.mpd_id = id
+			end
+
+			@history.push col
+
+			@mpd.next if now
+		end
+
+		def queue
+			# associate known Tracks with Queue items
+			mapped_queue = @mpd.queue.map do |mpd_song|
+				t = Track.retreive_from_mpd_id(mpd_song.id)
+				t.queue_pos = mpd_song.pos
+				t
+			end
+			# mapped_queue.delete_if { |t| t == current_song }
+			mapped_queue
+		end
+
+		def current_song
+			Track.retreive_from_mpd_id(@mpd.current_song.id) if @mpd.playing?
+		end
+
+		def undo
+			last_collection = @history.pop
+
+			last_collection.tracks.each do |t|
+				to_delete = @mpd.queue.select { |mpd_song| mpd_song.id == t.mpd_id }.first
+				@mpd.delete(to_delete.pos) if to_delete
+			end
+			last_collection
+		end
+
+		def clear_all
+			@mpd.clear
+		end
+
+		def clear_queue
+			current = @mpd.current_song
+			@mpd.queue.each do |t|
+				@mpd.delete :id => t.id unless t.id == current.id
+			end
+		end
+
+		
+=begin 
+		# Deprecated add methods. Time to remove?
+
+		def add(track)
+			id = @mpd.addid track.url
+			track.mpd_id = id
+		end
+
+		def add_batch(tracks)
+			tracks.each do |t|
+				id = @mpd.addid t.url
+				t.mpd_id = id
+			end
+		end
+
+		def add_now(track)
+			id = @mpd.addid track.url, 1
+			track.mpd_id = id
+			@mpd.next
+		end
+
+		def add_now_batch(tracks)
+			tracks.each do |t|
+				id = @mpd.addid t.url, tracks.index(t)+1
+				t.mpd_id = id
+			end
+			@mpd.next
+		end
+=end
+
+		# Playback commands
+
+		def play
+			@mpd.play
+		end
+
+		def pause
+			@mpd.pause = (@mpd.playing?) ? true : false
+		end
+
+		def next
+			@mpd.next
+		end
+
+		def stop
+			@mpd.stop
+		end
+
+	end
+
+end

data/lib/mumbletune/mumble_client.rb

@@ -0,0 +1,55 @@
+require 'mumble-ruby'
+
+module Mumbletune
+	class MumbleClient
+
+		def initialize
+			opts = Mumbletune.config['mumble']
+			@cli = Mumble::Client.new(opts['host'], opts['port'], opts['username'], opts['password'])
+
+			@cli.on_server_sync do |message| # Once connected.
+				@cli.session = message.session # housekeeping for mumble-ruby
+				connect_to = @cli.channels.select { |key, hash| hash["name"] == opts['channel'] }.first[1][:name]
+				@cli.join_channel(connect_to)
+
+				@ready = true
+				puts ">> Connected to Mumble server at #{opts['host']}."
+			end
+
+			@cli.on_text_message do |data|
+				if data[:session].include?(@cli.me[:actor]) # if message was sent to us
+					# interpret the message in a separate thread
+					Thread.new { Message.parse(@cli, data) }
+				end
+			end
+		end
+
+		def connect
+			@ready = false
+			@cli.connect
+
+			@ready_wait = Thread.new do 
+				sleep 0.1 until @ready
+			end
+		end
+
+		def stream
+			@ready_wait.join
+			input = Mumbletune.config['mpd']['fifo_out']
+			Thread.current.priority = 5
+			puts ">> Streaming to Mumble from #{input}"
+			@cli.stream_raw_audio(input)
+		end
+
+
+	end
+
+end
+
+# on_server_sync is used internally, and our callback overloads its own.
+#   We need access to `session` to handle the function internally
+module Mumble
+	class Client
+		attr_accessor :session
+	end
+end