autotune 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b96bb0565047eb7e7e1742a16db9ee3077fe6e1
+  data.tar.gz: 356cb428a62f23eccc3acaa105ff382fea4d2862
+SHA512:
+  metadata.gz: '06099031c410c4fe7857dcef7663a35ed158072c2344484826729730e89ca34160bc4b04d5afc56bf4c468f019dc5e31ae81ed8a4ecbd920e88062051c373bf1'
+  data.tar.gz: a99bce17579166142e012258cd9b95c3c12aa938175215f3133ea362ab960ceaab06ae5dff4c56c3b13f61b6637609d47a3a0f14c5b29f6cddcd3e3379c5f36d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 2.4.1
+before_install:
+  - gem update
+  - gem install bundler
+install:
+  - bundle install --retry=3
+script:
+  - gem build autotune.gemspec
+  - gem install autotune*.gem
+addons:
+  apt:
+    packages:
+    - libtag1-dev

data/Dockerfile

@@ -0,0 +1,19 @@
+FROM ruby:2.4
+
+MAINTAINER Dominic Philip <domi.a.philip@gmail.com>
+
+RUN apt-get update && apt-get -y install cmake
+RUN mkdir temp && cd temp && curl http://taglib.org/releases/taglib-1.11.1.tar.gz > /temp/taglib.tar.gz
+RUN cd /temp && tar -xzvf taglib*
+RUN cd /temp/taglib* && cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_BUILD_TYPE=Release . -DBUILD_SHARED_LIBS=ON
+RUN cd /temp/taglib* && make && make install
+RUN gem install taglib-ruby
+RUN rm -rf /temp
+RUN apt-get autoremove && apt-get clean
+
+RUN mkdir resources/
+COPY . resources/
+RUN cd /resources && gem build autotune.gemspec && gem install ./*.gem
+RUN rm -rf /resources
+
+CMD ["/bin/bash"]

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Dominic Philip
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# AutoTune [![Build Status](https://travis-ci.org/dominicap/auto-tune.svg?branch=master)](https://travis-ci.org/dominicap/auto-tune)
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/autotune`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'autotune'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install autotune
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dominicap/auto-tune.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/autotune.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'autotune/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "autotune"
+  spec.version       = AutoTune::VERSION
+  spec.authors       = ["Dominic Antony Philip"]
+  spec.email         = ["domi.a.philip@gmail.com"]
+
+  spec.summary       = "A music auto-tagging library using the iTunes API"
+  spec.description   = "AutoTune is a library that automates the task of adding metadata to music with the help of the iTunes Affiliates Search API."
+  spec.homepage      = "https://github.com/dominicap/auto-tune"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 12.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+
+  spec.add_runtime_dependency "taglib-ruby", "~> 0.7.0", ">= 0.7.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "autotune"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/autotune

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'autotune'
+
+options = { album: nil, artist: nil, directory: nil, deluxe: false, clean: false, single: false }
+ARGV << '--help' if ARGV.empty?
+
+overview_msg = 'OVERVIEW: A music auto-tagging library using the iTunes API'
+usage_msg    = 'USAGE: autotune [options] <inputs>'
+options_msg  = 'OPTIONS:'
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = overview_msg + "\n\n" + usage_msg + "\n\n" + options_msg + "\n"
+
+  album_help_msg = 'Pass in album name as argument'
+  opts.on('-a', '--album <album>', album_help_msg) do |album|
+    options[:album] = album.to_s
+  end
+
+  artist_help_msg = 'Pass in artist name as argument'
+  opts.on('-s', '--artist <artist>', artist_help_msg) do |artist|
+    options[:artist] = artist.to_s
+  end
+
+  directory_help_msg = 'Pass in the directory path as argument'
+  opts.on('-d', '--directory <directory>', directory_help_msg) do |directory|
+    unless File.exist?(File.expand_path(directory.to_s))
+      abort 'autotune: error: directory path given does not exist'
+    end
+    options[:directory] = File.expand_path(directory.to_s)
+  end
+
+  clean_help_msg = 'Use clean version of album, if applicable'
+  opts.on('-c', '--clean', clean_help_msg) do |clean|
+    options[:clean] = true unless clean.nil?
+  end
+
+  deluxe_help_msg = 'Use deluxe version of album, if applicable'
+  opts.on('-x', '--deluxe', deluxe_help_msg) do |deluxe|
+    options[:deluxe] = true unless deluxe.nil?
+  end
+
+  single_help_msg = 'Use single version of album, if applicable'
+  opts.on('-l', '--single', single_help_msg) do |single|
+    options[:single] = true unless single.nil?
+  end
+
+  opts.on('-h', '--help', 'Displays available options') do
+    puts opts
+    exit
+  end
+
+  opts.on('-v', '--version', 'Displays the version number') do
+    puts 'autotune version ' + AutoTune::VERSION
+    exit
+  end
+end
+
+begin
+  option_parser.parse!
+rescue OptionParser::InvalidOption
+  abort 'autotune: error: invalid option(s)'
+rescue OptionParser::MissingArgument
+  abort 'autotune: error: too few arguments'
+end
+
+options.each do |_option, argument|
+  abort 'autotune: error: too few arguments' if argument.nil?
+end
+
+unless AutoTune::Util.os == 'macos'
+  abort 'autotune: error: operating system not compatible'
+end
+
+paths = AutoTune::Util.paths(options[:directory])
+album_tags = AutoTune::Obtainer.get_tags(options[:album], options[:artist], options[:clean], options[:deluxe])
+
+album_details = AutoTune::Obtainer.get_album_details(options[:album], options[:artist], options[:clean], options[:deluxe])
+
+if album_tags['resultCount'].to_i.zero?
+  abort "autotune: error: no results from iTunes with given arguments"
+end
+
+AutoTune::Obtainer.get_artwork(album_tags)
+
+album_artist = AutoTune::Obtainer.get_album_artist(album_details)
+genre_id = AutoTune::Obtainer.get_genre_id(album_details)
+copyright = AutoTune::Obtainer.get_copyright(album_details)
+
+paths.each do |path|
+  track_number = AutoTune::Obtainer.get_track_number(path)
+
+  until track_number > 0
+    print "Please enter the track number for #{File.basename(path)}: "
+    track_number = STDIN.gets.chomp.to_i
+  end
+
+  tune_tags = AutoTune::Util.parse(album_tags, track_number).push(album_artist, genre_id, copyright)
+
+  AutoTune::Designator.set_all(tune_tags, path)
+
+end
+
+system('rm /var/tmp/artwork.jpg')

data/lib/autotune.rb

@@ -0,0 +1,6 @@
+module AutoTune
+  require "autotune/designator"
+  require "autotune/obtainer"
+  require "autotune/util"
+  require "autotune/version"
+end

data/lib/autotune/designator.rb

@@ -0,0 +1,319 @@
+require 'taglib'
+
+module AutoTune
+  class Designator
+    def self.set_artist_id(artist_id, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless artist_id.nil?
+              item = TagLib::MP4::Item.from_int(artist_id)
+              tune.tag.item_list_map.insert('atID', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_playlist_id(playlist_id, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless playlist_id.nil?
+              item = TagLib::MP4::Item.from_int(playlist_id)
+              tune.tag.item_list_map.insert('plID', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_catalogue_id(catalogue_id, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless catalogue_id.nil?
+              item = TagLib::MP4::Item.from_int(catalogue_id)
+              tune.tag.item_list_map.insert('cnID', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_artist(artist, song)
+      if File.exists? song
+        TagLib::FileRef.open(song) do |tune|
+          unless tune.null?
+            tune.tag.artist = artist unless artist.nil?
+            tune.save
+          end
+        end
+      end
+    end
+
+    def self.set_album(album, song)
+      if File.exists? song
+        TagLib::FileRef.open(song) do |tune|
+          unless tune.null?
+            tune.tag.album = album unless album.nil?
+            tune.save
+          end
+        end
+      end
+    end
+
+    def self.set_title(title, song)
+      if File.exists? song
+        TagLib::FileRef.open(song) do |tune|
+          unless tune.null?
+            tune.tag.title = title unless title.nil?
+            tune.save
+          end
+        end
+      end
+    end
+
+    def self.set_release_date(release_date, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless release_date.nil?
+              item = TagLib::MP4::Item.from_string_list([release_date])
+              tune.tag.item_list_map.insert('©day', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_rating(rating, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless rating.nil?
+              if rating.include? 'clean'
+                item = TagLib::MP4::Item.from_int(2)
+                tune.tag.item_list_map.insert('rtng', item)
+                tune.save
+              elsif rating.include? 'explicit'
+                item = TagLib::MP4::Item.from_int(1)
+                tune.tag.item_list_map.insert('rtng', item)
+                tune.save
+              elsif rating.include? 'notExplicit'
+                item = TagLib::MP4::Item.from_int(0)
+                tune.tag.item_list_map.insert('rtng', item)
+                tune.save
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_genre(genre, song)
+      if File.exists? song
+        TagLib::FileRef.open(song) do |tune|
+          unless tune.null?
+            tune.tag.genre = genre unless genre.nil?
+            tune.save
+          end
+        end
+      end
+    end
+
+    def self.track_number(track_number, song)
+      if File.exists? song
+        TagLib::FileRef.open(song) do |tune|
+          unless tune.null?
+            tune.tag.track = track_number unless track_number.nil?
+            tune.save
+          end
+        end
+      end
+    end
+
+    def self.set_artwork(artwork, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless artwork.nil?
+              image_data = File.open(artwork, 'rb') { |f| f.read }
+              cover_art = TagLib::MP4::CoverArt.new(TagLib::MP4::CoverArt::JPEG, image_data)
+              item = TagLib::MP4::Item.from_cover_art_list([cover_art])
+              tune.tag.item_list_map.insert('covr', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_copyright(copyright, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless copyright.nil?
+              item = TagLib::MP4::Item.from_string_list([copyright])
+              tune.tag.item_list_map.insert('cprt', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_album_artist_name(album_artist, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless album_artist.nil?
+              item = TagLib::MP4::Item.from_string_list([album_artist])
+              tune.tag.item_list_map.insert('aART', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_catalogue_id(catalogue_id, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless catalogue_id.nil?
+              item = TagLib::MP4::Item.from_int(catalogue_id)
+              tune.tag.item_list_map.insert('cnID', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_track_number(track_number, total_tracks, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless track_number.nil? || total_tracks.nil?
+              item = TagLib::MP4::Item.from_int_pair([track_number, total_tracks])
+              tune.tag.item_list_map.insert('trkn', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_disk_number(disk_number, total_disks, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless disk_number.nil? || total_disks.nil?
+              item = TagLib::MP4::Item.from_int_pair([disk_number, total_disks])
+              tune.tag.item_list_map.insert('disk', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_playlist_id(playlist_id, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless playlist_id.nil?
+              item = TagLib::MP4::Item.from_int(playlist_id)
+              tune.tag.item_list_map.insert('plID', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_composer_id(composer_id, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless composer_id.nil?
+              item = TagLib::MP4::Item.from_int(composer_id)
+              tune.tag.item_list_map.insert('cmID', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_genre_id(genre_id, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless genre_id.nil?
+              item = TagLib::MP4::Item.from_int(genre_id)
+              tune.tag.item_list_map.insert('geID', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_tempo(tempo, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless tempo.nil?
+              item = TagLib::MP4::Item.from_int(tempo)
+              tune.tag.item_list_map.insert('tmpo', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_composer(composer, song)
+      if File.exists? song
+        if song =~ /.*\.M4A$/i
+          TagLib::MP4::File.open(song) do |tune|
+            unless composer.nil?
+              item = TagLib::MP4::Item.from_string_list([composer])
+              tune.tag.item_list_map.insert('©wrt', item)
+              tune.save
+            end
+          end
+        end
+      end
+    end
+
+    def self.set_all(tune_tags, song)
+
+      
+
+
+      set_artist_id(tune_tags.at(0), song)
+      set_playlist_id(tune_tags.at(1), song)
+      set_catalogue_id(tune_tags.at(2), song)
+      set_artist(tune_tags.at(3), song)
+      set_album(tune_tags.at(4), song)
+      set_title(tune_tags.at(5), song)
+      set_release_date(tune_tags.at(7), song)
+      set_rating(tune_tags.at(9), song)
+      set_disk_number(tune_tags.at(11), tune_tags.at(10), song)
+      set_track_number(tune_tags.at(13), tune_tags.at(12), song)
+      set_genre(tune_tags.at(17), song)
+      set_album_artist_name(tune_tags.at(19), song)
+      set_genre_id(tune_tags.at(20), song)
+      set_copyright(tune_tags.at(21), song)
+      set_composer('', song)
+      set_artwork('/var/tmp/artwork.jpg', song)
+    end
+  end
+end

data/lib/autotune/obtainer.rb

@@ -0,0 +1,85 @@
+require 'json'
+require 'net/http'
+require 'taglib'
+
+module AutoTune
+  class Obtainer
+    def self.get_tags(album, artist, clean, deluxe)
+      album_id = get_album_id(album, artist, clean, deluxe)
+      lookup = "https://itunes.apple.com/lookup?id=#{album_id}&entity=song"
+      return JSON.parse(Net::HTTP.get(URI.parse(lookup)))
+    end
+
+    def self.get_album_details(album, artist, clean, deluxe)
+      album_id = get_album_id(album, artist, clean, deluxe)
+      lookup = "https://itunes.apple.com/lookup?id=#{album_id}"
+      return JSON.parse(Net::HTTP.get(URI.parse(lookup)))
+    end
+
+    def self.get_artwork(album_details)
+      artwork_url = album_details.dig('results', 0, 'artworkUrl100')
+      artwork_url = artwork_url.gsub!(/100x100bb.jpg/, '1000000000x1000000000bb.jpg')
+      File.write('/var/tmp/artwork.jpg', Net::HTTP.get(URI.parse(URI.encode(artwork_url.to_s))))
+    end
+
+    def self.get_track_number(song)
+      TagLib::FileRef.open(song) do |tune|
+        return tune.tag.track unless tune.nil?
+      end
+    end
+
+    def self.get_genre_id(album_details)
+      genre_name = album_details.dig('results', 0, 'primaryGenreName')
+      genre_appendix_lookup =
+          'http://itunes.apple.com/WebObjects/MZStoreServices.woa/ws/genres'
+      unless genre_name.nil?
+        genre_appendix = JSON.parse(Net::HTTP.get(URI.parse(genre_appendix_lookup)))
+        genre_appendix['34']['subgenres'].each { |genres|
+          genres.each { |genre|
+            unless genre.nil?
+              if genre['name'].to_s.include? genre_name
+                return genre['id'].to_i
+              end
+            end
+          }
+        }
+      end
+    end
+
+    def self.get_copyright(album_details)
+      return album_details.dig('results', 0, 'copyright').to_s
+    end
+
+    def self.get_album_artist(album_details)
+      return album_details.dig('results', 0, 'artistName').to_s
+    end
+
+    # TODO: Refactor this and etc. Also, add exclusive to deluxe option
+    def self.get_album_id(album, artist, clean, deluxe)
+      lookup = 'https://itunes.apple.com/search?term='
+      query = (artist + ' ' + album).downcase.tr!(' ', '+') + '&entity=album'
+      result_hash = JSON.parse(Net::HTTP.get(URI.parse(lookup + query)))
+      unless result_hash['resultCount'].to_i.zero?
+        (0..result_hash['resultCount'].to_i).each do |key|
+          itunes_rating = result_hash.dig('results', key, 'contentAdvisoryRating')
+          itunes_rating = result_hash.dig('results', key, 'collectionExplicitness') if itunes_rating.nil?
+          if (itunes_rating == 'Clean' || itunes_rating == 'notExplicit') && clean
+            if (result_hash.dig('results', key, 'collectionName').include? 'Deluxe') && deluxe
+              return result_hash.dig('results', key, 'collectionId')
+            elsif !(result_hash.dig('results', key, 'collectionName').include? 'Deluxe') && !deluxe
+              return result_hash.dig('results', key, 'collectionId')
+            end
+          elsif (itunes_rating == 'Explicit' || itunes_rating == 'notExplicit') && !clean
+            if (result_hash.dig('results', key, 'collectionName').include? 'Deluxe') && deluxe
+              return result_hash.dig('results', key, 'collectionId')
+            elsif !(result_hash.dig('results', key, 'collectionName').include? 'Deluxe') && !deluxe
+              return result_hash.dig('results', key, 'collectionId')
+            end
+          end
+        end
+      end
+    end
+
+    private_class_method :get_album_id
+  end
+end

data/lib/autotune/util.rb

@@ -0,0 +1,40 @@
+require 'find'
+require 'json'
+
+module AutoTune
+  class Util
+
+    ITUNES_TAG_KEYS = Array.new.push('artistId', 'collectionId', 'trackId', 'artistName',
+                                     'collectionName', 'trackName', 'artworkUrl100',
+                                     'releaseDate', 'collectionExplicitness',
+                                     'trackExplicitness', 'discCount', 'discNumber',
+                                     'trackCount', 'trackNumber', 'trackTimeMillis',
+                                     'country', 'currency', 'primaryGenreName')
+
+    def self.paths(directory)
+      Array.new(Find.find(directory).select { |p| /.*\.M4A$/i =~ p })
+    end
+
+    def self.parse(result_hash, track_number)
+      (0..result_hash['resultCount'].to_i).each { |key|
+        itunes_track_number = result_hash.dig('results', key, 'trackNumber')
+        if track_number == itunes_track_number.to_i
+          info = Array.new
+          (0..ITUNES_TAG_KEYS.length).each { |index|
+            info.push(result_hash.dig('results', key, ITUNES_TAG_KEYS[index]))
+          }
+          return info
+        end
+      }
+    end
+
+    def self.os
+      case RUBY_PLATFORM
+        when /darwin|mac os/
+          return 'macos'
+        else
+          raise SystemCallError.new('Operating System is not supported', 1)
+      end
+    end
+  end
+end

data/lib/autotune/version.rb

@@ -0,0 +1,3 @@
+module AutoTune
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: autotune
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dominic Antony Philip
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: taglib-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+description: AutoTune is a library that automates the task of adding metadata to music
+  with the help of the iTunes Affiliates Search API.
+email:
+- domi.a.philip@gmail.com
+executables:
+- autotune
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Dockerfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- autotune.gemspec
+- bin/console
+- bin/setup
+- exe/autotune
+- lib/autotune.rb
+- lib/autotune/designator.rb
+- lib/autotune/obtainer.rb
+- lib/autotune/util.rb
+- lib/autotune/version.rb
+homepage: https://github.com/dominicap/auto-tune
+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.6.11
+signing_key: 
+specification_version: 4
+summary: A music auto-tagging library using the iTunes API
+test_files: []