somadic 0.0.1

data/lib/somadic.rb

@@ -0,0 +1,12 @@
+require 'mono_logger'
+require 'observer'
+require 'open-uri'
+require 'json'
+require 'api_cache'
+
+module Somadic
+  # Your code goes here...
+end
+
+Dir[File.join(__dir__, 'somadic', '*.rb')].each { |f| require f }
+Dir[File.join(__dir__, 'somadic', 'channel', '*.rb')].each { |f| require f }

data/lib/somadic/audio_addict.rb

@@ -0,0 +1,26 @@
+module Somadic
+  class AudioAddict
+    def initialize(channel_id)
+      @url = "http://api.audioaddict.com/v1/di/track_history/channel/" \
+             "#{channel_id}.jsonp?callback=_AudioAddict_TrackHistory_Channel"
+    end
+
+    def refresh_playlist
+      f = open(@url)
+      page = f.read
+      data = JSON.parse(page[page.index("(") + 1..-3])
+
+      symbolized_data = []
+      data.each { |d| symbolized_data << symbolize_keys(d) }
+      @songs = symbolized_data.keep_if { |d| d[:title] }
+    end
+
+    private
+
+    def symbolize_keys(hash)
+      sym_hash = {}
+      hash.each { |k, v| sym_hash[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v }
+      sym_hash
+    end
+  end
+end

data/lib/somadic/base_channel.rb

@@ -0,0 +1,53 @@
+module Somadic
+  class BaseChannel
+    attr_reader :channels, :song
+
+    API_TIMEOUT = 60
+    ONE_DAY = 86400
+
+    def initialize(options)
+      @url = options[:url]
+      playlist = @url.split('/').last
+      name = playlist[0..playlist.index('.pls') - 1]
+      @channel = find_channel(name)
+
+      @mp = Mplayer.new(options)
+      @mp.add_observer(self)
+      @listeners = options[:listeners]
+    end
+
+    # Let's go already.
+    def start
+      Somadic::Logger.debug('BaseChannel#start')
+      @mp.start
+    rescue => e
+      Somadic::Logger.error("BaseChannel#start error: #{e}")
+    end
+
+    # Enough already.
+    def stop
+      Somadic::Logger.debug('BaseChannel#stop')
+      @mp.stop
+    end
+
+    def stopped?
+      @mp.stopped?
+    end
+
+    # Observer callback, and also one of the simplest displays possible.
+    def update(time, song)
+      Somadic::Logger.debug("BaseChannel#update: #{time} - #{song}")
+      songs = [{ 'started' => Time.now.to_i - 1,
+                 'duration' => 1,
+                 'track' => song,
+                 'votes' => { 'up' => 0, 'down' => 0 } }]
+      @listeners.each do |l|
+        l.update(@channel, songs) if l.respond_to?(:update)
+      end
+    end
+
+    def find_channel(name)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/somadic/channel/di.rb

@@ -0,0 +1,83 @@
+module Somadic
+  module Channel
+    class DI < Somadic::BaseChannel
+      def initialize(options)
+        url = if options[:premium_id]
+          "http://listen.di.fm/premium_high/#{options[:channel]}.pls?#{options[:premium_id]}"
+        else
+          "http://listen.di.fm/public3/#{options[:channel]}.pls"
+        end
+        @channels = load_channels
+        super(options.merge({ url: url }))
+      end
+
+      # Overrides BaseChannel
+      def find_channel(name)
+        Somadic::Logger.debug("DI#find_channel(#{name})")
+        @channels.each do |c|
+          return c if c[:name] == name
+        end
+        nil
+      end
+
+      # Observer callback.
+      #
+      # TODO: time isn't used, song isn't required
+      def update(time, song)
+        @song = song if song
+        aa = Somadic::AudioAddict.new(@channel[:id])
+        songs = aa.refresh_playlist
+        if songs.first[:track] != @song
+          # try again
+          songs = poll_for_song
+        end
+        @listeners.each do |l|
+          Somadic::Logger.debug("DI#update: updating listener #{l}")
+          l.update(@channel, songs) if l.respond_to?(:update)
+        end
+      rescue => e
+        Somadic::Logger.error("DI#update: error #{e}")
+      end
+
+      # Overrides BaseChannel.
+      def stop
+        Somadic::Logger.debug('DI#stop')
+        @mp.stop
+      end
+
+      private
+
+      def poll_for_song
+        aa = Somadic::AudioAddict.new(@channel[:id])
+        songs = aa.refresh_playlist
+        one_minute_from_now = Time.now + 1
+        while songs.first[:track] != @song
+          Somadic::Logger.debug("DI#poll_for_song: #{songs.first[:track]} != #{@song}")
+          break if Time.now > one_minute_from_now
+          sleep one_minute_from_now - Time.now < 15 ? 2 : 5
+          songs = aa.refresh_playlist
+        end
+        songs
+      end
+
+      # Loads the channel list.
+      def load_channels
+        APICache.logger = Somadic::Logger
+        APICache.get('di_fm_channel_list', cache: ONE_DAY, timeout: API_TIMEOUT) do
+          Somadic::Logger.debug('DI#load_channels')
+          channels = []
+          f = open('http://www.di.fm')
+          page = f.read
+          chan_ids = page.scan(/data-channel-id="(\d+)"/).flatten
+          chans = page.scan(/data-tunein-url="http:\/\/www.di.fm\/(.*?)"/).flatten
+          zipped = chan_ids.zip(chans)
+          zipped.each do |z|
+            channels << {id: z[0], name: z[1]}
+          end
+          channels.sort_by! {|k, _| k[:name]}
+          channels.uniq! {|k, _| k[:name]}
+        end
+      end
+    end
+  end
+end

data/lib/somadic/channel/soma.rb

@@ -0,0 +1,91 @@
+module Somadic
+  module Channel
+    class Soma < Somadic::BaseChannel
+      def initialize(options)
+        @options = options
+        @channels = load_channels
+        super(options.merge({ url: "http://somafm.com/#{options[:channel]}.pls" }))
+      end
+
+      # Overrides BaseChannel
+      def find_channel(name)
+        Somadic::Logger.debug("Soma#find_channel(#{name})")
+        { id: 0, name: name }
+      end
+
+      # Observer callback.
+      def update(time, song)
+        @song = song if song
+        songs = refresh_playlist
+        channel = { id: 0, name: @options[:channel] }
+        @listeners.each do |l|
+          l.update(channel, songs) if l.respond_to?(:update)
+        end
+      end
+
+      private
+
+      def load_channels
+        APICache.logger = Somadic::Logger
+        APICache.get('soma_fm_chanel_list', cache: ONE_DAY, timeout: API_TIMEOUT) do
+          Somadic::Logger.debug('Soma#load_channels')
+          channels = []
+          f = open('http://somafm.com/listen')
+          page = f.read
+          chans = page.scan(/\/play\/(.*?)"/).flatten
+          chans.each do |c|
+            unless c.start_with?('fw/') || c.gsub(/\d+$/, '') != c
+              channels << {id: 0, name: c}
+            end
+          end
+          channels.sort_by! {|k, _| k[:name]}
+          channels.uniq! {|k, _| k[:name]}
+        end
+      end
+
+      def refresh_playlist
+        # soma
+        c = @options[:channel].gsub(/(130|64|48|32)$/, '')
+        url = "http://somafm.com/#{c}/songhistory.html"
+
+        f = open(url)
+        page = f.read
+        page.gsub!("\n", "")
+
+        playlist = page.scan(/<!-- line \d+ -->.*?<tr>.*?<td>(.*?)<\/td>.*?<td>(<a.*?)<\/td>.*?<td>(.*?)<\/td>.*?<td>(.*?)<\/td>/)
+        songs = []
+        @next_load = Time.at(1)
+        playlist.each do |song|
+          if @next_load == Time.at(1)
+            @next_load = Time.now + 30
+          end
+          next if song[3].scan(/<a.*?>(.*?)<\/a>/).empty?
+
+          d = {}
+          song[0] = song[0][0..song[0].index('&')-1]if song[0]['&'] # clean hh:mm:ss&nbsp; (Now)
+
+          pt = Time.parse(song[0])
+          local = Chronic.parse(pt.to_s.gsub(/-\d+$/, '-0700'))
+          d[:started] = local.to_i
+
+          d[:votes] = {up: 0, down: 0}
+          d[:duration] = 0
+          d[:artist] = strip_a(song[1])
+          d[:title] = song[2]
+          d[:track] = "#{d[:artist]} - #{d[:title]}"
+          album = strip_a(song[3])
+          d[:title] += "- #{strip_a(song[3])}" unless album.empty?
+          songs << d
+        end
+        songs
+      end
+
+      # Removes anchor tags from `s`.
+      def strip_a(s)
+        results = s.scan(/<a.*?>(.*?)<\/a>/)
+        return [] if results.empty?
+        results[0][0]
+      end
+    end
+  end
+end

data/lib/somadic/logger.rb

@@ -0,0 +1,33 @@
+require 'fileutils'
+
+module Somadic
+  class Logger
+    LOG_PATH = "#{ENV['HOME']}/.somadic/"
+    LOG_FILE = 'somadic.log'
+
+    def self.debug(msg)
+      instance.debug(msg)
+    end
+
+    def self.info(msg)
+      instance.info(msg)
+    end
+
+    def self.error(msg)
+      instance.error(msg)
+    end
+
+    def self.warn(msg)
+      instance.warn(msg)
+    end
+
+    def self.instance
+      ::FileUtils.mkdir_p(LOG_PATH) unless File.directory?(LOG_PATH)
+      l = MonoLogger.new(File.join(LOG_PATH, LOG_FILE), 'daily')
+      l.formatter = proc do |severity, datetime, _, msg|
+        "[#{severity}] #{datetime}: #{msg}\n"
+      end
+      l
+    end
+  end
+end

data/lib/somadic/mplayer.rb

@@ -0,0 +1,84 @@
+module Somadic
+  class Mplayer
+    include Observable
+
+    MPLAYER = 'mplayer'
+
+    attr_accessor :url, :cache, :cache_min
+
+    # Sets up a new instance of Mplayer.
+    #
+    # Valid options are:
+    #
+    #   :cache     - how much memory in kBytes to use when precaching
+    #                a file or URL
+    #   :cache_min - playback will start when the cache has been filled up
+    #                to `cache_min` of the total.
+    #
+    # See the mplayer man page for more.
+    def initialize(options)
+      @url = options[:url]
+      @cache = options[:cache]
+      @cache_min =options[:cache_min]
+      @stopped = true
+    end
+
+    # Starts mplayer on a new thread.
+    def start
+      @stopped = false
+      @player_thread = Thread.new do
+        cmd = command
+        Somadic::Logger.debug("Mplayer#start: popen #{cmd}")
+        pipe = IO.popen(cmd, 'r+')
+        loop do
+          line = pipe.readline.chomp
+          if line['Starting playback']
+            Somadic::Logger.debug("Mplayer#pipe: #{line}")
+          elsif line.start_with?('ICY ')
+            begin
+              Somadic::Logger.debug("Mplayer#pipe: #{line}")
+              _, v = line.split(';')[0].split('=')
+              song = v[1..-2]
+            rescue Exception => e
+              Somadic::Logger.debug("unicode fuckup: #{e}")
+            end
+            notify(song)
+          end
+        end
+        pipe.close
+      end
+    rescue => e
+      Somadic::Logger.error("Mplayer#start: error #{e}")
+    end
+
+    # Stops mplayer.
+    def stop
+      Somadic::Logger.debug("Mplayer#stop")
+      @stopped = true
+      `killall mplayer`
+    end
+
+    def stopped?
+      @stopped
+    end
+
+    private
+
+    # Builds the command line for launching mplayer.
+    def command
+      cmd = MPLAYER
+      cmd = "#{cmd} -cache #{@cache}" if @cache
+      cmd = "#{cmd} -cache-min #{@cache_min}" if @cache_min
+      cmd = "#{cmd} -playlist #{@url}"
+      cmd = "#{cmd} 2>&1"
+      cmd
+    end
+
+    # Tell everybody who cares that something happened.
+    def notify(message)
+      Somadic::Logger.debug("Mplayer#notify(#{message})")
+      changed
+      notify_observers(Time.now, message)
+    end
+  end
+end

data/lib/somadic/version.rb

@@ -0,0 +1,3 @@
+module Somadic
+  VERSION = "0.0.1"
+end

data/presets/chill.yaml

@@ -0,0 +1,6 @@
+---
+- soma:secretagent
+- soma:beatblender
+- soma:groovesalad
+- di:chillout
+- di:psychill

data/presets/lounge.yaml

@@ -0,0 +1,4 @@
+---
+- di:lounge
+- di:downtempolounge
+- soma:illstreet

data/somadic.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'somadic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'somadic'
+  spec.version       = Somadic::VERSION
+  spec.authors       = ['Shane Thomas']
+  spec.email         = ['shane@devshane.com']
+  spec.summary       = %q{Somadic is a terminal-based player for somafm.com and DI.fm}
+  spec.description   = %q{Somadic is a terminal-based player for somafm.com and DI.fm.}
+  spec.homepage      = 'https://github.com/devshane/somadic'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_runtime_dependency 'mono_logger', '~> 1.1'
+  spec.add_runtime_dependency 'curses', '~> 1.0'
+  spec.add_runtime_dependency 'progress_bar', '~> 1.0'
+  spec.add_runtime_dependency 'api_cache', '~> 0.3'
+  spec.add_runtime_dependency 'chronic', '~> 0.10'
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'guard-rspec', '~> 4.3'
+  spec.add_development_dependency 'pry', '~> 0.10'
+end

data/spec/lib/somadic/audio_addict_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Somadic::AudioAddict do
+  it 'can refresh a playlist' do
+    aa = Somadic::AudioAddict.new(4)
+    songs = aa.refresh_playlist
+    expect(songs.count).to be > 0
+    s = songs.first
+    expect(s[:title].length).to be > 0
+    expect(s[:votes].length).to eql 4
+  end
+end