media-organizer 0.1.0

data/lib/filescanner.rb

@@ -0,0 +1,112 @@
+#
+#filescanner.rb: defines the class Filescanner, which scans directory trees for media files
+#
+
+require 'scrapers/image.rb'
+require 'scrapers/music.rb'
+
+class FileNotValidError < StandardError ; end
+
+class Filescanner
+  include Image
+  include Music
+
+  attr_reader :root_nodes
+  attr_accessor :source_list
+
+
+  def initialize()
+    @root_nodes = []
+    @source_list = []
+  end
+
+  #
+  #Filescanner.open(String, {}): scans directory tree for media files, starting at String specified in first argument.
+  #
+  #==Inputs
+  #===Required
+  #(1) String: String containing the URI of the top of the directory tree to scan
+  #
+  #===Optional
+  #(2) Arguments Hash:
+  #*:mode => (:single) -- if set to :single, only the given URI will be scanned. Subdirectories will be ignored. 
+  #*:music => (true, false) -- if true, music files will be included in the scan. Set to false to exclude music files. Defaults to true
+  #*:image => (true, false) -- if true, image files will be included in the scan. Set to false to exclude image files. Defaults to true
+  #
+  #==Outputs
+  #Returns array of strings, where each string is a file URI for a music or image file. 
+  #
+  #
+  #==Usage Example
+  #Filescanner.open("/absolute/path/for/top/of/directory/tree")
+  #
+  def open(uri = "", args = {})
+    unless !uri.nil? && uri.is_a?(String) && (File.directory?(uri) || File.exists?(uri))   
+      raise FileNotFoundError, "Directory given (#{uri}) could not be accessed."
+    end
+    
+    include_images = true unless args[:image] == false     
+    include_music = true unless args[:music] == false     
+    files = []
+    if args[:mode] == :single
+      files = Dir.glob("#{uri}/*")
+    else
+      files = Dir.glob("#{uri}/**/*")    
+    end
+    
+    #add all files found to @source_list, if they are music files
+    files.each do |f|
+      if (Music.is_music?(f) && include_music) || (Image.is_image?(f) && include_images)
+        @source_list << f
+      end
+    end
+
+    return @source_list
+
+  rescue FileNotFoundError => e
+    puts e.message
+    puts e.backtrace.inspect
+    return false
+  end
+
+  #alternative run mode. Add multiple "root" directories to scan at once
+  def addRoot(dir_uri)
+      unless !dir_uri.nil? && dir_uri.is_a?(String) && File.directory?(dir_uri)   
+        raise FileNotFoundError, "Directory given (#{dir_uri}) could not be accessed."
+      end
+      @root_nodes << dir_uri
+  rescue FileNotFoundError => e
+    puts e.message
+    puts e.backtrace.inspect
+    return false
+  end
+
+  #<<(): synonym for addRoot(). Also a deformed emoticon.
+#  def << (dir_uri) addRoot(dir_uri)  end
+
+  #
+  #multiscan(): scans multiple directories added to @root_nodes using the addRoot() method.
+  #
+  #==Inputs
+  #===Required
+  #none  
+  #
+  #===Optional
+  #(1) Arguments Hash:
+  #*:mode => (:single, :multiple) 
+  #*:music => (true, false) -- if true, music files will be included in the scan. Set to false to exclude music files. Defaults to true
+  #*:image => (true, false) -- if true, image files will be included in the scan. Set to false to exclude image files. Defaults to true
+  #
+  #==Outputs
+  #Array of strings, where each string is a file URI for a music or image file.
+  #
+  def multiscan(args = {})
+    @root_nodes.each do |uri|
+      open(uri, args)
+    end
+    return @source_list
+  end
+  
+end
+
+

data/lib/media-organizer.rb

@@ -0,0 +1,9 @@
+#media-renamer.rb
+
+require 'renamer.rb'
+require 'filescanner.rb'
+
+class MediaRenamer < Renamer
+	
+end
+

data/lib/renamer.rb

@@ -0,0 +1,158 @@
+#renamer.rb: main codebase for the media-renamer gem. 
+#Currently configured to only rename JPG and TIF files (using EXIFR to extract metadata)
+	#next major release will include support 
+
+
+require 'scrapers/image.rb'
+require 'scrapers/music.rb'
+
+class FileNotValidError < StandardError ; end
+class InvalidArgumentError < StandardError ; end
+class UnsupportedFileTypeError < StandardError ; end
+class RenameFailedError < StandardError ; end
+
+
+class Renamer
+	include Image
+	include Music
+	attr_accessor	:naming_scheme 	# => array of strings and literals used to construct filenames
+
+	def initialize
+		@naming_scheme = ["Renamed-default-"]
+	end
+
+	def setNamingScheme(arr = [])
+		@naming_scheme = setScheme(arr)
+	end
+	#Input: list of URIs in the form of an array
+	#Output: hash of "file name pairs." old_file => new_file
+	#Accepts optional arguments: :scheme (array of strings and symbols specifying file naming convention)
+	def generateRenameList(uri_list = [], args = {})
+		if args[:scheme] != nil && args[:scheme].is_a?(Array) && !args[:scheme].empty?
+			scheme = setScheme(args[:scheme])
+		else
+			scheme = @naming_scheme
+		end
+		unless !uri_list.nil? && uri_list.is_a?(Array) 
+			raise InvalidArgumentError
+		end
+
+		filename_pairs = {}
+		uri_list.each do |i|
+			new_string = handleFile(i, scheme)
+			#If this is a valid file path, add it to the filename_pairs
+			#puts "New file rename added: #{new_string}"
+			if new_string != nil && new_string != ""
+				filename_pairs[i] = new_string
+			end
+		end
+
+		return filename_pairs
+	
+	rescue InvalidArgumentError => arg_e
+		puts arg_e
+		puts "Invalid arguments provided. Expected: uri_list = [], args = {}"
+		puts arg_e.backtrace.inspect
+	rescue => e
+		puts e 
+		puts e.message 
+		puts e.backtrace.inspect
+	end
+
+	def overwrite(renames_hash = {})
+		renames_hash.each do |old_name, new_name|
+			begin
+				#error/integrity checking on old_name and new_name
+	  			raise FileNotValidError, "Could not access specified source file: #{i}." unless old_name.is_a?(String) && File.exists?(old_name)    
+	    		raise FileNotValidError, "New file name provided is not a string" unless new_name.is_a?(String)
+	    		
+	    		#puts (File.dirname(File.absolute_path(old_name)) + "/" + new_name) #Comment this line out unless testing
+	    		File.rename(File.absolute_path(old_name),File.dirname(File.absolute_path(old_name)) + "/" + new_name)
+								
+				#check that renamed file exists - Commented out because this currently does not work.
+				#unless new_name.is_a?(String) && File.exists?(new_name)    
+	      		#	raise RenameFailedError, "Could not successfuly rename file: #{old_name} => #{new_name}. Invalid URI or file does not exist."
+	    		#end
+	    	rescue => e
+	    		puts "Ignoring rename for #{old_name} => #{new_name}"
+	    		puts e
+	    		puts e.backtrace.inspect
+			end
+		end
+	end
+
+	#Routes metadata scrape based on file type (currently relies on extension - future version should use MIME)
+	#currently assumes file was checked for validity in calling code
+	def	getFileMetadata(file)
+		
+		#LOAD EXIF DATA	
+		case File.extname(file).downcase
+		when '.jpg'
+			Image::getJpegData(file)
+		when '.tif'
+			Image::getTiffData(file)
+		when '.mp3' , '.wav' , '.flac' , '.aiff', '.ogg', '.m4a', '.asf'
+			Music::getMusicData(file)
+		else
+			raise UnsupportedFileTypeError, "Error processing #{file}"
+		end
+		#otherwise, outsource
+	rescue UnsupportedFileTypeError => e
+		puts "Could not process file: Extension #{File.extname(file)} is not supported."
+		puts e.backtrace.inspect
+	end
+
+
+	private
+	def handleFile(file, scheme)
+			#Check file is real
+	    unless file.is_a?(String) && File.exists?(file) 
+  			raise FileNotValidError, "Could not access specified file file: #{file}."
+		end
+		#convert URI (i) to absolute path
+
+		#get metadata hash for this file (i)
+		metadata = getFileMetadata(File.absolute_path(file))
+		#build URI string
+		new_string = ""
+		scheme.each do |j|
+			if j.is_a?(String) then new_string += j
+			elsif j.is_a?(Symbol) 
+				begin
+					raise EmptyMetadataError unless metadata[j] != nil
+					new_string += metadata[j].to_s
+				rescue => e 
+					puts "Could not get string for metadata tag provided in scheme: #{j} for file #{file}." 
+					puts "Ignoring file #{file}"
+					puts e.backtrace.inspect
+					return nil
+				end
+			end
+		end
+		#puts "Found file metadata: #{metadata[:date_time]}"
+		return new_string + File.extname(file)	
+	rescue FileNotValidError => e
+		puts ("Ignoring file #{file}")
+		puts e 
+		puts e.backtrace
+		return nil
+	rescue => e
+		puts e.message
+		puts e.backtrace.inspect
+		return nil
+	end
+
+	def setScheme(input_arr = [])
+		clean_scheme = []
+		input_arr.each do |i|
+			if i.is_a?(String) || i.is_a?(Symbol)
+				clean_scheme << i
+			end
+		end
+		return clean_scheme
+	end
+end
+
+
+
+

data/lib/scrapers/image.rb

@@ -0,0 +1,41 @@
+require 'exifr'
+
+class FileNotFoundError < StandardError ; end
+
+module Image
+	SUPPORTED_FILETYPES = %w{.jpg .tif}
+
+	def Image.getJpegData(file)
+		meta = EXIFR::JPEG.new(file)
+		return meta.to_hash
+		#!!! Rescue from common file-related and exifr-related errors here
+	end
+
+	def Image.getTiffData(file)
+		meta = EXIFR::TIFF.new(file)	
+		return meta.to_hash
+		#!!! Rescue from common file-related and exifr-related errors here
+	end
+
+	def Image.supported_filetypes
+		return SUPPORTED_FILETYPES		
+	end
+
+	def Image.is_image?(uri)
+		unless !uri.nil? && uri.is_a?(String) && File.exists?(uri)
+			raise FileNotFoundError, "Directory given (#{uri}) could not be accessed."
+		end
+
+		if SUPPORTED_FILETYPES.include?(File.extname(uri).downcase)
+			return true
+		else
+			return false
+		end
+
+	rescue FileNotFoundError => e
+		puts e.message
+		puts e.backtrace.inspect
+		return false
+	end
+
+end

data/lib/scrapers/music.rb

@@ -0,0 +1,59 @@
+require 'taglib'
+
+class FileNotFoundError < StandardError ; end
+
+module Music
+
+	SUPPORTED_FILETYPES = %w{.mp3 .m4a .mp4 .flac .m4a .ogg .aiff .asf .wav}
+
+	def Music.getMusicData(file)
+		attributes = {}
+	    TagLib::FileRef.open(file) do |fileref|
+	      unless fileref.null?
+	        #sign tags to local variables
+	        tag = fileref.tag
+	        properties = fileref.audio_properties
+	        
+	        #load tags into attributes attribute
+	        attributes[:track_name] = tag.title
+	        attributes[:track_number] = tag.track
+	        attributes[:track_genre] = tag.genre
+	        attributes[:track_release_date] = tag.year
+	        attributes[:album_name] = tag.album
+	        attributes[:artist_name] = tag.artist
+	        attributes[:comment] = tag.comment
+	        	        
+	        attributes[:track_length] = properties.length
+	        attributes[:track_bitrate] = properties.bitrate
+	        attributes[:track_channels] = properties.channels
+	        attributes[:track_sample_rate] = properties.sample_rate
+	        
+	      end
+	    end
+	    return attributes
+	end
+
+	def Music.supported_filetypes
+		reutrn SUPPORTED_FILETYPES		
+	end
+
+	def Music.is_music?(uri)
+		unless !uri.nil? && uri.is_a?(String) && File.exists?(uri)
+			raise FileNotFoundError, "Directory given (#{uri}) could not be accessed."
+		end
+
+		if SUPPORTED_FILETYPES.include?(File.extname(uri).downcase)
+			return true
+		else
+			return false
+		end
+
+	rescue FileNotFoundError => e
+		puts e.message
+		puts e.backtrace.inspect
+		return false
+	end
+
+
+end
+

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: media-organizer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Stephen Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: taglib-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: exifr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'Provides a set of functions for scanning directory trees and dynamically
+  renaming files using their metadata, according to a customizable taxonomy. For example,
+  use media-organizer to set filenames for a directory of photos to a standard such
+  as: "<date-taken> - Ski Vacation.jpg". Currently supports only JPEG and TIFF files,
+  and various music formats.'
+email: djeserkare@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/media-organizer.rb
+- lib/renamer.rb
+- lib/filescanner.rb
+- lib/scrapers/image.rb
+- lib/scrapers/music.rb
+homepage: http://rubygems.org/gems/media-organizer
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Organize & rename files in bulk based on file metadata.
+test_files: []