media-renamer 0.0.2 → 0.1.3

data/lib/filescanner.rb

@@ -0,0 +1,114 @@
+#
+#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
+
+
+    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
+    #   *(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
+    #
+    #===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")
+    #
+    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
+
+    #Filescanner:multiscan(): scans multiple directories added to @root_nodes using the addRoot() method.
+    #
+    #===Inputs
+    #
+    #   *Optional 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
+
+end
+

data/lib/media-organizer.rb

@@ -0,0 +1,21 @@
+#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.2"	
+
+	class FileNotValidError < StandardError ; end
+	class InvalidArgumentError < StandardError ; end
+	class UnsupportedFileTypeError < StandardError ; end
+	class RenameFailedError < StandardError ; end
+	class FileNotFoundError < StandardError ; end
+
+end
+

data/lib/renamer.rb

@@ -1,156 +1,213 @@
 #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 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
+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
 
-		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
+		#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
 
-		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.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 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)
-	    		
-	    		File.rename(File.absolute_path(old_name),File.dirname(File.absolute_path(old_name)) + "/" + new_name)
-								
-				#check that renamed file exists
-				unless new_name.is_a?(String) && File.exists?(new_name)    
-	      			raise RenameFailedError, "Could not successfuly rename file: #{old_name} => #{new_name}."
-	    		end
-	    	rescue => e
-	    		puts "Ignoring rename for #{old_name} => #{new_name}"
-	    		puts e
-	    		puts e.backtrace.inspect
+			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
-		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)
+			return filename_pairs
 		
-		#LOAD EXIF DATA	
-		case File.extname(file)
-		when '.jpg'
-			Image::getJpegData(file)
-		when '.tif'
-			Image::getTiffData(file)
-		when '.mp3' , '.wav' , '.m4a' , '.flac' , '.aiff'
-			Music::getMusicData(file)
-		else
-			raise UnsupportedFileTypeError, "Error processing #{file}"
+		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
-		#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) 
+		#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
-					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
+					#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
-		#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
+		#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
-		return clean_scheme
-	end
-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
 
+end

data/lib/scrapers/image.rb

@@ -1,15 +1,43 @@
 require 'exifr'
 
-module Image
-	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 MediaOrganizer
+
+	module Image
+		SUPPORTED_FILETYPES = %w{.jpg .tif}
+		class FileNotFoundError < StandardError ; 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.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
 
-	def Image.getTiffData(file)
-		meta = EXIFR::TIFF.new(file)	
-		return meta.to_hash
-		#!!! Rescue from common file-related and exifr-related errors here
 	end
 end

data/lib/scrapers/music.rb

@@ -1,32 +1,115 @@
 require 'taglib'
 
-module Music
-	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
 
-end
+	module Music
+		class FileNotFoundError < StandardError ; end
+
+		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[: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
+
+		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
 
+		#
+		#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	        
+
+		        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-renamer
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,55 +9,25 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-09 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 dynamically renaming files using their
-  metadata, according to a customizable taxonomy. For example, use bulk-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.'
+date: 2015-03-24 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.'
 email: djeserkare@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/renamer.rb
-- lib/media-renamer.rb
-- lib/scrapers/image.rb
+- lib/media-organizer.rb
+- lib/filescanner.rb
 - lib/scrapers/music.rb
-homepage: http://rubygems.org/gems/bulk-renamer
+- lib/scrapers/image.rb
+homepage: http://rubygems.org/gems/media-organizer
 licenses:
 - MIT
 post_install_message: 
@@ -81,5 +51,5 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Rename files in bulk based on file metadata.
+summary: Rename media files in bulk based on file metadata.
 test_files: []

data/lib/media-renamer.rb

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