music_metadata_score 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODhjMzM4ODU3YTFjOWU1NmExNjA4YWQ5YWFhNzU2MDllMjgwYzA1Nw==
+  data.tar.gz: !binary |-
+    NjcyYzU4YTA5NmI3Y2RmYmQwY2IzNjk2MzMwNWFkZGVkOTVmYzZmNw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    Y2MyMTAxMzAyMDY1YWJiNjdlNTQ3YWMzZGNiYTYzYWVhZmNkMGY5ZDNmNGUz
+    MzNhNTY5OWMwZDgwMTQzMjIyMjEwYTJmYzQ2YTRiODdkNjZmMDM5Mzc1ZWU3
+    MWVhMjc3NzRkMDk4NGZlYzgyNGFjM2FjOTA1OTc5YWIwMTgyZDM=
+  data.tar.gz: !binary |-
+    ZWMzZWRmNjg3YzA3ZjFiZDM0ZDRmMjNiYjY5MjRjNzRjY2RiMDVhMzE5ZjJi
+    NGQyYjA1ZjMwMmQyNDE4MGJkNTUyM2YwNWY1NGFlNjc4MTFlMzgyY2NkNzI3
+    OTUxMTczY2Y4NWY5YmI2NGVhODYzMDRlYTA4ODZmODE0ZmUwMWU=

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in music_metadata_score.gemspec
+gemspec

data/README.md

@@ -0,0 +1,29 @@
+# MusicMetadataScore
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'music_metadata_score'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install music_metadata_score
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  #t.libs << "test"
+  #t.test_files = FileList['test/test*.rb']
+  #t.verbose = true
+  t.libs = ["lib"]
+	t.warning = true
+	t.verbose = true
+	t.test_files = FileList['test/test_*.rb']
+end
+
+desc "Run tests"
+task :default => :test

data/lib/music_metadata_score/artist.rb

@@ -0,0 +1,123 @@
+class Artist
+	
+	def self.are_proper_artist_format?(artists, override, level)
+		if artists && artists != []
+			Artist.loop_artists(artists, override, level)
+		else
+			false
+		end
+	end
+	
+	def self.loop_artists(artists, override, level)
+		value = true
+		artists.each do |a|
+			if !Artist.is_proper_artist_format?(a, override, level)
+				value = false
+				break
+			end
+		end
+		value
+	end
+	
+	def self.is_proper_artist_format?(artist, override, level)
+		if Artist.is_title_case?(artist, override) && !Artist.is_compound_artist?(artist, override) && !Artist.is_bad_various_artists?(artist) && Artist.artist_fits_level?(artist, override, level)
+			true
+		else
+			false
+		end
+	end
+	
+	def self.is_title_case?(artist, override)
+		if MusicMetadataScore.is_title_case?(artist) || override == true
+			true
+		else
+			false
+		end
+	end
+	
+	def self.is_compound_artist?(artist, override)
+		if override != true && (artist.downcase.include?('and') || artist.include?('&') || artist.downcase.include?('vs') || artist.downcase.include?('with') || artist.downcase.include?('feat') || artist.downcase.include?('present')) || artist.include?('/')
+			true
+		else
+			false
+		end
+	end
+	
+	def self.is_bad_various_artists?(artist)
+		# various, va, v/a
+		if artist.downcase == 'various' || artist.downcase == 'va' || artist.downcase == 'v/a' || artist.downcase == 'various artist'
+			true
+		else
+			false
+		end
+	end
+	
+	def self.artist_fits_level?(artist, override, level)
+		if override == false && level == :track && (artist.downcase == 'various artists' || artist.downcase == 'various artist' || artist.downcase == 'v/a' || artist.downcase == 'various')
+			false
+		else
+			true
+		end
+	end
+	
+	def self.format_artists(artists, override, level)
+		array = []
+		artists.each do |a|
+			new_artist = Artist.title_case(a)
+			separated_artists = Artist.separate_compound_artists(new_artist)
+			separated_artists.each do |sa|
+				array << sa
+			end
+		end
+		return array
+	end
+	
+	def self.title_case(artist)
+		new_artist = MusicMetadataScore.title_case(artist)
+		Artist.capitalize_the(new_artist)
+	end
+	
+	def self.capitalize_the(string)
+		split = string.split(' ')
+		split.each_with_index do |s, i|
+			if s == 'the'
+				split[i] = 'The'
+			end
+		end
+		return split.join(' ')
+	end
+	
+	def self.separate_compound_artists(artist)
+		if artist.downcase.include?('and')
+			Artist.split_artists(artist, 'and')
+		elsif artist.downcase.include?('&')
+			Artist.split_artists(artist, '&')
+		elsif artist.downcase.include?('vs.')
+			Artist.split_artists(artist, 'vs.')
+		elsif artist.downcase.include?('vs')
+			Artist.split_artists(artist, 'vs')
+		elsif artist.downcase.include?('with')
+			Artist.split_artists(artist, 'with')
+		elsif artist.downcase.include?('feat.')
+			Artist.split_artists(artist, 'feat.')
+		elsif artist.downcase.include?('featuring')
+			Artist.split_artists(artist, 'featuring')
+		elsif artist.downcase.include?('feat')
+			Artist.split_artists(artist, 'feat')
+		elsif artist.downcase.include?('presents')
+			Artist.split_artists(artist, 'presents')
+		else
+			[artist]
+		end
+	end
+	
+	def self.split_artists(string, separator)
+		array = string.split(separator)
+		new_array = []
+		array.each_with_index do |a, i|
+			new_array << a.strip
+		end
+		return new_array
+	end
+	
+end

data/lib/music_metadata_score/barcode.rb

@@ -0,0 +1,80 @@
+class Barcode
+	# Check length
+	# Check checksum
+	
+	def self.is_valid?(barcode)
+		if Barcode.valid_length?(barcode) && Barcode.valid_characters?(barcode) && Barcode.valid_checksum?(barcode)
+			true
+		else
+			false
+		end
+	end
+	
+	def self.valid_length?(barcode)
+		if barcode.to_s.length == 12 || barcode.to_s.length == 13
+			true
+		else
+			false
+		end
+	end
+	
+	def self.valid_characters?(barcode)
+		number = Integer(barcode) rescue false
+		if number != false
+			true
+		else
+			false
+		end
+	end
+	
+	def self.valid_checksum?(barcode)
+		if barcode.to_s[barcode.to_s.length - 1].to_i == Barcode.get_checksum(barcode)
+			true
+		else
+			false
+		end
+	end
+	
+	def self.get_checksum(barcode)
+		barcode_sum = Barcode.calculate_barcode(Barcode.remove_checksum(barcode))
+		if barcode_sum != nil
+			Barcode.calculate_checksum(barcode_sum)
+		else
+			nil
+		end
+	end
+	
+	def self.remove_checksum(barcode)
+		barcode = barcode.to_s
+		return barcode[0..barcode.length - 2]
+	end
+	
+	def self.calculate_barcode(barcode)
+		barcode = barcode.to_s
+  	if barcode.length == 11
+  		(barcode[0].to_i * 3) + barcode[1].to_i + (barcode[2].to_i * 3) + barcode[3].to_i + (barcode[4].to_i * 3) + barcode[5].to_i + (barcode[6].to_i * 3) + barcode[7].to_i + (barcode[8].to_i * 3) + barcode[9].to_i + (barcode[10].to_i * 3)
+  	elsif barcode.length == 12
+  		barcode[0].to_i + (barcode[1].to_i * 3) + barcode[2].to_i + (barcode[3].to_i * 3) + barcode[4].to_i + (barcode[5].to_i * 3) + barcode[6].to_i + (barcode[7].to_i * 3) + barcode[8].to_i + (barcode[9].to_i * 3) + barcode[10].to_i + (barcode[11].to_i * 3)
+  	else
+  		nil
+  	end
+	end
+	
+	def self.calculate_checksum(number)
+		over = number % 10
+		if over != 0
+			10 - over
+		else
+			0
+		end
+	end
+	
+	def self.valid_barcode_or_nil(barcode)
+		if Barcode.is_valid?(barcode)
+			barcode
+		else
+			nil
+		end
+	end
+	
+end

data/lib/music_metadata_score/composer.rb

@@ -0,0 +1,30 @@
+class Composer
+
+	def self.are_proper_format?(composers)
+		if composers && composers != []
+			Composer.loop_composers(composers)
+		else
+			false
+		end
+	end
+	
+	def self.loop_composers(composers)
+		value = true
+		composers.each do |c|
+			if !Composer.is_proper_format?(c)
+				value = false
+				break
+			end
+		end
+		value
+	end
+	
+	def self.is_proper_format?(composer)
+		if Contributor.is_human_name?(composer) && MusicMetadataScore.is_title_case?(composer) && !Artist.is_compound_artist?(composer, false)
+			true
+		else
+			false
+		end
+	end
+
+end

data/lib/music_metadata_score/contributor.rb

@@ -0,0 +1,46 @@
+class Contributor
+	
+	def self.are_proper_format?(contributors)
+		if contributors && contributors != []
+			Contributor.loop_contributors(contributors)
+		else
+			false
+		end
+	end
+	
+	def self.loop_contributors(contributors)
+		value = true
+		contributors.each do |c|
+			if !Contributor.is_proper_format?(c)
+				value = false
+				break
+			end
+		end
+		value
+	end
+	
+	def self.is_proper_format?(contributor)
+		if Contributor.is_human_name?(contributor[:name]) && Contributor.has_role?(contributor[:role]) && !Artist.is_compound_artist?(contributor[:name], false) && MusicMetadataScore.is_title_case?(contributor[:name])
+			true
+		else
+			false
+		end
+	end
+	
+	def self.is_human_name?(contributor)
+		if contributor.downcase.include?('the ') || contributor.split(' ').count < 2
+			false
+		else
+			true
+		end
+	end
+	
+	def self.has_role?(role)
+		if role && role != ""
+			true
+		else
+			false
+		end
+	end
+	
+end

data/lib/music_metadata_score/isrc.rb

@@ -0,0 +1,55 @@
+class Isrc
+	
+	def self.is_valid?(isrc)
+		isrc = Isrc.strip_isrc(isrc)
+		if Isrc.valid_length?(isrc) && Isrc.valid_country_code?(isrc[0..1]) && Isrc.valid_numbers?(isrc[5..11])
+			true
+		else
+			false
+		end
+	end
+	
+	def self.valid_length?(isrc)
+		length = Isrc.strip_isrc(isrc).length rescue 0
+		if length != 12
+			false
+		else
+			true
+		end
+	end
+	
+	def self.strip_isrc(isrc)
+  	if isrc
+			isrc.strip!
+			isrc.tr!('^A-Za-z0-9', '')
+			isrc.upcase!
+  	end
+  	return isrc
+  end
+  
+  def self.valid_country_code?(code)
+  	if code.length == 2 && code[/[a-zA-Z]+/] == code
+  		true
+  	else
+  		false
+  	end
+  end
+  
+  def self.valid_numbers?(numbers)
+  	number = Integer(numbers) rescue false
+  	if numbers.to_s.length == 7 && number
+  		true
+  	else
+  		false
+  	end
+  end
+  
+  def self.valid_isrc_or_nil(isrc)
+		if Isrc.is_valid?(isrc)
+			Isrc.strip_isrc(isrc)
+		else
+			nil
+		end
+	end
+	
+end

data/lib/music_metadata_score/publisher.rb

@@ -0,0 +1,30 @@
+class Publisher
+	
+	def self.are_proper_format?(publishers)
+		if publishers && publishers != []
+			Publisher.loop_publishers(publishers)
+		else
+			false
+		end
+	end
+	
+	def self.loop_publishers(publishers)
+		value = true
+		publishers.each do |c|
+			if !Publisher.is_proper_format?(c)
+				value = false
+				break
+			end
+		end
+		value
+	end
+	
+	def self.is_proper_format?(publisher)
+		if publisher && publisher != ""
+			true
+		else
+			false
+		end
+	end
+	
+end

data/lib/music_metadata_score/score.rb

@@ -0,0 +1,234 @@
+class Score
+	# Errors
+	
+	# Product level scores
+	def self.product_score(metadata)
+		score = Score.product_fields_exist(metadata) + Score.product_fields_quality(metadata)
+		percent = score.to_f / 87 * 100
+		return percent.round(1)
+	end
+	
+	def self.product_fields_exist(metadata)
+		score = 0
+		score += 2 if !Score.object_is_blank?(metadata[:title])
+		score += 2 if !Score.object_is_blank?(metadata[:cat_no])
+		score += 2 if !Score.object_is_blank?(metadata[:barcode])
+		score += 2 if !Score.object_is_blank?(metadata[:label])
+		score += 2 if !Score.object_is_blank?(metadata[:primary_artists])
+		score += 2 if !Score.object_is_blank?(metadata[:release_date])
+		score += 1 if !Score.object_is_blank?(metadata[:original_release_date])
+		score += 2 if !Score.object_is_blank?(metadata[:p_year])
+		score += 2 if !Score.object_is_blank?(metadata[:p_line])
+		score += 2 if !Score.object_is_blank?(metadata[:c_year])
+		score += 2 if !Score.object_is_blank?(metadata[:c_line])
+		score += 2 if !Score.object_is_blank?(metadata[:parental_advisory])
+		score += 1 if !Score.object_is_blank?(metadata[:live])
+		score += 1 if !Score.object_is_blank?(metadata[:remastered])
+		score += 2 if !Score.object_is_blank?(metadata[:type])
+		score += 2 if !Score.object_is_blank?(metadata[:media])
+		score += 2 if !Score.object_is_blank?(metadata[:format])
+		score += 2 if !Score.object_is_blank?(metadata[:primary_genre])
+		score += 1 if !Score.object_is_blank?(metadata[:secondary_genre])
+		score += 1 if !Score.object_is_blank?(metadata[:description])
+		return score
+	end
+	
+	def self.product_fields_quality(metadata)
+		score = 0
+		score += 10 if TitleCase.is_proper_title_format?(metadata[:title], metadata[:primary_artists], metadata[:featuring_artists])
+		score += 10 if MusicMetadataScore.is_title_case?(metadata[:version])
+		score += 5 if MusicMetadataScore.valid_barcode?(metadata[:barcode])
+		score += 2 if MusicMetadataScore.is_title_case?(metadata[:label])
+		score += 5 if MusicMetadataScore.is_title_case?(metadata[:p_line])
+		score += 5 if MusicMetadataScore.is_title_case?(metadata[:c_line])
+		score += 10 if Artist.are_proper_artist_format?(metadata[:primary_artists], false, :product)
+		score += 5 if Artist.are_proper_artist_format?(metadata[:featuring_artists], false, :product)
+		return score
+	end
+	
+	def self.product_fields_corrected(metadata)
+		titles = TitleCase.build_proper_title(metadata[:title], metadata[:version], metadata[:primary_artists], metadata[:featuring_artists])
+		{
+			:title => titles[:title],
+			:version => titles[:version],
+			:cat_no => metadata[:cat_no].upcase,
+			:barcode => Barcode.valid_barcode_or_nil(metadata[:barcode]),
+			:label => TitleCase.title_case(metadata[:label]),
+			:primary_artists => Artist.format_artists(metadata[:primary_artists], false, :product),
+			:featuring_artists => Artist.format_artists(metadata[:featuring_artists], false, :product),
+			:release_date => metadata[:release_date],
+			:original_release_date => metadata[:original_release_date],
+			:p_year => metadata[:p_year],
+			:p_line => TitleCase.title_case(metadata[:p_line]),
+			:c_year => metadata[:c_year],
+			:c_line => TitleCase.title_case(metadata[:c_line]),
+			:parental_advisory => metadata[:parental_advisory],
+			:live => metadata[:live],
+			:remastered => metadata[:remastered],
+			:type => metadata[:type],
+			:media => metadata[:media],
+			:format => metadata[:format],
+			:primary_genre => TitleCase.title_case(metadata[:primary_genre]),
+			:secondary_genre => TitleCase.title_case(metadata[:secondary_genre]),
+			:description => metadata[:description]
+		}
+	end
+	
+	# Track level scores
+	def self.track_score(metadata)
+		score = Score.track_fields_exist(metadata) + Score.track_fields_quality(metadata)
+		percent = score.to_f / 107 * 100
+		return percent.round(1)
+	end
+	
+	def self.track_fields_exist(metadata)
+		score = 0
+		score += 2 if !Score.object_is_blank?(metadata[:title])
+		score += 2 if !Score.object_is_blank?(metadata[:isrc])
+		score += 2 if !Score.object_is_blank?(metadata[:primary_artists])
+		score += 2 if !Score.object_is_blank?(metadata[:p_year])
+		score += 2 if !Score.object_is_blank?(metadata[:p_line])
+		score += 2 if !Score.object_is_blank?(metadata[:parental_advisory])
+		score += 2 if !Score.object_is_blank?(metadata[:primary_genre])
+		score += 2 if !Score.object_is_blank?(metadata[:secondary_genre])
+		score += 2 if !Score.object_is_blank?(metadata[:recording_year])
+		score += 2 if !Score.object_is_blank?(metadata[:recording_country])
+		score += 2 if !Score.object_is_blank?(metadata[:recording_location])
+		score += 2 if !Score.object_is_blank?(metadata[:country_of_commission])
+		score += 2 if !Score.object_is_blank?(metadata[:rights_holder])
+		score += 2 if !Score.object_is_blank?(metadata[:contributors])
+		score += 2 if !Score.object_is_blank?(metadata[:composers])
+		score += 2 if !Score.object_is_blank?(metadata[:publishers])
+		return score
+	end
+	
+	def self.track_fields_quality(metadata)
+		score = 0
+		score += 10 if TitleCase.is_proper_title_format?(metadata[:title], metadata[:primary_artists], metadata[:featuring_artists])
+		score += 10 if MusicMetadataScore.is_title_case?(metadata[:version])
+		score += 5 if MusicMetadataScore.valid_isrc?(metadata[:isrc])
+		score += 5 if MusicMetadataScore.is_title_case?(metadata[:p_line])
+		score += 10 if Artist.are_proper_artist_format?(metadata[:primary_artists], false, :product)
+		score += 5 if Artist.are_proper_artist_format?(metadata[:featuring_artists], false, :product)
+		score += 10 if Contributor.are_proper_format?(metadata[:contributors])
+		score += 10 if Composer.are_proper_format?(metadata[:composers])
+		score += 10 if Publisher.are_proper_format?(metadata[:publishers])
+		return score
+	end
+	
+	def self.track_fields_corrected(metadata)
+		titles = TitleCase.build_proper_title(metadata[:title], metadata[:version], metadata[:primary_artists], metadata[:featuring_artists])
+		{
+			:title => titles[:title],
+			:version => titles[:version],
+			:isrc => Isrc.valid_isrc_or_nil(metadata[:isrc]),
+			:primary_artists => Artist.format_artists(metadata[:primary_artists], false, :track),
+			:featuring_artists => Artist.format_artists(metadata[:featuring_artists], false, :track),
+			:p_year => metadata[:p_year],
+			:p_line => TitleCase.title_case(metadata[:p_line]),
+			:parental_advisory => metadata[:parental_advisory],
+			:primary_genre => TitleCase.title_case(metadata[:primary_genre]),
+			:secondary_genre => TitleCase.title_case(metadata[:secondary_genre]),
+			:recording_year => metadata[:recording_year],
+			:recording_country => metadata[:recording_country],
+			:recording_location => metadata[:recording_location],
+			:country_of_commission => metadata[:country_of_commission],
+			:rights_holder => metadata[:rights_holder],
+			:contributors => metadata[:contributors],
+			:composers => metadata[:composers],
+			:publishers => metadata[:publishers]
+		}
+	end
+	
+	def self.object_is_blank?(value)
+		if value != nil && value != "" && value != [] && value != {}
+			false
+		else
+			true
+		end
+	end
+	
+	# Total Product Score
+	def self.total_product_score(metadata)
+		product_score = Score.product_score(metadata[:product])
+		tracks_score = Score.tracks_score(metadata[:tracks])
+		final_score = (product_score + tracks_score) / (metadata[:tracks].count + 1)
+		return final_score.round(1)
+	end
+	
+	def self.tracks_score(tracks)
+		tracks_score = 0
+		if tracks
+			tracks.each do |t|
+				tracks_score += Score.track_score(t)
+			end
+		end
+		return tracks_score
+	end
+	
+	# Corrections
+	def self.corrections(metadata)
+		array = []
+		array = Score.combine_arrays(array, Score.product_corrections(metadata[:product]))
+		array = Score.combine_arrays(array, Score.tracks_corrections(metadata[:tracks]))
+	end
+	
+	def self.product_corrections(metadata)
+		array = []
+		corrected_metadata = Score.product_fields_corrected(metadata)
+		metadata.each do |m|
+			error = Score.missing_or_corrected(m[0].to_s, m[1], corrected_metadata[m[0]])
+			array << error if error
+		end
+		array
+	end
+	
+	def self.tracks_corrections(tracks)
+		array = []
+		tracks.each_with_index do |t, index|
+			track_returned = Score.track_corrections(t)
+			track_returned.each do |tr|
+				array << "Track #{index + 1} #{tr}"
+			end
+		end
+		array
+	end
+	
+	def self.track_corrections(metadata)
+		array = []
+		corrected_metadata = Score.track_fields_corrected(metadata)
+		metadata.each do |m|
+			error = Score.missing_or_corrected(m[0].to_s, m[1], corrected_metadata[m[0]])
+			array << error if error
+		end
+		array
+	end
+	
+	def self.missing_or_corrected(field, original, corrected)
+		if original && original != "" && original != [] || original == false
+			if original == corrected || corrected == ''
+				nil
+			else
+				"#{Score.format_field_name(field)} is incorrect. It should be #{corrected}"
+			end
+		else
+			"#{Score.format_field_name(field)} is missing"
+		end
+	end
+	
+	def self.format_field_name(field)
+		split = field.split('_')
+		split.each do |s|
+			s = TitleCase.titleize(s)
+		end
+		split.join(' ')
+	end
+	
+	def self.combine_arrays(first, second)
+		second.each do |s|
+			first << s
+		end
+		first
+	end
+	
+end

data/lib/music_metadata_score/title_case.rb

@@ -0,0 +1,330 @@
+class TitleCase
+	# Split string
+	# Capitalize all
+	# Find list of words
+	# If they're not first or last, or have a bracket on the beginning or end make em lower case
+	
+	def self.featuring_words
+		[
+			' Featuring',
+			'Feat ',
+			' Feat.',
+			' With '
+			
+		]
+	end
+	
+	def self.title_case(string)
+		if string.is_a?(String)
+			string = TitleCase.add_spacing_to_punctuation(string)
+			array = TitleCase.lower_case_array(TitleCase.titleize_array(TitleCase.split_string(string.downcase)))
+			new_string = TitleCase.capitalize_artist_the(array.join(' '))
+			return TitleCase.capitalize_anomalies(new_string)
+		else
+			""
+		end
+	end
+	
+	# Add spaces after any punctuation if it doesn't already exist
+	def self.add_spacing_to_punctuation(string)
+		newstring = ""
+		string.split('').each_with_index do |letter, i|
+			newstring += ' ' if TitleCase.add_space_before?(string, letter, i)
+			newstring += letter
+			newstring += ' ' if TitleCase.add_space_after?(string, letter, i)
+		end
+		return newstring
+	end
+	
+	def self.add_space_after?(string, letter, i)
+		if letter =~ /[,.)]/ && string[i + 1] != ' '
+			true
+		elsif letter == '"'
+			if string[i - 1] =~ /[[:alpha:]]/ && string[i + 1] != ' '
+				true
+			end
+		else
+			false
+		end
+	end
+	
+	def self.add_space_before?(string, letter, i)
+		if letter =~ /[(]/ && string[i - 1] != ' '
+			true
+		else
+			false
+		end
+	end
+	
+	# String to Array
+	def self.split_string(string)
+		if string && string.is_a?(String)
+			string.split(' ')
+		else
+			[]
+		end
+	end
+	
+	# Capitalize all first letters
+	def self.titleize_array(array)
+		array.each do |a|
+			a = TitleCase.titleize(a)
+		end
+		return array
+	end
+	
+	def self.titleize(string)
+		if string[0] =~ /[[:alpha:]]/
+			string.capitalize!
+		elsif string.length > 1 && !string.include?('feat.')
+			string[1] = string[1].capitalize
+		end
+		return string
+	end
+	
+	# Pick words for lower case
+	def self.lower_case_array(array)
+		array.each do |a|
+			if a != array.first && a != array.last
+				a = TitleCase.lower_case_string(a)
+			end
+		end
+		return array
+	end
+	
+	def self.lower_case_string(string)
+		#a, an, and, as, at, but, by, for, from, in, into, nor, of, off, on, onto, or, out, over, so, the, to, up, with and yet
+		words = ["a", "an", "and", "as", "at", "but", "by", "for", "from", "in", "into", "nor", "of", "off", "on", "onto", "or", "out", "over", "so", "the", "to", "up", "with", "yet"] 		
+		if words.include?(string.downcase)
+			string.downcase!
+		else
+			string
+		end
+	end
+	
+	# Includes Featuring Artistst
+	def self.is_proper_title_format?(title, primary_artists, featuring_artists)
+		if MusicMetadataScore.is_title_case?(title) && TitleCase.includes_proper_featuring_artists?(title, featuring_artists) && !TitleCase.includes_version?(title) && !TitleCase.improper_abbreviations?(title)
+			true
+		else
+			false
+		end
+	end
+	
+	def self.includes_proper_featuring_artists?(title, featuring_artists)
+		count = featuring_artists.count rescue 0
+		if count > 0
+			TitleCase.is_proper_featuring_artists?(title, featuring_artists)
+		else
+			true
+		end
+	end
+	
+	def self.includes_featuring_artists?(title, featuring_artists)
+		value = false
+		featuring_artists.each do |a|
+			if title.include?(a)
+				value = true
+				break
+			end
+		end
+		value
+	end
+	
+	def self.is_proper_featuring_artists?(title, featuring_artists)
+		if title.include?(TitleCase.featuring_artists_string(featuring_artists, "feat.")) || title.include?(TitleCase.featuring_artists_string(featuring_artists, "with")) || title.include?(TitleCase.featuring_artists_string(featuring_artists, "vs.")) || title.include?(TitleCase.featuring_artists_string(featuring_artists, "Meets"))
+			true
+		else
+			false
+		end
+	end
+	
+	def self.featuring_artists_string(featuring_artists, type)
+		string = ""
+		if featuring_artists.count > 0
+			string = " (#{type} " if type != 'vs.'
+			string = TitleCase.add_artists_to_string(string, featuring_artists, type)
+			string += ")"
+		end
+		return string
+	end
+	
+	def self.add_artists_to_string(string, featuring_artists, type)
+		featuring_artists.each do |a|
+			string += a
+			string += TitleCase.featuring_artists_join(featuring_artists, a, type)
+		end
+		return string
+	end
+	
+	def self.featuring_artists_join(featuring_artists, a, type)
+		if featuring_artists.count == 1 || a == featuring_artists.last
+			""
+		elsif featuring_artists.index(a) == featuring_artists.count - 2 && type != "vs."
+			" & "
+		elsif type == "vs."
+			" vs. "
+		elsif type == "Meets"
+			" Meets "
+		else
+			", "
+		end
+	end
+	
+	def self.combined_artists(primary_artists, featuring_artists)
+		featuring_artists.each do |a|
+			primary_artists << a
+		end
+		primary_artists
+	end
+	
+	# Includes a Version
+	def self.includes_version?(title)
+		if title.downcase.include?('version') || title.downcase.include?('edition') || title.downcase.include?('issue') || title.downcase.include?('print') || title.downcase.include?('anniversary')
+			true
+		else
+			false
+		end
+	end
+	
+	# Check for abbreviations
+	def self.improper_abbreviations?(title)
+		# TODO find pt. and vol. not formatted properly
+		if title.downcase.include?(' part') || title.downcase.include?(' volume') || title.downcase.include?(' number') || title.downcase.include?(' aka') || title.downcase.include?(' d.j') || title.downcase.include?(' num')
+			true
+		else
+			false
+		end
+	end
+	
+	def self.replace_improper_abbreviations(title)
+		title.gsub!(" part", " Pt.")
+		title.gsub!(" volume", " Vol.")
+		title.gsub!(" number", " No.")
+		title.gsub!(" no ", " No. ")
+		title.gsub!(" num ", " No. ")
+		title.gsub!(" d.j", " DJ")
+		title.gsub!(" d.j.", " DJ")
+		title.gsub!(" aka", " a.k.a")
+		title.gsub!(" AKA", " a.k.a")
+		title.gsub!("featuring", "feat.")
+		title.gsub!("(feat ", "(feat. ")
+		title.gsub!(" feat ", " feat. ")
+		title.gsub!(" vs ", " Vs. ")
+		title.gsub!(" VS ", " Vs. ")
+		
+		return title
+	end
+	
+	# Capitalize The's in Artist Names
+	def self.capitalize_artist_the(title)
+		if title[0] != '(' && title.include?('(')
+			split_title = title.split('(')
+			inside_bracket = split_title[1].split(')')
+			new_inside_bracket = inside_bracket[0].gsub('the', 'The')
+			string = split_title[0] + "(" + new_inside_bracket + ")"
+			string += inside_bracket[1] if inside_bracket[1]
+			return string
+		else
+			return title
+		end
+	end
+	
+	# Capitalize any anomalies, like DJ
+	def self.capitalize_anomalies(title)
+		title.gsub('Dj ', 'DJ ')
+	end
+	
+	# Get Value Inside Brackets
+	def self.get_inside_brackets(string)
+		if string.include?('(') && string.include?(')')
+			split_string = string.split('(')
+			array = []
+			split_string.each do |s|
+				stripped = s.strip
+				if stripped[stripped.length - 1] == ')'
+					array << stripped[0..stripped.length - 2]
+				end
+			end
+			array
+		end
+	end
+	
+	# Build proper title
+	def self.build_proper_title(title, version, primary_artists, featuring_artists)
+		# Title Case
+		title = TitleCase.title_case(title)
+		# find any versions
+		split_out_version = TitleCase.strip_version_from_title(title, version)
+		# reformat featuring artists
+		title = TitleCase.strip_artists_from_title(split_out_version[:title], primary_artists, featuring_artists)
+		title += TitleCase.featuring_artists_string(featuring_artists, "feat.")
+		# replace abbreviations
+		return {:title => title, :version => split_out_version[:version]}
+	end
+	
+	def self.strip_version_from_title(title, version)
+		inside_brackets = TitleCase.get_inside_brackets(title)
+		#version = nil
+		if inside_brackets
+			inside_brackets.each do |b|
+				if TitleCase.includes_version?(b)
+					title.gsub!(" (#{b})", "")
+					version = b.strip
+				end
+			end
+		end
+		return {
+			:title => title.strip,
+			:version => version
+		}
+	end
+	
+	def self.strip_artists_from_title(title, primary_artists, featuring_artists)
+		title = TitleCase.strip_artists_in_brackets_from_title(title, primary_artists, featuring_artists)
+		title = TitleCase.strip_artists_from_outside_brackets_from_title(title, primary_artists, featuring_artists)
+		title
+	end
+	
+	def self.strip_artists_in_brackets_from_title(title, primary_artists, featuring_artists)
+		inside_brackets = TitleCase.get_inside_brackets(title)
+		if inside_brackets
+			inside_brackets.each do |b|
+				if TitleCase.includes_featuring_artists?(b, featuring_artists)
+					title.gsub!(" (#{b})", "")
+				end
+			end
+		end
+		title
+	end
+	
+	def self.strip_artists_from_outside_brackets_from_title(title, primary_artists, featuring_artists)
+		title = TitleCase.remove_artist_names_from_title(title, TitleCase.combined_artists(primary_artists, featuring_artists))
+		TitleCase.strip_featuring_words_from_title(title)
+	end
+	
+	def self.remove_artist_names_from_title(title, artists)
+		artists.each do |a|
+			if title.include?(" #{a} &")
+				title.gsub!(" #{a} &", "")
+			elsif title.include?(" #{a} and")
+				title.gsub!(" #{a} and", "")
+			elsif title.include?(" #{a} And")
+				title.gsub!(" #{a} And", "")
+			elsif title.include?(" #{a},")
+				title.gsub!(" #{a},", "")
+			else
+				title.gsub!(" #{a}", "")
+			end
+		end
+		title
+	end
+	
+	def self.strip_featuring_words_from_title(title)
+		TitleCase.featuring_words.each do |w|
+			title.gsub!(" #{w.strip}", "")
+		end
+		title
+	end
+	
+end

data/lib/music_metadata_score/version.rb

@@ -0,0 +1,3 @@
+module MusicMetadataScore
+  VERSION = "0.0.1"
+end

data/lib/music_metadata_score.rb

@@ -0,0 +1,46 @@
+require "music_metadata_score/version"
+require "music_metadata_score/score"
+require "music_metadata_score/title_case"
+require "music_metadata_score/barcode"
+require "music_metadata_score/isrc"
+require "music_metadata_score/artist"
+require "music_metadata_score/contributor"
+require "music_metadata_score/composer"
+require "music_metadata_score/publisher"
+
+module MusicMetadataScore
+	
+	# Title Casing
+	def self.title_case(string)
+		TitleCase.title_case(string)
+	end
+	
+	def self.is_title_case?(string)
+		proper = TitleCase.title_case(string)
+		if proper == string
+			true
+		else
+			false
+		end
+	end
+	
+	# Barcode
+	def self.valid_barcode?(barcode)
+		Barcode.is_valid?(barcode)
+	end
+	
+	def self.generate_checksum(barcode)
+		barcode_sum = Barcode.calculate_barcode(barcode)
+		if barcode_sum != nil
+			Barcode.calculate_checksum(barcode_sum)
+		else
+			nil
+		end
+	end
+	
+	# ISRC
+	def self.valid_isrc?(isrc)
+		Isrc.is_valid?(isrc)
+	end
+	
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: music_metadata_score
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- tomallen400
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- tomallen4000@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Gemfile
+- Rakefile
+- lib/music_metadata_score.rb
+- lib/music_metadata_score/artist.rb
+- lib/music_metadata_score/barcode.rb
+- lib/music_metadata_score/composer.rb
+- lib/music_metadata_score/contributor.rb
+- lib/music_metadata_score/isrc.rb
+- lib/music_metadata_score/publisher.rb
+- lib/music_metadata_score/score.rb
+- lib/music_metadata_score/title_case.rb
+- lib/music_metadata_score/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []