kagu 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b924d298951b8a31fa4c0518deab9c81016440b2
-  data.tar.gz: 9658119eb3f372c711d8c280791c122468671e9e
+  metadata.gz: 5f2eb7f1dc5e7068bb9aac193c238d9692dabdbf
+  data.tar.gz: 8b6a3dbbdaaa42c74da8060d61b30be3843c594b
 SHA512:
-  metadata.gz: 14e2a280b7cbab02c48532c716f6190e908875dd129eb51ec0d01b7b296afbd466ec5826adac01c8378747cb742f87ed855a18bbf0712993febc2f691c191ad7
-  data.tar.gz: 8ecd82e0a16cdf505e5320fc17e64a797c8d26815d10784d34e775f070da975937c2885919e62c05e703bef07876abc335d543a30c6aa0045530af10a895a2e6
+  metadata.gz: 4a22628b4870b924f88a3db00d910667a1d66286d2112c8d44f1bef072ef872c106134da2fa8d2e32ed8bfd40450b5ffefbb91f40a27250d22d4f9c7bf427a42
+  data.tar.gz: 3b3903a0ded1b34a2e35cd2509964e3779e0ce311cd731c8b9b3b2a360404fa3e0940e826728a94511ab3f2e239633a2e8f29baa2fb32344a0f5cfc97009b3c8

data/VERSION

@@ -1 +1 @@
-1.2.0
+1.2.1

data/kagu.gemspec

@@ -9,8 +9,7 @@ Gem::Specification.new do |s|
   s.description = 'API to manage iTunes tracks and playlists'
   s.license = 'MIT'
 
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.files = `git ls-files | grep -vE '^(spec/|test/|\\.|Gemfile|Rakefile)'`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kagu
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-21 00:00:00.000000000 Z
+date: 2017-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -136,12 +136,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- Gemfile
 - MIT-LICENSE
 - README.mdown
-- Rakefile
 - VERSION
 - kagu.gemspec
 - lib/kagu.rb
@@ -153,14 +149,6 @@ files:
 - lib/kagu/playlists.rb
 - lib/kagu/track.rb
 - lib/kagu/tracks.rb
-- spec/kagu/error_spec.rb
-- spec/kagu/finder_spec.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
@@ -185,12 +173,4 @@ rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: API for iTunes
-test_files:
-- spec/kagu/error_spec.rb
-- spec/kagu/finder_spec.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
+test_files: []

data/.gitignore

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

data/.rspec

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

data/Gemfile

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

data/Rakefile

@@ -1,10 +0,0 @@
-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/spec/kagu/error_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Kagu::Error do
-
-  let(:error) { Kagu::Error.new('BAM!') }
-  let(:original) { StandardError.new('BIM!') }
-
-  describe '#message' do
-
-    it 'is message set at initialization' do
-      expect(error.message).to eq('BAM!')
-    end
-
-    it 'message is squished' do
-      expect(Kagu::Error.new(" hello  \n world").message).to eq('hello world')
-    end
-
-    it 'default one if blank' do
-      expect(Kagu::Error.new(" ").message).to eq('Kagu::Error')
-    end
-
-  end
-
-  describe '#original' do
-
-    it 'is nil by default' do
-      expect(error.original).to be_nil
-    end
-
-    it 'is exception given at initialization' do
-      expect(Kagu::Error.new(original).original).to be(original)
-    end
-
-    it 'sets message from original' do
-      expect(Kagu::Error.new(original).message).to eq('BIM!')
-    end
-
-  end
-
-end

data/spec/kagu/finder_spec.rb

@@ -1,314 +0,0 @@
-require 'spec_helper'
-
-describe Kagu::Finder do
-
-  let(:finder) { Kagu::Finder.new(library) }
-  let(:library) { Kagu::Library.new }
-
-  describe '.replace' do
-
-    it 'replace given value with replacements' do
-      expect(Kagu::Finder.replace('Hello World!', 'World' => 'John', 'Hello' => 'Bye')).to eq('Bye John!')
-    end
-
-    it 'is case sensitive' do
-      expect(Kagu::Finder.replace('Hello World!', 'world' => 'John', 'Hello' => 'Bye')).to eq('Bye World!')
-    end
-
-    it 'replace given value with some regexp' do
-      expect(Kagu::Finder.replace('Hello World!', 'World' => 'John', /l+/ => 'i')).to eq('Heio John!')
-    end
-
-    it 'returns nil if blank' do
-      expect(Kagu::Finder.replace('    ', 'world' => 'John', 'Hello' => 'Bye')).to be_nil
-    end
-
-    it 'accepts arrays as replacements' do
-      expect(Kagu::Finder.replace('Hello World!', [['World', 'John'], ['Hello', 'Bye']])).to eq('Bye John!')
-    end
-
-  end
-
-  describe '.transliterate' do
-
-    it 'removes accents' do
-      expect(Kagu::Finder.transliterate('éàlôrs')).to eq('ealors')
-    end
-
-    it 'removes consecutive white spaces' do
-      expect(Kagu::Finder.transliterate(" hello   \t world\n  ")).to eq('hello world')
-    end
-
-    it 'converts value to lower case' do
-      expect(Kagu::Finder.transliterate('Hello World')).to eq('hello world')
-    end
-
-    it 'removes nil if blank' do
-      expect(Kagu::Finder.transliterate(' ')).to be_nil
-    end
-
-  end
-
-  describe '#find' do
-
-    it 'returns some tracks' do
-      tracks = finder.find(artist: 'korn', title: 'blind')
-      expect(tracks).to be_an(Array)
-      expect(tracks.first).to be_a(Kagu::Track)
-      expect(tracks.first.title).to match(/blind/i)
-    end
-
-    it 'returns nothing if artist is blank' do
-      expect(finder.find(title: 'blind')).to be_empty
-    end
-
-    it 'returns nothing if title is blank' do
-      expect(finder.find(artist: 'korn')).to be_empty
-    end
-
-    it 'returns nothing if artist match an artist and a track' do
-      expect(finder.find(artist: 'korn blind')).to be_empty
-    end
-
-    it 'artist and title can be specified as string' do
-      expect(finder.find('artist' => 'KoRn', 'title' => 'Ball Tongue').first).to be_a(Kagu::Track)
-    end
-
-    it 'returns an array of array of tracks if there is some replacements' do
-      finder.reload(replacements: { 'ball tongue' => 'blind' })
-      results = finder.find(artist: 'korn', title: 'blind')
-      expect(results.size).to eq(2)
-      expect(results.first).to be_an(Array)
-      expect(results.first.first.title).to match(/blind/i)
-      expect(results.second.first.title).to match(/ball tongue/i)
-    end
-
-    it 'replacements are working with given attributes' do
-      finder.reload(replacements: { 'hello world' => 'blind' })
-      results = finder.find(artist: 'korn', title: 'hello world')
-      expect(results.size).to eq(1)
-      expect(results.first.first).to be_a(Kagu::Track)
-      expect(results.first.first.title).to match(/blind/i)
-    end
-
-    it 'put at first position the exact matches from given attributes' do
-      finder.reload(replacements: { 'ball tongue' => 'blind' })
-      results = finder.find(artist: 'korn', title: 'ball tongue')
-      expect(results.size).to eq(2)
-
-      expect(results.first).not_to be_empty
-      results.first.each do |track|
-        expect(track.title).to match(/ball tongue/i)
-      end
-
-      expect(results.second).not_to be_empty
-      results.second.each do |track|
-        expect(track.title).to match(/blind/i)
-      end
-    end
-
-    it 'does not include ignored tracks' do
-      expect {
-        finder.reload(ignored: 'korn blind')
-      }.to change { finder.find(artist: 'korn', title: 'blind').size }.to(0)
-      expect(finder.find(artist: 'korn', title: 'ball tongue')).not_to be_empty
-    end
-
-    it 'does not include ignored tracks for each digest' do
-      finder.reload(replacements: { 'blind' => 'foo' })
-      expect {
-        finder.reload(ignored: 'korn foo', replacements: { 'blind' => 'foo' })
-      }.to change { finder.find(artist: 'korn', title: 'blind').size }.to(0)
-    end
-
-    it 'finds for some tracks with replacements as regexp' do
-      finder.reload(replacements: { /subsonik (\d+)/ => "subsonik podcast \\1" })
-      results = finder.find(artist: 'subsonik', title: '002')
-      expect(results.size).to eq(1)
-      expect(results.first.first.title).to match(/podcast 002/i)
-    end
-
-    it 'does not fails if it does not match last replacements' do
-      finder.reload(replacements: [{ /subsonik (\d+)/ => "subsonik podcast \\1" }, { /\s+/ => '' }])
-      results = finder.find(artist: 'subsonik', title: '002')
-      expect(results.size).to eq(1)
-      expect(results.first.first.title).to match(/podcast 002/i)
-    end
-
-  end
-
-  describe '#ignored' do
-
-    it 'can be set as an array of string' do
-      expect {
-        finder.reload(ignored: ['test', 'foo'])
-      }.to change { finder.ignored }.from([]).to(['test', 'foo'])
-    end
-
-    it 'can be set as a simple string' do
-      expect {
-        finder.reload(ignored: 'test')
-      }.to change { finder.ignored }.from([]).to(['test'])
-    end
-
-    it 'is transliterated' do
-      expect {
-        finder.reload(ignored: ['testé  HeLLo World', 'foo'])
-      }.to change { finder.ignored }.from([]).to(['teste hello world', 'foo'])
-    end
-
-    it 'can be set from a track' do
-      expect {
-        finder.reload(ignored: [finder.find(artist: 'KoRn', title: 'Blind').first])
-      }.to change { finder.ignored }.from([]).to(['korn blind'])
-    end
-
-    it 'can be set from an hash (as string keys)' do
-      expect {
-        finder.reload(ignored: { 'artist' => 'KoRn', 'title' => 'Blind' })
-      }.to change { finder.ignored }.from([]).to(['korn blind'])
-    end
-
-    it 'can be set from an hash (with symbol keys)' do
-      expect {
-        finder.reload(ignored: { artist: 'KoRn', title: 'Blind' })
-      }.to change { finder.ignored }.from([]).to(['korn blind'])
-    end
-
-    it 'removes duplicates' do
-      expect {
-        finder.reload(ignored: ['test', 'Foo ', 'foo', 'TEST'])
-      }.to change { finder.ignored }.from([]).to(['test', 'foo'])
-    end
-
-  end
-
-  describe '#ignored?' do
-
-    it 'is false if nil is given' do
-      expect(finder.ignored?(nil)).to be(false)
-    end
-
-    it 'is true if at least one digest is ignored' do
-      finder.reload(replacements: { 'hello' => 'world' }, ignored: 'korn world')
-      expect(finder.ignored?(double(artist: 'korn', title: 'blind'))).to be(false)
-      expect(finder.ignored?(double(artist: 'korn', title: 'hello'))).to be(true)
-      expect(finder.ignored?(double(artist: 'korn', title: 'world'))).to be(true)
-      expect(finder.ignored?(double(artist: 'korn', title: 'hellow'))).to be(false)
-    end
-
-  end
-
-  describe '#library' do
-
-    it 'is library given at initialization' do
-      expect(finder.library).to be(library)
-    end
-
-    it 'raise an error if library is nil' do
-      expect {
-        Kagu::Finder.new(nil)
-      }.to raise_error(ArgumentError, 'Kagu::Finder#library must be a library, nil given')
-    end
-
-  end
-
-  describe '#reload' do
-
-    it 'sets replacements' do
-      expect {
-        finder.reload(replacements: { 'foo' => 'bar' })
-      }.to change { finder.replacements }.from([]).to([{ 'foo' => 'bar' }])
-    end
-
-    it 'removes replacements' do
-      finder.reload(replacements: { 'foo' => 'bar' })
-      expect {
-        finder.reload
-      }.to change { finder.replacements }.to([])
-    end
-
-    it 'removes ignored' do
-      finder.reload(ignored: 'foo')
-      expect {
-        finder.reload
-      }.to change { finder.ignored }.to([])
-    end
-
-    it 'returns finder' do
-      expect(finder.reload).to be(finder)
-    end
-
-    it 'reload tracks' do
-      expect {
-        finder.reload(replacements: { /\./ => '' })
-      }.to change { finder.find(artist: 'korn', title: 'adidas').present? }.from(false).to(true)
-    end
-
-    it 'returns finder' do
-      expect(finder.reload).to be(finder)
-    end
-
-  end
-
-  describe '#reload!' do
-
-    it 'invokes reload' do
-      expect(finder).to receive(:reload).with('foo' => 'bar')
-      finder.reload!('foo' => 'bar')
-    end
-
-    it 'removes tracks cache' do
-      finder.find(artist: 'korn', title: 'blind')
-      expect {
-        finder.reload!
-      }.to change { finder.instance_variable_get(:@tracks) }.to(nil)
-    end
-
-    it 'returns finder' do
-      expect(finder.reload!).to be(finder)
-    end
-
-  end
-
-  describe '#replacements' do
-
-    it 'can be ommited' do
-      expect(finder.reload.replacements).to eq([])
-    end
-
-    it 'can be specified as regexp' do
-      expect(finder.reload(replacements: { /bar/ => 'foo' }).replacements).to eq([/bar/ => 'foo'])
-    end
-
-    it 'can be specified with a string as key' do
-      expect(finder.reload('replacements' => { 'foo' => 'bar' }).replacements).to eq([{ 'foo' => 'bar' }])
-    end
-
-    it 'can be specified as hash' do
-      expect(finder.reload(replacements: { 'foo' => 'bar' }).replacements).to eq([{ 'foo' => 'bar' }])
-    end
-
-    it 'can be specified as array of hashes' do
-      expect(finder.reload(replacements: [{ 'foo' => 'bar' }, { 'titi' => 'toto' }]).replacements).to eq([{ 'foo' => 'bar' }, { 'titi' => 'toto' }])
-    end
-
-    it 'can be specified as array of array' do
-      expect(finder.reload(replacements: [['foo', 'bar' ], ['titi' => 'toto']]).replacements).to eq([['foo', 'bar' ], ['titi' => 'toto']])
-    end
-
-    it 'raise an error if a string is given' do
-      expect {
-        finder.reload(replacements: 'foo')
-      }.to raise_error('Replacements must be an array or a hash, "foo" given')
-    end
-
-    it 'raise an error if it contains something else than an hash or array' do
-      expect {
-        finder.reload(replacements: [{ 'foo' => 'bar' }, 'titi'])
-      }.to raise_error('Replacements must contain only hashes or arrays')
-    end
-
-  end
-
-end

data/spec/kagu/library_spec.rb

@@ -1,57 +0,0 @@
-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(Kagu::Error, '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(Kagu::Error, 'No such file: "/tmp/bar.foo.baz"')
-    end
-
-  end
-
-  describe '#finder' do
-
-    it 'returns a Kagu::Finder instance' do
-      expect(library.finder).to be_a(Kagu::Finder)
-    end
-
-    it 'options can be specified' do
-      expect(library.finder(replacements: { 'foo' => 'bar' }).replacements).to eq([{ 'foo' => 'bar' }])
-    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

@@ -1,74 +0,0 @@
-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::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 an empty array by default' do
-      expect(Kagu::Playlist.new(name: 'Test').tracks).to eq([])
-    end
-
-    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

@@ -1,47 +0,0 @@
-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 {}).to be_nil
-    end
-
-  end
-
-  describe '#library' do
-
-    it 'is library given at initialization' do
-      expect(playlists.library).to be(library)
-    end
-
-    it 'raise an error if library is nil' do
-      expect {
-        Kagu::Playlists.new(nil)
-      }.to raise_error(ArgumentError, 'Kagu::Playlists#library must be a library, nil given')
-    end
-
-  end
-
-end

data/spec/kagu/track_spec.rb

@@ -1,303 +0,0 @@
-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::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 '#bpm' do
-
-    it 'is nil if invalid' do
-      track.send(:bpm=, "42a")
-      expect(track.bpm).to be_nil
-    end
-
-    it 'is an integer' do
-      track.send(:bpm=, '143')
-      expect(track.bpm).to be(143)
-    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 '#exists?' do
-
-    it 'is true if path is a file' do
-      expect {
-        allow(track).to receive(:path).and_return('/tmp/foo.mp3')
-      }.to change { track.exists? }.from(true).to(false)
-    end
-
-    it 'is false if path is a directory' do
-      expect {
-        allow(track).to receive(:path).and_return('/tmp')
-      }.to change { track.exists? }.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::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::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::Error, 'Kagu::Track#path is mandatory')
-    end
-
-    it 'does not raise an error if not found' do
-      expect {
-        Kagu::Track.new(attributes.merge(path: '/tmp/bar.mp3'))
-      }.not_to raise_error
-    end
-
-    it 'logs an error if not exist' do
-      expect(Kagu.logger).to receive(:error)
-      Kagu::Track.new(attributes.merge(path: '/tmp/bar.mp3'))
-    end
-
-    it 'raise an error if exists but not a file' do
-      expect {
-        Kagu::Track.new(attributes.merge(path: '/tmp'))
-      }.to raise_error(Kagu::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
-
-  describe '#year' do
-
-    it 'is an integer' do
-      expect(track.year).to be_an(Integer)
-    end
-
-    it 'is correct' do
-      expect(track.year.to_s).to match(/\A\d{4}\z/)
-    end
-
-    it 'is nil if negative' do
-      track.send(:year=, -1)
-      expect(track.year).to be_nil
-    end
-
-    it 'is nil if invalid' do
-      track.send(:year=, 20434)
-      expect(track.year).to be_nil
-    end
-
-    it 'can be < 1000' do
-      track.send(:year=, 942)
-      expect(track.year).to be(942)
-    end
-
-    it 'can be set as string' do
-      track.send(:year=, '1984')
-      expect(track.year).to be(1984)
-    end
-
-    it 'is nil if string is invalid' do
-      track.send(:year=, '1984 ')
-      expect(track.year).to be_nil
-    end
-
-  end
-
-end

data/spec/kagu/tracks_spec.rb

@@ -1,66 +0,0 @@
-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.exists?).to be(true)
-        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
-        expect(track.year).to be_an(Integer)
-        expect(track.year.to_s).to match(/\A\d{4}\z/)
-      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 {}).to be_nil
-    end
-
-    it 'all tracks must exists and path should not include UTF-8-MAC charset' do
-      library.tracks.each do |track|
-        expect(track.path).not_to include("\u{65}\u{301}")
-        expect(track.exists?).to be(true)
-      end
-    end
-
-  end
-
-  describe '#library' do
-
-    it 'is library given at initialization' do
-      expect(tracks.library).to be(library)
-    end
-
-    it 'raise an error if library is nil' do
-      expect {
-        Kagu::Tracks.new(nil)
-      }.to raise_error(ArgumentError, 'Kagu::Tracks#library must be a library, nil given')
-    end
-
-  end
-
-end

data/spec/spec_helper.rb

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