rjl-itunes 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4fb59ab8673076305fb0813d5d13f0b075d831c6
+  data.tar.gz: c817756e947c2a24757e8d2a0024d199b188c246
+SHA512:
+  metadata.gz: db5ad5e51298f53168feac23361abd9e7e75874626675573e6c472ad9f8e56b6140a382d7c904b886e94b147ee4a060835710911122cdf3cd595e67fd1c5491b
+  data.tar.gz: 7a93638d0ecc070c885d70b7977dff897170757dbe2b64fce0eb0ec352763c5f016530ea73ebcd74811d6175121e7d6b179931eb60febaf2a879325e2914b4a3

data/.gitignore

@@ -0,0 +1,17 @@
+.DS_Store
+*.out
+*.db
+*.log
+/sandpit/
+
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+rjl-itunes-0.1.gem
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.yardopts

@@ -0,0 +1 @@
+- LICENSE.txt

data/Changelog.md

@@ -0,0 +1,13 @@
+## Change log
+
+Below is a complete listing of changes for each revision of Rjl_itunes
+
+### 0.1
+
+#### CHANGES SUMMARY
+
+*
+
+#### NOTES
+
+* 

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in wanker.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) Richard Lyon
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,88 @@
+# rjl-itunes 0.1
+
+`rjl-itunes` is a Ruby client for Apple's iTunes application. It's designed to support utilities that  make it both easier and more pleasant to maintain your collection of albums.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rjl-itunes'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rjl-itunes
+
+## Usage
+
+### Getting a list of albums
+
+    require 'rjl/itunes'
+
+    itunes = RJL::Itunes.new
+
+    itunes.albums.each do |album|
+        puts "#{album.album_artist}, '#{album.title}'"
+        album.tracks.each do |track|
+          puts track.title, track.genre
+        end
+    end
+
+### Updating an album's genre
+
+    album = itunes.albums[0]
+    album.genre = "Pop/Rock"
+
+See `/bin` for more uses. See 'Warning' below.
+
+## How it works
+
+`rjl-itunes` uses applescript to interact with your currently active Itunes library. Albums can be manipulated in a straightforward manner. Playlists and Playlist Folders can be created and destroyed, and albums added to them.
+
+### Genres
+
+Album genres are sometimes divided into sub-genres. [Allmusic.com](allmusic.com) refers to these sub-genres as 'styles', and can return several genres and styles for an album. iTunes provides the field `genre` for specifying genre and allows albums to be sorted by this field in the 'Albums' view. It also provides the field `grouping`, but only allows albums to be sorted by this via the column Browser in the 'Songs' view. There is no straightforward way of mapping multiple genres and styles into this these fields.
+
+`rjl-itunes` computes a single string to represents the album's genre from the genres and styles obtained from [Allmusic.com](allmusic.com). The frequency of each genre and style in the whole library is calculated. For each album that has more than one genre or style, the highest frequency genre and style is chosen and combined.
+
+### Tags
+
+Tags can be used to control how `rjl-itunes` interacts with your library. Tags are encoded as `[tag1][tag2]` in the track's `groupings` field in iTunes (this is likely to change in future versions).
+
+Reserved tags are as follows:
+
+* `[protected]`
+Track is excluded from processing. Use this if, for example, you have set your own genre and do not want `rjl-itunes` to change it.
+
+## Warning
+
+This might wreck your iTunes library in two ways. You might use commands that accidentally hose your library. Or the commands may have unknown side-effects. Always back up your library up first.
+
+`rjl-itunes` tries to be efficient in the way it interacts with iTunes, but Applescript is something of a dark art (to me). Expect scripts to mysteriously slow down, especially with large changes. [Ruby Progressbar](https://github.com/jfelchner/ruby-progressbar/wiki) is your friend.
+
+## Testing
+
+RSpec tests are provided. The tests will not work with your library, but I can't distribute mine because of copyright issues. You can edit the tests to suit your own library.
+
+## Changes
+
+### 17 March 2016 -- 0.1
+Initial release.
+
+## Acknowledgements
+
+`rjl-itunes` uses [Brendan Thompson's Ruby fork](https://github.com/BrendanThompson/rb-scpt) of the SF Project [appscript](http://appscript.sourceforge.net/rb-appscript/index.html) for accessing itunes via applescript.
+
+## Contacting me
+
+You can contact me at r i c h l y o n @ m a c . c o m
+
+## Copyright
+
+Copyright (c) 2016 Richard Lyon. See {file:LICENSE.txt LICENSE} for
+further details.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rjl-itunes"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/fix_genres.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+# fix_genres.rb
+
+# Ruby script to classify iTunes track genres. Retrieves genre and style
+# information from Allmusic.com, computes a genre, and sets track genre to it.
+# Insert [protected] in Groupings to exclude tracks from classification.
+
+# (c) Richard Lyon 15 March, 2016
+
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'rjl/itunes'
+
+# require 'metadata'
+require 'ruby-progressbar' # https://github.com/jfelchner/ruby-progressbar/wiki
+
+itunes = RJL::Itunes.new
+
+progressbar = ProgressBar.create(
+  :format => '%e |%b>>%i| %p%% %t',
+  :title => "Tracks",
+  :total => itunes.albums.count)
+
+# main loop - fix album genre unless tagged 'proteected'
+itunes.albums.each do |album|
+  metadata = RJL::Metadata.new( album: album )
+  progressbar.increment
+  unless album.protected?
+    new_genre = metadata.genre( album )
+    unless new_genre == ""
+      album.genre = metadata.genre( album )
+      progressbar.log "#{album.album_artist}, '#{album.title}' -> #{new_genre}"
+    end
+  end
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rjl/album.rb

@@ -0,0 +1,83 @@
+module RJL
+  # Represents an album in Apple's 'iTunes' application.
+  class Album
+
+    attr_reader   :album_artist
+    attr_reader   :title
+    attr_accessor :genre
+    attr_reader   :tracks
+
+    # Creates a new RJL::Album. Album properties are derived from the
+    # properties of the supplied tracks.
+    # @param [List of Track] tracks  the album tracks
+    def initialize( tracks: [])
+      @tracks = tracks
+    end
+
+    #  Album's artist e.g "Simply Red". Returns 'Various Artists' if more than one.
+    # @return [String artist name] the album artist if only one
+    # @return [String 'Various Artists'] if more than one
+    def album_artist
+      album_artist = nil
+      if unique?(@tracks, "artist" )
+        album_artist = @tracks[0].artist
+      else
+        album_artist = 'Various Artists'
+      end
+      return album_artist
+    end
+
+    # Album title e.g "Greatest Hits"
+    # @return [String] album title
+    def title
+      return @tracks[0].album
+    end
+
+    # Album genre e.g "Pop/Rock [Alternative/Indie Rock]"
+    # @return [String] album genre
+    def genre
+      if unique?( @tracks, "genre" )
+        return @tracks[0].genre
+      else
+        return 'mixed'
+      end
+    end
+
+    # @param [String] album genre
+    def genre=(str)
+      if !self.protected?
+        @tracks.each do |track|
+          track.genre = str
+        end
+      end
+    end
+
+    # The tracks in the album
+    # @return [List of Track] tracks the album tracks
+    def tracks
+      return @tracks
+    end
+
+    # Is the album protected from changes?
+    # @return [Boolean] true if it is
+    def protected?
+      protected = false
+      @tracks.each do |track|
+        if track.tags.include? 'protected'
+          protected = true
+          break
+        end
+      end
+      return protected
+    end
+
+    def to_s
+      puts "-"*50
+      puts "> #{self.album_artist}, '#{self.title}'"
+      @tracks.each do |track|
+        puts "  #{track.name}"
+      end
+      puts "="*50
+    end
+  end
+end

data/lib/rjl/itunes.rb

@@ -0,0 +1,179 @@
+require 'rjl'
+require 'rb-scpt' # https://github.com/BrendanThompson/rb-scpt
+include Appscript
+
+module RJL
+  # RJL_itunes::Itunes contains the public api for Itunes.
+  # @api public
+  # @example itunes = Itunes.new
+
+  class Itunes
+
+    attr_reader :version
+    attr_reader :albums
+
+    # Create a new RJL_itunes::Itunes. Can be called with a Playlist name to only
+    # get the tracks in that Playlist - useful for testing, and may be deprecated
+    # @param [String] playlist optional name of a Playlist to open
+    def initialize( playlist = nil )
+      @tracks = get_tracks( playlist )
+      @albums = get_albums( @tracks )
+      @playlists = fetch_playlists( kind: :none )
+      @playlist_folders = fetch_playlists( kind: :none )
+    end
+
+    # iTunes version number
+    # @return [String] the iTunes application version number.
+    def version
+      return app("iTunes").version.get
+    end
+
+    # The albums, or a single album
+    # @example
+    #   albums = itunes.albums
+    #   puts albums.count # => 5
+    #
+    #   album = itunes.albums(album_artist: "Simply Red", title: "Greatest Hits" )
+    #   puts album.genre # => "Pop/Rock"
+    # @param [String] artist the album artist
+    # @param [String] title the album title
+    # @return [List of Album]  if more than one album
+    # @return [Album] if only one album
+    def albums( album_artist: nil, title: nil )
+      albums = []
+      if album_artist.nil? && title.nil?
+        albums = @albums
+      elsif !album_artist.nil? && title.nil?
+        albums = @albums.select{ |album| album.album_artist == album_artist }
+      elsif album_artist.nil? && !title.nil?
+        albums = @albums.select{ |album| album.title == title }
+      elsif !album_artist.nil? and !title.nil?
+        albums = @albums.select{ |album| album.album_artist == album_artist && album.title == title}
+        albums = albums[0]
+      end
+      return albums
+    end
+
+    # Return a list of the playlists.
+    # @return [List of Playlist] the playlists
+    def playlists
+      return @playlists
+    end
+
+    # Get a playlist of the specified name. Raises error if more than one.
+    # @param playlist_name [String] The name of the playlist to get
+    # @return [Playlist] the named playlist
+    def playlist( playlist_name )
+      play_list = @playlists.select { |playlist| playlist.name == playlist_name }
+      if play_list.count == 1
+        return play_list[0]
+      else
+        raise "ERROR: #{play_list.count} playlists with name #{playlist_name}"
+      end
+    end
+
+    def create_playlist( playlist_name: "Playlist", track_list: nil )
+      playlist_obj = app("iTunes").make(
+        :new => :playlist,
+        :with_properties => {:name => playlist_name}
+        )
+      playlist = Playlist.new( playlist_obj )
+      playlist.tracks = track_list unless track_list.nil?
+      @playlists << playlist
+      return playlist
+    end
+
+    def destroy_playlist( playlist_name )
+      app("iTunes").sources["Library"].user_playlists[playlist_name].delete
+      # TODO remove from @playlists
+    end
+
+    def create_playlist_folder( folder_name: "untitled folder", playlists: nil )
+      playlist_obj = app("iTunes").make(
+        :new => :folder_playlist,
+        :with_properties => {:name => folder_name}
+        )
+      # TODO add playlists
+      # TODO make and add to @playlist_folders
+    end
+
+    def destroy_playlist_folder( folder_name: nil )
+      app("iTunes").sources["Library"].folder_playlists[folder_name].delete
+    end
+
+    private
+
+    # Get the tracks
+    # @param [String] playlist the name of a playlist to get tracks from
+    # @return [List of Track] the tracks
+    def get_tracks( playlist = nil)
+
+      track_list = []
+
+      if playlist.nil?
+        tracks = app("iTunes").playlists[1].tracks[its.video_kind.eq(:none)].get
+      else
+        tracks = app("iTunes").playlists[playlist].tracks[its.video_kind.eq(:none)].get
+      end
+
+
+      tracks.each do |track_obj|
+        # puts ">>> #{track_obj.class_.get}"
+        track_list << Track.new(track_obj)
+      end
+      return track_list
+    end
+
+    # Get the albums
+    # Three possibilities:
+    #   1. one album, one artist e.g. "Spiceworld, Spice Girls"
+    #   2. one album, multiple artists, not compilation  e.g. "Greatest Hits"
+    #   3. one album, multiple artists, compilation e.g. "The Firm"
+    # @param [List of Track] the tracks
+    # @return [List of Album] the albums
+    def get_albums( tracks )
+
+      album_list = []
+
+      # build hash of tracks with album name as key
+      album_hash = Hash.new { |h,k| h[k] = [] }
+      tracks.each do |track|
+        album_hash[track.album] << track
+      end
+
+      # split the album tracks by track artist
+      album_hash.each do |album_name, album_tracks|
+        artist_hash = Hash.new { |h,k| h[k] = [] }
+        album_tracks.each do |album_track|
+          artist_hash[album_track.artist] << album_track
+        end
+
+        if album_tracks[0].compilation?
+          album_list << Album.new( tracks: album_tracks)
+        else
+          artist_hash.each do |artist, tracks|
+            album_list << Album.new( tracks: tracks)
+          end
+        end
+
+      end
+
+      return album_list
+    end
+
+    def fetch_playlists( kind: :none )
+      playlist_list = []
+      reject_list = ["Music Videos", "Home Videos", "Books", "PDFs", "Audiobooks"]
+      playlists = app("iTunes").user_playlists[its.special_kind.eq(:none)].get
+      playlists.each do |playlist_obj|
+        playlist_list << Playlist.new( playlist_obj ) unless reject_list.include? (playlist_obj.name.get)
+      end
+      return playlist_list
+    end
+
+    def make_key( artist, album )
+      return "#{artist}__#{album}"
+    end
+
+  end
+end

data/lib/rjl/metadata.rb

@@ -0,0 +1,135 @@
+require 'allmusic'        # https://github.com/richardjlyon/allmusic
+require 'daybreak'        # http://propublica.github.io/daybreak/
+
+module RJL
+  # Gets metadata for an album from allmusic.com, caching the results. See
+  # [rjl-music](https://github.com/richardjlyon/allmusic) for details. Computes
+  # a simplified genre by selecting the highest frequency genre and style in the
+  # library and combining them in a string.
+  class Metadata
+
+    attr_reader :genres
+    attr_reader :styles
+    attr_reader :genre
+
+    # Create a new RJL::Metadata from the supplied Itunes object. This opens or
+    # creates a cache for storing metadata from allmusic to speed things up, and
+    # closes it on exit.
+    # @param [Itunes] itunes the itunes client to generate metadata for
+    def initialize( itunes )
+      @db = Daybreak::DB.new 'cache.db', :default => {}
+      @itunes = itunes
+      at_exit { @db.close }
+    end
+
+    # allmusic.com genres for album.
+    # @return [List of String] allmusic.com genres for album
+    def genres( album )
+      return get_metadata( album )[:genres]
+    end
+
+    # allmusic.com styles for album.
+    # @return [List of String] allmusic.com styles for album
+    def styles( album)
+      return get_metadata( album )[:styles]
+    end
+
+    # Compute a genre for album. Reduce genres and styles and construct a
+    # string from them.
+    # @param [Album] album
+    # @return [String] computed genre for album
+    def genre( album )
+      metadata = compute_metadata( album )
+      @genre = build_genre_string( metadata )
+      return @genre
+    end
+
+    private
+
+    # Compute the frequencies of each genre and style in the iTunes database
+    def compute_frequencies
+      genre_freq = Hash.new(0)
+      style_freq = Hash.new(0)
+
+      @db.each do |album_key, metadata|
+        unless album_key == ""
+          metadata[:genres].each{ |key| genre_freq[key] += 1}
+          metadata[:styles].each{ |key| style_freq[key] += 1}
+        end
+      end
+
+      return {genre_freq: genre_freq, style_freq: style_freq }
+    end
+
+    # Get genres and styles for the album from allmusic (or the cache, if it exists)
+    # @param [Album] the album
+    # @return [Hash] {genres: [List of String], styles: [List of String]}
+    def get_metadata( album )
+      genres = []
+      styles = []
+      album_key = make_key( album )
+      unless album_key.nil?
+        if @db[album_key].any?
+          genres = @db[album_key][:genres]
+          styles = @db[album_key][:styles]
+        else
+          allmusic = Allmusic.new album.album_artist, album.title
+          genres = allmusic.genres
+          styles = allmusic.styles
+          metadata = { :genres => genres, :styles => styles }
+          @db[album_key] = metadata
+        end
+      end
+
+      return {genres: genres, styles: styles}
+    end
+
+    # Reduce multiple genres and styles to a single genre and style.
+    # In this approach, select the genre and style with the highest frequency
+    # in the library.
+    def compute_metadata ( album )
+      genre_sort_hash = Hash.new
+      style_sort_hash = Hash.new
+
+      frequencies = compute_frequencies
+      self.genres( album ).each do |album_genre|
+        genre_sort_hash[album_genre] = frequencies[:genre_freq][album_genre]
+      end
+      genre_sort_list = genre_sort_hash.sort_by{ | genre, count | count }.reverse
+      genre, count = genre_sort_list[0]
+
+      self.styles( album ).each do |album_style|
+        style_sort_hash[album_style] = frequencies[:style_freq][album_style]
+      end
+      style_sort_list = style_sort_hash.sort_by{ | style, count | count }.reverse
+      style, count = style_sort_list[0]
+
+      return {genre: genre, style: style}
+    end
+
+    # Build the genre string e.g. "Jazz", "Guitar Jazz" => "Jazz [Guitar Jazz]"
+    def build_genre_string( metada )
+      genre = metada[:genre]
+      style = metada[:style]
+      computed_genre = case
+      when genre.nil? && style.nil?
+        ""
+      when !genre.nil? && style.nil?
+        genre
+      when genre.nil? && !style.nil?
+        style
+      else
+        "#{genre} [#{style}]"
+      end
+
+      return computed_genre
+    end
+
+    # @example
+    #    key = make_key( album ) # => "ABBA__Gold"
+    # @return [String] an album key
+    def make_key( album )
+      return "#{album.album_artist}__#{album.title}" unless album.nil?
+    end
+  end
+end

data/lib/rjl/playlist.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+#
+# = Playlist
+#
+# Copyright 2016 Richard Lyon
+# Distributed under the MIT license
+#
+module RJL
+  class Playlist
+    attr_reader :tracks
+    def initialize( playlist_obj )
+      @playlist_obj = playlist_obj
+      @folder = playlist_obj.special_kind.get
+      @tracks = get_tracks( playlist_obj )
+    end
+
+    def get_tracks( playlist_obj )
+      tracks = []
+      track_obj_list = playlist_obj.tracks.get
+      track_obj_list.each do |track_obj|
+        tracks << RJL::Track.new( track_obj )
+      end
+      return tracks
+    end
+
+    def name
+      return @playlist_obj.name.get
+    end
+    def name=(str)
+      @playlist_obj.name.set(str)
+    end
+
+    def tracks
+      return @tracks
+    end
+    def tracks=(track_list)
+      track_list.each do |track|
+        app("iTunes").library_playlists[1].tracks[its.database_ID.eq(track.database_id)].duplicate(:to => app.playlists[self.name])
+      end
+      @tracks = track_list
+    end
+  end
+end

data/lib/rjl/track.rb

@@ -0,0 +1,121 @@
+module RJL
+  class Track
+
+    def initialize track_obj
+      @track_obj = track_obj
+    end
+
+    def database_id
+      return @track_obj.database_ID.get
+    end
+
+    def name
+      return @track_obj.name.get
+    end
+    def name=(str)
+      @track_obj.name.set(str)
+    end
+
+    def artist
+      return @track_obj.artist.get
+    end
+    def artist=(str)
+      @track_obj.artist.set(str)
+    end
+
+    def sort_artist
+      return @track_obj.sort_artist.get
+    end
+    def sort_artist=(str)
+      @track_obj.sort_artist.set(str)
+    end
+
+    def album
+      return @track_obj.album.get
+    end
+    def album=(str)
+      @track_obj.album.set(str)
+    end
+
+    def sort_album
+      return @track_obj.sort_album.get
+    end
+    def sort_album=(str)
+      @track_obj.sort_album.set(str)
+    end
+
+    def album_artist
+      return @track_obj.album_artist.get
+    end
+    def album_artist=(str)
+      @track_obj.album_artist.set(str)
+    end
+
+    def sort_album_artist
+      return @track_obj.sort_album_artist.get
+    end
+    def sort_album_artist=(str)
+      @track_obj.sort_album_artist.set(str)
+    end
+
+    def composer
+      return @track_obj.composer.get
+    end
+    def composer=(str)
+      @track_obj.composer.set(str)
+    end
+
+    def grouping
+      return @track_obj.grouping.get
+    end
+    def grouping=(str)
+      @track_obj.grouping.set(str)
+    end
+
+    def genre
+      return @track_obj.genre.get
+    end
+    def genre=(str)
+      unless self.class == :shared_track
+        @track_obj.genre.set(str)
+      end
+    end
+
+    def comment
+      return @track_obj.comment.get
+    end
+    def comment=(str)
+      @track_obj.comment.set(str)
+    end
+
+    def disc_number
+      return @track_obj.disc_number.get
+    end
+    def disc_number=(int)
+      @track_obj.disc_number.set(int)
+    end
+
+    def compilation?
+      return @track_obj.compilation.get
+    end
+
+    def class
+      return @track_obj.class_.get
+    end
+
+    # Tags use square bracket markup in the 'groupings' field of iTunes
+    # @return [List of String] tags
+    def tags
+      tags = []
+      begin
+        tags = self.grouping.gsub("][", ",")[1..-2].split(',')
+      rescue
+      end
+      return tags
+    end
+
+    def to_s
+      puts "#{self.artist} - #{self.name}"
+    end
+  end
+end

data/lib/rjl/utils.rb

@@ -0,0 +1,8 @@
+# return true if tracks have only one value for 'parameter_name'
+def unique?( tracks, parameter_name )
+  values = []
+  tracks.each do |track|
+    values << track.send( parameter_name )
+  end
+  return values.uniq.length == 1
+end

data/lib/rjl/version.rb

@@ -0,0 +1,4 @@
+module RJL
+  # Version string
+  VERSION = '0.1.1'
+end

data/lib/rjl.rb

@@ -0,0 +1,7 @@
+require 'rjl/itunes'
+require 'rjl/album'
+require 'rjl/track'
+require 'rjl/playlist'
+require 'rjl/utils'
+require 'rjl/metadata'
+require 'rjl/version'

data/rjl-itunes.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+require File.expand_path('../lib/rjl/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.author         = 'Richard Lyon'
+  spec.email          = 'richard@richardlyon.net'
+  spec.summary        = %q{A ruby client for Apple's iTunes}
+  spec.description    = %q{Manage album track genre in the library  using data from allmusic.com}
+  spec.homepage       = 'https://github.com/richardjlyon/rjl-itunes'
+
+  spec.executables    = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.files          = `git ls-files`.split("\n")
+  spec.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.require_path   = 'lib'
+
+  spec.name           = 'rjl-itunes'
+  spec.version        = RJL::VERSION
+  spec.license        = 'MIT'
+
+  spec.add_development_dependency 'rake', '~> 10.4', '>= 10.4.2'
+  spec.add_runtime_dependency     'rjl-allmusic', '~> 0.5', '>= 0.5'
+  spec.add_runtime_dependency     'rb-scpt', '~> 1.0', '>= 1.0.1'
+  spec.add_runtime_dependency     'ruby-progressbar', '~> 1.7', '>= 1.7.5'
+  spec.add_runtime_dependency     'daybreak', '~> 0.3', '>= 0.3.0'
+
+end

data/spec/album_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe RJL::Album do
+
+  before :all do
+    @itunes = RJL::Itunes.new
+    TEST = "TEST " + Time.now.strftime("%d/%m/%Y %H:%M")
+  end
+
+  describe ".albums" do
+
+    context "when no album or artist are specified " do
+      it "returns all the albums" do
+        expect(@itunes.albums.count).to eq(24)
+      end
+    end
+
+    context "when an album artist is specified" do
+      it "returns all albums by that artist" do
+        album_artist = "Altan"
+        albums = @itunes.albums(album_artist: album_artist)
+        expect(albums.count).to eq(2)
+        albums.each do |album|
+          expect(album.album_artist).to eq(album_artist)
+        end
+      end
+    end
+
+    context "when an album title is specified" do
+      it "returns all albums with that title" do
+        album_title = "Greatest Hits"
+        albums = @itunes.albums(title: album_title)
+        expect(albums.count).to eq(2)
+        albums.each do |album|
+          expect(album.title).to eq(album_title)
+        end
+      end
+    end
+
+    context "when an album title and artist is specified" do
+      it "returns that album " do
+        album_artist = "Simply Red"
+        album_title = "Greatest Hits"
+        album = @itunes.albums(album_artist: album_artist, title: album_title )
+        expect(album.class).to eq RJL::Album
+        expect(album.title).to eq(album_title)
+        expect(album.album_artist).to eq(album_artist)
+      end
+    end
+
+    context "when a non-existent title and artist is specified" do
+      it "returns nil" do
+        album_artist = "sdfsadasd"
+        album_title = "asasasdfasdf"
+        album = @itunes.albums(album_artist: album_artist, title: album_title )
+        expect(album).to be_nil
+      end
+    end
+
+    context "when track artists in an album are all the same" do
+      it "returns as album artist the track artists" do
+        album_artist = "Simply Red"
+        album_title = "Greatest Hits"
+        album = @itunes.albums(album_artist: album_artist, title: album_title )
+        expect(album.album_artist).to eq(album_artist)
+      end
+    end
+
+    context "when track artists in an album are all not the same" do
+      it "returns as album artist 'Various Artists'" do
+        album_title = "The Firm"
+        album = @itunes.albums(title: album_title )[0]
+        expect(album.album_artist).to eq('Various Artists')
+      end
+    end
+
+    context "when I change the genre of an album" do
+      it "changes all the genres of the album's tracks" do
+        album = @itunes.albums(album_artist: "Simply Red", title: "Greatest Hits" )
+        old_genre = album.genre
+        expect(old_genre).to eq("Pop/Rock [Alternative/Indie Rock]")
+        album.genre = TEST
+        expect(album.tracks[0].genre).to eq(TEST)
+        album.genre = old_genre
+      end
+    end
+
+    context "when an album is protected" do
+      it "the genre can't be changed" do
+        album = @itunes.albums(album_artist: "Benny Green", title: "These Are Soulful Days" )
+        old_genre = album.genre
+        expect(old_genre).to eq("Jazz [Guitar Jazz]")
+        album.genre = TEST
+        expect(album.tracks[0].genre).to eq(old_genre)
+        album.genre = old_genre
+      end
+    end
+  end
+end

data/spec/metadata_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe RJL::Metadata do
+
+  before :all do
+    @itunes = RJL::Itunes.new
+    @metadata = RJL::Metadata.new( @itunes )
+  end
+
+  describe ".genres" do
+    context "when given an album" do
+      it "gets the album's genres from allmusic" do
+        album = @itunes.albums(album_artist: "Simply Red", title: "Greatest Hits" )
+        genres = @metadata.genres( album )
+        expected_genres = ["Pop/Rock", "R&B"]
+        expect(genres).to eq(expected_genres)
+      end
+    end
+  end
+
+  describe ".genre" do
+    context "when there is a valid album" do
+      it "gets a computed genre" do
+        album = @itunes.albums(album_artist: "Simply Red", title: "Greatest Hits" )
+        genre = @metadata.genre( album )
+        expect(genre).to eq("Pop/Rock [Alternative/Indie Rock]")
+      end
+    end
+    context "when there is not a valid album" do
+      it "returns an empty string" do
+        album = @itunes.albums(album_artist: "sdafadsf", title: "sadfsadf" )
+        genre = @metadata.genre( album )
+        expect(genre).to eq("")
+      end
+    end
+  end
+end

data/spec/playlist.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Playlist do
+  before :each do
+    @itunes = Itunes.new
+    @test_playlist_name = "TEST " + Time.now.strftime("%d/%m/%Y %H:%M")
+  end
+
+  describe ".create_playlist" do
+
+    context "when no tracks are given" do
+      it "creates an empty playlist" do
+        @itunes.create_playlist( playlist_name: @test_playlist_name )
+        playlist = @itunes.playlist( @test_playlist_name )
+        expect(playlist.name).to eq( @test_playlist_name )
+        @itunes.destroy_playlist( @test_playlist_name )
+      end
+    end
+
+    context "when tracks are given" do
+      it "creates a playlist with the tracks" do
+        some_tracks = @itunes.albums[2].tracks
+        @itunes.create_playlist( playlist_name: @test_playlist_name, track_list: some_tracks )
+        playlist = @itunes.playlist( @test_playlist_name )
+        expect(playlist.tracks.count).to eq(some_tracks.count)
+        @itunes.destroy_playlist( @test_playlist_name )
+      end
+    end
+  end
+
+  describe ".create_playlist_folder" do
+
+    context "when no playlists are given" do
+      it "creates an empty playlist folder" do
+        @itunes.create_playlist_folder( folder_name: @test_playlist_name )
+        # TODO check it exists
+        @itunes.destroy_playlist_folder( folder_name: @test_playlist_name )
+      end
+    end
+
+    context "when playlists are given" do
+      it "creates a playlist folder with the playlists" do
+        playlist = @itunes.create_playlist( playlist_name: @test_playlist_name )
+        @itunes.create_playlist_folder( folder_name: @test_playlist_name, playlists: [playlist] )
+        # TODO check it exists
+        @itunes.destroy_playlist_folder( folder_name: @test_playlist_name )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rjl'

data/spec/track_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe RJL::Track do
+  before :each do
+    @track = RJL::Itunes.new( "TEST" ).albums[0].tracks[0]
+  end
+
+  describe ".name" do
+    it "returns the correct name" do
+      expect(@track.name).to eql("Virgo")
+    end
+  end
+
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: rjl-itunes
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Richard Lyon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: rjl-allmusic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: rb-scpt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+- !ruby/object:Gem::Dependency
+  name: daybreak
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: Manage album track genre in the library  using data from allmusic.com
+email: richard@richardlyon.net
+executables:
+- console
+- fix_genres.rb
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- Changelog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/fix_genres.rb
+- bin/setup
+- lib/rjl.rb
+- lib/rjl/album.rb
+- lib/rjl/itunes.rb
+- lib/rjl/metadata.rb
+- lib/rjl/playlist.rb
+- lib/rjl/track.rb
+- lib/rjl/utils.rb
+- lib/rjl/version.rb
+- rjl-itunes.gemspec
+- spec/album_spec.rb
+- spec/metadata_spec.rb
+- spec/playlist.rb
+- spec/spec_helper.rb
+- spec/track_spec.rb
+homepage: https://github.com/richardjlyon/rjl-itunes
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A ruby client for Apple's iTunes
+test_files:
+- spec/album_spec.rb
+- spec/metadata_spec.rb
+- spec/playlist.rb
+- spec/spec_helper.rb
+- spec/track_spec.rb
+has_rdoc: