kagu 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c8cfd404d70114c5ab0432216ae8d4b1e978357c
+  data.tar.gz: c07c6fa355ab50c7bd1033de65cd4495b5fb11db
+SHA512:
+  metadata.gz: 23c65772592525da40e5ebc004f6a98f812bc91da10d88a1301de5b925bbee511e88491615a20555e39a0538390a545c06ca2b34dc71242d7dd5757c10e683f5
+  data.tar.gz: d0c149fb4d705457b6b4a4760c0b9519b18ad77b8743f6597a389633dd00b5f2c3eaba33ec5279d94efc73e25143e7eaa0be3fe1de5341229575674a18b4bc2a

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.bundle
+.ruby-version
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--order random

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Alexis Toulotte
+
+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.mdown

@@ -0,0 +1,28 @@
+# Kagu
+
+Ruby API to manage iTunes tracks and playlists.
+
+## Installation
+
+Just add this into your `Gemfile`:
+
+    gem 'kagu'
+
+Then, just run `bundle install`.
+
+## Example
+
+    library = Kagu::Library.new
+
+    library.tracks.each do |track|
+      puts track.artist
+    end
+
+    library.playlists.each do |playlist|
+      puts "#{playlist.name}: #{playlist.tracks.count}"
+    end
+
+## Executing test suite
+
+This project is fully tested with [Rspec 3](http://github.com/rspec/rspec).
+Just run `bundle exec rake` (after a `bundle install`).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+
+Bundler::GemHelper.install_tasks
+
+desc 'Default: runs specs.'
+task default: :spec
+
+desc 'Run all specs in spec directory.'
+RSpec::Core::RakeTask.new(:spec)

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/kagu.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |s|
+  s.name = 'kagu'
+  s.version = File.read("#{File.dirname(__FILE__)}/VERSION").strip
+  s.platform = Gem::Platform::RUBY
+  s.author = 'Alexis Toulotte'
+  s.email = 'al@alweb.org'
+  s.homepage = 'https://github.com/alexistoulotte/kagu'
+  s.summary = 'API for iTunes'
+  s.description = 'API to manage iTunes tracks and playlists'
+  s.license = 'MIT'
+
+  s.rubyforge_project = 'kagu'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'activesupport', '>= 4.1.0', '< 4.2.0'
+  s.add_dependency 'htmlentities', '>= 4.3.0', '< 4.4.0'
+
+  s.add_development_dependency 'byebug', '>= 3.2.0', '< 3.3.0'
+  s.add_development_dependency 'rake', '>= 10.3.0', '< 10.4.0'
+  s.add_development_dependency 'rspec', '>= 3.0.0', '< 3.1.0'
+end

data/lib/kagu/attributes_initializer.rb

@@ -0,0 +1,12 @@
+module AttributesInitializer
+
+  def initialize(attributes = {})
+    attributes.each do |name, value|
+      send("#{name}=", value) if respond_to?("#{name}=", true)
+    end
+    self.class.const_get(:MANDATORY_ATTRIBUTES).each do |attribute|
+      raise("#{self.class}##{attribute} is mandatory") if send(attribute).nil?
+    end
+  end
+
+end

data/lib/kagu/library.rb

@@ -0,0 +1,30 @@
+module Kagu
+
+  class Library
+
+    PATH = "#{ENV['HOME']}/Music/iTunes/iTunes Music Library.xml"
+
+    attr_reader :path
+
+    def initialize(path = PATH)
+      self.path = path
+    end
+
+    def playlists
+      Playlists.new(self)
+    end
+
+    def tracks
+      Tracks.new(self)
+    end
+
+    private
+
+    def path=(path)
+      raise IOError.new("No such file: #{path.inspect}") unless File.file?(path)
+      @path = path
+    end
+
+  end
+
+end

data/lib/kagu/playlist.rb

@@ -0,0 +1,35 @@
+module Kagu
+
+  class Playlist
+
+    MANDATORY_ATTRIBUTES = %w(name)
+
+    include AttributesInitializer
+    include Enumerable
+
+    attr_reader :name, :tracks
+
+    delegate :each, to: :tracks
+
+    def to_s
+      name
+    end
+
+    private
+
+    def itunes_name=(value)
+      @@html_entities ||= HTMLEntities.new
+      self.name = @@html_entities.decode(value)
+    end
+
+    def name=(value)
+      @name = value.to_s.squish.presence
+    end
+
+    def tracks=(values)
+      @tracks = [values].flatten.select { |value| value.is_a?(Track) }
+    end
+
+  end
+
+end

data/lib/kagu/playlists.rb

@@ -0,0 +1,49 @@
+module Kagu
+
+  class Playlists
+
+    include Enumerable
+
+    attr_reader :library
+
+    def initialize(library)
+      @library = library.is_a?(Library) ? library : raise("#{self.class}#library must be a library, #{library.inspect} given")
+    end
+
+    def each(&block)
+      return unless block_given?
+      tracks = {}.tap do |tracks|
+        library.tracks.each { |track| tracks[track.id] = track }
+      end
+      File.open(library.path, 'r') do |file|
+        begin
+          line = file.readline.strip
+        end while !line.starts_with?('<key>Playlists</key>')
+        playlist_name = nil
+        playlist_tracks = []
+        while !file.eof? && (line = file.readline.strip)
+          if line == '<key>Master</key><true/>'
+            playlist_name = nil
+            next
+          elsif line == '</array>'
+            yield(Playlist.new(itunes_name: playlist_name, tracks: playlist_tracks)) if playlist_name.present?
+            playlist_name = nil
+            playlist_tracks = []
+            next
+          end
+          match = line.match(/<key>(.+)<\/key><(\w+)>(.*)<\/\2>/)
+          next unless match
+          name = match[1]
+          value = match[3]
+          if name == 'Name'
+            playlist_name = value
+          elsif name == 'Track ID'
+            playlist_tracks << tracks[value.to_i]
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/kagu/track.rb

@@ -0,0 +1,111 @@
+module Kagu
+
+  class Track
+
+    include AttributesInitializer
+    include Comparable
+
+    MANDATORY_ATTRIBUTES = %w(added_at id length path)
+
+    attr_reader :added_at, :album, :artist, :genre, :id, :length, :path, :title
+
+    def initialize(attributes = {})
+      super
+      raise("No such file: #{path.inspect}") unless File.file?(path)
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+      added_at <=> other.added_at
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && artist == other.artist && title == other.title && (length.to_i - other.length.to_i).abs < 3
+    end
+
+    def eql?(other)
+      super || self == other
+    end
+
+    def relative_path(directory)
+      directory.present? && directory.starts_with?(directory) ? path.gsub(/\A#{Regexp.escape(directory)}\//, '') : path
+    end
+
+    def to_s
+      "#{artist} - #{title}"
+    end
+
+    private
+
+    def added_at=(value)
+      @added_at = value.is_a?(Time) ? value.utc : nil
+    end
+
+    def album=(value)
+      @album = value.to_s.squish.presence
+    end
+
+    def artist=(value)
+      @artist = value.to_s.squish.presence
+    end
+
+    def genre=(value)
+      @genre = value.to_s.squish.presence
+    end
+
+    def html_entities_decode(value)
+      @@html_entities ||= HTMLEntities.new
+      @@html_entities.decode(value.to_s)
+    end
+
+    def id=(value)
+      @id = value.to_s =~ /\A[0-9]+\z/ ? value.to_i : nil
+    end
+
+    def itunes_album=(value)
+      self.album = html_entities_decode(value)
+    end
+
+    def itunes_artist=(value)
+      self.artist = html_entities_decode(value)
+    end
+
+    def itunes_date_added=(value)
+      self.added_at = value.present? ? Time.parse(value.to_s) : nil
+    end
+
+    def itunes_genre=(value)
+      self.genre = html_entities_decode(value)
+    end
+
+    def itunes_location=(value)
+      self.path = CGI.unescape(html_entities_decode(value).gsub('+', '%2B')).gsub(/\Afile:\/\/localhost/, '')
+    end
+
+    def itunes_name=(value)
+      self.title = html_entities_decode(value)
+    end
+
+    def itunes_total_time=(value)
+      self.length = value.to_s =~ /\A[0-9]+\z/ ? (value.to_i / 1000.0).round : nil
+    end
+
+    def itunes_track_id=(value)
+      self.id = value
+    end
+
+    def length=(value)
+      @length = value.to_s =~ /\A[0-9]+\z/ ? value.to_i : nil
+    end
+
+    def path=(value)
+      @path = value.to_s.presence
+    end
+
+    def title=(value)
+      @title = value.to_s.squish.presence
+    end
+
+  end
+
+end

data/lib/kagu/tracks.rb

@@ -0,0 +1,32 @@
+module Kagu
+
+  class Tracks
+
+    include Enumerable
+
+    attr_reader :library
+
+    def initialize(library)
+      @library = library.is_a?(Library) ? library : raise("#{self.class}#library must be a library, #{library.inspect} given")
+    end
+
+    def each(&block)
+      return unless block_given?
+      File.open(library.path, 'r') do |file|
+        while !file.eof? && (line = file.readline.strip)
+          next unless line.starts_with?('<key>Track ID</key>')
+          attributes = {}
+          begin
+            match = line.match(/<key>(.+)<\/key><(\w+)>(.*)<\/\2>/)
+            name = "itunes_#{match[1].downcase.gsub(' ', '_')}"
+            value = match[3]
+            attributes[name] = value
+          end while (line = file.readline.strip) != '</dict>'
+          yield(Track.new(attributes)) if attributes['itunes_track_type'] == 'File' && attributes['itunes_podcast'].blank?
+        end
+      end
+    end
+
+  end
+
+end

data/lib/kagu.rb

@@ -0,0 +1,13 @@
+require 'active_support/core_ext'
+require 'byebug' if ENV['DEBUGGER']
+require 'fileutils'
+require 'htmlentities'
+
+lib_path = "#{__dir__}/kagu"
+
+require "#{lib_path}/attributes_initializer"
+require "#{lib_path}/library"
+require "#{lib_path}/playlist"
+require "#{lib_path}/playlists"
+require "#{lib_path}/track"
+require "#{lib_path}/tracks"

data/spec/kagu/library_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Kagu::Library do
+
+  let(:library) { Kagu::Library.new }
+
+  describe '#initialize' do
+
+    it 'is correct by default' do
+      expect(library.path).to eq("#{ENV['HOME']}/Music/iTunes/iTunes Music Library.xml")
+    end
+
+    it 'raise an error if directory' do
+      expect {
+        Kagu::Library.new('/tmp')
+      }.to raise_error(IOError, 'No such file: "/tmp"')
+    end
+
+    it "raise an error if file can't be found" do
+      expect {
+        Kagu::Library.new('/tmp/bar.foo.baz')
+      }.to raise_error(IOError, 'No such file: "/tmp/bar.foo.baz"')
+    end
+
+  end
+
+  describe '#playlists' do
+
+    it 'returns a Playlists object' do
+      expect(library.playlists).to be_a(Kagu::Playlists)
+      expect(library.playlists.library).to be(library)
+    end
+
+  end
+
+  describe '#tracks' do
+
+    it 'returns a Tracks object' do
+      expect(library.tracks).to be_a(Kagu::Tracks)
+      expect(library.tracks.library).to be(library)
+    end
+
+  end
+
+end

data/spec/kagu/playlist_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Kagu::Playlist do
+
+  let(:library) { Kagu::Library.new }
+  let(:playlist) { Kagu::Playlist.new(name: 'Best tracks', tracks: tracks) }
+  let(:tracks) { library.tracks.take(15) }
+
+  describe '#each' do
+
+    it 'is delegated to tracks' do
+      track = nil
+      playlist.each do |t|
+        track = t
+        break
+      end
+      expect(track).to be_a(Kagu::Track)
+    end
+
+  end
+
+  describe '#itunes_name=' do
+
+    it 'set name and convert entities' do
+      expect {
+        playlist.send(:itunes_name=, 'Hello & World')
+      }.to change { playlist.name }.from('Best tracks').to('Hello & World')
+    end
+
+  end
+
+  describe '#name' do
+
+    it 'is set at initialization' do
+      expect(Kagu::Playlist.new(name: 'Best tracks').name).to eq('Best tracks')
+    end
+
+    it 'is squished' do
+      expect(Kagu::Playlist.new(name: "Best  \t tracks\n").name).to eq('Best tracks')
+    end
+
+    it 'is mandatory' do
+      expect {
+        Kagu::Playlist.new(name: ' ')
+      }.to raise_error('Kagu::Playlist#name is mandatory')
+    end
+
+  end
+
+  describe '#to_s' do
+
+    it 'is name' do
+      expect(Kagu::Playlist.new(name: 'Best tracks').to_s).to eq('Best tracks')
+    end
+
+  end
+
+  describe '#tracks' do
+
+    it 'is tracks given at initialization' do
+      expect(Kagu::Playlist.new(name: 'Test', tracks: tracks).tracks).to eq(tracks)
+    end
+
+    it 'removes invalid tracks' do
+      expect(Kagu::Playlist.new(name: 'Test', tracks: ['bar', [tracks.first], 'foo']).tracks).to eq([tracks.first])
+    end
+
+  end
+
+end

data/spec/kagu/playlists_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Kagu::Playlists do
+
+  let(:library) { Kagu::Library.new }
+  let(:playlists) { Kagu::Playlists.new(library) }
+
+  describe '#each' do
+
+    it 'playlists must contains at least 1 song and a name' do
+      expect(playlists.count).to be > 5
+      playlists.each do |playlist|
+        expect(playlist.name).not_to eq('Bibliothèque')
+        expect(playlist.name).not_to match(/\&#\d+;/)
+        expect(playlist.name).to be_a(String)
+        expect(playlist.name).to be_present
+        expect(playlist.tracks.size).to be > 0
+      end
+    end
+
+    it 'does not fails if block is not given' do
+      expect {
+        expect(playlists.each).to be_nil
+      }.not_to raise_error
+    end
+
+    it 'returns nil' do
+      expect(playlists.each { break }).to be_nil
+    end
+
+  end
+
+  describe '#initialize' do
+
+    it 'raise an error if library is nil' do
+      expect {
+        Kagu::Playlists.new(nil)
+      }.to raise_error('Kagu::Playlists#library must be a library, nil given')
+    end
+
+  end
+
+end

data/spec/kagu/track_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe Kagu::Track do
+
+  let(:attributes) { { added_at: track.added_at, album: track.album, artist: track.artist, id: track.id, length: track.length, path: track.path, title: track.title } }
+  let(:library) { Kagu::Library.new }
+  let(:track) { library.tracks.first }
+
+  describe '#==' do
+
+    let(:other) { track.dup }
+
+    it 'is false if not a track' do
+      expect(track == 'foo').to be(false)
+    end
+
+    it 'is false if artist differs' do
+      expect {
+        allow(other).to receive(:artist).and_return('Foo')
+      }.to change { track == other }.from(true).to(false)
+    end
+
+    it 'is false if title differs' do
+      expect {
+        allow(other).to receive(:title).and_return('Bar')
+      }.to change { track == other }.from(true).to(false)
+    end
+
+    it 'is false if length differs' do
+      expect {
+        allow(other).to receive(:length).and_return(track.length - 5)
+      }.to change { track == other }.from(true).to(false)
+    end
+
+    it 'is true if length differs just a little' do
+      expect {
+        allow(other).to receive(:length).and_return(track.length - 2)
+      }.not_to change { track == other }
+    end
+
+    it 'is true if album differs' do
+      expect {
+        allow(other).to receive(:album).and_return('Baz')
+      }.not_to change { track == other }
+    end
+
+  end
+
+  describe '#<=>' do
+
+    let(:other) { track.dup }
+
+    it 'compares tracks lengths' do
+      expect {
+        allow(other).to receive(:added_at).and_return(1.day.from_now)
+      }.to change { track <=> other }.from(0).to(-1)
+    end
+
+    it 'is nil if added_at is nil' do
+      allow(track).to receive(:added_at).and_return(nil)
+      expect(track <=> other).to be_nil
+    end
+
+    it 'is nil if other track added_at is nil' do
+      allow(other).to receive(:added_at).and_return(nil)
+      expect(track <=> other).to be_nil
+    end
+
+    it 'is nil if other is not a track' do
+      expect(track <=> '').to be_nil
+    end
+
+  end
+
+  describe '#added_at' do
+
+    it 'returns a time' do
+      expect(track.added_at).to be_a(Time)
+    end
+
+    it 'return a time in utc' do
+      expect(track.added_at.zone).to eq('UTC')
+    end
+
+    it 'raise an error if not specified' do
+      expect {
+        Kagu::Track.new(attributes.except(:added_at))
+      }.to raise_error('Kagu::Track#added_at is mandatory')
+    end
+
+  end
+
+  describe '#album' do
+
+    it 'is is squished' do
+      track.send(:album=, " Life Is   \r Peachy  \n")
+      expect(track.album).to eq('Life Is Peachy')
+    end
+
+  end
+
+  describe '#artist' do
+
+    it 'is is squished' do
+      track.send(:artist=, " Benny   \r Page  \n")
+      expect(track.artist).to eq('Benny Page')
+    end
+
+  end
+
+  describe '#eql?' do
+
+    it 'is true for same object' do
+      expect(track.eql?(track)).to be(true)
+    end
+
+    it 'is true if == returns true' do
+      other = track.dup
+      expect {
+        allow(track).to receive(:==).and_return(false)
+      }.to change { track.eql?(other) }.from(true).to(false)
+    end
+
+  end
+
+  describe '#genre' do
+
+    it 'is correct' do
+      expect(track.genre).to be_a(String)
+      expect(track.genre).to be_present
+    end
+
+  end
+
+  describe '#id' do
+
+    it 'is correct' do
+      expect(track.id).to be_an(Integer)
+      expect(track.id).to be > 0
+    end
+
+    it 'raise an error if not specified' do
+      expect {
+        Kagu::Track.new(attributes.except(:id))
+      }.to raise_error('Kagu::Track#id is mandatory')
+    end
+
+  end
+
+  describe '#itunes_name=' do
+
+    it 'sets title with entities decoded' do
+      expect {
+        track.send(:itunes_name=, 'Racing &amp; Green')
+      }.to change { track.title }.to('Racing & Green')
+    end
+
+  end
+
+  describe '#length' do
+
+    it 'is correct' do
+      expect(track.length).to be_an(Integer)
+      expect(track.length).to be > 0
+    end
+
+    it 'raise an error if not specified' do
+      expect {
+        Kagu::Track.new(attributes.except(:length))
+      }.to raise_error('Kagu::Track#length is mandatory')
+    end
+
+  end
+
+  describe '#path' do
+
+    it 'is correct' do
+      expect(track.path).to be_a(String)
+      expect(File.file?(track.path)).to be(true)
+    end
+
+    it 'raise an error if not specified' do
+      expect {
+        Kagu::Track.new(attributes.except(:path))
+      }.to raise_error('Kagu::Track#path is mandatory')
+    end
+
+    it 'raise an error if not found' do
+      expect {
+        Kagu::Track.new(attributes.merge(path: '/tmp/bar.mp3'))
+      }.to raise_error('No such file: "/tmp/bar.mp3"')
+    end
+
+    it 'raise an error if not a file' do
+      expect {
+        Kagu::Track.new(attributes.merge(path: '/tmp'))
+      }.to raise_error('No such file: "/tmp"')
+    end
+
+  end
+
+  describe '#relative_path' do
+
+    it 'is correct' do
+      expect(track.relative_path(ENV['HOME'])).to eq(track.path.gsub("#{ENV['HOME']}/", ''))
+    end
+
+    it 'is full path if not starting with given path' do
+      expect(track.relative_path('/Users/john')).to eq(track.path)
+    end
+
+  end
+
+  describe '#title' do
+
+    it 'is is squished' do
+      track.send(:title=, " Racing   \r Green  \n")
+      expect(track.title).to eq('Racing Green')
+    end
+
+  end
+
+  describe '#to_s' do
+
+    it 'is "artist - title"' do
+      expect(track.to_s).to eq("#{track.artist} - #{track.title}")
+    end
+
+  end
+
+end

data/spec/kagu/tracks_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Kagu::Tracks do
+
+  let(:library) { Kagu::Library.new }
+  let(:tracks) { Kagu::Tracks.new(library) }
+
+  describe '#each' do
+
+    it 'most of tracks must be correct path must be a file' do
+      tracks.take(100).each do |track|
+        expect(File.file?(track.path)).to be(true)
+        expect(track).to be_a(Kagu::Track)
+        expect(track.added_at).to be_a(Time)
+        expect(track.album).to be_a(String)
+        expect(track.album).to be_present
+        expect(track.artist).to be_a(String)
+        expect(track.artist).to be_present
+        expect(track.genre).to be_a(String)
+        expect(track.genre).to be_present
+        expect(track.id).to be_an(Integer)
+        expect(track.length).to be_an(Integer)
+        expect(track.path).not_to include('file://')
+        expect(track.path).to include('Music')
+        expect(track.title).to be_a(String)
+        expect(track.title).to be_present
+      end
+    end
+
+    it 'does not fails if block is not given' do
+      expect {
+        expect(tracks.each).to be_nil
+      }.not_to raise_error
+    end
+
+    it 'returns nil' do
+      expect(tracks.each { break }).to be_nil
+    end
+
+  end
+
+  describe '#initialize' do
+
+    it 'raise an error if library is nil' do
+      expect {
+        Kagu::Tracks.new(nil)
+      }.to raise_error('Kagu::Tracks#library must be a library, nil given')
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require File.expand_path("#{__dir__}/../lib/kagu")
+require 'byebug'
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: kagu
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexis Toulotte
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 4.4.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 10.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 10.4.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: API to manage iTunes tracks and playlists
+email: al@alweb.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- MIT-LICENSE
+- README.mdown
+- Rakefile
+- VERSION
+- kagu.gemspec
+- lib/kagu.rb
+- lib/kagu/attributes_initializer.rb
+- lib/kagu/library.rb
+- lib/kagu/playlist.rb
+- lib/kagu/playlists.rb
+- lib/kagu/track.rb
+- lib/kagu/tracks.rb
+- spec/kagu/library_spec.rb
+- spec/kagu/playlist_spec.rb
+- spec/kagu/playlists_spec.rb
+- spec/kagu/track_spec.rb
+- spec/kagu/tracks_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alexistoulotte/kagu
+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: kagu
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: API for iTunes
+test_files:
+- spec/kagu/library_spec.rb
+- spec/kagu/playlist_spec.rb
+- spec/kagu/playlists_spec.rb
+- spec/kagu/track_spec.rb
+- spec/kagu/tracks_spec.rb
+- spec/spec_helper.rb