subcl 1.0.1 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cce8d7f636cf3a5898c7ce68aa2287a8dcc6673d
+  data.tar.gz: 1df467a85ba4ab604668844a359704200ee4c88c
+SHA512:
+  metadata.gz: adae72dbd6ab95c0501234706cdeceeb41fece5aacabf5847dd020c060e4d9a3f8cc36010ad34f70bd6c98bbe818b813f509711f98c2d7fd5bd7258ae2064513
+  data.tar.gz: 8a5219d0d537d6d8450de8518d334084ddcea5be42709c8db0e4871db4bd468fb2bf22c0af3c430b1231176cbad23b46e18b75e674e2c0ec1a150278eb94da8a

data/bin/subcl

@@ -1,132 +1,12 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/Subcl'
-require 'optparse'
+require 'subcl'
 
 #don't throw a huge stacktrace
 trap("INT") {
-	puts "\n"
-	exit
+  puts "\n"
+  exit
 }
 
-options = { :tty => true }
+Runner.new.run ARGV
 
-if File.exist?('debug')
-	puts "DEBUGGING"
-	options[:debug] = true
-end
-
-#no idea how to get this variable from outside, so we'll just set it in the loop
-usage = nil
-OptionParser.new do |opts|
-	opts.banner = "Usage: subcl [options] command"
-	opts.separator %{
-Commands
-  list to terminal
-      search[-song|-album|-artist] <pattern>
-      ss|sl|sr <pattern>
-  clear queue and immediately start playing
-      play[-song|-album|-artist|-playlist] <pattern>
-      ps|pl|pr|pp <pattern>
-  clear queue and immediately start playing random songs
-			play-random <count, default 10>
-			r <count, default 10>
-  add to end of queue
-      queue-last[-song|-album|-artist|-playlist] <pattern>
-      ls|ll|lr|lp <pattern>
-  add after the current song
-      queue-next[-song|-album|-artist|-playlist] <pattern>
-      ns|nl|nr|np <pattern>
-  albumart-url [size] - print url of albumart to terminal, 
-      optionally with a specified image size
-
-Options }
-
-	usage = opts
-
-	opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
-		options[:verbose] = v
-	end
-	opts.on('-1', '--use-first', 'On multiple matches, use the first match instead of asking interactively') do
-		options[:interactive] = false
-	end
-	opts.on('-s', '--shuffle', "Shuffle playlist before queueing") do
-		options[:shuffle] = true
-	end
-	opts.on('-c', '--current', 'Use info currently playing song instead of commandline argument') do
-		options[:current] = true
-	end
-	opts.on('-h', '--help', 'Display this screen') do
-		puts opts
-		exit
-	end
-	opts.on("--version", "Print version information") do
-		puts Configs.new.app_version
-		exit
-	end
-
-end.parse!
-
-unless ARGV.size >= 1
-	puts usage
-	exit
-end
-
-unless system('tty -s')
-	#not running in a tty, so no use for interactivity
-	options[:tty] = false
-	options[:interactive] = false
-end
-
-subcl = Subcl.new options
-
-arg = ARGV[1,ARGV.length-1].join(" ") #put rest of args together so no quotes are required
-
-
-case ARGV[0].downcase
-when /^play-song$|^ps$/
-	subcl.queue(arg, :song, {:play => true, :clear => true})
-when /^play-artist$|^pr$/
-	subcl.queue(arg, :artist, {:play => true, :clear => true})
-when /^play-album$|^pl$/
-	subcl.queue(arg, :album, {:play => true, :clear => true})
-when /^play-playlist$|^pp$/
-	subcl.queue(arg, :playlist, {:play => true, :clear => true})
-when /^play-random$|^r$/
-	subcl.queue(arg, :randomSong, {:play => true, :clear => true})
-when /^queue-next-song$|^ns$/
-	subcl.queue(arg, :song, {:insert => true})
-when /^queue-next-artist$|^nr$/
-	subcl.queue(arg, :artist, {:insert => true})
-when /^queue-next-album$|^nl$/
-	subcl.queue(arg, :album, {:insert => true})
-when /^queue-next-playlist$|^np$/
-	subcl.queue(arg, :playlist, {:insert => true})
-when /^queue-last-song$|^ls$/
-	subcl.queue(arg, :song)
-when /^queue-last-artist$|^lr$/
-	subcl.queue(arg, :artist)
-when /^queue-last-album$|^ll$/
-	subcl.queue(arg, :album)
-when /^queue-last-playlist$|^lp$/
-	subcl.queue(arg, :playlist)
-when /^search-song$|^ss$/
-	subcl.searchSong(arg)
-when /^search-artist$|^sr$/
-	subcl.searchArtist(arg)
-when /^search-album$|^sl$/
-	subcl.searchAlbum(arg)
-when "albumart-url"
-	arg = nil if arg.empty?
-	puts subcl.albumartUrl(arg)
-when /^album-list$|^al$/
-	subcl.subsonic.albumlist
-when "test-notify"
-	subcl.testNotify
-else
-	if options[:tty] then
-		puts usage
-	else
-		subcl.notifier.notify "Unrecognized command"
-	end
-end

data/bin/subcl-api

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'subcl'
+
+if ARGV.empty?
+  puts "Usage: subcl-api <method> [opt1=val1 [opt2=val2]...]"
+  exit 1
+end
+
+api = SubsonicAPI.new(Configs.new)
+method = ARGV.shift
+method += ".view" unless method.end_with? ".view"
+params = Hash[ARGV.collect { |arg| arg.split('=') }]
+
+LOGGER.level = Logger::INFO
+
+begin
+  puts api.query(method, params)
+rescue SubclError => e
+  $stderr.puts e.message
+end
+

data/lib/subcl.rb

@@ -0,0 +1,14 @@
+require 'subcl/configs'
+require 'subcl/player'
+require 'subcl/notify'
+require 'subcl/picker'
+require 'subcl/runner'
+require 'subcl/song'
+require 'subcl/subcl'
+require 'subcl/subcl_error'
+require 'subcl/subsonic_api'
+
+require 'logger'
+
+LOGGER = Logger.new(STDERR)
+LOGGER.level = Logger::INFO

data/lib/subcl/configs.rb

@@ -0,0 +1,61 @@
+class Configs
+
+  attr_accessor :configs
+
+  REQUIRED_SETTINGS = %i{ server username password }
+  OPTIONAL_SETTINGS = %i{ max_search_results notify_method random_song_count }
+
+  def initialize(file = '~/.subcl')
+    @configs = {
+      :notifyMethod => "auto",
+    }
+
+    @filename = File.expand_path(file)
+    unless File.file?(@filename)
+      raise "Config file not found"
+    end
+
+    read_configs
+  end
+
+  def read_configs
+    settings = REQUIRED_SETTINGS + OPTIONAL_SETTINGS
+    open(@filename).each_line do |line|
+      next if line.start_with? '#'
+
+      key, value = line.split(' ')
+      key = key.to_sym
+      if settings.include? key
+        @configs[key] = value
+      else
+        LOGGER.warn { "Unknown setting: '#{key}'" }
+      end
+    end
+
+    REQUIRED_SETTINGS.each do |setting|
+      if @configs[setting].nil?
+        raise "Missing setting '#{setting}'"
+      end
+    end
+  end
+
+  def [](key)
+    raise "Undefined setting #{key}" unless @configs.has_key? key
+    @configs[key]
+  end
+
+  def []=(key, val)
+    settings = REQUIRED_SETTINGS + OPTIONAL_SETTINGS
+    settings.each do |name|
+      if key == name
+        @configs[key] = val
+        return
+      end
+    end
+    raise "Undefined setting #{key}"
+  end
+
+  def to_hash
+    @configs
+  end
+end

data/lib/subcl/notify.rb

@@ -0,0 +1,66 @@
+class Notify
+
+  SupportedMethods = %w{notify-send growlnotify awesome-client}
+  Icon = File.dirname(__FILE__) + "/../../share/icon.png"
+
+  def initialize(notifyMethod)
+    @method = nil
+
+    case notifyMethod
+    when nil
+      #do nothing
+    when "none"
+      #do nothing
+    when "auto"
+      #auto detect notifier lib
+      SupportedMethods.each do |method|
+        @binary = get_binary(method)
+        unless @binary.nil?
+          @method = method
+          break
+        end
+      end
+    else
+      #use specified binary
+      unless SupportedMethods.include? notifyMethod
+        raise ArgumentError, "Notification method #{notifyMethod} is not supported"
+      end
+      @binary = get_binary(notifyMethod)
+      @method = notifyMethod
+      raise ArgumentError, "No binary found for #{notifyMethod} in PATH" if @binary.nil?
+    end
+  end
+
+  def get_binary(name)
+    binary = `which #{name}`.chomp
+    if $?.success?
+      binary
+    else
+      nil
+    end
+  end
+
+  def notify(message)
+    case @method
+    when nil
+      #great, do nothing
+    when "notify-send"
+      system("notify-send --icon #{Icon} --urgency critical Subcl '#{message}'")
+    when "growlnotify"
+      system("growlnotify --image #{Icon} --title Subcl --message '#{message}'")
+    when "awesome-client"
+      naughtyCmd = %Q{
+        naughty.notify({
+          title='subcl',
+          text='#{message}',
+          icon='#{Icon}',
+          timeout = 10
+        })
+      }
+      naughtyCmd.gsub! "\n" " "
+
+      system(%Q{echo "#{naughtyCmd}" | awesome-client})
+    end
+  end
+end
+

data/lib/subcl/picker.rb

@@ -0,0 +1,63 @@
+class Picker
+  def initialize(ary)
+    @available = ary
+    if ary.empty? then
+      raise ArgumentError, "Cannot initialize Picker with an empty array!"
+    end
+  end
+
+  def pick
+    choices = {}
+
+    i = 1
+    @available.each do |elem|
+      choices[i] = elem
+      $stderr.print "[#{i}] "
+      yield(elem)
+      i = i + 1
+    end
+
+
+    begin
+      picks = []
+      valid = true
+      $stderr.print "Pick any: "
+
+      choice = $stdin.gets
+
+      return @available if choice.chomp == 'all'
+
+      choice.split(/[ ,]+/).each do |part|
+        possibleRange = part.split(/\.\.|-/)
+        if possibleRange.length == 2
+          start = possibleRange[0].to_i
+          stop = possibleRange[1].to_i
+          [start, stop].each do |num|
+            valid = validate(num)
+          end
+          (start..stop).each do |num|
+            picks << choices[num]
+          end
+
+        elsif validate(num = part.to_i)
+          picks << choices[num]
+        else
+          valid == false
+        end
+      end
+    end while !valid
+
+    return picks
+  end
+
+  def validate(pickNum)
+    #no -1, we start filling choices{} at 1
+    if pickNum > 0 and pickNum <= @available.length
+      true
+    else
+      $stderr.puts "Invalid pick. Try again."
+      false
+    end
+  end
+
+end

data/lib/subcl/player.rb

@@ -0,0 +1,54 @@
+require 'ruby-mpd'
+require 'delegate'
+
+class Player < SimpleDelegator
+  def initialize
+    #TODO add configs for host/port/security
+    @mpd = MPD.new
+    @mpd.connect
+    super(@mpd)
+  end
+
+  #insert: whether to add the song after the currently playing one
+  #instead of the end of the queue
+  def add(song, insert = false)
+    unless song[:stream_url]
+      raise ArgumentError, "argument has no :stream_url!"
+    end
+    LOGGER.debug { "Adding #{song['title']}: #{song[:stream_url]}. Insert: #{insert}" }
+    if insert then
+      pos = @mpd.current_song.pos + 1
+      @mpd.addid(song[:stream_url], pos)
+    else
+      @mpd.add(song[:stream_url])
+    end
+  end
+
+  #stops the player and clears the playlist
+  def clearstop
+    @mpd.stop
+    @mpd.clear
+  end
+
+  # if song has been playing for more than 4 seconds, rewind it to the start
+  # otherwise go to the previous song
+  def rewind
+    if @mpd.status[:elapsed] > 4
+      @mpd.seek 0
+    else
+      @mpd.previous
+    end
+  end
+
+  # if mpd is playing, pause it. Otherwise resume playback
+  def toggle
+    @mpd.pause = @mpd.playing? ? 1 : 0
+  end
+
+  def pause
+    @mpd.pause = 1
+  end
+
+  #TODO: might create a wrapper for current_song that makes API calls for artist, album, etc,
+  # in case mpd is unable to decode the metadata
+end

data/lib/subcl/runner.rb

@@ -0,0 +1,154 @@
+require 'optparse'
+
+class Runner
+  def initialize(options = {})
+    @options = {
+      :tty => true,
+      :out_stream => STDOUT,
+      :err_stream => STDERR,
+      :mock_player => nil,
+      :mock_api => nil
+    }.merge! options
+
+    #TODO refactor this away
+    if File.exist?('debug')
+      puts "DEBUGGING"
+      @options[:debug] = true
+    end
+  end
+
+  def parse_options! args
+    OptionParser.new do |opts|
+      opts.banner = "Usage: subcl [options] command"
+      opts.separator %{
+    Queue Commands
+      clear queue and immediately start playing
+          play[-song|-album|-artist|-playlist] <pattern>
+          ps|pl|pr|pp <pattern>
+      clear queue and immediately start playing random songs
+          play-random <count, default 10>
+          r <count, default 10>
+      add to end of queue
+          queue-last[-song|-album|-artist|-playlist] <pattern>
+          ls|ll|lr|lp <pattern>
+      add after the current song
+          queue-next[-song|-album|-artist|-playlist] <pattern>
+          ns|nl|nr|np <pattern>
+      albumart-url [size] - print url of albumart to terminal,
+          optionally with a specified image size
+
+    Playback Commands
+      play
+      pause
+      toggle (play when pause, pause when played)
+      stop
+      next
+      previous
+      rewind (get to start of song, or previous song when at start)
+
+    Options }
+
+      @usage = opts
+
+      opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+        @options[:verbose] = v
+      end
+      opts.on('-1', '--use-first', 'On multiple matches, use the first match instead of asking interactively') do
+        @options[:interactive] = false
+      end
+      opts.on('-s', '--shuffle', "Shuffle playlist before queueing") do
+        @options[:shuffle] = true
+      end
+      opts.on('-c', '--current', 'Use info currently playing song instead of commandline argument') do
+        @options[:current] = true
+      end
+      opts.on('-h', '--help', 'Display this screen') do
+        out_stream.puts opts
+        exit
+      end
+      opts.on("--version", "Print version information") do
+        out_stream.puts Configs.new[:app_version]
+        exit
+      end
+
+    end.parse! args
+  end
+
+  def run(args)
+    LOGGER.debug { "args = #{args}" }
+
+    parse_options!(args)
+
+    LOGGER.debug { "args = #{args}" }
+
+    unless args.size >= 1
+      @options[:err_stream].puts @usage
+      exit 3
+    end
+
+    unless system('tty -s')
+      #not running in a tty, so no use for interactivity
+      @options[:tty] = false
+      @options[:interactive] = false
+    end
+
+    subcl = Subcl.new @options
+
+    arg = args[1,args.length-1].join(" ") #put rest of args together so no quotes are required
+
+    command = args[0].downcase
+    case command
+
+    when /^play-song$|^ps$/
+      subcl.queue(arg, :song, {:play => true, :clear => true})
+    when /^play-artist$|^pr$/
+      subcl.queue(arg, :artist, {:play => true, :clear => true})
+    when /^play-album$|^pl$/
+      subcl.queue(arg, :album, {:play => true, :clear => true})
+    when /^play-playlist$|^pp$/
+      subcl.queue(arg, :playlist, {:play => true, :clear => true})
+    when /^play-random$|^r$/
+      subcl.queue(arg, :randomSong, {:play => true, :clear => true})
+    when /^queue-next-song$|^ns$/
+      subcl.queue(arg, :song, {:insert => true})
+    when /^queue-next-artist$|^nr$/
+      subcl.queue(arg, :artist, {:insert => true})
+    when /^queue-next-album$|^nl$/
+      subcl.queue(arg, :album, {:insert => true})
+    when /^queue-next-playlist$|^np$/
+      subcl.queue(arg, :playlist, {:insert => true})
+    when /^queue-last-song$|^ls$/
+      subcl.queue(arg, :song)
+    when /^queue-last-artist$|^lr$/
+      subcl.queue(arg, :artist)
+    when /^queue-last-album$|^ll$/
+      subcl.queue(arg, :album)
+    when /^queue-last-playlist$|^lp$/
+      subcl.queue(arg, :playlist)
+    when "albumart-url"
+      arg = nil if arg.empty?
+      @options[:out_stream].puts subcl.albumart_url(arg)
+    when /^album-list$|^al$/
+      subcl.albumlist
+    when "test-notify"
+      subcl.testNotify
+    else
+      begin
+        #pass through for player commands
+        subcl.send(command, [])
+      rescue NoMethodError
+        unknown(command)
+      end
+    end
+  end
+
+  def unknown(command)
+    if @options[:tty] then
+      @options[:err_stream].puts "Unknown command '#{command}'"
+      @options[:err_stream].puts @usage
+    else
+      subcl.notifier.notify "Unknown command '#{command}'"
+    end
+    exit 3
+  end
+end