kagu 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2dd607618f6af1f48b5c1372e6231e7ac1ce276c
-  data.tar.gz: dbc913a388fd6472861c5278f7a8aae2d7b0774e
+  metadata.gz: dc8ff8418f368b1c12f3d2f8b01d6af8e7d7a3a6
+  data.tar.gz: e7be4e6197998c38421f7208d0c84a898c83b6e9
 SHA512:
-  metadata.gz: 2eb43b8406afce2f01ebabea8c2e24f9cff4990699ef867dfbb725cc135a048330acd34a8c078ce40fded93431d07676a71382f1f7734a151898807996ba8400
-  data.tar.gz: 158bf6e51ecd12fafa3f645ebe7f0e90bab7a793ff9a9143ce31e6ca191ab9cc7d89462adbff8cc60b5892485bf0723a19ff08a64b0e05fdff5691d371b2c0fe
+  metadata.gz: c7a69aeed895d34f70b4cda33304f48cd284a81105b79d772c7c1e3e1fe3d472110aad768241edbe2c651486f494d851e7380d60cc5b7c70ad2e9ecabfbc8bdb
+  data.tar.gz: eb07e916b94813b67ed2872bc94897bacaf06873b25df46b71bdeddebcca8c586dc22d335833d71222e5c7b0678e375cd0dc445334ff8690a563965fe3479def

data/README.mdown

@@ -6,7 +6,9 @@ Ruby API to manage iTunes tracks and playlists.
 
 Just add this into your `Gemfile`:
 
-    gem 'kagu'
+```ruby
+gem 'kagu'
+```
 
 Then, just run `bundle install`.
 
@@ -14,26 +16,41 @@ Then, just run `bundle install`.
 
 ### Displaying all tracks artist
 
-    library = Kagu::Library.new
+```ruby
+library = Kagu::Library.new
 
-    library.tracks.each do |track|
-      puts track.artist
-    end
+library.tracks.each do |track|
+  puts track.artist
+end
+```
 
 ### Displaying all playlists and its tracks count
 
-    library = Kagu::Library.new
+```ruby
+library = Kagu::Library.new
 
-    library.playlists.each do |playlist|
-      puts "#{playlist.name}: #{playlist.tracks.count}"
-    end
+library.playlists.each do |playlist|
+  puts "#{playlist.name}: #{playlist.tracks.count}"
+end
+```
 
 ### Creating a playlist
 
-    library = Kagu::Library.new
+```ruby
+library = Kagu::Library.new
 
-    tracks = library.tracks.select { |track| track.genre == 'Drum & Bass' && track.added_at > 1.week.ago }
-    library.playlists.create(name: 'Recent - D&B', tracks: tracks)
+tracks = library.tracks.select { |track| track.genre == 'Drum & Bass' && track.added_at > 1.week.ago }
+library.playlists.create(name: 'Recent - D&B', tracks: tracks)
+```
+
+### Finding some tracks
+
+```ruby
+library = Kagu::Library.new
+library.finder.find(artist: 'Serial Killaz', title: 'Walk and Skank').each do
+  puts track.id
+end
+```
 
 ## Executing test suite
 

data/VERSION

@@ -1 +1 @@
-0.3.3
+0.4.0

data/kagu.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'applescript', '>= 1.0', '< 2.0'
   s.add_dependency 'htmlentities', '>= 4.3.0', '< 4.4.0'
 
-  s.add_development_dependency 'byebug', '>= 3.2.0', '< 3.6.0'
+  s.add_development_dependency 'byebug', '>= 3.2.0', '< 7.0.0'
   s.add_development_dependency 'rake', '>= 10.3.0', '< 10.5.0'
-  s.add_development_dependency 'rspec', '>= 3.1.0', '< 3.2.0'
+  s.add_development_dependency 'rspec', '>= 3.1.0', '< 3.4.0'
 end

data/lib/kagu/finder.rb

@@ -0,0 +1,123 @@
+module Kagu
+
+  class Finder
+
+    MANDATORY_ATTRIBUTES = []
+
+    attr_reader :library
+
+    delegate :replace, :transliterate, to: 'self.class'
+
+    def self.replace(value, replacements = {})
+      replaced = value.to_s.dup
+      replacements.each do |pattern, replacement|
+        replaced.gsub!(pattern, replacement)
+      end
+      replaced.presence
+    end
+
+    def self.transliterate(value)
+      ActiveSupport::Inflector.transliterate(value.to_s).squish.downcase.presence
+    end
+
+    def initialize(library, options = {})
+      raise ArgumentError.new("#{self.class}#library must be a library, #{library.inspect} given") unless library.is_a?(Library)
+      @library = library
+      reload(options)
+    end
+
+    def find(attributes = {})
+      attributes.stringify_keys!
+      results = [].tap do |matches|
+        tracks_digests.each_with_index do |hash, digests_index|
+          digests(attributes).each_with_index do |digest, digest_index|
+            tracks = hash[digest].presence || next
+            tracks = tracks.select { |track| !matches.any? { |match| match.include?(track) } }
+            next if tracks.empty?
+            index = [digests_index, digest_index].max
+            matches[index] ||= []
+            matches[index].push(*tracks)
+          end
+        end
+      end
+      results.compact!
+      replacements.any? ? results : results.flatten
+    end
+
+    def ignored
+      @ignored ||= []
+    end
+
+    def reload(options = {})
+      @ignored = nil
+      @replacements = nil
+      @tracks_digests = nil
+      options.each do |name, value|
+        send("#{name}=", value) if respond_to?("#{name}=", true)
+      end
+      self
+    end
+
+    def replacements
+      @replacements ||= []
+    end
+
+    private
+
+    def digests(attributes)
+      attributes.stringify_keys!
+      return [] if attributes['artist'].blank? || attributes['title'].blank?
+      digests = [transliterate("#{attributes['artist']} #{attributes['title']}")]
+      replacements.each do |item|
+        digests << replace(digests.last, item)
+      end
+      digests.uniq
+    end
+
+    def ignored=(values)
+      @ignored = [values].flatten.map do |value|
+        if value.is_a?(Hash)
+          value = value.stringify_keys
+          value = "#{value['artist']} #{value['title']}"
+        elsif value.is_a?(Track)
+          value = "#{value.artist} #{value.title}"
+        else
+          value = value.to_s
+        end
+        self.class.transliterate(value)
+      end.compact.uniq
+    end
+
+    def replacements=(value)
+      if value.nil?
+        @replacements = []
+      elsif value.is_a?(Hash)
+        @replacements = [value]
+      elsif value.is_a?(Array)
+        @replacements = value
+      else
+        raise("Replacements must be an array or a hash, #{value.inspect} given")
+      end
+      replacements.each do |item|
+        raise('Replacements must contain only hashes') unless item.is_a?(Hash)
+      end
+    end
+
+    def tracks_digests
+      @tracks_digests ||= begin
+        [].tap do |tracks_digests|
+          library.tracks.each do |track|
+            digests(artist: track.artist, title: track.title).each_with_index do |digest, index|
+              next if ignored.include?(digest)
+              tracks_digests[index] ||= {}
+              tracks_digests[index][digest] ||= []
+              tracks_digests[index][digest].push(track)
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/kagu/library.rb

@@ -10,6 +10,10 @@ module Kagu
       self.path = path
     end
 
+    def finder(options = {})
+      Finder.new(self, options)
+    end
+
     def playlists
       Playlists.new(self)
     end

data/lib/kagu.rb

@@ -8,6 +8,7 @@ lib_path = "#{__dir__}/kagu"
 
 require "#{lib_path}/attributes_initializer"
 require "#{lib_path}/error"
+require "#{lib_path}/finder"
 require "#{lib_path}/library"
 require "#{lib_path}/playlist"
 require "#{lib_path}/playlists"

data/spec/kagu/finder_spec.rb

@@ -0,0 +1,241 @@
+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
+
+  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
+
+  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 '#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
+
+  end
+
+  describe '#replacements' do
+
+    it 'can be ommited' do
+      expect(finder.reload.replacements).to eq([])
+    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 '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' do
+      expect {
+        finder.reload(replacements: [{ 'foo' => 'bar' }, 'titi'])
+      }.to raise_error('Replacements must contain only hashes')
+    end
+
+  end
+
+end

data/spec/kagu/library_spec.rb

@@ -24,6 +24,18 @@ describe Kagu::Library do
 
   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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kagu
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Alexis Toulotte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-16 00:00:00.000000000 Z
+date: 2015-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -79,7 +79,7 @@ dependencies:
         version: 3.2.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.6.0
+        version: 7.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -89,7 +89,7 @@ dependencies:
         version: 3.2.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.6.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -119,7 +119,7 @@ dependencies:
         version: 3.1.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 3.4.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -129,7 +129,7 @@ dependencies:
         version: 3.1.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 3.4.0
 description: API to manage iTunes tracks and playlists
 email: al@alweb.org
 executables: []
@@ -147,12 +147,14 @@ files:
 - lib/kagu.rb
 - lib/kagu/attributes_initializer.rb
 - lib/kagu/error.rb
+- lib/kagu/finder.rb
 - lib/kagu/library.rb
 - lib/kagu/playlist.rb
 - 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
@@ -185,6 +187,7 @@ 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