play 0.0.1

data/config.ru

@@ -0,0 +1,10 @@
+require File.expand_path(File.dirname(__FILE__) + '/lib/play')
+
+require 'play'
+require 'omniauth/oauth'
+oauth = Play.config
+
+use Rack::Session::Cookie
+use OmniAuth::Strategies::GitHub, oauth['gh_key'], oauth['gh_secret']
+
+run Play::App

data/db/migrate/01_create_schema.rb

@@ -0,0 +1,55 @@
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    create_table :songs do |t|
+      t.string  :title
+      t.string  :path
+      t.integer :artist_id
+      t.integer :album_id
+      t.integer :playcount
+      t.boolean :queued, :default => false
+      t.boolean :now_playing, :default => false
+      t.timestamps
+    end
+
+    create_table :artists do |t|
+      t.string  :name
+      t.timestamps
+    end
+
+    create_table :albums do |t|
+      t.string  :name
+      t.integer :artist_id
+      t.timestamps
+    end
+
+    create_table :users do |t|
+      t.string :login
+      t.string :name
+      t.string :email
+      t.string :office_string
+      t.string :alias
+    end
+
+    create_table :votes do |t|
+      t.integer :song_id
+      t.integer :user_id
+      t.integer :artist_id
+      t.boolean :active, :default => true
+      t.timestamps
+    end
+
+    create_table :histories do |t|
+      t.integer :song_id
+      t.integer :artist_id
+      t.timestamps
+    end
+  end
+ 
+  def self.down
+    drop_table :songs
+    drop_table :artists
+    drop_table :albums
+    drop_table :queues
+    drop_table :votes
+  end
+end

data/lib/play.rb

@@ -0,0 +1,73 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+
+require "rubygems"
+require "bundler/setup"
+
+require 'active_record'
+require 'audioinfo'
+require 'sinatra/base'
+require 'mustache/sinatra'
+require 'digest'
+require 'yajl'
+
+require 'play/core_ext/hash'
+
+require 'play/app'
+require 'play/artist'
+require 'play/album'
+require 'play/client'
+require 'play/history'
+require 'play/library'
+require 'play/office'
+require 'play/song'
+require 'play/views/layout'
+require 'play/user'
+require 'play/vote'
+
+module Play
+  
+  VERSION = '0.0.1'
+
+  # The path to your music library. All of the music underneath this directory
+  # will be added to the internal library.
+  #
+  #   path - a String absolute path to your music
+  #
+  # Returns nothing.
+  def self.path=(path)
+    @path = path
+  end
+
+  # The path of the music library on-disk.
+  #
+  # Returns a String absolute path on the local file system.
+  def self.path
+    config['path']
+  end
+
+  # The song that's currently playing.
+  #
+  # Returns the Song object from the database that's currently playing.
+  def self.now_playing
+    Song.where(:now_playing => true).first
+  end
+
+  # The path to play.yml.
+  #
+  # Returns the String path to the configuration file.
+  def self.config_path
+    "#{ENV['HOME']}/.play.yml"
+  end
+
+  # The configuration object for Play.
+  #
+  # Returns the Hash containing the configuration for Play. This includes:
+  #
+  #   path - the String path to where your music is located
+  #   gh_key - the Client ID from your GitHub app's OAuth settings
+  #   gh_secret - the Client Secret from your GitHub app's OAuth settings
+  #   office_url - the URL to an endpoint where we can see who's in your office
+  def self.config
+    YAML::load(File.open(config_path))
+  end
+end

data/lib/play/album.rb

@@ -0,0 +1,6 @@
+module Play
+  class Album < ActiveRecord::Base
+    has_many :songs
+    belongs_to :artist
+  end
+end

data/lib/play/app.rb

@@ -0,0 +1,118 @@
+require 'play/app/api'
+
+module Play
+  class App < Sinatra::Base
+    register Mustache::Sinatra
+
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    set :public,    "#{dir}/../../public"
+    set :static,    true
+    set :mustache, {
+      :namespace => Play,
+      :templates => "#{dir}/templates",
+      :views => "#{dir}/views"
+    }
+
+    def current_user
+      session['user_id'].blank? ? nil : User.find_by_id(session['user_id'])
+    end
+
+    configure :development,:production do
+      # This should use Play.config eventually, but there's some weird loading
+      # problems right now with this file. So it goes. Dupe it for now.
+      config = YAML::load(File.open("#{ENV['HOME']}/.play.yml"))
+      ActiveRecord::Base.establish_connection(config['db'])
+    end
+
+    configure :test do
+      ActiveRecord::Base.establish_connection(:adapter => 'sqlite3',
+                                              :database => ":memory:")
+    end
+
+    before do
+      if current_user
+        @login = current_user.login
+      else
+        if ['production','test'].include?(ENV['RACK_ENV'])
+          redirect '/login' unless request.path_info =~ /\/login/ ||
+                                   request.path_info =~ /\/auth/  ||
+                                   request.path_info =~ /\/api/
+        else
+          # This will create a test user for you locally in development.
+          session['user_id'] = User.create(:login => 'user',
+                                           :email => 'play@example.com').id
+        end
+      end
+    end
+
+    get "/" do
+      @songs = Song.queue.all
+      mustache :index
+    end
+
+    get "/login" do
+      redirect '/auth/github'
+    end
+
+    get '/auth/:name/callback' do
+      auth = request.env['omniauth.auth']
+      @user = User.authenticate(auth['user_info'])
+      session['user_id'] = @user.id
+      redirect '/'
+    end    
+
+    get "/now_playing" do
+      @song = Play.now_playing
+      mustache :now_playing
+    end
+
+    get "/add/:id" do
+      @song = Song.find(params[:id])
+      @song.enqueue!(current_user)
+      redirect '/'
+    end
+
+    get "/remove/:id" do
+      @song = Song.find(params[:id])
+      @song.dequeue!(current_user)
+      redirect '/'
+    end
+
+    get "/artist/*/album/*" do
+      @artist = Artist.where(:name => params[:splat].first).first
+      @album = @artist.albums.where(:name => params[:splat].last).first
+      @songs = @album.songs
+      mustache :album_songs
+    end
+
+    get "/artist/*" do
+      @artist = Artist.where(:name => params[:splat].first).first
+      @songs = @artist.songs
+      mustache :artist_songs
+    end
+
+    get "/song/:id" do
+      @song = Song.find(params[:id])
+      mustache :show_song
+    end
+
+    get "/search" do
+      @search = params[:q]
+      artist = Artist.where("LOWER(name) = ?", @search.downcase).first
+      redirect "/artist/#{URI.escape(artist.name)}" if artist
+      @songs = Song.where("title LIKE ?", "%#{@search}%").limit(100).all
+      mustache :search
+    end
+
+    get "/history" do
+      @songs = History.limit(100).order('created_at desc').collect(&:song)
+      mustache :play_history
+    end
+
+    get "/:login" do
+      @user = User.where(:login => params[:login]).first
+      mustache :profile
+    end
+  end
+end

data/lib/play/app/api.rb

@@ -0,0 +1,110 @@
+module Play
+  class App < Sinatra::Base
+    get "/api/now_playing" do
+      song = Play.now_playing
+      music_response(song)
+    end
+
+    post "/api/user/add_alias" do
+      user = User.find_by_login(params[:login])
+      if user
+        user.alias = params[:alias]
+        { :success => user.save }.to_json
+      else
+        error "Couldn't find that user. Crap."
+      end
+    end
+
+    post "/api/import" do
+      if Play::Library.import_songs
+        { :success => 'true' }.to_json
+      else
+        error "Had some problems importing into Play. Uh-oh."
+      end
+    end
+
+    post "/api/add_song" do
+      api_authenticate
+      artist = Play::Artist.find_by_name(params[:artist_name])
+      if artist
+        song = artist.songs.find_by_title(params[:song_title])
+        if song
+          song.enqueue!(api_user)
+          music_response(song)
+        else
+          error("Sorry, but we couldn't find that song.")
+        end
+      else
+        error("Sorry, but we couldn't find that artist.")
+      end
+    end
+
+    post "/api/add_artist" do
+      api_authenticate
+      artist = Play::Artist.find_by_name(params[:artist_name])
+      if artist
+        {:song_titles => artist.enqueue!(api_user).collect(&:title),
+         :artist_name => artist.name}.to_json
+      else
+        error("Sorry, but we couldn't find that artist.")
+      end
+    end
+
+    post "/api/remove" do
+      error "This hasn't been implemented yet. Whoops."
+    end
+
+    get "/api/search" do
+      songs = case params[:facet]
+      when 'artist'
+        artist = Artist.find_by_name(params[:q])
+        artist ? artist.songs : nil
+      when 'song'
+        Song.where(:title => params[:q])
+      end
+      
+      songs ? {:song_titles => songs.collect(&:title)}.to_json : error("Search. Problem?")
+    end
+
+    post "/api/volume" do
+      if Play::Client.volume(params[:level].to_i)
+        { :success => 'true' }.to_json
+      else
+        error "There's a problem adjusting the volume."
+      end
+    end
+
+    post "/api/pause" do
+      if Play::Client.pause
+        { :success => 'true' }.to_json
+      else
+        error "There's a problem pausing."
+      end
+    end
+
+    def api_user
+      Play::User.find_by_login(params[:user_login]) ||
+      Play::User.find_by_alias(params[:user_login])
+    end
+
+    def api_authenticate
+      if api_user
+        true
+      else
+        halt error("You must supply a valid `user_login` in your requests.")
+      end
+    end
+
+    def error(msg)
+      { :error => msg }.to_json
+    end
+
+    def music_response(song)
+      {
+        'artist_name' => song.artist_name,
+        'song_title'  => song.title,
+        'album_name'  => song.album_name
+      }.to_json
+    end
+  end
+end

data/lib/play/artist.rb

@@ -0,0 +1,21 @@
+module Play
+  class Artist < ActiveRecord::Base
+    has_many :songs
+    has_many :albums
+    has_many :votes
+
+    # Queue up an artist. This will grab ten random tracks for this artist and
+    # queue 'em up.
+    #
+    #   user - the User who is requesting the artist be queued
+    #
+    # Returns nothing.
+    def enqueue!(user)
+      songs.shuffle[0..9].collect do |song|
+        song.enqueue!(user)
+        song
+      end
+    end
+
+  end
+end

data/lib/play/client.rb

@@ -0,0 +1,67 @@
+module Play
+  class Client
+    # The main event loop for an audio client. It will loop through each song
+    # in the queue, unless it's paused.
+    #
+    # Returns nothing.
+    def self.loop
+      while true
+        Signal.trap("INT") { exit! }  
+
+        if paused?
+          sleep(1)
+        else
+          system("afplay", Song.play_next_in_queue.path)
+        end
+      end
+    end
+
+    # The temp file we use to signify whether Play should be paused.
+    #
+    # Returns the String path of the pause file.
+    def self.pause_path
+      '/tmp/play_is_paused'
+    end
+
+    # "Pauses" a client by stopping currently playing songs and setting up the
+    # pause temp file.
+    # 
+    # Returns nothing.
+    def self.pause
+      paused? ? `rm -f #{pause_path}` : `touch #{pause_path}`    
+      `killall afplay > /dev/null 2>&1`
+    end
+
+    # Are we currently paused?
+    #
+    # Returns the Boolean value of whether we're paused.
+    def self.paused?
+      File.exist?(pause_path)
+    end
+
+    # Are we currently playing? Look at the process list and check it out.
+    #
+    # Returns true if we're playing, false if we aren't.
+    def self.playing?
+      `ps aux | grep afplay | grep -v grep | wc -l | tr -d ' '`.chomp != '0'
+    end
+
+    # Stop the music, and stop the music server.
+    #
+    # Returns nothing.
+    def self.stop
+      `killall afplay > /dev/null 2>&1`
+      `kill \`ps ax | grep "play -d" | cut -d ' ' -f 1\``
+    end
+
+    # Set the volume level of the client.
+    #
+    #   number - The Integer volume level. This should be a number between 0
+    #            and 10, with "0" being "muted" and "10" being "real real loud"
+    #
+    # Returns nothing.
+    def self.volume(number)
+      system "osascript -e 'set volume #{number}' 2>/dev/null"
+    end
+  end
+end