candelabra 0.0.1 → 1.0.0

data/.gitignore

@@ -1,3 +1,6 @@
 pkg/*
 *.gem
 .bundle
+*.swp
+logs/*
+img.*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@candelabra --create

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    candelabra (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    minitest (2.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  candelabra!
+  minitest (>= 2.0.2)

data/README.md

@@ -0,0 +1,18 @@
+The candelbra is on top of the piano....bar
+===========================================
+
+# Candelbra
+-  is the  traditional  term  for a  set  of multiple  decorative
+candlesticks,  each of  which often  holds  a candle  on each  of
+multiple arms or branches connected to a column or pedestal.
+
+This is  not a  candlestick. It  is a  wrapper lib  for pianobar.
+I  will   handle  the  installtion,  configuration,   and  remote
+controlling of  pianobar. It  can support multiple  user accounts
+and the switching between them.
+
+There is a command line access to the lib as well as a ruby api.
+
+## Examples: ##
+
+TODO: put the examples here.

data/Rakefile

@@ -1,2 +1,11 @@
 require 'bundler'
+require 'rake/testtask'
 Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'spec'
+  test.pattern = './spec/**/*_spec.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/bin/candelabra

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require File.dirname(__FILE__) + '/../lib/candelabra'
+
+# If the input comes from the terminal (i.e. user) then have
+# candelabra handle it as user input, otherwise handle the input
+# as an event from another application.
+if $stdin.tty?
+  runner = Candelabra::Runner.new ARGV
+else
+  runner = Candelabra::EventCmd.new ARGV
+end
+
+runner.run

data/candelabra.gemspec

@@ -14,9 +14,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = ">= 1.3.6"
   s.rubyforge_project         = "candelabra"
 
-  s.add_development_dependency "bundler"  , ">= 1.0.0"
+  s.add_development_dependency "bundler"  , "~> 1.0.0"
   s.add_development_dependency "minitest" , ">= 2.0.2"
-  s.add_development_dependency "tomdoc"   , "= 0.1.0"
 
   s.files        = `git ls-files`.split("\n")
   s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact

data/lib/candelabra/configuration.rb

@@ -0,0 +1,50 @@
+module Candelabra
+  class Configuration
+    include Singleton
+
+    attr_accessor :auto_restart, :event_handler, :in_installer
+    attr_writer :on_song_start, :on_song_finish, :on_error
+
+    class << self
+      # Initilize the configuration
+      def go
+        clear
+        yield self.instance
+      end
+
+      # Clear out the old settings in the configuration
+      def clear
+        auto_restart, event_handler = nil,nil
+        @on_song_start, @on_song_finish, @on_error = nil,nil,nil
+      end
+    end
+
+    # Check to determine if the hander has been set yet or not
+    def handler?
+      !event_handler.nil?
+    end
+
+    # Call the event requested by the system
+    #
+    # Returns what ever the system is configured to or nil
+    def call_event( event )
+      if handler?
+        event_handler.send( event )
+      elsif instance_variable_get( "@" + event.to_s ).respond_to?( 'call' )
+        instance_variable_get( "@" + event.to_s ).send( :call )
+      else
+        instance_variable_get( "@" + event.to_s )
+      end
+    end
+
+    # short cut way of calling the system
+    def method_missing( method, *args )
+      if method.to_s =~ /on_/
+        call_event( method )
+      else
+        super method, *args
+      end
+    end
+
+  end
+end

data/lib/candelabra/event_cmd.rb

@@ -0,0 +1,62 @@
+module Candelabra
+  class EventCmd
+    include OSX
+    include Ubuntu
+
+    attr_reader :command, :artist, :title, :album, :stationName, :coverArt
+
+    # Inigialize the Event Command with the given command
+    # Once we have the command we can preform different actions
+    def initialize(args)
+      @command = args.shift
+    end
+
+    # Run the command.  Part of running the command
+    def run
+      parse( $stdin )
+      case command
+      when 'songstart'
+        notify
+        Remote.flush
+      when 'userlogin'
+        unless @pRet.to_i == 1
+          #`ps a | grep 'candelabra install' | cut -c1-5`.split("\n").each{|id| `kill #{id}` unless Process.pid == id.to_i }
+          `ps | grep candelabra`.split("\n").map{ |p| p.split(" ").last }.each{|x| `killall #{x}`}
+        end
+
+      else
+        #`notify-send #{@pRet}`
+        #`notify-send #{command}`
+        #`notify-send #{command}`
+        #instance_variables.each do |i|
+        #  `notify-send #{i}`
+        #end
+      end
+    end
+
+    # Parse out the data from  stdin. This will set instance vars
+    # that are named the same as the input from pianobar
+    #
+    # Retruns nothing
+    def parse(data)
+      data.each do |key_value|
+        key, value = key_value.chomp.split('=')
+        key = key
+        instance_variable_set( "@#{key}".to_sym, value )
+      end
+    end
+
+    # The 2011  release of  pianobar supports  album art.  If wen
+    # have album are the it will be displayed in the notification
+    #
+    # Returns nil or the path of the file
+    def art_work
+      if coverArt
+        Dir.glob('*.jpg').each { |imge| File.delete(imge) }
+        File.open( 'img.jpg', 'wb' ) { |f| f.write Net::HTTP.get( URI.parse( coverArt ) ) }
+        Dir.glob('*.jpg').first
+      end
+    end
+  end
+end
+

data/lib/candelabra/extensions.rb

@@ -0,0 +1,70 @@
+# This is used to colorize the ouput.
+#
+# Example usage
+#
+# "foo".red # => \033[0;31mfoo\033[0m
+#
+# This code was borrowed from https://github.com/stefanpenner/terminal-color
+# A big thanks this was much more sophisticated than my naive approach.
+#
+# class String
+#   def red
+#     "\033[0;31m#{self}\033[0m"
+#   end
+# end
+#
+# If you need colorization in your app and don't minde dependencies it is highly
+# recomended that you use the terminal-color or rainbow gem.
+
+class String
+  COLORS = {
+    :black     => '0',
+    :red       => '1',
+    :green     => '2',
+    :yellow    => '3',
+    :blue      => '4',
+    :magenta   => '5',
+    :cyan      => '6',
+    :white     => '7'
+  }
+
+  FORMAT_CODES = {
+    :bold      => '1',
+    :italic    => '3',
+    :underline => '4',
+    :blink     => '5',
+  }
+
+  def ansi_formatted
+    ansi_csi = "#{(0x1B).chr}["
+    formats = {}
+    FORMAT_CODES.each do |name, code|
+      formats[name] = code if @properties[name]
+    end
+    formats[:color] = "3#{COLORS[@properties[:color]]}" if @properties[:color]
+    "#{ansi_csi}#{formats.values.join(';')}m#{self}#{ansi_csi}m"
+  end
+
+  def make_colorized(color)
+    @properties ||= {}
+    @properties[:color] = color
+    ansi_formatted
+  end
+
+  COLORS.each do |color,v|
+
+    define_method color do
+      make_colorized(color)
+    end
+  end
+
+  FORMAT_CODES.each do |name, code|
+
+    define_method name do
+      @properties ||={}
+      @properties[name] = true
+      ansi_formatted
+    end
+  end
+end
+

data/lib/candelabra/installer.rb

@@ -0,0 +1,249 @@
+module Candelabra
+  # This  module handles  the installing  of pianobar  Candelabra
+  # will support two different ways of installing
+  # First is via osx # => brew
+  # Second is ubuntu # => apt-get
+  #
+  # It  will   also  know  if  pianobar   is  installed.  Because
+  # packagemanagers are  a good  thing Candelabra will  allow the
+  # packagemanage  handle  all the  hard  work  with keeping  the
+  # version correct
+  #
+  # For Example:
+  #   Candelabra::Installer.install 'pianobar'
+  #     # => brew install pianobar
+  #     # => sudo apt-get install pianobar
+  module Installer
+    module_function
+
+    CONSOLE_WIDTH = 70
+
+    extend OSX
+    extend Ubuntu
+
+    # Executing the installing process.
+    def run
+      Pianobar.stop_all # make sure all are off
+      header
+      what_is_installed?
+      install_pianobar
+      setup_config_file
+      make_fifos
+      setup_auto_play_station
+    end
+
+    def header
+      puts get_template 'header'
+    end
+
+    # Display what is installed to the user
+    #
+    # Return if all is ok to install
+    def what_is_installed?
+      which_os        = os.green
+      package_manager = ( has_installer?  ? 'Yes'.green : 'No'.red.blink )
+      exe_installed   = ( pianobar?       ? 'Yes'.green : 'No'.red.blink )
+      ctl_file        = ( ctl?            ? 'Yes'.green : 'No'.red.blink )
+      has_notifier    = ( notify?         ? 'Yes'.green : 'No'.red.blink )
+      ok              = ( has_installer?  ? 'Yes'.green : 'No'.red.blink )
+
+      puts get_template 'what_is_installed', binding
+
+      has_installer?
+    end
+
+    def setup_config_file
+      puts get_template 'setup_config_file'
+      @username, @password  = ask( "Enter username:" ), ask( "Enter password:", false )
+      write_config_file 
+    end
+
+    def write_config_file( station = nil )
+      FileUtils.mkdir_p piano_path
+      FileUtils.mv config_path, backup_config_name if File.exists? config_path
+      File.open( config_path, 'w' ) do |f| 
+        f.write config_template( station )
+      end
+    end
+
+    def make_fifos
+      mkfifo( ctl_path )    unless ctl?
+      mkfifo( output_path ) unless output?
+      mkfifo( input_path )  unless input?
+    end
+
+
+    def backup_config_name
+      [config_path, @username, Dir.glob(config_path + '*').size.to_s].join('.')
+    end
+
+    def config_template( station_id = nil )
+      exe_path = "#{File.dirname(__FILE__)}/../../bin/candelabra"
+      station  = station_id
+      get_template('config', binding)
+    end
+
+    def get_template( name, this_binding = nil )
+      erb = ERB.new(File.read(File.dirname(__FILE__) + "/templates/#{name}.erb"))
+      erb.result this_binding
+    end
+
+    def start_pianobar
+      if Pianobar.running?
+        print "Restarting Pianobar with Autostation".ljust(CONSOLE_WIDTH + 20, '.')
+        Pianobar.restart
+      else
+        print "Starting Pianobar".ljust(CONSOLE_WIDTH - 5, '.')
+        Pianobar.start
+      end
+
+      5.times do 
+        sleep(1)
+        putc '.'
+      end
+
+      print Pianobar.running? ? "SUCCESS".green : "FAILED".red.blink
+      puts ""
+    end
+
+    def setup_auto_play_station
+      puts "Testing Configuration".center(CONSOLE_WIDTH + 20)
+      start_pianobar
+
+
+      if Pianobar.running?
+        `echo '0' > #{Installer.input_path}` # forcing auto selection of the first station
+        sleep( 2 )
+        puts ''
+        puts "Select Auto station".center( CONSOLE_WIDTH + 20, ' ' )
+        stations = Remote.stations
+        stations.each { |s| puts s }
+        
+        begin
+          result = ask 'Select Station and press ENTER:'
+          raise "You must enter the number of a valid station" unless result == result.to_i.to_s
+          raise "That is not a valid station it must be a number between 0 and #{stations.size - 1}" unless (0..stations.size - 1).include? result.to_i
+          puts "You selected: #{stations[result.to_i]}"
+        rescue RuntimeError => e
+          puts e.message.red
+          puts "You Entered: #{result.red}"
+          puts "Try again"
+          retry
+        end
+
+        Remote.change_station result
+
+        write_config_file( Remote.station_id )
+
+        start_pianobar
+      end
+    end
+
+    # Instal
+    def install_pianobar
+      print "Installing Pianobar".ljust(CONSOLE_WIDTH, '.')
+      install 'pianobar' unless pianobar?
+      print pianobar? ? 'SUCCESS'.green : 'FAILED'.red.blink
+    end
+
+    alias update_pianobar install_pianobar
+
+    # Helper for asking a question
+    #
+    # Params:
+    #   question => the question u want to ask maybe?
+    #   visiable => this  will determine if  the output  should be
+    #     displayed or not
+    #
+    # Returns result of the user's input
+    def ask( question, visiable=true )
+      begin
+        `stty echo`
+        print question
+        `stty -echo` unless visiable
+        gets.chomp
+      ensure
+        `stty echo`
+      end
+    end
+
+
+    # Checking to determine  if pianobar is installed  it is just
+    # looking for the executable.
+    #
+    # Example:
+    #   Candelabra::Install.pianobar?
+    #     # => true if pianobar is in the path
+    #
+    # Returns true when pianobar is installed
+    def pianobar?
+      !pianobar_path.empty?
+    end
+
+    # Gets the path to pianobar.  If it's installed on the system
+    # and in your  path it will be located. This  path is what is
+    # used to determine if pianobar needs to be installed
+    #
+    # Example:
+    #   Candelabra::Installer.pianobar_path
+    #     # => /usr/local/bin/pianobar
+    #
+    # Returns a string
+    def pianobar_path
+      %x[which pianobar]
+    end
+
+
+    # Util method. Should be moved  to the install module when it
+    # has been created.
+    #
+    # Example:
+    #   Candelabra::Pianobar.make_logs
+    #     # => doesn't really belong here
+    #
+    # Returns nothing. but it makes the logs dir
+    def mkfifo( path )
+      %x[mkfifo "#{path}"]
+    end
+
+    def output?
+      test ?p, output_path
+    end
+
+    def input?
+      test ?p, input_path
+    end
+
+    # Pianobar can talk  to a remote file. This  will determin if
+    # the file is setup.
+    #
+    # Returns true when setup in the expected location
+    def ctl?
+      test ?p, ctl_path
+    end
+
+    def piano_path
+      "#{ENV['HOME']}/.config/pianobar"
+    end
+
+    def config_path
+      "#{piano_path}/config"
+    end
+
+    def output_path
+      "#{piano_path}/output.fifo"
+    end
+
+    def input_path
+      "#{piano_path}/input.fifo"
+    end
+
+    # The path of the control file. This file must be a fifo file
+    # inorder for it to be the correct ctl file.
+    #
+    # Returns the path to the control file
+    def ctl_path
+      "#{piano_path}/ctl"
+    end
+  end
+end

data/lib/candelabra/osx.rb

@@ -0,0 +1,88 @@
+module Candelabra
+  # This module contains installer  specific instructions for OSX
+  # using home bree Home brew is the best package manager for OSX
+  # 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 brew.
+  #
+  # NOTE: This module will only be active if the os is OSX
+  module OSX
+    module InstanceMethods
+      # Installs the  requested package  using home brew.  If the
+      # package is  already installed home brew  will not install
+      # it
+      #
+      # Example:
+      #   Candelabra::Install.install 'pianobar'
+      #     # => brew installs pianobar
+      #
+      # Returns standard output from home brew
+      def install lib
+        %x[brew install #{lib}] if has_installer?
+      end
+
+      # Gets  the path  of home  brew. If  it's somewere  on your
+      # system this  finds it. Candelabra assumes  that you don't
+      # use sudo to install the brew packages
+      #
+      # Example:
+      #   Candelabra::Install.brew_path
+      #     # => /usr/local/bin/brew
+      #
+      # Returns a string
+      def installer_path
+        %x[which brew].chomp
+      end
+
+      # Simple check to determine if home brew is installed
+      #
+      # Example:
+      #   Candelabra::Install.has_installer?
+      #     # => On osx it should be true
+      #     # => On ubuntu it should be false
+      #
+      # Returns true if home brew is there
+      def has_installer?
+        !installer_path.nil?
+      end
+
+      def os
+        'OSX'
+      end
+
+      def notify?
+        !%x[which growlnotify].chomp.nil?
+      end
+
+      # Notify the user using growl
+      def notify
+        %x[growlnotify --image #{art_work} -t "Pianobar - #{stationName}" -m "Now Playing: #{artist} - #{title}"]
+      end
+
+    end
+
+    # Load the installer methods IF this is the correct OS
+    def self.extended klass
+      klass.extend( InstanceMethods ) if osx?
+    end
+
+    # Load the installer methods IF this is the correct OS
+    def self.included klass
+      klass.send( :include, InstanceMethods ) if osx?
+    end
+
+    # This method will say if the OS is OSX or not
+    #
+    # Example:
+    #   [ On OSX ] osx?
+    #     # => true
+    #
+    #   [ On Linux ] osx?
+    #     # => false
+    #
+    # Returns true for OSX
+    def self.osx?
+      !( /darwin/ =~ RbConfig::CONFIG["target_os"] ).nil?
+    end
+  end
+end