media-organizer 0.1.1 → 0.1.2

data/lib/filescanner.rb

@@ -5,108 +5,112 @@
 require 'scrapers/image.rb'
 require 'scrapers/music.rb'
 
-class FileNotValidError < StandardError ; end
 
-class Filescanner
-  include Image
-  include Music
+module MediaOrganizer
 
-  attr_reader :root_nodes
-  attr_accessor :source_list
+  class FileNotValidError < StandardError ; end
 
+  class Filescanner
+    include Image
+    include Music
 
-  def initialize()
-    @root_nodes = []
-    @source_list = []
-  end
+    attr_reader :root_nodes
+    attr_accessor :source_list
 
-  #
-  #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}/**/*")    
+
+    def initialize()
+      @root_nodes = []
+      @source_list = []
     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
+
+    #
+    #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
 
-    return @source_list
+    #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
 
-  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
 
-  #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."
+    #
+    #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
-      @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)
+      return @source_list
     end
-    return @source_list
+    
   end
-  
-end
 
+end
 

data/lib/media-organizer.rb

@@ -3,7 +3,8 @@
 require 'renamer.rb'
 require 'filescanner.rb'
 
-class MediaRenamer < Renamer
-	
+module MediaOrganizer
+	VERSION = "0.1.2"	
+
 end
 

data/lib/renamer.rb

@@ -1,163 +1,212 @@
 #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
+module MediaOrganizer
 
-class Renamer
-	include Image
-	include Music
+	class FileNotValidError < StandardError ; end
+	class InvalidArgumentError < StandardError ; end
+	class UnsupportedFileTypeError < StandardError ; end
+	class RenameFailedError < StandardError ; end
+	
+	#Renamer: primary class to use for renaming files. Allows renaming of a given list of files to a user-defined scheme based on each file's metadata.
+	#
+	#===Key Methods
+	# 	*setNamingScheme()
+	# 	*generateRenameList()
+	# 	*overwrite()
+	#
+	#===Example Usage
+	#
+	#	old_uris = ['./test/data/hs-2003-24-a-full_tif.tif']
+	#
+	#	scheme = ["Test-", :date_time]
+	#
+	#	r = Renamer.new()
+	#
+	#	r.setNamingScheme(scheme)
+	#
+	#	new_uris = r.generateRenameList(old_uris)
+	#
+	#	r.overwrite(new_uris) #new filename: "./test/data/Test-2003-09-03 12_52_43 -0400.tif")
+	#
+	class Renamer
+		DISALLOWED_CHARACTERS = /[\\:\?\*<>\|"\/]/ 	#Characters that are not allowed in file names by many file systems. Replaced with @subchar character.
+
+		attr_accessor	:naming_scheme 	#Array of strings and literals used to construct filenames. Set thruough setNamingScheme as opposed to typical/default accessor.
+		attr_accessor 	:subchar 		#Character with which to substitute disallowed characters
+
+		def initialize(args = {})
+			@naming_scheme = ["Renamed-default-"]
+			@subchar = "_"
+		end
 
-	DISALLOWED_CHARACTERS = /[\\:\?\*<>\|"\/]/
+		#Renamer.setNamingScheme(): sets the naming scheme for the generateRenameList method. 
+		#
+		#===Inputs
+		# 		1. Array containing strings and symbols.
+		#
+		#===Outputs
+		#None (sets instance variable @naming_scheme)
+		#
+		#===Example
+		#setNamingScheme(["Vacation_Photos_", :date_taken]). 
+		#This will rename files into a format like "Vacation_Photos_2014_05_22.png" based on the file's date_taken metadata field.
+		def setNamingScheme(arr = [])
+			@naming_scheme = setScheme(arr)
+		end
 
-	attr_accessor	:naming_scheme 	# => array of strings and literals used to construct filenames
-	attr_accessor 	:subchar
+		#Renamer.generateRenameList(): Creates a hash mapping the original filenames to the new (renamed) filenames
+		#
+		#===Inputs
+		# 		1. List of URIs in the form of an array
+		# 		2. Optional hash of arguments.
+		# 			*:scheme - array of strings and symbols specifying file naming convention
+		#
+		#===Outputs
+		#Hash of "file name pairs." old_file => new_file
+		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
 
-	def initialize(args = {})
-		@naming_scheme = ["Renamed-default-"]
-		@subchar = "_"
-	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
 
-	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
+			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
 
-		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
+		#Renamer.overwrite(): Writes new file names based upon mapping provided in hash argument. NOTE: this will create changes to file names!
+		#
+		#===Inputs 
+		# 		1. Hash containing mappings between old filenames (full URI) and new filenames (full URI). Example: {"/path/to/oldfile.jpg" => "/path/to/newfile.jpg"}
+		#
+		#===Outputs 
+		#none (file names are overwritten)
+		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
 
-		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
+		#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.
+		#
+		#===Inputs 
+		#String containing full file URI (path and filename) 
+		#
+		#===Outputs 
+		#Returns hash of metadata for file, or nil if none/error.
+		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
+		rescue UnsupportedFileTypeError => e
+			puts "Could not process file: Extension #{File.extname(file)} is not supported."
+			puts e.backtrace.inspect
 		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
+		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 subHazardousChars(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
-		#puts "Found file metadata: #{metadata[:date_time]}"
-		return subHazardousChars(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
+		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
-		return clean_scheme
-	end
 
-	def subHazardousChars(str = "")
-		return str.gsub(DISALLOWED_CHARACTERS, @subchar)
+		def subHazardousChars(str = "")
+			return str.gsub(DISALLOWED_CHARACTERS, @subchar)
+		end
 	end
-end
 
+end

data/lib/scrapers/image.rb

@@ -2,40 +2,43 @@ require 'exifr'
 
 class FileNotFoundError < StandardError ; end
 
-module Image
-	SUPPORTED_FILETYPES = %w{.jpg .tif}
+module MediaOrganizer
 
-	def Image.getJpegData(file)
-		meta = EXIFR::JPEG.new(file)
-		return meta.to_hash
-		#!!! Rescue from common file-related and exifr-related errors here
-	end
+	module Image
+		SUPPORTED_FILETYPES = %w{.jpg .tif}
 
-	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.getJpegData(file)
+			meta = EXIFR::JPEG.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.getTiffData(file)
+			meta = EXIFR::TIFF.new(file)	
+			return meta.to_hash
+			#!!! Rescue from common file-related and exifr-related errors here
+		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."
+		def Image.supported_filetypes
+			return SUPPORTED_FILETYPES		
 		end
 
-		if SUPPORTED_FILETYPES.include?(File.extname(uri).downcase)
-			return true
-		else
+		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
 
-	rescue FileNotFoundError => e
-		puts e.message
-		puts e.backtrace.inspect
-		return false
 	end
-
 end

data/lib/scrapers/music.rb

@@ -1,59 +1,116 @@
 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
+module MediaOrganizer
 
-	def Music.supported_filetypes
-		reutrn SUPPORTED_FILETYPES		
-	end
+	class FileNotFoundError < StandardError ; end
+
+	module Music
+
+		SUPPORTED_FILETYPES = %w{.mp3 .m4a .mp4 .flac .m4a .ogg .aiff .asf .wav}
 
-	def Music.is_music?(uri)
-		unless !uri.nil? && uri.is_a?(String) && File.exists?(uri)
-			raise FileNotFoundError, "Directory given (#{uri}) could not be accessed."
+		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[:title] = tag.title
+		        attributes[:track] = tag.track
+		        attributes[:genre] = tag.genre
+		        attributes[:year] = tag.year
+		        attributes[:album] = tag.album
+		        attributes[:artist] = tag.artist
+		        attributes[:comment] = tag.comment
+		        	        
+		        attributes[:length] = properties.length
+		        attributes[:bitrate] = properties.bitrate
+		        attributes[:channels] = properties.channels
+		        attributes[:sample_rate] = properties.sample_rate
+		        
+		      end
+		    end
+		    return attributes
 		end
 
-		if SUPPORTED_FILETYPES.include?(File.extname(uri).downcase)
-			return true
-		else
+		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
 
-	rescue FileNotFoundError => e
-		puts e.message
-		puts e.backtrace.inspect
-		return false
-	end
+		#
+		#availableMetadata(file, args): returns list of fields available as metadata for the given file.
+		#
+		#===Inputs
+		# 	*(1) filepath: full/absolute URI of the file to be analyzed. Required input.
+		# 	*(2) args: optional arguments passed as hash. Set ":include_null" to false to only return populated metadata fields.
+		#
+		def Music.availableMetadata(filepath = "", args = {})
+			attrs = getMusicData(filepath)
+
+			unless args[:include_null] == false
+				attrs.each do |field, value|
+					if value == nil || value == ""
+						attrs.delete(field)
+					end
+				end
+			end
+			return attrs
+		end
 
+		#
+		#writeMetadata(file = "", meta = {}): returns list of fields available as metadata for the given file.
+		#
+		#===Inputs
+		# 	*(1) filepath: full/absolute URI of the file to be analyzed. Required input.
+		# 	*(2) meta: metadata to be written, passed as a hash in the format :metadata_field => metadata_value
+		#
+		#===Outputs
+		#Returns true if the file was successfully saved. Note: true status does not necessarily indicate each field was successfully written.
+		#
+		#===Examples
+		#Music.writeMetadata("/absolute/path/to/file.mp3", {:artist => "NewArtistName", :year => "2019"})
+		#
+		def Music.writeMetadata(filepath, meta = {})
+			attributes = {}
+			successflag = false
+		    TagLib::FileRef.open(filepath) do |fileref|
+		      unless fileref.null?
+		        #sign tags to local variables
+		        tag = fileref.tag
+		        properties = fileref.audio_properties	        
 
-end
+		        meta.each do |field, value|
+					if tag.respond_to?(field)
+						tag.send("#{field.to_s}=", value)
+					elsif properties.respond_to?(field)
+						properties.send("#{field.to_s}=", value)
+					end
+	            end
+				successflag = fileref.save
+		      end
+		    end	    
+		    return successflag
 
+		end
+
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: media-organizer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-01 00:00:00.000000000 Z
+date: 2015-03-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: taglib-ruby