subcl 1.0.1 → 1.1.0

data/lib/subcl/song.rb

@@ -0,0 +1,14 @@
+class Song < Hash
+  def initialize(subsonic, attributes)
+    @subsonic = subsonic
+    self['type'] = 'song'
+    attributes.each do |key, val|
+      self[key] = val
+    end
+  end
+
+  #returns the streaming url for a song
+  def url
+    @subsonic.song_url(self['id'])
+  end
+end

data/lib/subcl/subcl.rb

@@ -0,0 +1,146 @@
+
+class Subcl
+  attr_accessor :player, :api, :notifier
+
+  def initialize(options = {})
+    @options = {
+      :interactive => true,
+      :tty => true,
+      :insert => false,
+      :out_stream => STDOUT,
+      :err_stream => STDERR
+    }.merge! options
+
+    @out = @options[:out_stream]
+    @err = @options[:err_stream]
+
+    begin
+      @configs = Configs.new
+    rescue => e
+      @err.puts "Error initializing config"
+      @err.puts e.message
+      exit 4
+    end
+
+    @player = @options[:mock_player] || Player.new
+
+    @api = @options[:mock_api] || SubsonicAPI.new(@configs)
+
+    @notifier = Notify.new @configs[:notify_method]
+
+    @display = {
+      :song => proc { |song|
+        @out.puts sprintf "%-20.20s %-20.20s %-20.20s %-4.4s", song[:title], song[:artist], song[:album], song[:year]
+      },
+      :album => proc { |album|
+        @out.puts sprintf "%-30.30s %-30.30s %-4.4s", album[:name], album[:artist], album[:year]
+      },
+      :artist => proc { |artist|
+        @out.puts "#{artist[:name]}"
+      },
+      :playlist => proc { |playlist|
+        @out.puts "#{playlist[:name]} by #{playlist[:owner]}"
+      },
+    }
+
+  end
+
+  def albumart_url(size = nil)
+    current = @player.current
+    @api.albumart_url(current, size) unless current.empty?
+  end
+
+  def queue(query, type, inArgs = {})
+    args = {
+      :clear => false, #whether to clear the playlist prior to adding songs
+      :play => false, #whether to start the player after adding the songs
+      :insert => false #whether to insert the songs after the current instead of the last one
+    }
+    args.merge! inArgs
+
+    if @options[:current]
+      query = case type
+              when :album
+                @player.current_song.album
+              when :artist
+                @player.current_song.artist
+              else
+                raise ArgumentError, "'current' option can only be used with albums or artists."
+              end
+    end
+
+    songs = case type
+            when :randomSong
+              begin
+                @api.random_songs(query)
+              rescue ArgumentError
+                raise ArgumentError, "random-songs takes an integer as argument"
+              end
+            else #song, album, artist, playlist
+              entities = @api.search(query, type)
+              entities = invoke_picker(entities, &@display[type])
+              @api.get_songs(entities)
+            end
+
+    no_matches if songs.empty?
+
+    @player.clearstop if args[:clear]
+
+    songs.shuffle! if @options[:shuffle]
+
+    songs.each do |song|
+      @player.add(song, args[:insert])
+    end
+
+    @player.play if args[:play]
+  end
+
+  def print(name, type)
+    entities = @api.search(name, type)
+    no_matches(type) if entities.empty?
+    entities.each do |entity|
+      @display[type].call(entity)
+    end
+  end
+
+  #print an error that no matches were found, then exit with code 2
+  def no_matches(what = nil)
+    if what
+      message = "No matching #{what}"
+    else
+      message = "No matches"
+    end
+
+    if @options[:tty]
+      @err.puts message
+    else
+      @notifier.notify(message)
+    end
+    exit 2
+  end
+
+  def testNotify
+    @notifier.notify("Hi!")
+  end
+
+  def albumlist
+    @api.albumlist.each do |album|
+      @display[:album].call(album)
+    end
+  end
+
+  #show an interactive picker that lists every element of the array using &display_proc
+  #The user can then choose one, many or no of the elements which will be returned as array
+  def invoke_picker(array, &display_proc)
+    return array if array.length <= 1
+    return [array.first] unless @options[:interactive]
+    return Picker.new(array).pick(&display_proc)
+  end
+
+  PLAYER_METHODS = %i{play pause toggle stop next previous rewind}
+  def method_missing(name, args)
+    raise NoMethodError unless PLAYER_METHODS.include? name
+    @player.send(name)
+  end
+
+end

data/lib/subcl/subcl_error.rb

@@ -0,0 +1 @@
+class SubclError < StandardError; end

data/lib/subcl/subsonic_api.rb

@@ -0,0 +1,239 @@
+###
+# This class interfaces with the subsonic API
+# http://www.subsonic.org/pages/api.jsp
+###
+
+require 'net/http'
+require 'rexml/document'
+require 'thread' #Do I need this?
+require 'cgi'
+include REXML
+
+class SubsonicAPI
+
+  REQUIRED_SETTINGS = %i{server username password}
+
+  def initialize(configs)
+    @configs = {
+      :appname => 'subcl',
+      :app_version => '0.0.4',
+      :proto_version => '1.9.0', #subsonic API protocol version
+      :max_search_results => 20,
+      :random_song_count => 10
+    }.merge! configs.to_hash
+
+    REQUIRED_SETTINGS.each do |setting|
+      unless @configs.key? setting
+        raise "Missing setting '#{setting}'"
+      end
+    end
+  end
+
+  #takes a list of albums or artists and returns a list of their songs
+  def get_songs(entities)
+    entities.collect_concat do |entity|
+      case entity[:type]
+      when :song
+        entity
+      when :album
+        album_songs(entity[:id])
+      when :artist
+        artist_songs(entity[:id])
+      when :playlist
+        playlist_songs(entity[:id])
+      else
+        raise "Cannot get songs for '#{entity[:type]}'"
+      end
+    end
+  end
+
+  #returns an array of songs for the given album id
+  def album_songs(id)
+    doc = query('getAlbum.view', {:id => id})
+    doc.elements.collect('subsonic-response/album/song') do |song|
+      decorate_song(song.attributes)
+    end
+  end
+
+  #returns an array of songs for the given artist id
+  def artist_songs(id)
+    doc = query('getArtist.view', {:id => id})
+    doc.elements.inject('subsonic-response/artist/album', []) do |memo, album|
+      memo += album_songs(album.attributes['id'])
+    end
+  end
+
+  #returns all songs from playlist(s) matching the name
+  def playlist_songs(id)
+    doc = query('getPlaylist.view', {:id => id})
+    doc.elements.collect('subsonic-response/playlist/entry') do |entry|
+      decorate_song(entry.attributes)
+    end
+  end
+
+  #returns all playlists
+  def all_playlists
+    doc = query('getPlaylists.view')
+    doc.elements.collect('subsonic-response/playlists/playlist') do |playlist|
+      {
+        :id => playlist.attributes['id'],
+        :name => playlist.attributes['name'],
+        :owner => playlist.attributes['owner'],
+        :type => :playlist
+      }
+    end
+  end
+
+
+  #returns all playlists matching name
+  #subsonic features no mechanism to search by playlist name, so this method retrieves
+  #all playlists and and filters them locally. This might become problematic when the server
+  #has a huge amount of playlists
+  def get_playlists(name)
+    name.downcase!
+    all_playlists().select do |playlist|
+      playlist[:name].downcase.include? name
+    end
+  end
+
+  #returns a list of albums from the specified type
+  #http://www.subsonic.org/pages/api.jsp#getAlbumList2
+  def albumlist(type = :random)
+    #TODO might want to add validation for the type here
+    doc = query('getAlbumList2.view', {:type => type})
+    doc.elements.collect('subsonic-response/albumList2/album') do |album|
+      album = album.attributes
+      album = Hash[album.collect { |key,val| [key.to_sym, val] }]
+      album[:type] = :album
+      album
+    end
+  end
+
+  def random_songs(count = @configs[:random_song_count])
+    #throws an exception if its not parseable to an int
+    count = Integer(count)
+
+    doc = query('getRandomSongs.view', {:size => count})
+    doc.elements.collect('subsonic-response/randomSongs/song') do |song|
+      decorate_song(song.attributes)
+    end
+  end
+
+  #takes the attributes of a song tag from the xml and applies the
+  #:type and :stream_url attribute
+  def decorate_song(attributes)
+    attributes = Hash[attributes.collect {|key, val| [key.to_sym, val]}]
+    attributes[:type] = :song
+    attributes[:stream_url] = stream_url(attributes[:id])
+    attributes
+  end
+
+  def search(query, type)
+    params = {
+      :query => query,
+      :songCount => 0,
+      :albumCount => 0,
+      :artistCount => 0,
+    }
+
+    max = @configs[:max_search_results]
+    case type
+    when :artist
+      params[:artistCount] = max
+    when :album
+      params[:albumCount] = max
+    when :song
+      params[:songCount] = max
+    when :playlist
+      return get_playlists(query)
+    when :any
+      #XXX or do we now use max/3 for each?
+      params[:songCount] = max
+      params[:albumCount] = max
+      params[:artistCount] = max
+    else
+      raise "Cannot search for type '#{type}'"
+    end
+
+    doc = query('search3.view', params)
+
+    %i{artist album song}.collect_concat do |entity_type|
+      doc.elements.collect("subsonic-response/searchResult3/#{entity_type}") do |entity|
+        entity = Hash[entity.attributes.collect{ |key, val| [key.to_sym, val]}]
+        entity[:type] = entity_type
+        if entity_type == :song
+          entity[:stream_url] = stream_url(entity[:id])
+        end
+        entity
+      end
+    end
+  end
+
+  def query(method, params = {})
+    uri = build_url(method, params)
+    LOGGER.debug { "query: #{uri} (basic auth sent per HTTP header)" }
+
+    req = Net::HTTP::Get.new(uri.request_uri)
+    req.basic_auth(@configs[:username], @configs[:password])
+    res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request(req)
+    end
+
+    doc = Document.new(res.body)
+
+    LOGGER.debug { "response: " + doc.to_s }
+
+    #handle error response
+    doc.elements.each('subsonic-response/error') do |error|
+      raise SubclError, "#{error.attributes["message"]} (#{error.attributes["code"]})"
+    end
+
+    #handle http error
+    case res.code
+    when '200'
+      return doc
+    else
+      msg = case res.code
+      when '401'
+        "HTTP 401. Might be an incorrect username/password"
+      else
+        "HTTP #{res.code}"
+      end
+      raise SubclError, msg
+    end
+  end
+
+  def build_url(method, params)
+    params[:v] = @configs[:proto_version]
+    params[:c] = @configs[:appname]
+    query = params.collect {|k,v| "#{k}=#{URI.escape(v.to_s)}"}.join('&')
+
+    URI("#{@configs[:server]}/rest/#{method}?#{query}")
+  end
+
+  #adds the basic auth parameters from the config to the URI
+  def add_basic_auth(uri)
+    uri.user = @configs[:username]
+    uri.password = @configs[:password]
+    return uri
+  end
+
+  #returns the streaming URL for the song, including basic auth
+  def stream_url(songid)
+    raise ArgumentError, "no songid!" unless songid
+    uri = build_url('stream.view', {:id => songid})
+    add_basic_auth(uri)
+  end
+
+  #returns the albumart URL for the song
+  def albumart_url(streamUrl, size = nil)
+    raise ArgumentError if streamUrl.empty?
+    id = CGI.parse(URI.parse(streamUrl).query)['id'][0]
+    params = {:id => id};
+    params[:size] = size unless size.nil?
+    add_basic_auth(
+      build_url('getCoverArt.view', params)
+    )
+  end
+
+end

metadata

@@ -1,55 +1,90 @@
 --- !ruby/object:Gem::Specification
 name: subcl
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Daniel Latzer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-03 00:00:00.000000000 Z
-dependencies: []
-description: ! ' This is a commandline client for the subsonic music server (www.subsonic.org).
-  It relies on mpd and mpc. '
+date: 2014-02-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: ruby-mpd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+description: " This is a commandline client for the subsonic music server (www.subsonic.org)
+  relying on mpd for playback. It supports searching for songs, albums, etc on the
+  commandline and adding them to mpds playlist. It also brings some commands to control
+  the playback."
 email: latzer.daniel@gmail.com
 executables:
 - subcl
+- subcl-api
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/Picker.rb
-- lib/Configs.rb
-- lib/Subcl.rb
-- lib/Subsonic.rb
-- lib/Mpc.rb
-- lib/Notify.rb
-- lib/Song.rb
 - bin/subcl
+- bin/subcl-api
+- lib/subcl.rb
+- lib/subcl/configs.rb
+- lib/subcl/notify.rb
+- lib/subcl/picker.rb
+- lib/subcl/player.rb
+- lib/subcl/runner.rb
+- lib/subcl/song.rb
+- lib/subcl/subcl.rb
+- lib/subcl/subcl_error.rb
+- lib/subcl/subsonic_api.rb
 - share/icon.png
 homepage: https://github.com/Tourniquet/subcl
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-requirements: []
+requirements:
+- mpd
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A commandline client for the subsonic music server
 test_files: []