radiodan 0.0.1 → 0.0.2

data/lib/radiodan/builder.rb

@@ -1,9 +1,8 @@
 require 'active_support'
 require 'active_support/core_ext/string'
 
-require 'radiodan/logging'
-require 'radiodan/player'
-require 'radiodan/state'
+require 'logging'
+require 'player'
 
 class Radiodan
 class Builder
@@ -13,19 +12,19 @@ class Builder
     @middleware = []
     @player = Player.new
     
-    yield(self)
+    yield(self) if block_given?
   end
 
   def use(klass, *config)
-    @middleware << register(klass, *config)
+    @middleware << register(klass, 'middleware', *config)
   end
   
   def adapter(klass, *config)
-    @player.adapter = register(klass, *config)
+    player.adapter = register(klass, 'adapter', *config)
   end
   
-  def state(options)
-    @player.state = State.new(options) if @player
+  def playlist(new_playlist)
+    player.playlist = new_playlist if player
   end
   
   def log(log)
@@ -33,11 +32,11 @@ class Builder
   end
   
   def call_middleware!
-    @middleware.each{ |m| m.call(@player) }
+    middleware.each{ |m| m.call(@player) }
   end
 
   private
-  def register(klass, *config)
+  def register(klass, klass_type, *config)
     klass = klass.to_s
 
     begin
@@ -47,12 +46,12 @@ class Builder
       raise if klass_path
       
       # attempt to require from middleware
-      klass_path = Pathname.new("#{File.dirname(__FILE__)}/middleware/#{klass.underscore}.rb")
+      klass_path = Pathname.new(File.join(File.dirname(__FILE__), klass_type, "#{klass.underscore}.rb"))
       require klass_path if klass_path.exist?
-      
+
       retry
     end
-
+    
     if config.empty?
       radio_klass.new
     else

data/lib/radiodan/logging.rb

@@ -2,18 +2,18 @@ require 'logger'
 
 class Radiodan
 module Logging
-  @output = '/dev/null'
+  @@output = '/dev/null'
   
   def self.included(klass)
     klass.extend ClassMethods
   end
   
   def self.output=(output)
-    @output = output
+    @@output = output
   end
   
   def self.output
-    @output
+    @@output
   end
 
   def logger

data/lib/radiodan/middleware/panic.rb

@@ -5,7 +5,7 @@ class Panic
   def initialize(config)
     @panic      = false
     @timeout    = config.delete(:duration).to_i
-    @state      = State.new(config)
+    @playlist   = Playlist.new(config)
   end
   
   def call(player)
@@ -25,11 +25,11 @@ class Panic
     
     @panic = true
     
-    original_state = @player.state
+    original_state = @player.playlist
   
     Thread.new do
       logger.debug "panic for #{@timeout} seconds"
-      @player.state = @state
+      @player.playlist = @playlist
       sleep(@timeout)
       return_to_state original_state
     end
@@ -40,7 +40,7 @@ class Panic
   def return_to_state(state)
     logger.debug "calming"
     @panic = false
-    @player.state = state
+    @player.playlist = playlist
   end
 end
 end

data/lib/radiodan/player.rb

@@ -1,15 +1,13 @@
-require 'radiodan/event_binding'
+require 'logging'
+require 'event_binding'
+require 'playlist_sync'
 
 class Radiodan
 class Player
   include Logging
   include EventBinding
   
-  attr_reader :adapter, :state
-  
-  def initialize
-    @state = State.new(:playback => 'stopped')
-  end
+  attr_reader :adapter, :playlist
   
   def adapter=(adapter)
     @adapter = adapter
@@ -20,11 +18,12 @@ class Player
     !adapter.nil?
   end
   
-  def state=(new_state)
-    @state = new_state
-    trigger_event(:state, @state)
+  def playlist=(new_playlist)
+    @playlist = new_playlist
+    trigger_event(:playlist, @playlist)
+    # run sync to explicitly conform to new playlist?
     
-    @state
+    @playlist
   end
   
 =begin
@@ -34,19 +33,34 @@ class Player
   makes changes required to keep them the same.
 =end
   def sync
-    current_state  = adapter.state
-    expected_state = state
+    return false unless adapter?
 
-    # playlist
-    unless expected_state.content.files.include?(current_state.file)
-      logger.debug "Expected: #{expected_state.content.files.first} Got: #{current_state.file}"
-      trigger_event :playlist, expected_state.content
-    end
+    current  = adapter.playlist
+    expected = playlist
+
+    state = Radiodan::PlaylistSync.new expected, current
 
-    # playback state
-    unless expected_state.playback == current_state.state
-      logger.debug "Expected: #{expected_state.playback} Got: #{current_state.state}"
-      trigger_event expected_state.playback
+    if state.sync?
+      true
+    else
+      # playback state
+      if state.errors.include? :state
+        logger.debug "Expected: #{expected.state} Got: #{current.state}"
+        trigger_event :play_state, expected.state
+      end
+      
+      if state.errors.include? :mode
+        logger.debug "Expected: #{expected.mode} Got: #{current.mode}"
+        trigger_event :play_mode, expected.mode
+      end
+      
+      # playlist
+      if state.errors.include? :playlist
+        logger.debug "Expected: #{expected.current} Got: #{current.current}"
+        trigger_event :playlist, expected
+      end
+      
+      false
     end
   end
 end

data/lib/radiodan/playlist.rb

@@ -0,0 +1,112 @@
+=begin
+  The playlist object defines the source of audio
+  for the player.
+  
+  We cant return the name of a stored playlist from mpd: we might as well build it up
+  in memory.
+  
+  Attributes:
+    name: name of playlist (optional?)
+    state: playing, stopped, paused
+    mode: sequential, random, resume
+    tracks: an array of URIs to play
+    position: song to resume play
+    seek: position to resume from (seconds)
+=end
+require 'forwardable'
+require 'track'
+
+class Radiodan
+class Playlist
+  class StateError < Exception; end
+  class ModeError < Exception; end
+  class PositionError < Exception; end
+  class SeekError < Exception; end
+  class VolumeError < Exception; end
+
+  extend  Forwardable
+  
+  STATES = [:play, :stop, :pause]
+  MODES  = [:sequential, :resume, :random]
+  attr_reader :state, :mode, :repeat, :tracks, :position, :seek, :volume
+  def_delegators :@tracks, :size
+
+  def initialize(options={})
+    self.state    = options.fetch(:state, STATES.first)
+    self.mode     = options.fetch(:mode, MODES.first)
+    self.repeat   = options.fetch(:repeat, false)
+    self.tracks   = options.fetch(:tracks, Array.new)
+    self.position = options.fetch(:position, 0)
+    self.seek     = options.fetch(:seek, 0.0)
+    self.volume   = options.fetch(:volume, 100)
+  end
+
+  def current
+    tracks[position]
+  end
+
+  def state=(new_state)
+    state = new_state.to_sym
+
+    if STATES.include? state
+      @state = state
+    else
+      raise StateError
+    end
+  end
+
+  def mode=(new_mode)
+    mode = new_mode.to_sym
+
+    if MODES.include? mode
+      @mode = mode
+    else
+      raise ModeError
+    end
+  end
+  
+  def repeat=(new_repeat)
+    @repeat = (new_repeat === true)
+  end
+
+  def tracks=(new_tracks)
+    if new_tracks.is_a?(String)
+      new_tracks = Track.new(file: new_tracks)
+    end
+    
+    @tracks = Array(new_tracks)
+    @position = 0
+  end
+
+  def position=(new_position)
+    begin
+      position = Integer(new_position)
+      raise ArgumentError if position > tracks.size
+    rescue ArgumentError
+      raise PositionError, "Item #{new_position} invalid for playlist size #{tracks.size}"
+    end
+
+    @position = position
+  end
+
+  def seek=(new_seek)
+    begin
+      @seek = Float(new_seek)
+    rescue ArgumentError
+      raise SeekError, "#{new_seek} invalid"
+    end
+  end
+  
+  def volume=(new_volume)
+    begin
+      new_volume = Integer(new_volume)
+      
+      raise ArgumentError if new_volume > 100 || new_volume < 0
+    rescue ArgumentError
+      raise VolumeError, "#{new_volume} not an integer 0-100"
+    end
+    
+    @volume = new_volume
+  end
+end
+end

data/lib/radiodan/playlist_sync.rb

@@ -0,0 +1,47 @@
+class Radiodan
+class PlaylistSync
+  class SyncError < Exception; end
+  attr_accessor :expected, :current
+  attr_reader   :errors
+  
+  def initialize(expected = nil, current = nil)
+    @expected = expected
+    @current  = current
+    @errors   = []
+  end
+  
+  def sync?
+    prerequisites_check
+    compare_playback_state & compare_playback_mode & compare_playlist
+  end
+  
+  private
+  def prerequisites_check
+    raise SyncError, 'No expected playlist to compare to' if expected.nil?
+    raise SyncError, 'No current playlist to compare to'  if current.nil?
+  end
+  
+  def compare_playback_state
+    # add rules about when this is ok to be out of sync
+    # e.g. sequential expected runs out of tracks and stops
+    compare(:state) { @expected.state == @current.state }
+  end
+
+  def compare_playback_mode
+    compare(:mode) { @expected.mode == @current.mode }
+  end
+
+  def compare_playlist
+    compare(:playlist) do
+      @expected.size == @current.size && \
+      @expected.tracks == @current.tracks
+    end
+  end
+  
+  def compare(type, &blk)
+    result = blk.call
+    errors << type unless result
+    result
+  end
+end
+end

data/lib/radiodan/track.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+require 'active_support/core_ext/hash/indifferent_access'
+
+class Radiodan
+class Track
+  class NoFileError < Exception; end
+  extend  Forwardable
+  def_delegators :@attributes, :[]
+  
+  alias_method :eql?, :==
+  
+  def initialize(attributes={})
+    @attributes = HashWithIndifferentAccess.new(attributes)
+    raise NoFileError, 'No file given for track' \
+      unless @attributes.include?(:file)
+  end
+  
+  def ==(other)
+    self[:file] == other[:file]
+  end
+  
+  def method_missing(method, *args, &block)
+    if @attributes.include?(method)
+      @attributes[method]
+    else
+      super
+    end
+  end
+  
+  def respond_to?(method)
+    if @attributes.include?(method)
+      true
+    else
+      super
+    end
+  end
+end
+end

data/lib/radiodan/version.rb

@@ -1,3 +1,3 @@
 class Radiodan
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/radiodan.gemspec

@@ -6,21 +6,26 @@ require 'radiodan/version'
 EM_VERSION = '~> 1.0.3'
 
 Gem::Specification.new do |gem|
-  gem.name          = "radiodan"
+  gem.name          = 'radiodan'
   gem.version       = Radiodan::VERSION
-  gem.authors       = ["Dan Nuttall"]
-  gem.email         = ["pixelblend@gmail.com"]
+  gem.authors       = ['Dan Nuttall']
+  gem.email         = ['pixelblend@gmail.com']
   gem.description   = %q{Web-enabled radio that plays to my schedule.}
   gem.summary       = %q{Web-enabled radio that plays to my schedule.}
-  gem.homepage      = "https://github.com/pixelblend/radiodan"
+  gem.homepage      = 'https://github.com/pixelblend/radiodan'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
+  gem.add_development_dependency 'rake',        '~> 10.1.0'
+  gem.add_development_dependency 'rspec',       '~> 2.13.0'
+  gem.add_development_dependency 'guard-rspec', '~> 2.6.0'
+  gem.add_development_dependency 'terminal-notifier-guard', '~> 1.5.0'
   gem.add_dependency 'eventmachine',     EM_VERSION
   gem.add_dependency 'em-synchrony',     EM_VERSION
   gem.add_dependency 'em-http-request',  EM_VERSION
   gem.add_dependency 'em-simple_telnet', '~> 0.0.6'
   gem.add_dependency 'active_support',   '~> 3.0.0'
+  gem.add_dependency 'i18n',             '~> 0.6.4'
 end

data/spec/lib/builder_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'builder'
+
+describe Radiodan::Builder do
+  before :each do
+    @player = mock
+    Radiodan::Player.stub(:new).and_return(@player)
+  end
+
+  it 'passes a playlist to the player' do
+    playlist = mock
+
+    @player.should_receive(:playlist=).with(playlist)
+
+    builder = Radiodan::Builder.new do |b|
+      b.playlist playlist
+    end
+  end
+
+  it 'passes an instance of an adapter class with options to the player' do
+    class Radiodan::MockAdapter; end
+    adapter, options = mock, mock
+
+    Radiodan::MockAdapter.should_receive(:new).with(options).and_return(adapter)
+
+    @player.should_receive(:adapter=).with(adapter)
+
+    builder = Radiodan::Builder.new do |b|
+      b.adapter :mock_adapter, options
+    end
+  end
+
+  describe 'middleware' do
+    it 'creates an instance of middleware and stores internally' do
+      class Radiodan::MockMiddle; end
+
+      options, middleware = mock, mock
+      Radiodan::MockMiddle.should_receive(:new).with(options).and_return(middleware)
+
+      builder = Radiodan::Builder.new do |b|
+        b.use :mock_middle, options
+      end
+      
+      builder.middleware.size.should == 1
+      builder.middleware.should include middleware
+    end
+
+    it 'executes middleware, passing player instance' do
+      middleware = stub
+      middleware.should_receive(:call).with(@player)
+
+      builder = Radiodan::Builder.new
+      builder.should_receive(:middleware).and_return([middleware])
+      builder.call_middleware!
+    end
+  end
+end