sync_songs 0.0.1

data/lib/sync_songs/services/grooveshark_set.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+
+require 'grooveshark'
+require_relative '../song_set'
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  # Public: A set of Grooveshark songs.
+  class GroovesharkSet < SongSet
+
+    # Public: Creates a Grooveshark set by logging in to Grooveshark
+    # with the given user.
+    #
+    # user     - A String naming a Grooveshark user.
+    # password - A String naming the password of the user.
+    #
+    # Raises Grooveshark::InvalidAuthentication if authentication
+    #   fails.
+    # Raises SocketError if the network connection fails.
+    def initialize(user, password)
+      super()
+
+      # Setup a Grooveshark session.
+      @client = Grooveshark::Client.new
+      @session = @client.session
+
+      login(user, password)
+    end
+
+    # Public: Get the user's favorites from Grooveshark.
+    #
+    # Raises Grooveshark::GeneralError if the network connection fails.
+    #
+    # Returns self.
+    def favorites
+      @user.favorites.each { |s| add(Song.new(s.name, s.artist, s.album)) }
+      self
+    end
+
+    # Public: Add the songs in the given set to the user's favorite
+    # on Grooveshark.
+    #
+    # other - A SongSet to add from.
+    #
+    # Raises Grooveshark::GeneralError if the network connection fails.
+    #
+    # Returns an array of the songs that was added.
+    def addToFavorites(other)
+      songsAdded = []
+
+      other.each do |s|
+        songsAdded << s if s.id && @user.add_favorite(s.id)
+      end
+
+      songsAdded
+    end
+
+    # Public: Searches for the given song set at Grooveshark.
+    #
+    # other         - SongSet to search for.
+    # strict_search - True if search should be strict (default: true).
+    #
+    # Raises Grooveshark::GeneralError if the network connection
+    #   fails.
+    # Raises Grooveshark::ApiError if token is invalid.
+    #
+    # Returns a SongSet.
+    def search(other, strict_search = true)
+      result = SongSet.new
+
+      # Search for songs that are not already in this set and return
+      # them if they are sufficiently similar.
+      other.each do |song|
+        @client.search_songs(song.to_search_term).each do |s|
+          other = Song.new(s.name, s.artist, s.album,
+                           Float(s.duration), s.id)
+
+          if strict_search
+            next unless song.eql?(other)
+          else
+            next unless song.similar?(other)
+          end
+          result << other
+        end
+      end
+      result
+    end
+
+    private
+
+    # Internal: Tries to login to Grooveshark with the given user.
+    #
+    # user     - A String naming a Grooveshark user.
+    # password - A String naming the password of the user.
+    #
+    # Raises Grooveshark::InvalidAuthentication if authentication
+    #   fails.
+    def login(user, password)
+      @user = @client.login(user, password)
+    rescue Grooveshark::InvalidAuthentication => e
+      raise Grooveshark::InvalidAuthentication, "#{e.message} An "\
+      'authenticated user is required for getting data from '\
+      'Grooveshark'
+      raise
+    end
+  end
+end

data/lib/sync_songs/services/lastfm_cli.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+require 'highline/import'
+require 'launchy'
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  # Public: Command-line interface for a Last.fm set of songs.
+  class LastfmCLI
+
+    # Public: Creates a CLI.
+    #
+    # controller - A Controller for a Last.fm set of songs.
+    # ui         - General user interface to use.
+    def initialize(controller, ui)
+      @controller = controller
+      @ui = ui
+    end
+
+    # Public: Asks for a String naming a Last.fm API key and returns
+    # it.
+    def apiKey
+      ask("Last.fm API key for #{@controller.user}? ") { |q| q.echo = false }
+    end
+
+    # Public: Asks for a String naming a Last.fm API key and returns
+    # it.
+    def apiSecret
+      ask('Last.fm API secret for '\
+          "#{@controller.user}? ") { |q| q.echo = false }
+    end
+
+    # Public: Asks the user to authorize this tool with Last.fm and
+    # wait for input.
+    #
+    # url - A String naming a URL to use for authorization.
+    def authorize(url)
+      Launchy.open(url)
+      agree('A page asking for authorization with Last.fm should be '\
+            'open in your web browser. You need to approve it '\
+            'before proceeding. Continue? (y/n) ') do |q|
+        q.responses[:not_valid] = 'Enter y for yes or n for no'
+      end
+    end
+  end
+end

data/lib/sync_songs/services/lastfm_controller.rb

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+
+require_relative 'lastfm_cli'
+require_relative 'lastfm_set'
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  # Public: Controller for a Last.fm set of songs.
+  class LastfmController < ServiceController
+
+    # Public: Hash of types of services associated with what they
+    # support.
+    SERVICES = {loved: :rw}
+
+    # Public: Creates a controller.
+    #
+    # user   - A String naming the user name or the file path for the
+    #          service.
+    # name   - A String naming the name of the service.
+    # type   - A String naming the service type.
+    # ui     - General user interface to use.
+    def initialize(user, name, type, ui)
+      super(user, name, type, ui)
+
+      @service_ui = LastfmCLI.new(self, @ui)
+      @set = LastfmSet.new(@service_ui.apiKey,
+                           @service_ui.apiSecret,
+                           @user)
+    end
+
+    # Public: Wrapper for Last.fm loved songs.
+    def loved
+      @set.loved
+    rescue ArgumentError, EOFError, Lastfm::ApiError, SocketError, Timeout::Error => e
+      @ui.fail("Failed to get #{type} from #{name} #{user}\n"\
+               "#{e.message.strip}", 1, e)
+    end
+
+    # Public: Wrapper for adding to Last.fm loved songs. Authorizes
+    # the session before adding songs.
+    #
+    # other - A SongSet to add from.
+    def addToLoved(other)
+      # TODO Store token somewhere instead and only call URL if there is no
+      # stored token.
+      authorized = nil
+
+      @mutex.synchronize do
+        authorized = @service_ui.authorize(@set.authorizeURL)
+      end
+
+      if authorized
+        begin
+          @set.authorizeSession
+          @set.addToLoved(other)
+        rescue Lastfm::ApiError, SocketError => e
+        @ui.fail("Failed to add #{type} to #{name} #{user}\n"\
+                 "#{e.message.strip}", 1, e)
+        end
+      end
+    end
+
+    # Public: Wrapper for searching for the given song set at Last.fm.
+    #
+    # other         - SongSet to search for.
+    # limit         - Maximum limit for search results (default:
+    #                 @set.limit).
+    # strict_search - True if search should be strict (default: true).
+    #
+    # Returns a SongSet.
+    def search(other, limit = @set.limit, strict_search = true)
+      @set.search(other, limit, strict_search)
+    rescue ArgumentError, EOFError, Errno::EINVAL, SocketError,
+      Timeout::Error  => e
+      @ui.fail("Failed to search #{name} #{user}\n#{e.message.strip}", 1, e)
+    end
+  end
+end

data/lib/sync_songs/services/lastfm_set.rb

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+
+require 'lastfm'
+require_relative '../song_set'
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  # Public: A set of Grooveshark songs.
+  class LastfmSet < SongSet
+
+    # Public: Default limit for API calls.
+    DEFAULT_LIMIT = 1_000_000
+
+    attr_reader :limit
+
+    # Public: Creates a Last.fm set by logging in to Last.fm with the
+    # specified user.
+    #
+    # api_key    - Last.fm API key.
+    # api_secret - Last.fm secret for API key.
+    # username   - The username of the Last.fm user.
+    # limit      - The maximum number of results from calls (default:
+    #              DEFAULT_LIMIT).
+    def initialize(api_key, api_secret, username = nil, limit = DEFAULT_LIMIT)
+      super()
+      @api_key = api_key
+      @username = username
+      @lastfm = Lastfm.new(api_key, api_secret)
+      @limit = limit
+    end
+
+    # Public: Get the user's loved songs from Last.fm. The reason this
+    # takes ages to complete is that it first has to search tracks to
+    # find them and then get info for each found track to be able to
+    # get the album title.
+    #
+    # username - The username of the user to authenticate (default:
+    #            @username).
+    #
+    # limit    - The maximum number of loved tracks to get (default:
+    #            @limit).
+    #
+    # Raises ArgumentError from xml-simple some reason.
+    # Raises EOFError when end of file is reached.
+    # Raises Lastfm::ApiError if the username is invalid or there is a
+    #   temporary error.
+    # Raises SocketError if the connection fails.
+    # Raises Timeout::Error if the connection fails.
+    #
+    # Returns self.
+    def loved(username = @username, limit = @limit)
+      lov = @lastfm.user.get_loved_tracks(user: username,
+                                          api_key: @api_key,
+                                          limit: limit)
+
+      if lov                                # Remove if API is fixed.
+        lov = [lov] unless lov.is_a?(Array) # Remove if API is fixed.
+
+        lov.each do |l|
+
+          # Get metadata for loved track.
+          s = @lastfm.track.get_info(track: l['name'],
+                                     artist: l['artist']['name'])
+
+          add(Song.new(s['name'], s['artist']['name'],
+                       # Not all Last.fm tracks belong to an album.
+                       s.key?('album') ? s['album']['title'] : nil,
+                       Float(s['duration']) / 1_000, s['id']))
+        end
+      end
+
+      self
+    end
+
+    # Public: Add the songs in the given set to the given user's loved
+    # songs on Last.fm. This method requires an authorized session
+    # which is gotten by getting the user to authorize via the url
+    # given by authorizeURL and then running authorize.
+    #
+    # other - A SongSet to add from.
+    #
+    # Raises Lastfm::ApiError if the Last.fm token has not been
+    #   authorized or if the song is not recognized.
+    # Raises SocketError if the network connection fails.
+    #
+    # Returns an array of the songs that was added.
+    def addToLoved(other)
+      songsAdded = []
+
+      if @lastfm.session
+        other.each do |s|
+          songsAdded << s if @lastfm.track.love(track: s.name,
+                                                artist: s.artist)
+        end
+      end
+
+      songsAdded
+    end
+
+    # Public: Searches for the given song set at Last.fm. The reason
+    # this takes ages to complete is that it first has to search
+    # tracks to find them and then get info for each found track to be
+    # able to get the album title.
+    #
+    # other         - SongSet to search for.
+    # limit         - Maximum limit for search results (default:
+    #                 @limit).
+    # strict_search - True if search should be strict (default: true).
+    #
+    # Raises ArgumentError from xml-simple some reason.
+    # Raises EOFError when end of file is reached.
+    # Raises Errno::EINVAL if the network connection fails.
+    # Raises SocketError if the network connection fails.
+    # Raises Timeout::Error if the network connection fails.
+    #
+    # Returns a SongSet.
+    def search(other, limit = @limit, strict_search = true)
+      result = SongSet.new
+
+      # Search for songs and return them if they are sufficiently
+      # similar.
+      other.each do |song|
+        # The optional parameter artist for track.search does not seem
+        # to work so it is not used.
+        search_result = @lastfm.track.search(track: song.to_search_term,
+                                      limit: limit)['results']['trackmatches']['track'].compact
+
+        found_songs = []
+
+        search_result.each do |r|
+          found_songs << @lastfm.track.get_info(track: r['name'],
+                                                artist: r['artist'])
+        end
+
+        unless found_songs.empty?
+          found_songs.each do |f|
+            other = Song.new(f['name'], f['artist']['name'],
+                             # Not all Last.fm tracks belong to an album.
+                             f.key?('album') ? f['album']['title'] : nil,
+                             Float(f['duration']) / 1_000, f['id'])
+            if strict_search
+              next unless song.eql?(other)
+            else
+              next unless song.similar?(other)
+            end
+            result << other
+          end
+        end
+      end
+      result
+    end
+
+    # Public: Return an URL for authorizing a Last.fm session.
+    #
+    # Raises SocketError if the network connection fails.
+    def authorizeURL
+      @token = @lastfm.auth.get_token
+      "http://www.last.fm/api/auth/?api_key=#@api_key&token=#@token"
+    end
+
+
+    # Public: Authorize a Last.fm session (needed for certain calls to
+    # Last.fm, such as addToLoved). Get the user to authorize via the
+    # URL returned by authorizeURL before calling this method.
+    #
+    # Raises SocketError if the network connection fails.
+    def authorizeSession
+      if @token
+        @lastfm.session = @lastfm.auth.get_session(token: @token)['key']
+      else
+        fail StandardError, "Before calling #{__method__} a token "\
+        'must be authorized, e.g. by calling authorizeURL and '\
+        'getting the user to authorize via that URL'
+      end
+    end
+  end
+end

data/lib/sync_songs/services/service_controller.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+
+require_relative '../song_set'
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  # Public: Controller for a service.
+  class ServiceController
+
+    attr_reader :user, :name, :type, :set, :ui
+    attr_accessor :action, :strict_search, :interactive, :search_result,
+    :songs_to_add, :added_songs
+
+    # Public: Create a service controller.
+    #
+    # controller - The main controller.
+    # user       - A String naming the user name or the file path for
+    #              the service.
+    # name       - A String naming the name of the service.
+    # type       - A String naming the service type.
+    def initialize(controller, user, name, type)
+      @controller = controller
+      @user = user
+      @name = name
+      @type = type
+      @action = action
+      @ui = @controller.ui      # General user interface to use.
+      @mutex = @controller.mutex
+
+      @search_result = SongSet.new
+      @songs_to_add = SongSet.new
+    end
+
+    # Public: Returns true if this service controller is equal to the
+    # compared service controller. This method and hash are defined so
+    # that Sets of service controllers behave reasonably, i.e. service
+    # controller for the same user/file, name and type should be
+    # treated as equal.
+    #
+    # other - Service controller that this song is compared with.
+    def eql?(other)
+      user.casecmp(other.user) == 0 &&
+        name.casecmp(other.name) == 0 &&
+        type.casecmp(other.type) == 0
+    end
+
+    # Public: Makes a hash value for this object and returns it. This
+    # method and eql? are defined so that Sets of service controllers
+    # behave reasonably, i.e. service controller for the same
+    # user/file, name and type should be treated as equal.
+    def hash
+      [user, name, type].join('').downcase.hash
+    end
+  end
+end

data/lib/sync_songs/song.rb

@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  # Public: Stores a song.
+  class Song
+    include Comparable
+
+    # Public: Returns the name of the song and the artist performing the
+    # song.
+    attr_reader :name, :artist, :album, :duration, :id
+
+    # Public: Creates a song. Leading and trailing whitespace is
+    # removed as it has no semantic significance for songs.
+    #
+    # name     - The String name of the song.
+    # artist   - The String artist performing the song.
+    # album    - The String album the song is found on (default: nil).
+    # duration - The Float duration of the song in seconds (default:
+    #            nil).
+    # id       - An String id of for the song (default: nil).
+    #            Is service relative.
+    #
+    # Raises ArgumentError if the artist or the name is empty.
+    def initialize(name, artist, album = nil, duration = nil, id = nil)
+      @name     = name.strip
+      @artist   = artist.strip
+      @album    = album.strip if album
+      @duration = Float(duration) if duration
+      @id       = id
+
+      if @name.empty? || @artist.empty?
+        fail ArgumentError, 'Songs must have a non-empty name and artist'
+      end
+    end
+
+    # Public: Comparison -- returns -1 if other song is greater than,
+    # 0 if other song equal to and +1 if other song is less than this
+    # song.
+    #
+    # other - Song that this song is compared with.
+    def <=>(other)
+      comp = name.casecmp(other.name)
+
+      comp = artist.casecmp(other.artist) if comp == 0
+
+      if comp == 0 && album && other.album
+        comp = album.casecmp(other.album)
+      end
+
+      comp
+    end
+
+    # Public: Returns true if this song is equal to the compared song.
+    #
+    # other - Song that this song is compared with.
+    def eql?(other)
+      (self <=> other) == 0
+    end
+
+    # Public: Returns true if this song includes the other song.
+    #
+    # other - Song that this song is compared with.
+    def include?(other)
+      name.downcase.include?(other.name.downcase) &&
+        artist.downcase.include?(other.artist.downcase)
+    end
+
+    # Public: Returns true if this song is similar to the compared
+    # song.
+    #
+    # other - Song that this song is compared with.
+    def similar?(other)
+      # Since the other song is more probably a song from a search in
+      # a big database with many versions of every song the following
+      # test order should perform better.
+      other.include?(self) || include?(other)
+    end
+
+    # Public: Makes a hash value for this object and returns it.
+    def hash
+      [artist, name, album].compact.join('').downcase.hash
+    end
+
+    # Public: Returns the song formatted as a string.
+    def to_s
+      s = [artist, name, album].compact
+      s << Time.at(duration).utc.strftime('%H:%M:%S') if duration
+      s.join(' - ')
+    end
+
+    # Public: Returns the song formatted as appropriately for use in a
+    # search query.
+    def to_search_term
+      # When including album search on Last.fm barely finds anything.
+      [artist, name].compact.join(' ')
+    end
+  end
+end

data/lib/sync_songs/song_set.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+require 'delegate'
+require 'set'
+require_relative 'song'
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  # Public: A set of songs.
+  class SongSet < SimpleDelegator
+
+    # Public: Creates a new set.
+    #
+    # *songs - If songs are provided they are added to the set
+    #          (default: nil).
+    def initialize(*songs)
+      @songs = Set.new
+      super(@songs)
+      songs.each { |song| @songs << song } if songs
+    end
+
+    # Public: Returns songs that are in the given list but not in this
+    # list, i.e. songs that are exclusive to the given list.
+    #
+    # other - SongList to compare this list to.
+    def exclusiveTo(other)
+      other - @songs
+    end
+  end
+end

data/lib/sync_songs/version.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+# Public: Classes for syncing sets of songs.
+module SyncSongs
+  VERSION = '0.0.1'
+end

data/lib/sync_songs.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+require 'rubygems'
+require 'bundler/setup'
+
+PATH = './sync_songs/'
+SERVICES_PATH = "#{PATH}services/"
+
+# Load the library.
+require_relative "#{PATH}cli"
+require_relative "#{PATH}controller"
+require_relative "#{PATH}version"
+
+require_relative "#{SERVICES_PATH}service_controller"
+
+# Load sub classes of ServiceController.
+require_relative "#{SERVICES_PATH}csv_controller"
+require_relative "#{SERVICES_PATH}grooveshark_controller"
+require_relative "#{SERVICES_PATH}lastfm_controller"
+
+# Internal: A sync direction.
+Struct.new('Direction',
+           # Internal: An array of two keys two services to sync
+           # between.
+           :services,
+           # Internal: The direction to sync in.
+           :direction)

data/plan.org

@@ -0,0 +1,17 @@
+# -*- mode:org; indent-tabs-mode:nil; tab-width:2 -*-
+#+title: Plan
+
+* TODO Plan
+- Use https://gist.github.com/fnichol/1912050
+- Remove =lov = [lov] unless lov.is_a?(Array)= from last_fm_set.rb if https://github.com/youpy/ruby-lastfm/issues/52 is fixed.
+- Go through all documentation and fix it.
+- Fix all warnings upstream.
+- Add tests for all new things.
+  - Add tests for songs with album.
+- Use watir for testing last.fm auth.
+- Add examples to documentation as in the Tomdoc specification.
+- Add argument types to documentation, from Tomdoc: "The expected type (or types) of each argument SHOULD be clearly indicated in the explanation. When you specify a type, use the proper classname of the type (for instance, use 'String' instead of 'string' to refer to a String type)."
+- Make singleton classes that can carry API keys and passwords for a particular user so that one can check if such an instance is running and use it rather than asking the user for the same password again.
+- Consider adding support for the following: librefm, rhythmbox, gogoyoko, jamendo.
+- Use YAML.dump and lib tmpdir to store Last.fm token?
+- Integrate with Travis CI to automate tests.

data/sync_songs.gemspec

@@ -0,0 +1,25 @@
+# -*- coding: utf-8; mode: ruby -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sync_songs/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'sync_songs'
+  gem.version       = SyncSongs::VERSION
+  gem.authors       = ['Sleft']
+  gem.email         = ['fte08eas@student.lu.se']
+  gem.description   = 'Sync sets of songs'
+  gem.summary       = 'SyncSongs'
+  gem.homepage      = 'https://github.com/Sleft/sync_songs'
+
+  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_runtime_dependency 'grooveshark', ['~>0.2.7']
+  gem.add_runtime_dependency 'highline', ['~>1.6.16']
+  gem.add_runtime_dependency 'lastfm', ['~>1.17.0']
+  gem.add_runtime_dependency 'launchy', ['~>2.2.0']
+  gem.add_runtime_dependency 'thor', ['~>0.18.1']
+end