radiodan 0.0.1 → 0.0.2

data/.gitignore

@@ -11,13 +11,10 @@ spec/reports
 test/tmp
 test/version_tmp
 
-# YARD artifacts
-.yardoc
-_yardoc
-doc/
 .vagrant
 
 music/*.mp3
 playlists/*.m3u
 config.yml
 db/development.sqlite3
+tmp

data/Gemfile.lock

@@ -1,12 +1,13 @@
 PATH
   remote: .
   specs:
-    radiodan (0.0.1)
+    radiodan (0.0.2)
       active_support (~> 3.0.0)
       em-http-request (~> 1.0.3)
       em-simple_telnet (~> 0.0.6)
       em-synchrony (~> 1.0.3)
       eventmachine (~> 1.0.3)
+      i18n (~> 0.6.4)
 
 GEM
   remote: https://rubygems.org/
@@ -15,7 +16,9 @@ GEM
       activesupport (= 3.0.0)
     activesupport (3.0.0)
     addressable (2.3.4)
+    coderay (1.0.9)
     cookiejar (0.3.0)
+    diff-lcs (1.2.4)
     em-http-request (1.0.3)
       addressable (>= 2.2.3)
       cookiejar
@@ -29,10 +32,53 @@ GEM
     em-synchrony (1.0.3)
       eventmachine (>= 1.0.0.beta.1)
     eventmachine (1.0.3)
+    ffi (1.8.1)
+    formatador (0.2.4)
+    guard (1.8.0)
+      formatador (>= 0.2.4)
+      listen (>= 1.0.0)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-rspec (2.6.0)
+      guard (>= 1.8)
+      rspec (~> 2.13)
     http_parser.rb (0.5.3)
+    i18n (0.6.4)
+    listen (1.0.3)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    lumberjack (1.0.3)
+    method_source (0.8.1)
+    pry (0.9.12.1)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.1.0)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.0)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.0)
+      ffi (>= 0.5.0)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    slop (3.4.4)
+    terminal-notifier-guard (1.5.3)
+    thor (0.18.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  guard-rspec (~> 2.6.0)
   radiodan!
+  rake (~> 10.1.0)
+  rspec (~> 2.13.0)
+  terminal-notifier-guard (~> 1.5.0)

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/Rakefile

@@ -1 +1,7 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+

data/TODO

@@ -1,3 +1,15 @@
-* Add some goddamn tests, dammnit.
-* Generate gem
-* Move BBC Downloader into own radio player thing, using radio_dan as gem
+* Player
+  - explicitly set playlist when a new event is triggered, don't attempt to sync
+  - #sync reads state_sync methods
+    * #errors to determine which events to trigger
+* MPD Adapter
+  - Figure out a way of testing interface with playlist object
+* StateSync
+  - Attributes to sync:
+    + Position in playlist
+    + Seek position for current item in playlist
+  - Differentiate when a playlist 
+    + is new (make this match exactly) 
+    + is not (keep in bounds of acceptability)
+* Panic Mode
+  - Add tests

data/doc/state.markdown

@@ -0,0 +1,44 @@
+State Management
+----------------
+
+Two kinds of state:
+
+
+1.  Requested state AKA a playlist
+  *"This is what I want the player to be doing"*
+  
+  Includes:
+   * a Radiodan::Content object, defining a playlist of content
+   * a playback
+    * playing
+    * stopped
+    * paused?
+    * resume (play from position)
+
+  Examples:
+    * Play radio 1
+    * Play from this artist at random
+    * Resume play on this playlist from a defined position
+    * Don't play anything!
+
+2. Player feedback state
+  *"This is what the player is currently doing"*
+  
+  Examples:
+    * Playing track x.mp3 at 1m15s
+    * Playing <URL> for 5 minutes
+
+When the player syncs, we want to make sure the player state is within the parameters set by the request.
+
+  e.g. We don't expect the playlist to always be playing at a defined position, just that it resumed from there and that it is still playing the same set of podcasts.
+
+You set expected state when you want the player to change direction.
+Expected state defines how to respond to player state.
+
+You want feedback info in order to populate feedback displays. When you ask the player what it's state is, you want this information.
+
+    radio = Radiodan.new
+    
+    radio.playlist = Radiodan::Playlist.new(:playback => :playing, :content => :bbcradio1)
+    radio.state   #=> <playing (radio1_url)>
+    radio.sync?   #=> true

data/lib/radiodan.rb

@@ -1,12 +1,12 @@
 require 'eventmachine'
 require 'em-synchrony'
 
-$: << './lib'
+$: << File.dirname(__FILE__)+'/radiodan/'
 
 require 'em_additions'
-require 'radiodan/logging'
-require 'radiodan/builder'
-require 'radiodan/version'
+require 'logging'
+require 'builder'
+require 'version'
 
 class Radiodan
   include Logging
@@ -22,7 +22,7 @@ class Radiodan
     EM.synchrony do
       trap_signals!
       
-      EM.next_tick do      
+      EM::Synchrony.next_tick do      
         @builder.call_middleware!
       end
 

data/lib/radiodan/adapter/mpd.rb

@@ -0,0 +1,85 @@
+require 'forwardable'
+
+require_relative './mpd/connection'
+require_relative './mpd/playlist_parser'
+
+class Radiodan
+class MPD
+  include Logging
+  extend  Forwardable
+  
+  def_delegators :@connection, :cmd
+
+  COMMANDS = %w{stop pause clear play next previous}  
+  attr_reader :player
+
+  def initialize(options={})
+    @connection = Connection.new(options)
+  end
+    
+  def player=(player)
+    @player = player
+    
+    # register typical player commands
+    COMMANDS.each do |command|
+      @player.register_event command do |data|
+        if data
+          self.send(command, data)
+        else
+          self.send(command)
+        end
+      end
+    end
+    
+    # register new playlist events
+    @player.register_event :playlist do |playlist|
+      self.playlist = playlist
+    end
+  end
+
+  def playlist=(playlist)
+    # get rid of current playlist, stop playback
+    clear
+
+    if enqueue playlist
+      play playlist.position
+    else
+      raise "Cannot load playlist #{playlist}" 
+    end
+  end
+
+  def enqueue(playlist)
+    playlist.tracks.each do |track|
+      cmd(%Q{add "#{track[:file]}"})
+    end
+  end
+
+  def play(song_number=nil)
+    cmd("play #{song_number}")
+  end
+  
+  def playlist
+    status = cmd("status")
+    tracks = cmd("playlistinfo")
+    
+    PlaylistParser.parse(status, tracks)
+  end
+
+  def respond_to?(method)
+    if COMMANDS.include?(method.to_s)
+      true
+    else
+      super
+    end
+  end
+  
+  private
+  def method_missing(method, *args, &block)
+    if COMMANDS.include?(method.to_s)
+      cmd(method.to_s, *args, &block)
+    else
+      super
+    end
+  end
+end
+end

data/lib/radiodan/adapter/mpd/ack.rb

@@ -0,0 +1,11 @@
+class Radiodan::MPD
+  class Ack
+    FORMAT = /ACK \[(\d)+@(\d)+\] \{(.*)\} (.*)/
+    attr_accessor :error_id, :position, :command, :description
+    
+    def intialize
+      matches = FORMAT.match(ack)
+      error_id, position, command, description = *matches[1..-1].join
+    end
+  end
+end

data/lib/radiodan/adapter/mpd/connection.rb

@@ -0,0 +1,42 @@
+require 'em-simple_telnet'
+require 'logging'
+
+require_relative 'response'
+
+class Radiodan
+class MPD
+class Connection
+  include Logging
+  
+  def initialize(options={})
+    @port = options[:port] || 6600
+    @host = options[:host] || 'localhost'
+  end
+  
+  def cmd(command, options={})
+    options = {match: /^(OK|ACK)/}.merge(options)
+    response = false
+    
+    connect do |c|
+      begin
+        logger.debug command
+        response = c.cmd(command, options).strip
+      rescue Exception => e
+        logger.error "#{command}, #{options} - #{e.to_s}"
+        raise
+      end
+    end
+    
+    Response.new(response, command)
+  end
+
+  private
+  def connect(&blk)
+    EM::P::SimpleTelnet.new(host: @host, port: @port, prompt: /^(OK|ACK)(.*)$/) do |host|
+      host.waitfor(/^OK MPD \d{1,2}\.\d{1,2}\.\d{1,2}$/)
+      yield(host)
+    end
+  end
+end
+end
+end

data/lib/radiodan/adapter/mpd/playlist_parser.rb

@@ -0,0 +1,36 @@
+require 'playlist'
+
+class Radiodan
+class MPD
+module PlaylistParser
+  def self.parse(attributes={}, tracks=[])
+    options          = parse_attributes(attributes)
+    options[:tracks] = parse_tracks(tracks)
+    
+    Playlist.new(options)
+  end
+
+  private
+  def self.parse_attributes(attributes)
+    options = {}
+    options[:state]     = attributes['state'].to_sym
+    options[:mode]      = parse_mode(attributes)
+    options[:repeat]    = attributes['repeat'] == '1'
+    options[:position]  = attributes['song'].to_i
+    options[:seek]      = attributes['elapsed'].to_f
+    options[:volume]    = attributes['volume'].to_i
+    
+    options
+  end
+  
+  def self.parse_tracks(tracks)
+    p tracks.first.inspect
+    tracks.collect{ |t| Track.new(t) }
+  end
+
+  def self.parse_mode(attributes)
+    attributes['random'] == '1' ? :random : :sequential
+  end
+end
+end
+end

data/lib/radiodan/adapter/mpd/response.rb

@@ -0,0 +1,99 @@
+require_relative 'ack'
+
+class Radiodan::MPD
+  class Response
+    attr_accessor :value, :string
+    alias_method  :to_s, :string
+    
+    MULTILINE_COMMANDS = %w{playlistinfo}
+    
+    def initialize(response_string, command=nil)
+      @string = response_string
+      @command = command
+    end
+    
+    def value
+      @value ||= parse(@string, @command)
+    end
+    
+    def is_ack?
+      value.is_a?(Ack)
+    end
+    
+    def method_missing(method, *args, &block)
+      if value.respond_to?(method)
+        value.send(method, *args, &block)
+      else
+        super
+      end
+    end
+    
+    def respond_to?(method)
+      if value.respond_to?(method)
+        true
+      else
+        super
+      end
+    end
+    
+    private
+    
+    # returns true, ACK or formatted values
+    def parse(response, command)
+      case
+      when response == 'OK'
+        true
+      when response =~ /^ACK/
+        parse_ack(response)
+      when response.split.size == 1
+        # set value -> value
+        Hash[*(response.split.*2)]
+      when MULTILINE_COMMANDS.include?(command)
+        # create array of hash values
+        parse_multiline(response)
+      else
+        split = split_response(response).flatten
+        Hash[*split]
+      end
+    end
+    
+    def parse_ack(response)
+      ack = Ack.new(response)
+      logger.warn ack
+    
+      ack
+    end
+    
+    def parse_multiline(response)
+      multiline = []
+      values = {}
+      
+      split_response(response) do |key, value|
+        if values.include?(key)
+          multiline << values
+          values = {}
+        end
+        
+        values[key] = value
+      end
+      
+      multiline << values
+    end
+    
+    def split_response(response)
+      response = response.split("\n")
+      # remove first response: "OK"
+      response.pop
+      
+      response.collect do |r| 
+        split = r.split(':')
+        key   = split.shift.strip
+        value = split.join(':').strip
+        
+        yield(key, value) if block_given?
+        
+        [key, value]
+      end
+    end
+  end
+end