media-organizer 0.1.5 → 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b335d2088f9101cc6029772adee22c6700a5172
+  data.tar.gz: 04066471b4bc4c5a435ad382573caff3de4268a7
+SHA512:
+  metadata.gz: f466fc9895d1ecfc1e42f66a194d5123210876ee04f7846c100d4a8d23f4bb65fc2e1d3160e1caa05642b57f8a715653f6710d56d8d1b2c3d35d4d92e815a5ef
+  data.tar.gz: b6f2cb8be7177a70e0304bd64240f03541cc886bd9ef44f8b57333f9785f616af3d95c23a8a0cef12da3991e6330016ffb08a6102671f6f2c964333342154034

data/lib/filescanner.rb

@@ -1,115 +1,144 @@
 #
-#filescanner.rb: defines the class Filescanner, which scans directory trees for media files
+# filescanner.rb: defines the class Filescanner, which scans directory trees for media files
 #
 
 require 'scrapers/image.rb'
 require 'scrapers/music.rb'
 
-
 module MediaOrganizer
-
-
-  #FileScanner: scans a file system for images and/or music files, providing a list of file URIs.
-  #Output of FileScanner.open() returns a list of paths that can then be consumed by MediaOrganizer::Renamer.
-  #
-  #===Example
-  #
-  #Filescanner.open("/path/to/files/", {:image => true, :music => true})
-  #
-  #This will return a list of all music and image files contained in /path/to/files/ and it's
   class Filescanner
-    class FileNotValidError < StandardError ; end
-    class FileNotFoundError < StandardError ; end
-
+    include Image
+    include Music
 
     attr_reader :root_nodes
     attr_accessor :source_list
 
-
-    def initialize()
+    def initialize
       @root_nodes = []
       @source_list = []
     end
 
     #
-    #Filescanner.open(String, {}): scans directory tree for media files, starting at String specified in first argument.
+    # Filescanner.open(String, {}): scans directory tree for media files,
+    # starting at String specified in first argument.
     #
-    #===Inputs
-    #   *(1) String: String containing the URI of the top of the directory tree to scan
+    #==Inputs
+    #===Required
+    # (1) String: String containing the URI of the top of the directory tree to scan
     #
-    #   *2: Optional 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
+    #===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. 
+    #==Outputs
+    # Returns array of strings, where each string is a file URI for a music or image file.
     #
     #
-    #===Example
-    #Filescanner.open("/absolute/path/for/top/of/directory/tree")
+    #==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
+    def open(uri = '', args = {})
+      include_images = true unless args[:image] == false
+      include_music = true unless args[:music] == false
+
+      files = load_files(uri, args[:mode])
       files.each do |f|
-        if (Music.is_music?(f) && include_music) || (Image.is_image?(f) && include_images)
+        if (Music.music?(f) && include_music) || (Image.image?(f) && include_images)
           @source_list << f
         end
       end
 
       return @source_list
 
-    rescue FileNotFoundError => e
-      puts e.message
-      puts e.backtrace.inspect
+    rescue StandardError => e
+      puts "Warning: #{e.message}"
       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
+    # alternative run mode. Add multiple "root" directories to scan at once
+    def add_root(dir_uri)
+      validate_uri(dir_uri)
+      @root_nodes << dir_uri
+    rescue StandardError => e
+      puts "Warning: #{e.message}"
       return false
     end
 
-    #Filescanner:multiscan(): scans multiple directories added to @root_nodes using the addRoot() method.
+    # <<(): synonym for add_root(). Also a deformed emoticon.
+    #  def << (dir_uri) add_root(dir_uri)  end
+
+    #
+    # multiscan(): scans multiple directories added to @root_nodes using the add_root() method.
     #
-    #===Inputs
+    #==Inputs
+    #===Required
+    # none
     #
-    # @param [Hash] args Optional Arguments Hash:
-    # @option args [Symbol] :mode sets the mode to :single or :multiple 
-    # @option args [Boolean] :music => (true, false) -- if true, music files will be included in the scan. Set to false to exclude music files. Defaults to true
-    # @option args [Boolean] :image => (true, false) -- if true, image files will be included in the scan. Set to false to exclude image files. Defaults to true
+    #===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
-    # @return [Array<String>] Array of strings, where each string is a file URI for a music or image file.
+    #==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
+      @source_list
     end
-    
-  end
 
-end
+    private
 
+    # validate_uri(): support method for validating a file system URI.
+    #
+    #==Inputs
+    #===Required
+    # (1) String: String containing the URI to validate.
+    #
+    #===Optional
+    # none
+    #==Outputs
+    # Returns true if the URI is valid. Raises a StandardError exception if it is not.
+    #
+    def validate_uri(uri)
+      unless !uri.nil? && uri.is_a?(String) && (File.directory?(uri) || File.exist?(uri))
+        raise StandardError, "Directory given (#{uri}) could not be accessed."
+      end
+      true
+    end
+
+    #
+    # load_files(): given a URI and optional mode, scans and loads every file in
+    # the specifid folder or tree.
+    #
+    #==Inputs
+    #===Required
+    # (1) String: String containing the URI to validate.
+    #
+    #===Optional
+    # (1) Arguments Hash:
+    # *:mode => (:single, :multiple) - :single loads a folder, :multiple loads a full tree.
+    #
+    #==Outputs
+    # Array of strings, where each string is a file URI for a music or image file.
+    #
+    def load_files(uri, mode)
+      validate_uri(uri)
+      if !mode.nil? && mode == :single
+        Dir.glob("#{uri}/*")
+      else
+        Dir.glob("#{uri}/**/*")
+      end
+    end
+  end
+end

data/lib/media-organizer.rb

@@ -1,15 +1,8 @@
-#media-renamer.rb
+# media-renamer.rb
 
 require 'renamer.rb'
 require 'filescanner.rb'
 
-#MediaOrganizer: namespace container for MediaOrganizer sub-classes:
-# 	*Renamer
-# 	*Filescanner
-# 	*Image
-# 	*Music
 module MediaOrganizer
-	VERSION = "0.1.4"	
-
+  VERSION = '0.1.5'.freeze
 end
-

data/lib/metadata.rb

@@ -0,0 +1,19 @@
+# metadata.rb: contains definition of the Metadata module, which provides
+# a set of methods for analyzing metadata across multiple files, such as:
+# *Metadata.completeness(arr, fields): for each metadata field provided in the "fields" argument, returns a completeness score.
+# **E.g. {date_time: .95} means 95% of the files in arr have data in the "date_time" field
+# *Metadata.fields(arr): returns the full list of fields available, aggregated across all files in arr
+
+require 'scrapers/music.rb'
+require 'scrapers/image.rb'
+
+module Metadata
+  def self.completeness(arr = [], fields = [])
+    fields_count = {}
+    fields.each do |i|
+      fields_count[i] = 0
+    end
+    arr.each do |file|
+    end
+  end
+end

data/lib/renamer.rb

@@ -1,209 +1,193 @@
-#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 
+# 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'
 
 module MediaOrganizer
-	
-	#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.
-		class RenameFailedError < StandardError ; end
-		class FileNotValidError < StandardError ; end
-		class InvalidArgumentError < StandardError ; end
-		class UnsupportedFileTypeError < StandardError ; end
-		class FileNotFoundError < StandardError ; end
-
-
-		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
-
-		# Renamer.setNamingScheme(): sets the naming scheme for the generateRenameList method. 
-		#
-		# @param [Array<String, Symbol>] arr contains strings and symbols representing the naming scheme.
-		#
-		# @return [void] instance variable @naming_scheme is set based upon input
-		#
-		# @example Set the naming scheme to a format like "Vacation_Photos_2014_05_22.png" based on the file's date_taken metadata field.
-		# 	setNamingScheme(["Vacation_Photos_", :date_taken]). 
-		#
-		def setNamingScheme(arr = [])
-			@naming_scheme = setScheme(arr)
-		end
-
-		#Renamer.generateRenameList(): Creates a hash mapping the original filenames to the new (renamed) filenames
-		#
-		# @param [Array<String>] uri_list contains list of URIs (as full AKA absolute paths)
-		# @param [Hash] args hash of options.
-		# @option args [Array<String, Symbol>] :scheme - array of strings and symbols specifying file naming convention
-		#
-		# @return [Hash] filename_pairs - mapping between old filenames and new filenames 
-		#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
-
-			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
-
-		#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
-
-		#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
-
-
-		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
-
-		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
-
-		def subHazardousChars(str = "")
-			return str.gsub(DISALLOWED_CHARACTERS, @subchar)
-		end
-	end
-
+  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
+  # 	*naming_scheme()
+  # 	*generate()
+  # 	*overwrite()
+  #
+  #===Example Usage
+  #
+  #	old_uris = ['./test/data/hs-2003-24-a-full_tif.tif']
+  #
+  #	scheme = ["Test-", :date_time]
+  #
+  #	r = Renamer.new()
+  #
+  #	r.set_naming_scheme(scheme)
+  #
+  #	new_uris = r.generate(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_reader	:naming_scheme	# Array of strings and literals used to construct filenames. Set thruough naming_scheme 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
+
+    # Renamer.naming_scheme(): sets the naming scheme for the generate method.
+    #
+    #===Inputs
+    # 		1. Array containing strings and symbols.
+    #
+    #===Outputs
+    # None (sets instance variable @naming_scheme)
+    #
+    #===Example
+    # naming_scheme(["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 set_naming_scheme(arr = [])
+      @naming_scheme = set_scheme(arr)
+    end
+
+    # Renamer.generate(): 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 generate(uri_list = [], args = {})
+      scheme = if !args[:scheme].nil? && args[:scheme].is_a?(Array) && !args[:scheme].empty?
+                 set_scheme(args[:scheme])
+               else
+                 @naming_scheme
+               end
+      raise InvalidArgumentError unless !uri_list.nil? && uri_list.is_a?(Array)
+
+      filename_pairs = {}
+      uri_list.each do |i|
+        new_string = handle_file(i, scheme)
+        # If this is a valid file path, add it to the filename_pairs
+        # puts "New file rename added: #{new_string}"
+        filename_pairs[i] = new_string if !new_string.nil? && new_string != ''
+      end
+
+      return filename_pairs
+
+    rescue InvalidArgumentError => arg_e
+      puts arg_e
+      puts 'Invalid arguments provided. Expected: uri_list = [], args = {}'
+    rescue => e
+      puts e.message
+      puts e.backtrace.inspect
+    end
+
+    # 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.exist?(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.exist? - Commented out because this currently does not work.
+        # unless new_name.is_a?(String) && File.exist?(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}"
+        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.
+    #
+    #===Inputs
+    # String containing full file URI (path and filename)
+    #
+    #===Outputs
+    # Returns hash of metadata for file, or nil if none/error.
+    def	get_metadata(file)
+      # LOAD EXIF DATA
+      case File.extname(file).downcase
+      when '.jpg'
+        Image.get_jpeg_data(file)
+      when '.tif'
+        Image.get_tiff_data(file)
+      when '.mp3', '.wav', '.flac', '.aiff', '.ogg', '.m4a', '.asf'
+        Music.get_music_data(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
+
+    private
+
+    def handle_file(file, scheme)
+      # Check file is real
+      unless file.is_a?(String) && File.exist?(file)
+        raise FileNotValidError, "Could not access specified file file: #{file}."
+      end
+      metadata = get_metadata(File.absolute_path(file))
+      new_string = ''
+      scheme.each do |j|
+        if j.is_a?(String) then new_string += j
+        elsif j.is_a?(Symbol)
+          begin
+            raise EmptyMetadataError if 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}"
+            return nil
+          end
+        end
+      end
+      return sub_hazardous_chars(new_string + File.extname(file))
+
+    rescue FileNotValidError => e
+      puts "Ignoring file #{file}"
+      puts e
+      return nil
+    rescue => e
+      puts e.message
+      puts e.backtrace.inspect
+      return nil
+    end
+
+    def set_scheme(input_arr = [])
+      clean_scheme = []
+      input_arr.each do |i|
+        clean_scheme << i if i.is_a?(String) || i.is_a?(Symbol)
+      end
+      clean_scheme
+    end
+
+    def sub_hazardous_chars(str = '')
+      str.gsub(DISALLOWED_CHARACTERS, @subchar)
+    end
+  end
 end

data/lib/scrapers/image.rb

@@ -1,46 +1,45 @@
+#
+# image.rb: defines the class Image, which validates and loads
+# image files, providing image metadata in a hash format.
+#
+
 require 'exifr'
 
 module MediaOrganizer
-
-	module Image
-		SUPPORTED_FILETYPES = %w{.jpg .tif}
-		class FileNotFoundError < StandardError ; end
-		#
-		# @param [String] file URI for the file from which to pull metadata
-		#
-		# @return [Hash] metadata fields associated with the file provided as input
-		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
+  module Image
+    SUPPORTED_FILETYPES = %w(.jpg .tif).freeze
+
+    def self.get_jpeg_data(file)
+      meta = EXIFR::JPEG.new(file)
+      meta.to_hash
+      # !!! Rescue from common file-related and exifr-related errors here
+    end
+
+    def self.get_tiff_data(file)
+      meta = EXIFR::TIFF.new(file)
+      meta.to_hash
+      # !!! Rescue from common file-related and exifr-related errors here
+    end
+
+    def self.supported_filetypes
+      SUPPORTED_FILETYPES
+    end
+
+    def self.image?(uri)
+      unless !uri.nil? && uri.is_a?(String) && File.exist?(uri)
+        raise StandardError, "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
 end

data/lib/scrapers/music.rb

@@ -1,115 +1,112 @@
+#
+# music.rb: defines the scraper module Music, which validates and loads
+# music files, providing image metadata in a hash format.
+#
 require 'taglib'
 
 module MediaOrganizer
+  module Music
+    SUPPORTED_FILETYPES = %w(.mp3 .m4a .mp4 .flac .m4a .ogg .aiff .asf .wav).freeze
 
-	module Music
-		class FileNotFoundError < StandardError ; end
+    def self.get_music_data(file)
+      attributes = {}
+      TagLib::FileRef.open(file) do |fileref|
+        unless fileref.null?
+          # sign tags to local variables
+          tag = fileref.tag
+          properties = fileref.audio_properties
 
-		SUPPORTED_FILETYPES = %w{.mp3 .m4a .mp4 .flac .m4a .ogg .aiff .asf .wav}
+          # 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
 
-		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
+          attributes[:length] = properties.length
+          attributes[:bitrate] = properties.bitrate
+          attributes[:channels] = properties.channels
+          attributes[:sample_rate] = properties.sample_rate
 
-		def Music.supported_filetypes
-			reutrn SUPPORTED_FILETYPES		
-		end
+        end
+      end
+      attributes
+    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
+    def self.supported_filetypes
+      reutrn SUPPORTED_FILETYPES
+    end
 
-			if SUPPORTED_FILETYPES.include?(File.extname(uri).downcase)
-				return true
-			else
-				return false
-			end
+    def self.music?(uri)
+      unless !uri.nil? && uri.is_a?(String) && File.exist?(uri)
+        raise StandardError, "Directory given (#{uri}) could not be accessed."
+      end
 
-		rescue FileNotFoundError => e
-			puts e.message
-			puts e.backtrace.inspect
-			return false
-		end
+      if SUPPORTED_FILETYPES.include?(File.extname(uri).downcase)
+        return true
+      else
+        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)
+    rescue FileNotFoundError => e
+      puts e.message
+      puts e.backtrace.inspect
+      return false
+    end
 
-			unless args[:include_null] == false
-				attrs.each do |field, value|
-					if value == nil || value == ""
-						attrs.delete(field)
-					end
-				end
-			end
-			return attrs
-		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 self.availableMetadata(filepath = '', args = {})
+      attrs = get_music_data(filepath)
 
-		#
-		#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	        
+      unless args[:include_null] == false
+        attrs.each do |field, value|
+          attrs.delete(field) if value.nil? || value == ''
+        end
+      end
+      attrs
+    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
+    #
+    # 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 self.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
-
-	end
+          meta.each do |field, value|
+            if tag.respond_to?(field)
+              tag.send("#{field}=", value)
+            elsif properties.respond_to?(field)
+              properties.send("#{field}=", value)
+            end
+          end
+          successflag = fileref.save
+        end
+      end
+      successflag
+    end
+  end
 end

metadata

@@ -1,55 +1,52 @@
 --- !ruby/object:Gem::Specification
 name: media-organizer
 version: !ruby/object:Gem::Version
-  version: 0.1.5
-  prerelease: 
+  version: 0.1.6
 platform: ruby
 authors:
 - Stephen Johnson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-24 00:00:00.000000000 Z
+date: 2016-03-28 00:00:00.000000000 Z
 dependencies: []
-description: ! 'Provides a set of functions to scan file systems for media files,
-  and dynamically rename them using their metadata. Files are renamed according to
-  a customizable taxonomy. For example, use MediaOrganizer::Renamer 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. Future releases will include support
-  for music and additional image files.'
+description: 'Dynamically renaming files using their metadata, according to a customizable
+  pattern. For example, use media-organizer to set filenames for a library of photos
+  to a customizable standard such as: "<date-taken> - Ski Vacation.jpg". Currently
+  supports only JPEG, TIFF, MP3, M4A, WAV, FLAC, and OGG files.'
 email: djeserkare@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/renamer.rb
-- lib/media-organizer.rb
 - lib/filescanner.rb
-- lib/scrapers/music.rb
+- lib/media-organizer.rb
+- lib/metadata.rb
+- lib/renamer.rb
 - lib/scrapers/image.rb
+- lib/scrapers/music.rb
 homepage: http://rubygems.org/gems/media-organizer
 licenses:
 - MIT
+metadata: {}
 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
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
-summary: Rename media files in bulk based on file metadata.
+specification_version: 4
+summary: Automatically rename music and image files in bulk based on file metadata.
 test_files: []