candelabra 0.0.1 → 1.0.0

data/lib/candelabra/pianobar.rb

@@ -0,0 +1,142 @@
+module Candelabra
+  # The  Pianobar  module  of  Candelabra  handles  starting  and
+  # stopping of pianobar. The module  will contain the PID of the
+  # process.  It will  also be  able  to kill  of the  pianobar's
+  # running on the system
+  #
+  # For  Example:
+  #   Candelabra::Pianobar.start
+  #     # => pianobar has started
+  module Pianobar
+    #  Give me  super  powers and  the ability  to  call all  the
+    # methods in this file.
+    module_function
+
+    # The accessor  for the PID. If  this is nil then  no process
+    # has been started
+    #
+    # Returns int or nil
+    def pid
+      return @pid unless @pid.nil?
+      @pid = execute.command :pid
+    end
+
+    # Check to determine if pianobar is running anywhere on the system
+    #
+    # Returns true or false
+    def running?
+      !pid.nil?
+    end
+
+    # Start the  pianobar. ( bet  you couldn't have  guessed that
+    # one ) It  will take the output pianobar and  redirect it to
+    # logs/out.log in the gem folder.
+    #
+    # Example:
+    #   Candelabra::Pianobar.start
+    #     # => gives you the process ID
+    #
+    # Returns the process ID a.k.a pid
+    def start
+      @pid = execute.command :start
+    end
+
+    # Die pianobar die!!!! Yeah that is what it does. If you have
+    # a PID then this will send the kill command to that process
+    #
+    # Example:
+    #   Candelabra::Pianobar.stop
+    #     # => pianobar is done for
+    #
+    # Returns nothing
+    def stop
+      execute.commands[:stop] = Stop.new(pid)
+      execute.command :stop
+    end
+
+
+    # First stop all running pianobar instances and then start up a new one
+    #
+    # Example:
+    #   Candelabra::Pianobar.restart
+    #     # => pianobar is stoped and then restarted
+    #
+    # Returns nothing
+    def restart
+      stop_all
+      start
+    end
+
+    # When killing  one pianobar  is not  enough. Kill  them all.
+    # This  will  send  a  system  command to  kill  all  of  the
+    # pianobars running on the system.  This is useful because of
+    # rouge pianobars and stuff
+    #
+    # Example:
+    #   Candelabra::Pianobar.stop_all
+    #     # => and they are all dead
+    #
+    # Returns nothing useful
+    def stop_all
+      @pid = execute.command :stop_all
+    end
+
+    # An implementation of the command pattern
+    # see the GOF book...
+    def execute
+      @execute ||= Execute.new
+    end
+
+    class Execute
+      attr_accessor :commands
+
+      def initialize
+        @commands = {
+          :start => Start.new,
+          :stop_all => StopAll.new,
+          :pid => PID.new
+        }
+      end
+
+      def command(command)
+        @commands[command].go if @commands[command]
+      end
+    end
+
+    # The following classes are commands invoked with the 'go' method
+    class Start
+      def go
+        pid = spawn( 'pianobar', :in => File.open( Installer.input_path, 'r+' ), :out => File.open( Installer.output_path, 'w+' ) )
+        ::Process.detach(pid)
+        pid
+      end
+    end
+
+    class StopAll
+      def go
+        %x[killall pianobar]
+        nil
+      end
+    end
+
+    class Stop
+      def initialize(pid)
+        @pid = pid
+      end
+
+      def go
+        return if @pid.nil?
+        ::Process.kill('HUP', @pid)
+        @pid = nil
+      end
+    end
+
+    class PID
+      def go
+        pid = %x[ps -a | grep pianobar$].split(' ').first
+        pid = pid.to_i unless pid.nil?
+      end
+    end
+
+  end
+end

data/lib/candelabra/remote.rb

@@ -0,0 +1,152 @@
+module Candelabra
+  module Remote
+    module_function
+
+    # This is a  list of avaiable commands for  pianobar The list
+    # here is the  list that we are string with.  There are a few
+    # more commands but thoses  commands might have multple input
+    # request and  we have to figure  out how to do  that for the
+    # user
+    #
+    # Returns hash of commands and key
+    def commands
+      {
+        :pause          => 'p',
+        :continue       => 'p',
+        :love           => '+',
+        :ban            => '-',
+        :bookmark       => 'b',
+        :info           => 'i',
+        :skip           => 'n',
+        :next           => 'n',
+        :quit           => 'q',
+        :change_station => 's',
+        :tired          => 't',
+        :upcomming      => 'u',
+        :quick_mix      => 'x',
+      }
+    end
+
+    # Send the command to pianobar through the fifo file.  If Pianobar is not running
+    # it will start pianobar, but not send the command.
+    #
+    # Example:
+    #   If pianobar is NOT running
+    #   Candelabra::Remote.execute_command :pause
+    #     # => just starts pianobar.  It doesn't pause it
+    #
+    #   If pianobar IS running
+    #   Candelabra::Remote.execute_command :pause
+    #     # => pauses pianobar
+    #
+    # Returns command you passed in
+    def execute_command cmd
+      return Candelabra::Pianobar.start unless Candelabra::Pianobar.running?
+      if commands.include? cmd
+        %x[ echo #{commands[cmd]} > #{Candelabra::Installer.ctl_path} ]
+      else
+        %x[ echo #{cmd} > #{Candelabra::Installer.ctl_path} ]
+      end
+      cmd
+    end
+
+    # Wrapper for all the commands.  This will give you the ability to call the following methods
+    #
+    # Example:
+    #   Candelabra::Remote.pause
+    #     # => Candelabra.Remote.execute_command :pause
+    #
+    #   Candelabra::Remote.love
+    #     # => Candelabra.Remote.execute_command :love
+    #
+    # Returns result of execute_command or method missing
+    def method_missing(method,*args)
+      if commands.keys.include? method.to_sym
+        execute_command method.to_sym
+      else
+        super method, args
+      end
+    end
+
+    # When changing stations the user needs to get the list of stations.
+    #
+    # Example:
+    #   Candelabra::Remote.change_station
+    #     # => [ list of stations ]
+    #   Candelabra::Remote.change_station 6
+    #     # => go to the 6th station
+    #
+    # Returns list of stations _or_ changes the station to the requested station
+    def change_station( station_number = nil )
+      if station_number.nil?
+        stations
+      else
+        execute_command( :change_station )
+        execute_command( "s" + station_number.to_s ) unless station_number.nil?
+      end
+    end
+
+    def station_ids
+      return @ids unless @ids.nil?
+      @ids = []
+      stations.each_with_index do |station,index|
+        change_station(index)
+        @ids << station_id
+      end
+      pause # this is because the it will play the last station other wise
+      @ids
+    end
+
+    def station_id
+      /(\d+)/ =~ info
+      $1
+    end
+
+    def info
+      execute_command( :info )
+      song_info = ''
+      output do |io|
+        io.lines.each do |line|
+          /(Station .+ \(\d+\))/ =~ line
+          if $1
+            song_info = $1
+            break
+          end
+        end
+      end
+      song_info
+    end
+
+    # Get a list of stations from the system
+    # read the station list from the command line
+    #
+    # Returns an array of stations
+    def stations
+      list = []
+      execute_command( :change_station )
+      output do |io|
+        io.lines.each do |line|
+          /(\[\?\])/ =~ line
+          break if $1 == '[?]' # this denotes the use input for which station to change to
+          list << $1 if /(#{list.size}\).+)/ =~ line
+        end
+      end
+      list
+    end
+
+    def flush
+      output {|io| io.flush }
+    end
+
+    # The out put file for the commands
+    # This contains all the output from pianobar
+    #
+    # Yields and IO reader for pianobar's output
+    def output
+      File.open( Candelabra::Installer.output_path, 'r+' ) do |io|
+        yield( io )
+      end
+    end
+
+  end
+end

data/lib/candelabra/runner.rb

@@ -0,0 +1,93 @@
+module Candelabra
+  # This class gives access to candelabra from the command line
+  # It has several useful functions like starting, stoping, and
+  # firing events to candelabra
+  #
+  # Examples:
+  #   candelabra start
+  #     # => I will let you guess what this one does
+  #
+  #   candelabra stop
+  #     # => Yup it does that you are thinking
+  #
+  #   candelabra restart
+  #     # => see above
+  #
+  #   candelabra event -e on_error
+  #     # => send an error event to candelabra
+  class Runner
+    attr_reader :config, :options, :command, :data
+
+    # Set up the running for Candelabra.  Parse out command and
+    # get all the data required for any command
+    #
+    # Returns...it's the initializer
+    def initialize(args)
+      @command = args.shift
+    end
+
+    # Take in the arguments from the command line and parse out any
+    # options and set up the options hash
+    #
+    # Returns parsed optionr
+    def parse( args )
+      @options ={}
+      Candelabra::Configuration.go do |config|
+        OptionParser.new( args ) do |opts|
+          opts.banner = 'Usage: candelabra [command] [opts]'
+
+          opts.on( '-e','--event [EVENT=DATA]',
+                  'Send the EVENT to Candelabra.',
+                  'if the extra DATA is supplied',
+                  'set the EVENT to the DATA.' ) do |event_command|
+
+            event, cmd = event_command.split('=')
+            config.send( event + '=', cmd ) if cmd
+            @options[event] = true
+                  end
+
+          opts.on_tail( '-h', '--help', 'Show this message' ) do
+            puts opts
+            exit
+          end
+
+          opts.on_tail( '-v', '--version', 'Show Candelabra Version' ) do
+            puts "Candelabra's Version is: #{ Candelabra::VERSION }"
+            exit
+          end
+
+        end.parse!
+      end
+
+      Candelabra::Configuration.instance
+    end
+
+    # Execute the  given command. Also  fire off any  events that
+    # occur in the system
+    #
+    # Returns nothing special
+    def run
+      # here comes brute
+      cmds = Remote.commands.keys.map{|x| x.to_s }.abbrev
+      case command
+      when 'start'
+        Candelabra::Pianobar.start
+      when 'stop'
+        Candelabra::Pianobar.stop
+      when 'restart'
+        Candelabra::Pianobar.restart
+      when 'install'
+        Candelabra::Installer.run
+      when 'event'
+        # NOTE: this is mainly for debugging
+        puts "On Song Start: #{ config.on_song_start }" if options['on_song_start']
+        puts "On Song Finish: #{ config.on_song_finish }" if options['on_song_finish']
+        puts "On Error: #{ config.on_error }" if options['on_error']
+      when *cmds.keys
+        Remote.send cmds[command].to_sym
+      else
+        puts "No command given"
+      end
+    end
+  end
+end

data/lib/candelabra/templates/config.erb

@@ -0,0 +1,4 @@
+event_command = <%= exe_path %>
+user = <%= @username %>
+password = <%= @password %>
+autostart_station = <%= station %>

data/lib/candelabra/templates/header.erb

@@ -0,0 +1,11 @@
+
+            Installing Candelabra Version <%= Candelabra::VERSION %>
+
+          Welcome  to Candelabra!!  Before you  continue through  the
+          installer make sure  that you have an  account with Pandora
+               and at least ONE station configured. Please enjoy.
+
+                                     cajun
+                                    mwoods79
+                                     lex148
+

data/lib/candelabra/templates/setup_config_file.erb

@@ -0,0 +1,5 @@
+
+                          Configuring Pianobar account
+
+Enter your Pandora's account information
+

data/lib/candelabra/templates/what_is_installed.erb

@@ -0,0 +1,11 @@
+
+                             Checking Dependencies
+
+=> Detecting OS................................................................<%= which_os %>
+=> Detecting Package Manager...................................................<%= package_manager %>
+=> Detecting Pianobar..........................................................<%= exe_installed %>
+=> Detecting Control File......................................................<%= ctl_file %>
+=> Detecting Notifyer..........................................................<%= has_notifier %>
+
+=> Ok to install...............................................................<%= ok %>
+

data/lib/candelabra/ubuntu.rb

@@ -0,0 +1,96 @@
+module Candelabra
+  # This  module  contains  installer specific  instructions  for
+  # Ubuntu  using home  bree  Home apt_get  is  the best  package
+  # manager for  Ubuntu right  now and  the package  manager that
+  # is  going to  be  supported. Include  this  module into  your
+  # class/module  and you  will  be able  to  install using  home
+  # apt_get.
+  #
+  # NOTE: This module will only be active if the os is Ubuntu
+  module Ubuntu
+    module InstanceMethods
+      # Installs the requested package using home apt_get. If the
+      # package  is  already  installed  home  apt_get  will  not
+      # install it
+      #
+      # Example:
+      #   Candelabra::Install.install 'pianobar'
+      #     # => sudo apt-get install pianobar
+      #
+      # Returns standard output from home apt_get
+      def install lib
+        `gksudo apt-get install #{lib}` if has_installer?
+      end
+
+      # Gets the path  of home apt-get. If it's  somewere on your
+      # system this  finds it. Candelabra assumes  that you don't
+      # use sudo to install the apt_get packages
+      #
+      # Example:
+      #   Candelabra::Install.apt_get_path
+      #     # => /usr/bin/apt-get
+      #
+      # Returns a string
+      def installer_path
+        %x[which apt-get].chomp
+      end
+
+      # Simple check to determine if home apt_get is installed
+      #
+      # Example:
+      #   Candelabra::Install.has_apt_get?
+      #     # => On osx it should be true
+      #     # => On ubuntu it should be false
+      #
+      # Returns true if home apt_get is there
+      def has_installer?
+        !installer_path.nil?
+      end
+
+      def os
+        'Ubuntu\Linux'
+      end
+
+      def notify?
+        !%x[which notify-send].chomp.nil?
+      end
+
+      def notify
+        `notify-send -i #{File.realpath(art_work)} "Pianobar - #{stationName}" "Now Playing: #{ artist } - #{ title }"`
+      end
+    end
+
+    # Load the installer methods IF this is the correct OS
+    def self.extended klass
+      klass.extend( InstanceMethods ) if linux?
+    end
+
+    # Load the installer methods IF this is the correct OS
+    def self.included klass
+      klass.send( :include, InstanceMethods ) if linux?
+    end
+
+    # This method will say if the OS is Ubuntu or not
+    #
+    # Example:
+    #   [ On Ubuntu ] linux?
+    #     # => true
+    #
+    #   [ On OSX ] linux?
+    #     # => false
+    #
+    # Returns true for Ubuntu
+    def self.linux?
+      /linux/ =~ RbConfig::CONFIG["target_os"]
+    end
+  end
+end
+
+
+__END__
+notify-send "Pianobar - $stationName" "Now Playing: $artist - $title"
+if [ "$pRet" -ne 1 ]; then
+notify-send "Pianobar - ERROR" "$1 failed: $pRetStr"
+elif [ "$wRet" -ne 1 ]; then
+notify-send "Pianobar - ERROR" "$1 failed: $wRetStr"
+fi

data/lib/candelabra/version.rb

@@ -1,3 +1,3 @@
 module Candelabra
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/lib/candelabra.rb

@@ -1,3 +1,16 @@
-module Candelabra
-  # Your code goes here...
+# Pulling in all the libs we need to get the job done
+%w(shell fileutils singleton optparse net/http erb abbrev).each do |lib|
+  require lib
+end
+
+# NOTE: These must be first.
+dir = File.dirname(__FILE__)
+require "#{dir}/candelabra/osx.rb"
+require "#{dir}/candelabra/ubuntu.rb"
+
+# Requiring all of the files in the lib dir. kinda cool ( i guess
+# ). This  way we don't  have to worry  about loading any  of the
+# files by hand.
+Dir[File.join File.dirname(__FILE__), 'candelabra', '*.rb'].each do |file|
+  require file
 end

data/spec/candelabra_spec.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+describe Candelabra do
+  it 'should have a version number' do
+    Candelabra::VERSION.must_be_instance_of String
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,81 @@
+require 'helper'
+
+describe Candelabra::Configuration do
+  before(:each) do
+    Candelabra::Configuration.go { |config| } 
+    @config = Candelabra::Configuration.instance 
+  end
+
+  describe 'setting up configuration' do
+    it 'should be able to set "auto_restart"' do
+      Candelabra::Configuration.go do |config|
+        config.auto_restart = false
+      end
+
+      @config.auto_restart.must_equal false
+    end
+
+    describe 'events' do
+      it 'should be able to set "on_song_start" to a lambda' do
+        Candelabra::Configuration.go do |config|
+          config.on_song_start = lambda { 'song_started' }
+        end
+
+        @config.on_song_start.must_equal 'song_started'
+      end
+
+      it 'should be able to set "on_song_start" to a primitive' do
+        Candelabra::Configuration.go do |config|
+          config.on_song_start = 'another_song'
+        end
+
+        @config.on_song_start.must_equal 'another_song'
+      end
+
+      it 'should be able to set "on_song_finish" to a lambda' do
+        Candelabra::Configuration.go do |config|
+          config.on_song_finish = lambda { 'song_finished' }
+        end
+
+        @config.on_song_finish.must_equal 'song_finished'
+      end
+
+      it 'should be able to set "on_song_finish" to a primitive' do
+        Candelabra::Configuration.go do |config|
+          config.on_song_finish = 'another_song_is_done'
+        end
+
+        @config.on_song_finish.must_equal 'another_song_is_done'
+      end
+    end
+
+  end
+
+  describe 'event handler' do
+    it 'should be able to set "event_handler"' do
+      handler = Object.new
+      Candelabra::Configuration.go do |config|
+        config.event_handler = handler
+      end
+
+      @config.event_handler.must_equal handler
+    end
+
+    it 'should have a handler' do
+      Candelabra::Configuration.go do |config|
+        config.event_handler = Object.new
+      end
+
+      @config.handler?.must_equal true
+    end
+
+    it 'should call the handler "on_song_start"' do
+      handler = OpenStruct.new :on_song_start => 'song_started'
+      Candelabra::Configuration.go do |config|
+        config.event_handler = handler
+      end
+      
+      @config.on_song_start.must_equal 'song_started'
+    end
+  end
+end

data/spec/event_cmd_spec.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+describe Candelabra::EventCmd do
+  before( :each ) do
+    @data = ["artist=Dean Martin\n", "title=Sway\n", "album=Dino: The Essential Dean Martin\n", "stationName=Cake Radio\n", "pRet=1\n", "pRetStr=Everything is fine :)\n", "wRet=1\n", "wRetStr=Everything's fine :)\n", "songDuration=0\n", "songPlayed=0\n", "rating=0\n"]
+    @handler = Candelabra::EventCmd.new( [ 'hah' ] )
+  end
+
+  it 'should be able to parse ARTIST' do
+    @handler.parse @data
+    @handler.artist.must_equal 'Dean Martin'
+  end
+
+  it 'should be able to parse TITLE' do
+    @handler.parse @data
+    @handler.title.must_equal 'Sway'
+  end
+
+  it 'should be able to parse ALBUM' do
+    @handler.parse @data
+    @handler.album.must_equal 'Dino: The Essential Dean Martin'
+  end
+end
+

data/spec/helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'ostruct'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/pride'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'candelabra'
+
+def clean_up
+  begin
+    yield
+  ensure
+    # NOTE: this give a message  in the console stating you don't
+    # own this process.  The test seem to work just fine.
+    %x[killall pianobar]
+  end
+end
+
+def ctl_file
+  # TODO: clear out the file before we start using it
+  File.open( Candelabra::Installer.ctl_path, ( File::RDONLY | File::NONBLOCK ) ) do |file|
+    yield( file )
+  end
+end