terminal_player 0.0.7

data/lib/terminal_player/spotiphy/spotiphy_player.rb

@@ -0,0 +1,204 @@
+require 'spotify'
+require 'plaything'
+
+class SpotiphyPlayer
+  include Observable
+
+  def initialize(options)
+    @options = options
+
+    @plaything = Plaything.new
+    setup_session_callbacks
+
+    # HACK not sure this is copacetic
+    path = File.expand_path File.dirname(__FILE__)
+    path = "#{path}/../../../"
+    appkey = IO.read("#{path}spotify_appkey.key", encoding: "BINARY")
+    config = Spotify::SessionConfig.new({
+      api_version: Spotify::API_VERSION.to_i,
+      application_key: appkey,
+      cache_location: "#{path}.spotify/",
+      settings_location: "#{path}.spotify/",
+      tracefile: "#{path}spotify_tracefile.txt",
+      user_agent: "terminal_player gem",
+      callbacks: Spotify::SessionCallbacks.new($session_callbacks),
+    })
+    @session = create_session(config)
+
+    login(get_env("SPOTIFY_USERNAME"), get_env("SPOTIFY_PASSWORD"))
+  end
+
+  def play
+    u = @options[:url]
+    if u[':track:']
+      play_track_from_uri u
+    elsif u[':playlist:']
+      play_playlist u
+    elsif u[':album:']
+      play_album u
+    else
+      puts "unsupported URI #{u}"
+    end
+  end
+
+  def next
+    $end_of_track = true
+  end
+
+  def get_track(uri)
+    link = Spotify.link_create_from_string(uri)
+    track = Spotify.link_as_track(link)
+    track
+  end
+
+  def play_track_from_uri(uri)
+    track = get_track(uri)
+    play_track track
+  end
+
+  def play_track(track)
+    wait_for_track_to_load track
+    artist = Spotify.track_artist(track, 0)
+    notify "SPOTTY #{Spotify.track_name(track)} - #{Spotify.artist_name(artist)}"
+    begin
+      play_track_raw track
+      wait_for_track_to_end
+    rescue => e
+      puts "play_track: error playing track: #{e}"
+    end
+  end
+
+  def play_playlist(uri)
+    link = Spotify.link_create_from_string(uri)
+    plist = Spotify.playlist_create(@session, link)
+    poll(@session) { Spotify.playlist_is_loaded(plist) }
+    num_tracks = Spotify.playlist_num_tracks(plist)
+# TODO this should reset channel
+#    puts "\nPlaying #{Spotify.playlist_name(plist)}, #{num_tracks} tracks, " +
+#         "#{Spotify.playlist_num_subscribers(plist)} subscribers"
+    0.upto(num_tracks - 1) do |i|
+      track = Spotify.playlist_track(plist, i)
+      play_track track
+    end
+  end
+
+  def play_album(uri)
+    link = Spotify.link_create_from_string(uri)
+    browser = Spotify.albumbrowse_create(@session, Spotify.link_as_album(link), proc { }, nil)
+    poll(@session) { Spotify.albumbrowse_is_loaded(browser) }
+#    album = Spotify.albumbrowse_album(browser)
+    num_tracks = Spotify.albumbrowse_num_tracks(browser)
+# TODO this should reset channel
+#    puts "\nPlaying #{Spotify.album_name(album)} (#{Spotify.album_year(album)}), #{num_tracks} tracks"
+    0.upto(num_tracks - 1) do |i|
+      track = Spotify.albumbrowse_track(browser, i)
+      play_track track
+    end
+  end
+
+  def play_track_raw(track)
+    Spotify.try(:session_player_play, @session, false)
+    Spotify.try(:session_player_load, @session, track)
+    Spotify.try(:session_player_play, @session, true)
+  end
+
+  def wait_for_track_to_end
+    poll(@session) { $end_of_track }
+    $end_of_track = false
+  end
+
+  def wait_for_track_to_load(track)
+    poll(@session) { Spotify.track_is_loaded(track) }
+  end
+
+  private
+
+  def notify(message)
+    changed
+    notify_observers(Time.now, message)
+  end
+
+  def login(u, p)
+    Spotify.session_login(@session, u, p, false, nil)
+    poll(@session) { Spotify.session_connectionstate(@session) == :logged_in }
+  end
+
+  def poll(session)
+    until yield
+      FFI::MemoryPointer.new(:int) do |ptr|
+        Spotify.session_process_events(session, ptr)
+      end
+      sleep(0.1)
+    end
+  end
+
+  def create_session(config)
+    FFI::MemoryPointer.new(Spotify::Session) do |ptr|
+      Spotify.try(:session_create, config, ptr)
+      return Spotify::Session.new(ptr.read_pointer)
+    end
+  end
+
+  def setup_session_callbacks
+    # these must remain global. i think.
+    $session_callbacks = {
+      log_message: proc do |session, message|
+        #$logger.info("session (log message)") { message }
+      end,
+
+      logged_in: proc do |session, error|
+        #$logger.debug("session (logged in)") { Spotify::Error.explain(error) }
+      end,
+
+      logged_out: proc do |session|
+        #$logger.debug("session (logged out)") { "logged out!" }
+      end,
+
+      streaming_error: proc do |session, error|
+        #$logger.error("session (player)") { "streaming error %s" % Spotify::Error.explain(error) }
+      end,
+
+      start_playback: proc do |session|
+        #$logger.debug("session (player)") { "start playback" }
+        @plaything.play
+      end,
+
+      stop_playback: proc do |session|
+        #$logger.debug("session (player)") { "stop playback" }
+        @plaything.stop
+      end,
+
+      get_audio_buffer_stats: proc do |session, stats|
+        stats[:samples] = @plaything.queue_size
+        stats[:stutter] = @plaything.drops
+        #$logger.debug("session (player)") { "queue size [#{stats[:samples]}, #{stats[:stutter]}]" }
+      end,
+
+      music_delivery: proc do |session, format, frames, num_frames|
+        if num_frames == 0
+          #$logger.debug("session (player)") { "music delivery audio discontuity" }
+          @plaything.stop
+          0
+        else
+          frames = FrameReader.new(format[:channels], format[:sample_type], num_frames, frames)
+          consumed_frames = @plaything.stream(frames, format.to_h)
+          #$logger.debug("session (player)") { "music delivery #{consumed_frames} of #{num_frames}" }
+          consumed_frames
+        end
+      end,
+
+      end_of_track: proc do |session|
+        $end_of_track = true
+        #$logger.debug("session (player)") { "end of track" }
+        @plaything.stop
+      end,
+    }
+  end
+
+  def get_env(name)
+    ENV.fetch(name) do
+      raise "set the #{name} environment variable"
+    end
+  end
+end
+

data/spec/lib/terminal_player/di/audioaddict_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'terminal_player/di'
+
+describe AudioAddict do
+  class DummyClass
+  end
+
+  before(:each) do
+    @dummy = DummyClass.new
+    @dummy.extend(AudioAddict)
+  end
+
+  it "returns a good song list" do
+    songs = @dummy.get_recently_played_list(15) # 15 is breaks
+    songs.length.should be > 0
+    s = songs[0]
+    s.should.respond_to? :channel_id
+    s['channel_id'].should be 15
+
+    s.should.respond_to? :duration
+    s.should.respond_to? :length
+    s.should.respond_to? :started
+    s.should.respond_to? :title
+    s.should.respond_to? :track
+    s.should.respond_to? :votes
+  end
+end

data/spec/lib/terminal_player/site_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'terminal_player'
+
+describe Site do
+  it "bombs with no url" do
+    options = {cache: 999, cache_min: 12, url: ''}
+    lambda { Site.new(options, "di") }.should raise_error RuntimeError
+  end
+
+  it "sets up properly for di.fm" do
+    options = {cache: 999, cache_min: 12, url: 'http://www.di.fm/breaks.pls'}
+    s = Site.new(options, 'di')
+    s.name.should == 'di'
+    s.current_channel.should == 'breaks'
+    s.player.class.should be Mplayer
+    s.is_mplayer.should be true
+  end
+
+  it "should return appropriate types for spotify URIs" do
+    # use di because firing up spotify without username/password bombs
+    options = {cache: 999, cache_min: 12, url: 'http://www.di.fm/breaks.pls'}
+    s = Site.new(options, 'di')
+
+    output = s.send(:spotify_type, 'spotify:album:5PFwYpKSHE3Zab4YTrgyv2')
+    output.should == 'album'
+
+    output = s.send(:spotify_type, 'spotify:playlist:5PFwYpKSHE3Zab4YTrgyv2')
+    output.should == 'playlist'
+
+    output = s.send(:spotify_type, 'spotify:track:5PFwYpKSHE3Zab4YTrgyv2')
+    output.should == 'track'
+
+    output = s.send(:spotify_type, 'spotify:unknown:5PFwYpKSHE3Zab4YTrgyv2')
+    output.should == 'spotify:unknown:5PFwYpKSHE3Zab4YTrgyv2'
+  end
+end

data/spec/lib/terminal_player_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'terminal_player'
+
+def capture_stdout(&block)
+  original_stdout = $stdout
+  $stdout = fake = StringIO.new
+  begin
+    yield
+  ensure
+    $stdout = original_stdout
+  end
+  fake.string
+end
+
+describe TerminalPlayer do
+  it "sets up properly for di.fm" do
+    options = { url: 'http://www.di.fm/' }
+    tp = TerminalPlayer.new(options)
+    s = tp.instance_variable_get(:@site)
+    s.class.should be DI
+    s.instance_variable_get(:@name).should == 'di-lo'
+  end
+
+  it "sets up properly for somafm.com" do
+    options = { url: 'http://somafm.com/' }
+    tp = TerminalPlayer.new(options)
+    tp.instance_variable_get(:@site).class.should be Soma
+  end
+
+  it "sets up properly for spotify" do
+    options = { url: 'spotify:blah:blah' }
+    tp = TerminalPlayer.new(options)
+    tp.instance_variable_get(:@site).class.should be Spotiphy
+  end
+
+  it "bombs with a bad site" do
+    options = { url: 'unknown' }
+    lambda { TerminalPlayer.new(options) }.should raise_error
+  end
+
+  it "lists di channels" do
+    options = { url: 'http://www.di.fm/channels.pls' }
+    output = capture_stdout do
+      lambda { TerminalPlayer.new(options) }.should raise_error SystemExit
+    end
+    output.should include 'ambient'
+    output.should include 'breaks'
+    output.should include 'vocaltrance'
+  end
+
+  it "lists soma channels" do
+    options = { url: 'http://somafm.com/channels.pls' }
+    output = capture_stdout do
+      lambda { TerminalPlayer.new(options) }.should raise_error SystemExit
+    end
+    output.should include 'doomed'
+    output.should include 'lush64'
+    output.should include 'u80s130'
+  end
+
+  it "displays songs" do
+    options = {
+      url: 'http://www.di.fm/premium_high/breaks.pls?abc123',
+      play_history_path: ''
+    }
+    tp = TerminalPlayer.new(options)
+    tp.instance_variable_get(:@site).class.should be DI
+    tp.instance_variable_get(:@site).instance_variable_get(:@name).should == 'di-hi'
+    tp.instance_variable_get(:@site).instance_variable_get(:@current_channel).should == 'breaks'
+
+    t = Time.now
+    output = capture_stdout do
+      songs = ['one', 'two', 'three']
+      tp.update(t, songs)
+    end
+    output.should include t.strftime("%H:%M:%S")
+    output.should include '[di-hi/breaks]'
+    output.should include 'three'
+  end
+
+  it "doesn't display duplicate songs" do
+    options = {
+      url: 'http://www.di.fm/premium_high/breaks.pls?abc123',
+      play_history_path: ''
+    }
+    tp = TerminalPlayer.new(options)
+    t = Time.now
+    songs = ['one', 'two', 'three']
+    output = capture_stdout do
+      tp.update(t, songs)
+    end
+    output.scan(/three/).length.should == 1
+
+    # add a dupe
+    songs << 'three'
+    output += capture_stdout do
+      tp.update(t, songs)
+    end
+    output.scan(/three/).length.should == 1
+  end
+
+  it "cleans song titles" do
+    options = { url: 'http://somafm.com/' }
+    tp = TerminalPlayer.new(options)
+    ab = 'ali baba and the forty theieves'
+    output = tp.send(:cleanup, ab)
+    output.should == ab.gsub(/ /, '+')
+  end
+
+  it "removes common crud in song titles" do
+    options = { url: 'http://somafm.com/' }
+    tp = TerminalPlayer.new(options)
+    # Feat.
+    ab = 'ali baba Feat. the forty theieves'
+    output = tp.send(:cleanup, ab)
+    output.should == 'ali+baba+the+forty+theieves'
+
+    # Many, but not all, non-word characters
+    ab = "?ali \tbaba , th\ne .forty thei^eves&*"
+    output = tp.send(:cleanup, ab)
+    output.should == 'ali+baba+the+.forty+theieves'
+  end
+
+  it "removes stuff in parenthesis from song titles" do
+    options = { url: 'http://somafm.com/' }
+    tp = TerminalPlayer.new(options)
+
+    # anything in parenthesis
+    ab = 'ali baba (original mix) - forty thieves'
+    output = tp.send(:cleanup, ab)
+    output.should == 'ali+baba+forty+thieves'
+
+    # ... even partially
+    ab = 'ali baba (ori'
+    output = tp.send(:cleanup, ab)
+    output.should == 'ali+baba'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/terminal_player.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |gem|
+  gem.authors = ['Shane Thomas']
+  gem.email = ['shane@devshane.com']
+  gem.homepage = 'https://github.com/devshane/terminal-player'
+
+  gem.summary = 'A minimalistic terminal-based player for di.fm, somafm.com, and Spotify.'
+  gem.description = 'Terminal player is a minimalistic terminal-based player for di.fm, somafm.com, and Spotify.'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = ['terminal_player']
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+
+  gem.name = 'terminal_player'
+  gem.version = '0.0.7'
+  gem.date = '2013-12-15'
+  gem.licenses = ['MIT']
+
+  gem.require_paths = ['lib']
+
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_runtime_dependency('rake', '~> 10.1.0')
+  gem.add_runtime_dependency('rspec', '~> 2.14.1')
+  gem.add_runtime_dependency('spotify', '~> 12.5.3')
+  gem.add_runtime_dependency('plaything', '~> 1.1.1')
+end