itunes-controller 0.1.0

data/lib/itunesController/database/backend.rb

@@ -0,0 +1,41 @@
+# Copyright (C) 2011-2012  John-Paul.Stanford <dev@stanwood.org.uk>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author:: John-Paul Stanford <dev@stanwood.org.uk>
+# Copyright:: Copyright (C) 2011  John-Paul.Stanford <dev@stanwood.org.uk>
+# License:: GNU General Public License v3 <http://www.gnu.org/licenses/>
+#
+
+module ItunesController
+
+    class DatabaseConstraintException < Exception
+    end
+    
+    class DatabaseBackend               
+        
+        def prepare(sql)            
+        end
+        
+        def execute(sql)
+        end
+        
+        def close()
+        end
+        
+        def executeStatement(stmt,*args)            
+        end
+             
+    end
+end

data/lib/itunesController/database/database.rb

@@ -0,0 +1,166 @@
+# Copyright (C) 2011-2012  John-Paul.Stanford <dev@stanwood.org.uk>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author:: John-Paul Stanford <dev@stanwood.org.uk>
+# Copyright:: Copyright (C) 2011  John-Paul.Stanford <dev@stanwood.org.uk>
+# License:: GNU General Public License v3 <http://www.gnu.org/licenses/>
+#
+require 'itunesController/logging'
+require 'itunesController/itunescontroller'
+
+require 'fileutils'
+
+module ItunesController
+
+    class Database
+
+        PARAM_KEY_EXPECTED_TRACKS=1
+        PARAM_KEY_TRACK_COUNT=2
+
+        # The constructor
+        def initialize(controller,backend)
+            @controller = controller
+            @backend = backend            
+            createTables()
+        end
+
+        def addDeadTrack(track)
+            stmt = @backend.prepare("insert into dead_tracks(databaseId,location,name) values(?,?,?)")
+            id=track.databaseId.to_i
+            title=track.title.to_s
+            loc = nil
+            if (track.location!=nil)
+                loc = track.location.to_s
+            end
+            @backend.executeStatement(stmt,id,loc,title)            
+        end
+
+        def addTrack(track)
+            stmt = @backend.prepare("insert into tracks(databaseId,location,name) values(?,?,?)")
+            id=track.databaseId.to_i
+            title=track.title.to_s
+            loc=track.location.to_s
+            #ItunesController::ItunesControllerLogging::debug("Adding track to database with id=#{id}, title='#{title}' and location='#{loc}'")
+            begin  
+                @backend.executeStatement(stmt,id,loc,title)
+            rescue ItunesController::DatabaseConstraintException
+                stmt2 = @backend.prepare("select * from tracks where location = ?")
+                rows=@backend.executeStatement(stmt2,loc) 
+                if (rows.next!=nil)
+                    ItunesController::ItunesControllerLogging::warn("Duplicate track reference detected with databaseId #{id}, title '#{title}' and location '#{loc}'")
+                    stmt3 = @backend.prepare("insert into dupe_tracks(databaseId,location,name) values(?,?,?)")
+                    @backend.executeStatement(stmt3,id,loc,title)
+                else
+                    ItunesController::ItunesControllerLogging::warn("Unable to add track to database with #{id}, title '#{title}' and location '#{loc}'")
+                end
+            end
+        end
+
+        def removeTrack(track)
+            ItunesController::ItunesControllerLogging::debug("Removing track from database with id=#{track.databaseId.to_i}'")
+            stmt = @backend.prepare("delete from tracks where databaseId=?")
+            @backend.executeStatement(stmt,track.databaseId.to_i)
+            stmt = @backend.prepare("delete from dead_tracks where databaseId=?")
+            @backend.executeStatement(stmt,track.databaseId.to_i)
+            stmt = @backend.prepare("delete from dupe_tracks where databaseId=?")
+            @backend.executeStatement(stmt,track.databaseId.to_i)
+        end
+
+        def removeTracks()
+            ItunesController::ItunesControllerLogging::debug("Removing all tracks")
+            @backend.execute("delete from tracks")
+            @backend.execute("delete from dead_tracks")
+            @backend.execute("delete from dupe_tracks")
+        end
+
+        def setParam(key,value)
+            stmt = @backend.prepare("delete from params where key=?")
+            @backend.executeStatement(stmt,key)
+            stmt = @backend.prepare("insert into params(key,value) values(?,?)")
+            @backend.executeStatement(stmt,key,value)
+        end
+
+        def getParam(key,default)
+            stmt=@backend.prepare("select value from params where key = ?")
+            rows = @backend.executeStatement(stmt,key)
+            row=rows.next
+            if (row!=nil)
+                return row[0]
+            end
+
+            return default
+        end
+
+        def getTrack(path)
+            stmt=@backend.prepare("select databaseId,location,name from tracks where location=?")
+            rows = @backend.executeStatement(stmt,path)
+            row=rows.next
+            if (row!=nil)
+                return ItunesController::Track.new(row[1],row[0].to_i,row[2])
+            end
+            return nil
+        end
+
+        def getDeadTracks()
+            result=[]
+            stmt=@backend.prepare("select databaseId,location,name from dead_tracks")
+            rows = @backend.executeStatement(stmt)
+            while ((row = rows.next)!=nil)
+                result.push(ItunesController::Track.new(row[1],row[0].to_i,row[2]))
+            end
+            return result
+        end
+
+        def getTrackById(id)
+            stmt=@backend.prepare("select databaseId,location,name from tracks where databaseId=?")
+            rows = @backend.executeStatement(stmt,id)
+            row=rows.next
+            if (row!=nil)
+                return ItunesController::Track.new(row[1],row[0].to_i,row[2])
+            end
+            return nil
+        end
+
+        def close()
+            @backend.close()
+        end
+
+        def getTrackCount()
+            return @backend.execute("select count(*) from tracks")
+        end
+
+     private
+        def createTables()
+            ItunesController::ItunesControllerLogging::debug("Checking database tables exist")
+            @backend.execute("create table if not exists tracks ( databaseId INTEGER PRIMARY KEY, "+
+                                                            "location TEXT NOT NULL, "+
+                                                            "name TEXT NOT NULL) ")
+
+            @backend.execute("create table if not exists dead_tracks ( databaseId INTEGER NOT NULL, "+
+                                                                 "location TEXT, "+
+                                                                 "name TEXT NOT NULL) ")
+
+            @backend.execute("create table if not exists dupe_tracks ( databaseId INTEGER NOT NULL, "+
+                                                                 "location TEXT, "+
+                                                                 "name TEXT NOT NULL) ")
+
+            @backend.execute("create unique index if not exists 'loction_index' on tracks (location)")
+            
+            @backend.execute("create table if not exists params ( key INTEGER PRIMARY KEY, "+
+                                                             "value TEXT NOT NULL) ")
+        end
+    end
+end
+

data/lib/itunesController/database/sqlite3_backend.rb

@@ -0,0 +1,67 @@
+# Copyright (C) 2011-2012  John-Paul.Stanford <dev@stanwood.org.uk>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author:: John-Paul Stanford <dev@stanwood.org.uk>
+# Copyright:: Copyright (C) 2011  John-Paul.Stanford <dev@stanwood.org.uk>
+# License:: GNU General Public License v3 <http://www.gnu.org/licenses/>
+#
+
+require 'itunesController/logging'
+require 'itunesController/platform'
+require 'itunesController/database/backend'
+
+require 'rubygems'
+require 'sqlite3'
+
+module ItunesController
+
+    class SQLite3DatabaseBackend < DatabaseBackend                
+        
+        def initialize(dbPath=nil)
+            if (dbPath==nil)
+                dbPath=ItunesController::Platform::getUserHomeDir()+"/.itunesController/database.db"
+            end
+            if (!File.directory?(File.dirname(dbPath)))
+                FileUtils::mkdir_p(File.dirname(dbPath))
+            end
+            ItunesController::ItunesControllerLogging::info("Database path #{dbPath}")
+            @db=SQLite3::Database.new( dbPath )
+        end
+        
+        def prepare(sql)
+           return @db.prepare(sql)         
+        end
+        
+        def executeStatement(stmt,*args)
+            begin
+                return stmt.execute(*args)
+            rescue SQLite3::ConstraintException => e
+                raise ItunesController::DatabaseConstraintException, e.message
+            end
+        end
+        
+        def execute(sql)
+            begin
+                return @db.execute(sql)
+            rescue SQLite3::ConstraintException => e
+                raise ItunesController::DatabaseConstraintException, e.message
+            end
+        end
+        
+        def close()
+            @db.close()
+        end
+    end
+end

data/lib/itunesController/debug.rb

@@ -0,0 +1,124 @@
+#
+# Copyright (C) 2011-2012  John-Paul.Stanford <dev@stanwood.org.uk>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author:: John-Paul Stanford <dev@stanwood.org.uk>
+# Copyright:: Copyright (C) 2011  John-Paul.Stanford <dev@stanwood.org.uk>
+# License:: GNU General Public License v3 <http://www.gnu.org/licenses/>
+#
+
+module ItunesController    
+    
+    class ItunesControllerDebug     
+                     
+        ANSI_BOLD = "\033[1m"
+        ANSI_RESET = "\033[0m"
+        ANSI_LGRAY = "\033[0;37m"
+        ANSI_GRAY = "\033[1;30m"                  
+        
+        # Used to print the methods of a object
+        # @param [Object] obj The object
+        # @param options
+        def self.pm(obj, *options)
+            methods = obj.methods
+            methods -= Object.methods unless options.include? :more
+            filter = options.select {|opt| opt.kind_of? Regexp}.first
+            methods = methods.select {|name| name =~ filter} if filter
+
+            data = methods.sort.collect do |name|
+                method = obj.method(name)
+                if method.arity == 0
+                    args = "()"
+                elsif method.arity > 0
+                    n = method.arity
+                    args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")})"
+                elsif method.arity < 0
+                    n = -method.arity
+                    args = "(#{(1..n).collect {|i| "arg#{i}"}.join(", ")}, ...)"
+                end
+                klass = $1 if method.inspect =~ /Method: (.*?)#/
+                [name, args, klass]
+            end
+            max_name = data.collect {|item| item[0].size}.max
+            max_args = data.collect {|item| item[1].size}.max
+            data.each do |item|
+                print " #{ANSI_BOLD}#{item[0].to_s.rjust(max_name)}#{ANSI_RESET}"
+                print "#{ANSI_GRAY}#{item[1].ljust(max_args)}#{ANSI_RESET}"
+                print "   #{ANSI_LGRAY}#{item[2]}#{ANSI_RESET}\n"
+            end
+            data.size
+        end
+        
+        # Used to print the methods of a ole object
+        # @param [Object] obj The object   
+        # @param options   
+        def self.pm_ole(obj, *options)
+            methods = obj.ole_methods 
+            methods -= Object.methods unless options.include? :more
+            filter = options.select {|opt| opt.kind_of? Regexp}.first
+            methods = methods.select {|name| name =~ filter} if filter     
+                      
+            data = methods.collect do |m|
+                name = m.to_s               
+                method = obj.ole_method(name)                 
+                [name, "("+method.params.join(",")+")", method.return_type_detail,method.helpstring]
+            end
+            max_name = data.collect {|item| item[0].size}.max
+            max_args = data.collect {|item| item[1].size}.max
+            data.each do |item|
+                print " #{ANSI_BOLD}#{item[0].to_s.rjust(max_name)}#{ANSI_RESET}"
+                print "#{ANSI_GRAY}#{item[1].ljust(max_args)}#{ANSI_RESET}"
+                print "   #{ANSI_LGRAY}#{item[2]}#{ANSI_RESET}\n"
+            end
+            data.size
+        end
+        
+        # Used to print the methods of a objc object
+        # @param [Object] obj The object   
+        # @param options   
+        def self.pm_objc(obj, *options)
+            methods = obj.objc_methods 
+            puts methods
+        end
+
+        # Used to print track information
+        # @param track iTunes track
+        def self.printTrack(track)
+            puts getTrackDescription(track)
+        end      
+
+        # Used to get a track description
+        # @param track iTunes track
+        # @return the track information
+        def self.getTrackDescription(track)
+            result=[]
+            if (track.show!=nil && track.show!="")
+                result.push("Type: TV Episode")
+                result.push("Show Name: "+track.show)
+            else
+                result.push("Type: Film")
+            end
+            result.push("Name: "+track.name)
+            if (Platform.isWindows())
+                result.push("Database ID: "+track.TrackDatabaseID.to_s)
+                result.push("Location: "+track.location)
+            else
+                result.push("Database ID: "+track.databaseID.to_s)
+                result.push("Location: "+track.location.path)
+            end            
+            return result.join("\n")
+        end
+    end
+end

data/lib/itunesController/dummy_itunes_track.rb

@@ -0,0 +1,40 @@
+# Copyright (C) 2011-2012  John-Paul.Stanford <dev@stanwood.org.uk>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author:: John-Paul Stanford <dev@stanwood.org.uk>
+# Copyright:: Copyright (C) 2011  John-Paul.Stanford <dev@stanwood.org.uk>
+# License:: GNU General Public License v3 <http://www.gnu.org/licenses/>
+#
+
+module ItunesController
+    
+    class DummyItunesTrack
+        attr_accessor :location,:databaseID,:name
+                
+        def initialize(location,databaseId,name)
+            @location = location
+            @databaseID = databaseId
+            @name = name
+        end
+        
+        def refresh
+        end
+        
+        def to_s
+            return "Location: '#{@location}' - Database ID: #{@databaseID} - Name: '#{@name}' "
+        end
+    end
+    
+end

data/lib/itunesController/dummy_itunescontroller.rb

@@ -0,0 +1,142 @@
+#
+# Copyright (C) 2011-2012  John-Paul.Stanford <dev@stanwood.org.uk>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Author:: John-Paul Stanford <dev@stanwood.org.uk>
+# Copyright:: Copyright (C) 2011  John-Paul.Stanford <dev@stanwood.org.uk>
+# License:: GNU General Public License v3 <http://www.gnu.org/licenses/>
+#
+require 'itunesController/itunescontroller'
+require 'itunesController/dummy_itunes_track'
+
+module ItunesController
+    # This is a dummy implementation of the itunes controller which can be used
+    # in tests to check that they talk to the server correctly. Any commands
+    # that are recived are logged in the COMMNAD_LOG list. Tests can read
+    # these to make sure they did the correct thing
+    class DummyITunesController < ItunesController::BaseITunesController
+                   
+        # The constructor
+        def initialize            
+        end
+        
+        def self.getCommandLog()
+            return @@commandLog
+        end
+        
+        def self.resetCommandLog()
+            @@commandLog=[]
+        end
+        
+        def self.resetTracks()
+            @@tracks=[]
+        end
+        
+        def self.forceAddTrack(track)
+            ItunesController::ItunesControllerLogging::debug("Force Adding track #{track}")
+            dummyTrack=DummyItunesTrack.new(track.location,track.databaseId,track.title)
+            @@tracks.push(dummyTrack)
+        end
+
+        def version
+            return "Dummy"
+        end
+
+        # Used to tell iTunes to refresh a list of tracks data from the info stored in the files.
+        # This is a dummy implementaion that is used with tests. It pushes messages into the
+        # ItunesController::DummyITunesController::COMMAND_LOG so that tests can check the result.
+        # @param track The track
+        def refreshTracks(tracks)
+            tracks.each do | track |
+                ItunesController::ItunesControllerLogging::debug("Refresh track #{track}")
+                @@commandLog.push("refreshTracks(#{track})")
+            end
+        end
+
+        # Used to remove tracks from the libaray. This is a dummy implementaion that is used with tests.
+        # It pushes messages into the ItunesController::DummyITunesController::COMMAND_LOG so that tests 
+        # can check the result.
+        # @param [Array] tracks A list of tracks to remove from the itunes libaray
+        def removeTracksFromLibrary(tracks)
+            tracks.each do | track |
+                ItunesController::ItunesControllerLogging::debug("Remove track #{track}")
+                @@commandLog.push("removeTracksFromLibrary(#{track})")
+                @@tracks.delete(track)
+            end
+        end
+
+        # Used to add a list of files to the itunes library. This is a dummy implementaion that is used 
+        # with tests. It pushes messages into the ItunesController::DummyITunesController::COMMAND_LOG 
+        # so that tests can check the result.
+        # @param [Array[String]] A list of files to add to the itunes library
+        # @return [Array[ItunesController::Track]] List of ids of the new tracks once they are in the database
+        def addFilesToLibrary(files)
+            tracks=[]          
+            files.each do | file |                                                                             
+                track=ItunesController::Track.new(file,@@tracks.length,"Test #{@@tracks.length}")                
+                ItunesController::ItunesControllerLogging::debug("Adding track #{track}")              
+                dummyTrack=DummyItunesTrack.new(track.location,track.databaseId,track.title)
+                tracks.push(track)                
+                @@tracks.push(dummyTrack)                           
+                @@commandLog.push("addFilesToLibrary("+file+")")                
+            end
+            return tracks
+        end
+        
+        def findPlaylists(types)
+            playlists=[]
+            @@commandLog.push("findPlaylists(types)")
+            return playlists
+        end
+        
+        def getTrackCount()
+            @@commandLog.push("getTrackCount() = #{@@tracks.length}")
+            return @@tracks.length
+        end
+        
+        def getTracks(&b)
+            @@commandLog.push("getTracks()")
+            for i in (0..@@tracks.length-1)
+                track=@@tracks[i]                
+                dead=!File.exist?(track.location)
+                ItunesController::ItunesControllerLogging::debug("Getting track: #{track}, dead = #{dead}")
+                b.call(ItunesController::Track.new(track.location,track.databaseID,track.name),i,@@tracks.length,dead)
+            end
+        end
+             
+        
+        def searchLibrary(title)
+            tracks=[]
+            ItunesController::ItunesControllerLogging::debug("Searching for tracks with title '#{title}'")            
+            @@tracks.each do | track |
+                if (track.name == title)                    
+                    tracks.push(track)                    
+                    ItunesController::ItunesControllerLogging::debug("Found track '#{track}'")
+                end
+            end
+            return tracks
+        end
+        
+        # Used to get the database of a itunes track
+        # @param track the track
+        # @return The database id
+        def getTrackDatabaseId(track)
+            return track.databaseID
+        end
+
+    end
+    
+end
+