walkman 0.1.1

data/lib/walkman/song.rb

@@ -0,0 +1,11 @@
+require "active_model"
+
+module Walkman
+  class Song
+    include ActiveModel::Model
+
+    attr_accessor :source_type, :source_id
+    attr_accessor :title, :artist, :album
+    attr_accessor :echonest_song_id, :echonest_artist_id
+  end
+end

data/spec/factories/echowrap.rb

@@ -0,0 +1,79 @@
+FactoryGirl.define do
+  factory :echowrap_track, class: Echowrap::Track do
+    skip_create
+
+    ignore do
+      catalog { "rdio-US" }
+      duration { 300 }
+      foreign_id { "rdio-US:track:t12345678" }
+      foreign_release_id { "rdio-US:release:a123456" }
+      id { "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890" }
+    end
+
+    initialize_with do
+      Echowrap::Track.new(
+        catalog: catalog,
+        duration: duration,
+        foreign_id: foreign_id,
+        foreign_release_id: foreign_release_id,
+        id: id
+      )
+    end
+  end
+
+  factory :echowrap_song, class: Echowrap::Song do
+    skip_create
+
+    ignore do
+      artist_name { "Artist" }
+      artist_foreign_ids { [{ catalog: "rdio-US", foreign_id: "rdio-US:artist:r12345" }] }
+      title { "Title" }
+      tracks { [create(:echowrap_track)] }
+    end
+
+    initialize_with do
+      song = Echowrap::Song.new(
+        artist_name: artist_name,
+        artist_foreign_ids: artist_foreign_ids,
+        title: title
+      )
+
+      [tracks].flatten.each { |track| song.tracks << track }
+      song
+    end
+  end
+
+  factory :echowrap_playlist, class: Echowrap::Playlist do
+    skip_create
+
+    ignore do
+      code 0
+      message { "Success" }
+      version "4.2"
+      session_id { "ABCDEFG123456789" }
+      lookahead { [] }
+      songs { [create(:echowrap_song)] }
+    end
+
+    trait :dynamic_create do
+      initialize_with do
+        Echowrap::Playlist.new(
+          status: { version: version, code: code, message: message },
+          session_id: session_id
+        )
+      end
+    end
+
+    trait :dynamic_next do
+      initialize_with do
+        playlist = Echowrap::Playlist.new(
+          status: { version: version, code: code, message: message },
+          lookahead: lookahead,
+        )
+
+        [songs].flatten.each { |song| playlist.songs << song }
+        playlist
+      end
+    end
+  end
+end

data/spec/factories/playlist.rb

@@ -0,0 +1,32 @@
+FactoryGirl.define do
+  factory :playlist, class: Walkman::Playlist do
+    skip_create
+
+    ignore do
+      artist { "Artist" }
+      auto_queue { false }
+      session_id { "ABCDEFG123456789" }
+      songs { [] }
+      type { "artist" }
+    end
+
+    initialize_with do
+      Walkman::Playlist.new(
+        session_id: session_id,
+        songs: songs
+      )
+    end
+
+    trait :dynamic_artist do
+      initialize_with do
+        Walkman::Playlist.new(
+          artist: artist,
+          auto_queue: auto_queue,
+          session_id: session_id,
+          songs: songs,
+          type: type
+        )
+      end
+    end
+  end
+end

data/spec/factories/song.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :song, class: Walkman::Song do
+    skip_create
+
+    sequence(:album)              { |x| "Album#{x}" }
+    sequence(:artist)             { |x| "Artist#{x}" }
+    sequence(:echonest_artist_id) { |x| "ARTISTID#{x}" }
+    sequence(:echonest_song_id)   { |x| "SONGID#{x}" }
+    sequence(:source_id)          { |x| "t#{x}" }
+    source_type { Walkman::Player::SERVICES.shuffle.first.to_s }
+    sequence(:title)              { |x| "Title#{x}" }
+  end
+end

data/spec/sinatra_helper.rb

@@ -0,0 +1,12 @@
+require "rack/test"
+
+module SinatraSpecHelpers
+  def app
+    described_class
+  end
+end
+
+RSpec.configure do |config|
+  config.include Rack::Test::Methods
+  config.include SinatraSpecHelpers
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+if ENV["TRAVIS"]
+  require "coveralls"
+  Coveralls.wear!
+end
+
+require "walkman"
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].each { |f| require f }
+
+Walkman.logger.level = Walkman.log_level(:info)

data/spec/support/factory_girl.rb

@@ -0,0 +1,7 @@
+require "factory_girl"
+
+RSpec.configure do |config|
+  config.include(FactoryGirl::Syntax::Methods)
+end
+
+FactoryGirl.find_definitions

data/spec/walkman/commands/controls_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe Walkman::Commands::Controls do
+  let!(:player) { Walkman.player }
+
+  describe ".play" do
+    it "calls play on the player" do
+      expect(player).to receive(:play)
+      Walkman::Commands::Controls.play
+    end
+  end
+
+  describe ".stop" do
+    it "calls stop on the player" do
+      expect(player).to receive(:stop)
+      Walkman::Commands::Controls.stop
+    end
+  end
+
+  describe ".next" do
+    it "calls next on the player" do
+      expect(player).to receive(:next)
+      Walkman::Commands::Controls.next
+    end
+  end
+end

data/spec/walkman/commands/information_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Walkman::Commands::Information do
+  let(:player) { Walkman.player }
+  let(:song) { Walkman::Song.new(title: "Bar", artist: "Foo", album: "Baz") }
+
+  describe ".now_playing" do
+    it "returns track info about the current song if playing" do
+      player.current_song = song
+
+      expect(Walkman::Commands::Information.now_playing).to include("Now playing")
+    end
+
+    it "returns a notice if no song is playing" do
+      player.current_song = nil
+
+      expect(Walkman::Commands::Information.now_playing).to eq("No music is playing")
+    end
+  end
+
+  describe ".up_next" do
+    before :each do
+      player.playlist = Walkman::Playlist.new
+      5.times { player.playlist.add(song) }
+    end
+
+    it "shows the next 5 songs in the playlist" do
+      expect(Walkman::Commands::Information.up_next).to eq(
+        "Foo - Bar\n" +
+        "Foo - Bar\n" +
+        "Foo - Bar\n" +
+        "Foo - Bar\n" +
+        "Foo - Bar\n"
+      )
+    end
+
+    it "shows the specified number of songs in the playlist" do
+      expect(Walkman::Commands::Information.up_next(3)).to eq(
+        "Foo - Bar\n" +
+        "Foo - Bar\n" +
+        "Foo - Bar\n"
+      )
+    end
+  end
+end

data/spec/walkman/commands/player_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe Walkman::Commands::Player do
+  let!(:player) { Walkman.player }
+
+  describe ".start" do
+    it "calls startup on the player" do
+      expect(player).to receive(:startup)
+      Walkman::Commands::Player.start
+    end
+  end
+
+  describe ".stop" do
+    it "calls shutdown on the player" do
+      expect(player).to receive(:shutdown)
+      Walkman::Commands::Player.stop
+    end
+  end
+end

data/spec/walkman/commands/queueing_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe Walkman::Commands::Queueing do
+  let!(:player) { Walkman.player }
+  let!(:song) { create(:echowrap_song, artist_name: "Artist") }
+  let!(:playlist_dynamic_create) { create(:echowrap_playlist, :dynamic_create) }
+  let!(:playlist_dynamic_next) { create(:echowrap_playlist, :dynamic_next, songs: [song]) }
+
+  before :each do
+    player.playlist = nil
+    player.current_song = nil
+
+    Walkman.echowrap.stub(:playlist_dynamic_create) { playlist_dynamic_create }
+    Walkman.echowrap.stub(:playlist_dynamic_next) { playlist_dynamic_next }
+  end
+
+  describe ".artist" do
+    it "queries echo nest for the songs by the given artist" do
+      expect(Walkman.echowrap).to receive(:playlist_dynamic_create)
+      expect(Walkman.echowrap).to receive(:playlist_dynamic_next)
+
+      expect {
+        Walkman::Commands::Queueing.artist("Artist") # from stub
+      }.to change {
+        player.playlist.size
+      }.from(0).to(1)
+
+      expect(player.playlist.instance_variable_get("@session_id")).to eq(playlist_dynamic_create.session_id)
+    end
+
+    describe "songs found on echo nest" do
+      it "adds songs to the current playlist" do
+        expect {
+          Walkman::Commands::Queueing.artist("Artist") # from stub
+        }.to change {
+          player.playlist.size
+        }.from(0).to(1)
+
+        expect(player.current_song.artist).to eq(song.artist_name)
+        expect(player.current_song.title).to eq(song.title)
+      end
+    end
+
+    describe "no songs found on echo nest" do
+      it "displays information about the failed search" do
+        playlist_dynamic_next = create(:echowrap_playlist, :dynamic_next, songs: [])
+        Walkman.echowrap.stub(:playlist_dynamic_next) { playlist_dynamic_next }
+
+        expect(player.playlist.size).to eq(0)
+        expect(Walkman::Commands::Queueing.artist("Foo")).to eq("That artist couldn't be queued")
+        expect(player.playlist.size).to be(0)
+      end
+    end
+  end
+
+  describe ".play_song"
+  describe ".play_album_by_artist"
+  describe ".play_song_by_artist"
+
+  describe ".play_like_artist"
+  describe ".play_like_song_by_artist"
+end

data/spec/walkman/player_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+
+describe Walkman::Player do
+  let!(:player) { Walkman.player }
+
+  after :each do
+    player.shutdown
+    player.playlist = nil
+  end
+
+  it "responds to #playlist" do
+    expect(player).to respond_to(:playlist)
+  end
+
+  describe "#services" do
+    it "returns a hash of all services this player knows about" do
+      expect(player.services.keys).to include("Walkman::Services::Rdio")
+    end
+  end
+
+  describe "#startup" do
+    it "starts up all music services" do
+      Walkman::Player::SERVICES.each do |service|
+        service.any_instance.stub(:startup)
+        expect_any_instance_of(service).to receive(:startup)
+      end
+
+      player.startup
+    end
+  end
+
+  describe "#shutdown" do
+    it "shuts down all music services" do
+      Walkman::Player::SERVICES.each do |service|
+        service.any_instance.stub(:shutdown)
+        expect_any_instance_of(service).to receive(:shutdown)
+      end
+
+      player.shutdown
+    end
+  end
+
+  describe "#play" do
+    it "plays a song from a specific music service" do
+      player.startup
+
+      Walkman::Player::SERVICES.each do |service|
+        service.any_instance.stub(:play)
+        player.current_song = create(:song, source_type: service.name)
+        expect_any_instance_of(service).to receive(:play)
+      end
+
+      player.play
+
+      sleep 0.2 # have to give the play loop a chance to pick up the song
+    end
+  end
+
+  describe "#stop" do
+    it "stops all music services" do
+      Walkman::Player::SERVICES.each do |service|
+        service.any_instance.stub(:stop)
+        expect_any_instance_of(service).to receive(:stop)
+      end
+
+      player.stop
+    end
+  end
+
+  describe "#next" do
+    let!(:song) { create(:song) }
+    let!(:playlist) { create(:playlist) }
+
+    before do
+      player.startup
+      player.playlist = playlist
+    end
+
+    it "plays the next song in the playlist" do
+      player.playlist.clear
+      player.playlist.add(song)
+      player.current_song = nil
+
+      expect {
+        player.next
+      }.to change {
+        player.current_song
+      }.from(nil).to(song)
+    end
+
+    it "stops playing if there are no more songs in the playlist queue" do
+      player.playlist.clear
+      player.playing = true
+      player.current_song = song
+
+      player.next
+
+      expect(player.current_song).to be_nil
+      expect(player.playing).to be_false
+    end
+  end
+end

data/spec/walkman/playlist_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+
+describe Walkman::Playlist do
+  let(:playlist) { create(:playlist) }
+  let(:song) { create(:song) }
+
+  it "responds to #session_id" do
+    expect(playlist).to respond_to(:session_id)
+  end
+
+  describe ".new" do
+    it "initializes an empty queue" do
+      expect(playlist.queue).to eq([])
+    end
+
+    it "initializes with a single song" do
+      song_playlist = Walkman::Playlist.new(songs: song)
+
+      expect(song_playlist.queue).to eq([song])
+    end
+
+    it "initializes with a multiple songs" do
+      song2 = create(:song)
+      songs_playlist = Walkman::Playlist.new(songs: [song, song2])
+
+      expect(songs_playlist.queue).to eq([song, song2])
+    end
+  end
+
+  describe "#queue" do
+    it "returns the current queue" do
+      playlist.add(song)
+
+      expect(playlist.queue).to eq([song])
+    end
+  end
+
+  describe "#include?" do
+    it "returns true if the given song is currently queued" do
+      playlist.add(song)
+
+      expect(playlist.include?(song)).to be_true
+      expect(playlist.queued?(song)).to be_true
+    end
+
+    it "returns false if the given song is not currently queued" do
+      expect(playlist.include?(song)).to be_false
+      expect(playlist.queued?(song)).to be_false
+    end
+  end
+
+  describe "#clear" do
+    it "empties the current queue" do
+      playlist.add(song)
+
+      expect {
+        playlist.clear
+      }.to change {
+        playlist.queue.count
+      }.from(1).to(0)
+    end
+  end
+
+  describe "#add" do
+    it "adds multiple songs to the end of the queue" do
+      songs = []
+
+      3.times do
+        songs << create(:song)
+      end
+
+      expect {
+        playlist.add(songs)
+      }.to change {
+        playlist.queue.size
+      }.from(0).to(3)
+    end
+
+    it "adds a song to the end of the queue" do
+      3.times { playlist.add(create(:song)) }
+
+      expect {
+        playlist.add(song)
+      }.to change {
+        playlist.queue.size
+      }.from(3).to(4)
+
+      expect(playlist.queue.index(song)).to eq(3)
+    end
+
+    it "inserts a song into the given index" do
+      3.times { playlist.add(create(:song)) }
+
+      playlist.add(song, 0)
+
+      expect(playlist.queue.index(song)).to eq(0)
+    end
+
+    it "ignores invalid indexes when adding a song" do
+      3.times { playlist.add(create(:song)) }
+
+      playlist.add(song, 999)
+
+      expect(playlist.queue.index(song)).to eq(3)
+    end
+  end
+
+  describe "#remove" do
+    it "removes the given song from the queue" do
+      playlist.add(song)
+
+      expect {
+        playlist.remove(song)
+      }.to change {
+        playlist.queue.size
+      }.from(1).to(0)
+    end
+  end
+
+  describe "#shuffle" do
+    it "changes the order of songs in the queue" do
+      100.times { playlist.add(create(:song)) }
+
+      expect {
+        playlist.shuffle
+      }.to change {
+        playlist.queue.first
+      }
+    end
+  end
+
+  describe "#next" do
+    it "returns the next song from the playlist" do
+      song2 = create(:song)
+
+      playlist.add([song, song2])
+
+      expect(playlist.next).to eq(song)
+      expect(playlist.next).to eq(song2)
+    end
+  end
+
+  describe "#size" do
+    it "returns the size of the playlist queue" do
+      3.times { playlist.add(create(:song)) }
+
+      expect(playlist.size).to eq(3)
+    end
+  end
+end