radiodan 0.0.1

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+.vagrant
+
+music/*.mp3
+playlists/*.m3u
+config.yml
+db/development.sqlite3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in radiodan.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    radiodan (0.0.1)
+      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)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    active_support (3.0.0)
+      activesupport (= 3.0.0)
+    activesupport (3.0.0)
+    addressable (2.3.4)
+    cookiejar (0.3.0)
+    em-http-request (1.0.3)
+      addressable (>= 2.2.3)
+      cookiejar
+      em-socksify
+      eventmachine (>= 1.0.0.beta.4)
+      http_parser.rb (>= 0.5.3)
+    em-simple_telnet (0.0.9)
+      eventmachine (>= 1.0.0)
+    em-socksify (0.2.1)
+      eventmachine (>= 1.0.0.beta.4)
+    em-synchrony (1.0.3)
+      eventmachine (>= 1.0.0.beta.1)
+    eventmachine (1.0.3)
+    http_parser.rb (0.5.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  radiodan!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Dan Nuttall
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,30 @@
+# Radiodan
+
+Web-enabled radio that plays to my schedule.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'radiodan'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install radiodan
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/TODO

@@ -0,0 +1,3 @@
+* Add some goddamn tests, dammnit.
+* Generate gem
+* Move BBC Downloader into own radio player thing, using radio_dan as gem

data/lib/em_additions.rb

@@ -0,0 +1,31 @@
+=begin
+  Most periodic tasks need to be run both now 
+  and after a specificed time period.
+  
+  This Eventmachine helper does that. You can
+  specify the timeframe in hours, minutes or 
+  seconds.
+=end
+
+module EventMachine
+  def self.now_and_every(period, &blk)
+    seconds = case
+      when period.respond_to?(:to_f)
+        period.to_f
+      when period.include?(:hours)
+        period[:hours]*60*60
+      when period.include?(:minutes)
+        period[:minutes]*60
+      else
+        period[:seconds]
+    end
+    
+    EM::Synchrony.next_tick do
+      yield
+    end
+    
+    EM::Synchrony.add_periodic_timer(seconds) do
+      yield
+    end
+  end
+end

data/lib/radiodan/builder.rb

@@ -0,0 +1,63 @@
+require 'active_support'
+require 'active_support/core_ext/string'
+
+require 'radiodan/logging'
+require 'radiodan/player'
+require 'radiodan/state'
+
+class Radiodan
+class Builder
+  attr_reader :middleware, :player
+    
+  def initialize(&blk)
+    @middleware = []
+    @player = Player.new
+    
+    yield(self)
+  end
+
+  def use(klass, *config)
+    @middleware << register(klass, *config)
+  end
+  
+  def adapter(klass, *config)
+    @player.adapter = register(klass, *config)
+  end
+  
+  def state(options)
+    @player.state = State.new(options) if @player
+  end
+  
+  def log(log)
+    Logging.output = log
+  end
+  
+  def call_middleware!
+    @middleware.each{ |m| m.call(@player) }
+  end
+
+  private
+  def register(klass, *config)
+    klass = klass.to_s
+
+    begin
+      radio_klass = Radiodan.const_get(klass.classify)
+    rescue NameError => e
+      klass_path ||= false
+      raise if klass_path
+      
+      # attempt to require from middleware
+      klass_path = Pathname.new("#{File.dirname(__FILE__)}/middleware/#{klass.underscore}.rb")
+      require klass_path if klass_path.exist?
+      
+      retry
+    end
+
+    if config.empty?
+      radio_klass.new
+    else
+      radio_klass.new(*config)
+    end
+  end
+end
+end

data/lib/radiodan/content.rb

@@ -0,0 +1,18 @@
+=begin
+  The Content object defines the source of audio
+  for the player.
+  
+  We cant return the name of a playlist from mpd: we might as well build it up
+  in memory.
+  
+  Attributes:
+    type: playlist, a URL, or a single file
+    location: URI for the content
+    mode: sequential, random, resume
+    song_number: song to resume play
+    play_from: position to resume from (seconds)
+=end
+
+class Radiodan
+class Content < Struct.new(:type, :name, :files, :mode, :song_number, :play_from); end
+end

data/lib/radiodan/event_binding.rb

@@ -0,0 +1,49 @@
+class Radiodan
+module EventBinding
+  def register_event(event, &blk)
+    logger.info "Registered event #{event}"
+    event = event.to_sym
+    event_bindings[event] << blk
+    
+    true
+  end
+  
+  def trigger_event(event, data=nil)
+    event = event.to_sym
+    bindings = event_bindings[event]
+    
+    unless bindings
+      logger.error "Event #{event} triggered but not found" 
+    end
+    
+    bindings.each do |blk|
+      blk.call(data)
+    end
+  end
+  
+  def events
+    event_bindings.keys.sort
+  end
+  
+  def respond_to?(method)
+    if event_bindings.include?(method)
+      true
+    else
+      super
+    end
+  end
+  
+  private
+  def event_bindings
+    @event_bindings ||= Hash.new{ |h, k| h[k] = [] }
+  end
+  
+  def method_missing(method, *args, &block)
+    if event_bindings.include?(method)
+      trigger_event(method, *args)
+    else
+      super
+    end
+  end  
+end
+end

data/lib/radiodan/logging.rb

@@ -0,0 +1,38 @@
+require 'logger'
+
+class Radiodan
+module Logging
+  @output = '/dev/null'
+  
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+  
+  def self.output=(output)
+    @output = output
+  end
+  
+  def self.output
+    @output
+  end
+
+  def logger
+    self.class.logger
+  end
+
+  module ClassMethods    
+    @@logs = {}
+    
+    def logger
+      unless @@logs.include? self.name
+        new_log = Logger.new(Logging.output)
+        new_log.progname = self.name
+        
+        @@logs[self.name] = new_log
+      end
+      
+      @@logs[self.name]
+    end
+  end
+end
+end

data/lib/radiodan/middleware/mpd.rb

@@ -0,0 +1,145 @@
+require 'em-simple_telnet'
+require 'ostruct'
+
+class Radiodan
+class MPD
+  include Logging
+  COMMANDS = %w{stop pause clear play}
+  Ack = Struct.new(:error_id, :position, :command, :description)
+  class AckError < Exception; end
+  
+  attr_reader :player
+
+  def initialize(options={})
+    @port = options[:port] || 6600
+    @host = options[:host] || 'localhost'
+  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.song_number
+    else
+      raise "Cannot load playlist #{playlist}" 
+    end
+  end
+
+  def enqueue(playlist)
+    playlist.files.each do |file|
+      cmd(%Q{add "#{file}"})
+    end
+  end
+
+  def play(song_number=nil)
+    cmd("play #{song_number}")
+  end
+  
+  def state
+    @state = cmd("status")
+    playlist = cmd("playlistinfo")
+    
+    unless playlist == true
+      @state.merge!(playlist)
+    end
+    
+    OpenStruct.new(@state)
+  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
+
+  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
+    
+    format_response(response)
+  end
+  
+  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
+  
+  # returns true or hash of values
+  def format_response(response)
+    case
+    when response == 'OK'
+      true
+    when response =~ /^ACK/
+      ack = format_ack(response)
+      logger.warn ack
+      
+      ack
+    when response.split.size == 1
+      # set value -> value
+      Hash[*(response.split.*2)]
+    else
+      response = response.split("\n")
+      # remove first response: "OK"
+      response.pop
+      
+      split_response = response.collect do |r| 
+        split = r.split(':')
+        key   = split.shift
+        value = split.join(':')
+        [key.strip, value.strip]
+      end.flatten
+      
+      Hash[*split_response]
+    end
+  end
+  
+  def format_ack(ack)
+    matches = /ACK \[(\d)+@(\d)+\] \{(.*)\} (.*)/.match(ack)    
+    AckError.new(*matches[1..-1].join)
+  end
+end
+end

data/lib/radiodan/middleware/panic.rb

@@ -0,0 +1,46 @@
+class Radiodan
+class Panic
+  include Logging
+  
+  def initialize(config)
+    @panic      = false
+    @timeout    = config.delete(:duration).to_i
+    @state      = State.new(config)
+  end
+  
+  def call(player)
+    @player = player
+    
+    @player.register_event :panic do
+      panic!
+    end
+  end
+  
+  def panic?
+    @panic == true
+  end
+
+  def panic!
+    return true if panic?
+    
+    @panic = true
+    
+    original_state = @player.state
+  
+    Thread.new do
+      logger.debug "panic for #{@timeout} seconds"
+      @player.state = @state
+      sleep(@timeout)
+      return_to_state original_state
+    end
+  
+    @panic
+  end
+
+  def return_to_state(state)
+    logger.debug "calming"
+    @panic = false
+    @player.state = state
+  end
+end
+end

data/lib/radiodan/middleware/touch_file.rb

@@ -0,0 +1,31 @@
+=begin
+Controls the radio by touching files.
+
+This class looks for matching files in 
+a given directory. When the file exists,
+the corresponding event is triggered and
+the file deleted.
+=end
+
+class Radiodan
+class TouchFile
+  include Logging  
+  def initialize(config)
+    @path = config[:dir]
+  end
+
+  def call(player)
+    EM.now_and_every(0.5) do
+      player.events.each do |event|
+        file = event.to_s
+        p = Pathname.new(File.join(@path, file))
+        if p.exist?
+          logger.debug "Responding to file #{file}"
+          p.delete
+          player.trigger_event file
+        end
+      end
+    end
+  end
+end
+end

data/lib/radiodan/player.rb

@@ -0,0 +1,53 @@
+require 'radiodan/event_binding'
+
+class Radiodan
+class Player
+  include Logging
+  include EventBinding
+  
+  attr_reader :adapter, :state
+  
+  def initialize
+    @state = State.new(:playback => 'stopped')
+  end
+  
+  def adapter=(adapter)
+    @adapter = adapter
+    @adapter.player = self
+  end
+  
+  def adapter?
+    !adapter.nil?
+  end
+  
+  def state=(new_state)
+    @state = new_state
+    trigger_event(:state, @state)
+    
+    @state
+  end
+  
+=begin
+  Sync checks the current status of the player.
+  Is it paused? Playing? What is it playing?
+  It compares the expected to actual statuses and
+  makes changes required to keep them the same.
+=end
+  def sync
+    current_state  = adapter.state
+    expected_state = state
+
+    # 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
+
+    # playback state
+    unless expected_state.playback == current_state.state
+      logger.debug "Expected: #{expected_state.playback} Got: #{current_state.state}"
+      trigger_event expected_state.playback
+    end
+  end
+end
+end

data/lib/radiodan/state.rb

@@ -0,0 +1,24 @@
+=begin
+  The State object determines what the player
+  should be doing at any given moment.
+  
+  Attributes:
+    playback: boolean
+    content: content object to be playing
+  
+  It can be updated by any of the stimulus objects.
+=end
+
+require 'radiodan/content'
+
+class Radiodan
+class State
+  include Logging
+  attr_reader :playback, :content
+
+  def initialize(config={})
+    @playback = config[:playback] || 'play'
+    @content  = config[:content]
+  end
+end
+end

data/lib/radiodan/version.rb

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

data/lib/radiodan.rb

@@ -0,0 +1,73 @@
+require 'eventmachine'
+require 'em-synchrony'
+
+$: << './lib'
+
+require 'em_additions'
+require 'radiodan/logging'
+require 'radiodan/builder'
+require 'radiodan/version'
+
+class Radiodan
+  include Logging
+
+  def initialize(&blk)
+    @builder = Builder.new(&blk)
+  end
+  
+  def start
+    # keep player running on schedule
+    raise "no player set" unless player.adapter?
+    
+    EM.synchrony do
+      trap_signals!
+      
+      EM.next_tick do      
+        @builder.call_middleware!
+      end
+
+      EM.now_and_every(seconds: 1) do
+        logger.info "SYNC!"
+        player.sync if player
+      end
+    end
+  end
+
+  def player
+    @builder.player
+  end
+  
+  def respond_to?(method)
+    if player.respond_to? method
+      true
+    else
+      super
+    end
+  end
+
+  private
+  
+  def method_missing(method, *args, &block)
+    if player.respond_to? method
+      player.send method, *args, &block
+    else
+      super
+    end
+  end
+  
+  def trap_signals!
+    %w{INT TERM SIGHUP SIGINT SIGTERM}.each do |signal|
+      Signal.trap(signal) do
+        logger.info "Trapped #{signal}"
+        EM::Synchrony.next_tick do
+          begin
+            stop
+          ensure
+            EM.stop
+          end
+        end
+      end
+    end
+  end
+end
+

data/radiodan.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'radiodan/version'
+
+EM_VERSION = '~> 1.0.3'
+
+Gem::Specification.new do |gem|
+  gem.name          = "radiodan"
+  gem.version       = Radiodan::VERSION
+  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.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.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'
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: radiodan
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dan Nuttall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.3
+- !ruby/object:Gem::Dependency
+  name: em-simple_telnet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: Web-enabled radio that plays to my schedule.
+email:
+- pixelblend@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- lib/em_additions.rb
+- lib/radiodan.rb
+- lib/radiodan/builder.rb
+- lib/radiodan/content.rb
+- lib/radiodan/event_binding.rb
+- lib/radiodan/logging.rb
+- lib/radiodan/middleware/mpd.rb
+- lib/radiodan/middleware/panic.rb
+- lib/radiodan/middleware/touch_file.rb
+- lib/radiodan/player.rb
+- lib/radiodan/state.rb
+- lib/radiodan/version.rb
+- radiodan.gemspec
+homepage: https://github.com/pixelblend/radiodan
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Web-enabled radio that plays to my schedule.
+test_files: []
+has_rdoc: