track_parser 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 41f48fe39a78f9c5bc0852de5826ba1473fd487e
+  data.tar.gz: 303e183dc8057a76b3585ea9a048bcb04f6e9c09
+SHA512:
+  metadata.gz: f2d9a92b145ee0172a4ab131e0542fe5847b7c47217c86a9a5f393bcdc6ebb576e1b3c6727796ddf338dcc7606fc69f807c20d4c17ae0622515cec96c5626b7c
+  data.tar.gz: cb4bdda3a49365c7360f62ecf4d976e42f4c71d0f78de9db2b67dbada973b63866aef0342789cbcb9d6d78e77bbc87799ade5ca4e6b5616569708f0e66b4b6df

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alexandre Quintino
+
+MIT License
+
+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,52 @@
+# TrackParser
+
+Tries to parse the name of a track (e.g. ArtistA - ABC (ArtistB remix)) and extract metadata from it (e.g. artists = ArtistA, track-name = ABC, remixer = ArtistB)
+It makes a best effort to extract the metadata by passing the track through a set of rules that most tracks follow. If the track does not follow those rules, the results might not be accurate.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'track_parser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install track_parser
+
+## Usage
+
+### Simple
+```ruby
+require "track_parser"
+TrackParser::Parser.do("Derek Marin - We've Been Expecting You - Hreno's Deep Pockets Dub")
+=> {:artists=>["Derek Marin"], :track_name=>"We've Been Expecting You", :remixer=>"Hreno", :remix_name=>"Deep Pockets Dub"}
+```
+
+### Structured
+You might know already the artists. In that case you can use:
+```ruby
+require "track_parser"
+TrackParser::Parser.do(artists: ["Derek Marin], name: "We've Been Expecting You - Hreno's Deep Pockets Dub")
+=> {:artists=>["Derek Marin"], :track_name=>"We've Been Expecting You", :remixer=>"Hreno", :remix_name=>"Deep Pockets Dub"}
+```
+
+## Non-exhaustive list of formats supported (for more check the [tests](https://github.com/alexquintino/track_parser/blob/master/spec/parser_spec.rb))
+
+* `<artist> - <track name>`
+* `<artist> - <track name> [-] (<remixer> Remix|Vocal|Dub|Mix)`
+* `<artist> - <track name> (<remixer>'s <remix name>)`
+* `<artist> & <artist> - <track name>`
+
+## Contributing
+
+1. Fork it ( https://github.com/alexquintino/track_parser/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/track_parser.rb

@@ -0,0 +1,5 @@
+require "track_parser/version"
+require "track_parser/parser"
+
+module TrackParser
+end

data/lib/track_parser/filter_pipeline.rb

@@ -0,0 +1,21 @@
+require_relative "filters/remix_filter"
+require_relative "filters/featuring_filter"
+require_relative "filtered_parts"
+
+module TrackParser
+  class FilterPipeline
+
+    FILTERS = [RemixFilter, FeaturingFilter] #order matters currently
+
+    def self.filter(text)
+      size_last_pass = 0
+      filtered = nil
+      loop do #make several passes until nothing new is found
+        filtered = FILTERS.reduce(FilteredParts.new(text)) { |data, filter_class| filter_class.filter(data) }
+        break if filtered.parts.size == size_last_pass
+        size_last_pass = filtered.parts.size
+      end
+      return filtered.parts, filtered.text
+    end
+  end
+end

data/lib/track_parser/filtered_parts.rb

@@ -0,0 +1,25 @@
+module TrackParser
+  class FilteredParts
+
+    def initialize(text)
+      @remaining = text
+      @parts = []
+    end
+
+    def text
+      @remaining
+    end
+
+    def add_part(type, text)
+      @parts << {type: type, text: text}
+    end
+
+    def remove_text(text)
+      @remaining = @remaining.gsub(text, "")
+    end
+
+    def parts
+      @parts
+    end
+  end
+end

data/lib/track_parser/filters/featuring_filter.rb

@@ -0,0 +1,30 @@
+module TrackParser
+  class FeaturingFilter
+
+    def self.filter(data)
+      self.new(data).filter
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def filter
+      if has_featuring?
+        featuring_text = regexp.match(@data.text)[:featuring]
+        @data.add_part(:featuring, featuring_text)
+        @data.remove_text(featuring_text) #remove featuring artists from trackname
+      end
+      return @data
+    end
+
+    def has_featuring?
+      !!regexp.match(@data.text)
+    end
+
+    def regexp
+      /(?<featuring>\(?(#{FeaturingNode::VERSIONS_REGEXP})\s.*\)?)/i #find featuring keywords
+    end
+
+  end
+end

data/lib/track_parser/filters/filter_nodes_mapping.rb

@@ -0,0 +1,12 @@
+require_relative '../nodes/remix_node'
+require_relative '../nodes/featuring_node'
+
+module TrackParser
+  class FilterNodesMapping
+    FILTERS_NODES_MAPPING = {remix: RemixNode, featuring: FeaturingNode}
+
+    def self.to_nodes(parts)
+      parts.map { |part| FILTERS_NODES_MAPPING[part[:type]].new(part[:text])}
+    end
+  end
+end

data/lib/track_parser/filters/remix_filter.rb

@@ -0,0 +1,41 @@
+require_relative "../nodes/remix_node"
+
+module TrackParser
+  class RemixFilter
+
+    def self.filter(data)
+      self.new(data).filter
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    def filter
+      if has_remix?
+        extracted = content.select {|match| !regexp.match(match).nil?}.first #select first that matches a remix
+        @data.add_part(:remix, extracted)
+        @data.remove_text "(#{extracted})" #remove remix string from
+      end
+      return @data
+    end
+
+    def has_remix?
+      !!regexp #find remix keywords
+    end
+
+    def content
+      text = @data.text
+      if text =~ /(\(|\))+/
+        text.scan(/\((?<content>.*?)\)/).flatten
+      else
+        [text]
+      end
+    end
+
+    def regexp
+      /(?<remix>.*?\b(#{RemixNode::VERSIONS_REGEXP})+)\b/i
+    end
+
+  end
+end

data/lib/track_parser/nodes/artist_node.rb

@@ -0,0 +1,14 @@
+require_relative 'base_node'
+
+module TrackParser
+  class ArtistNode < BaseNode
+
+    def initialize(raw)
+      super(:artist, raw)
+    end
+
+    def name
+      @raw.strip
+    end
+  end
+end

data/lib/track_parser/nodes/artists_node.rb

@@ -0,0 +1,31 @@
+require_relative 'artist_node'
+require_relative 'base_node'
+
+module TrackParser
+  class ArtistsNode < BaseNode
+
+    def initialize(artists)
+      super(:artists, artists)
+    end
+
+    def children
+      if @raw.is_a? String
+        if multiple?
+          @raw.split(regex).map { |capture| ArtistNode.new(capture) }
+        else
+          [ArtistNode.new(@raw)]
+        end
+      else
+        @raw.map { |artist| ArtistNode.new(artist) }
+      end
+    end
+
+    def multiple?
+      !!regex.match(@raw)
+    end
+
+    def regex
+      /\s(?:and|&)\s/i
+    end
+  end
+end

data/lib/track_parser/nodes/base_node.rb

@@ -0,0 +1,16 @@
+require 'ast'
+require_relative 'empty_node'
+
+module TrackParser
+  class BaseNode < AST::Node
+
+    def self.new(text)
+      return EmptyNode.new if text.nil? || (text.is_a?(String) && text.strip.empty?)
+      super(text)
+    end
+
+    def initialize(type, text)
+      super(type, [], {raw: text})
+    end
+  end
+end

data/lib/track_parser/nodes/empty_node.rb

@@ -0,0 +1,7 @@
+require 'ast'
+
+class EmptyNode < AST::Node
+  def initialize
+    super(:empty, [])
+  end
+end

data/lib/track_parser/nodes/featuring_node.rb

@@ -0,0 +1,22 @@
+require_relative 'artist_node'
+require_relative 'base_node'
+
+module TrackParser
+  class FeaturingNode < BaseNode
+
+    VERSIONS_REGEXP = ["feat.", "featuring", "ft."].join("|")
+
+    def initialize(artists)
+      super(:featuring, artists)
+    end
+
+    def regexp
+      /\(?(#{FeaturingNode::VERSIONS_REGEXP})\s(?<artist>[^\)]*)\)?/i
+    end
+
+    def children
+      artist = regexp.match(@raw)[:artist]
+      [ArtistsNode.new(artist)]
+    end
+  end
+end

data/lib/track_parser/nodes/name_node.rb

@@ -0,0 +1,14 @@
+require_relative 'base_node'
+
+module TrackParser
+  class NameNode < BaseNode
+
+    def initialize(name)
+      super(:name, name)
+    end
+
+    def name
+      @raw.strip
+    end
+  end
+end

data/lib/track_parser/nodes/remix_node.rb

@@ -0,0 +1,40 @@
+require_relative 'base_node'
+require_relative 'artists_node'
+require_relative 'name_node'
+
+module TrackParser
+  class RemixNode < BaseNode
+
+    VERSIONS_REGEXP = ["remix", "mix", "vocal", "dub", "rework", "edit", "version", "extended", "club", "original"].join("|")
+
+    def initialize(remix)
+      raw = remix.gsub(/(\(|\))/, "") # remove parantheses
+      super(:remix, raw)
+    end
+
+    def children
+      if has_remix_name?
+        nodes = @raw.split(/(?:'|´)s/)
+        [ArtistsNode.new(nodes[0]), NameNode.new(nodes[1])]
+      else
+        [ArtistsNode.new(remixer), NameNode.new(remix_version)]
+      end
+    end
+
+    def has_remix_name?
+      @raw.include?("'s") || @raw.include?("´s")
+    end
+
+    def remixer
+      without_version.strip
+    end
+
+    def remix_version(remix = @raw)
+      remix.scan(/(#{VERSIONS_REGEXP})\b/i).flatten.join(" ")
+    end
+
+    def without_version(part = @raw)
+      part.gsub(remix_version, "")
+    end
+  end
+end

data/lib/track_parser/nodes/track_node.rb

@@ -0,0 +1,49 @@
+require_relative 'base_node'
+require_relative 'artists_node'
+require_relative 'trackname_node'
+require_relative 'remix_node'
+
+module TrackParser
+  class TrackNode < BaseNode
+
+    def initialize(track)
+      raw = replace_parentheses(track)
+      super(:track, raw)
+    end
+
+    def children
+      if track_sections.size == 1
+        raise UnparseableTrack.new("Don't know how to parse a track without \"-\". Track was:#{@raw}")
+      else
+        nodes = track_sections[2..-1].map do |track_section|
+          parts = FilterPipeline.filter(track_section).first
+          FilterNodesMapping.to_nodes(parts)
+        end
+        [ArtistsNode.new(track_sections[0]), TracknameNode.new(track_sections[1])] + nodes.flatten
+      end
+    end
+
+    def replace_parentheses(text)
+      if text.is_a? String
+        text.gsub("[","(").gsub("]",")")
+      else
+        text[:name] = replace_parentheses(text[:name])
+        text
+      end
+    end
+
+    def track_sections
+      if @raw.is_a? String
+        split_sections(@raw)
+      else
+        [@raw[:artists]] + split_sections(@raw[:name])
+      end
+    end
+
+    def split_sections(text)
+      text.split(" - ").map(&:strip)
+    end
+  end
+
+  class UnparseableTrack < StandardError; end
+end

data/lib/track_parser/nodes/trackname_node.rb

@@ -0,0 +1,20 @@
+require_relative 'base_node'
+require_relative 'name_node'
+require_relative 'remix_node'
+require_relative 'featuring_node'
+require_relative '../filter_pipeline'
+require_relative '../filters/filter_nodes_mapping'
+
+module TrackParser
+  class TracknameNode < BaseNode
+
+    def initialize(trackname)
+      super(:trackname, trackname)
+    end
+
+    def children
+      parts, remaining_text = FilterPipeline.filter(@raw)
+      [NameNode.new(remaining_text)] + FilterNodesMapping.to_nodes(parts)
+    end
+  end
+end

data/lib/track_parser/parser.rb

@@ -0,0 +1,19 @@
+require_relative "nodes/track_node"
+require_relative "processor"
+
+module TrackParser
+  class Parser
+
+    def self.do(track)
+      self.new(track).parse
+    end
+
+    def initialize(track)
+      @track = TrackNode.new(track)
+    end
+
+    def parse
+      Processor.new.process(@track)
+    end
+  end
+end

data/lib/track_parser/processor.rb

@@ -0,0 +1,53 @@
+require "ast"
+require_relative "track"
+
+module TrackParser
+  class Processor < AST::Processor
+
+    def initialize
+      @track = Track.new
+    end
+
+    def on_track(node)
+      hash = process_all(node).reduce({}) { |mem, h| mem.merge(h) }
+      @track.add_artists(hash[:artists])
+      @track
+    end
+
+    def on_trackname(node)
+      hash = process_all(node).reduce({}) { |mem, h| mem.merge(h) }
+      @track.add_name(hash[:name])
+      {}
+    end
+
+    def on_artists(node)
+      artists = process_all(node)
+      { artists: artists }
+    end
+
+    def on_artist(node)
+      node.name
+    end
+
+    def on_name(node)
+      { name: node.name }
+    end
+
+    def on_remix(node)
+      hash = process_all(node).reduce({}) { |mem, h| mem.merge(h) }
+      @track.add_remixer(hash[:artists])
+      @track.add_remix_name(hash[:name])
+      {}
+    end
+
+    def on_featuring(node)
+      artists = process_all(node).first
+      @track.add_featuring(artists[:artists])
+      {}
+    end
+
+    def on_empty(node)
+      {}
+    end
+  end
+end

data/lib/track_parser/track.rb

@@ -0,0 +1,49 @@
+module TrackParser
+  class Track
+
+    attr_accessor :artists, :name, :remixer, :remix_name, :featuring
+
+    def initialize(hash = {})
+      @artists = hash[:artists]
+      @name = hash[:name]
+      @remixer = hash[:remixer]
+      @remix_name = hash[:remix_name]
+      @featuring = hash[:featuring]
+    end
+
+    def add_artists(artists)
+      @artists = artists
+    end
+
+    def add_remixer(remixer)
+      return if remixer.nil?
+      if @remixer.nil?
+        @remixer = remixer
+      else
+        @remixer.concat(remixer)
+      end
+    end
+
+    def add_remix_name(remix_name)
+      return if remix_name.nil?
+      if @remix_name.nil?
+        @remix_name = remix_name
+      else
+        @remix_name += " " + remix_name
+      end
+    end
+
+    def add_name(name)
+      @name = name
+    end
+
+    def add_featuring(featured_artists)
+      @featuring = featured_artists
+    end
+
+    def to_s
+      "artists='#{@artists}' name='#{@name}' remixer='#{@remixer}' remix_name='#{@remix_name}' featuring='#{featuring}'"
+    end
+
+  end
+end

data/lib/track_parser/version.rb

@@ -0,0 +1,3 @@
+module TrackParser
+  VERSION = "1.0.0"
+end

data/spec/parser_spec.rb

@@ -0,0 +1,96 @@
+describe TrackParser::Parser do
+
+  tracks = {
+    "SIS - Orgsa" =>
+      { artists: ["SIS"], name: "Orgsa", remixer: nil, remix_name: nil},
+    "Roy Davis Jr - About Love (Pezzner Remix)" =>
+      { artists: ["Roy Davis Jr"], name: "About Love", remixer: ["Pezzner"], remix_name: "Remix" },
+    "Julien Perez & Octavio Camino - Parada Maya" =>
+      { artists: ["Julien Perez", "Octavio Camino"], name: "Parada Maya", remixer: nil, remix_name: nil},
+    "Kollektiv Turmstrasse - Ordinary (Lake People's Circle Motive Remix)" =>
+      { artists: ["Kollektiv Turmstrasse"], name: "Ordinary", remixer: ["Lake People"], remix_name: "Circle Motive Remix" },
+    "Derek Marin - We've Been Expecting You - Hreno´s Deep Pockets Dub" =>
+      { artists: ["Derek Marin"], name: "We've Been Expecting You", remixer: ["Hreno"], remix_name: "Deep Pockets Dub" },
+    "Umek & Uto Karem - Crossing the Lines - Original Mix" =>
+      { artists: ["Umek", "Uto Karem"], name: "Crossing the Lines", remixer: nil, remix_name: "Original Mix" },
+    "Noir & Fraser Owen - &U - Mendo and Danny Serrano Remix" =>
+      { artists: ["Noir", "Fraser Owen"], name: "&U", remixer: ["Mendo", "Danny Serrano"], remix_name: "Remix"},
+    "Plastikman - Spastik - Dubfire Rework" =>
+      { artists: ["Plastikman"], name: "Spastik", remixer: ["Dubfire"], remix_name: "Rework" },
+    "Alex Under - El Encuentro - Richie Hawtin Edit" =>
+      { artists: ['Alex Under'], name: 'El Encuentro', remixer: ["Richie Hawtin"], remix_name: "Edit" },
+    "Gorge - Erotic Soul feat. The Writers Poet - Original Mix" =>
+      { artists: ["Gorge"], name: "Erotic Soul", featuring: ["The Writers Poet"], remixer: nil, remix_name: "Original Mix"},
+    "John Talabot & Pional - Destiny (Feat. Pional)" =>
+      { artists: ["John Talabot", "Pional"], name: "Destiny", featuring: ["Pional"], remixer: nil, remix_name: nil},
+    "Ornette - Crazy - Nôze Remix - Extended Club Version" =>
+      { artists: ["Ornette"], name: "Crazy", remixer: ["Nôze"], remix_name: "Remix Extended Club Version" },
+    "2 Guys in Venice & Spiller & Digitalism - Encore - Spiller & 2 Guys In Venice Remix" =>
+      { artists: ["2 Guys in Venice", "Spiller", "Digitalism"], name: "Encore", remixer: ["Spiller", "2 Guys In Venice"], remix_name: "Remix" },
+    "Subb-an - Take You Back (ft. Beckford)" =>
+      { artists: ["Subb-an"], name: "Take You Back", featuring: ["Beckford"] },
+    "Aki Bergen & Pezzner & Terry Grant - Tarareando - Vocal Mix" =>
+      { artists: ["Aki Bergen", "Pezzner", "Terry Grant"], name: "Tarareando", remixer: nil, remix_name: "Vocal Mix" },
+    "Jay Haze & Laila Tov - I Wait For You - Original" =>
+      { artists: ["Jay Haze", "Laila Tov"], name: "I Wait For You", remixer: nil, remix_name: "Original"},
+    "DJ T. - City Life - feat. Cari Golden [Maceo Plex Remix]" =>
+      { artists: ["DJ T."], name: "City Life", remixer: ["Maceo Plex"], remix_name: "Remix", featuring: ["Cari Golden"]},
+    "Fritz Kalkbrenner - Right in the Dark - Henrik Schwarz Remix - Chopstick & Johnjon Edit" =>
+      { artists: ["Fritz Kalkbrenner"], name: "Right in the Dark", remixer: ["Henrik Schwarz", "Chopstick", "Johnjon"], remix_name: "Remix Edit"}
+  }
+
+  tracks_structured = [
+    {track: { artists: ["Sailor & I"], name: "Tough Love - Aril Brikha Remix" }, result:
+      { artists: ["Sailor & I"], name: "Tough Love", remixer: ["Aril Brikha"], remix_name: "Remix"}}
+  ]
+
+  let(:parsed_track) { TrackParser::Parser.do(track) }
+
+  tracks.keys.each do |track|
+    context "#{track}" do
+      let(:track) { track }
+
+      it "returns the artist correctly" do
+        expect(parsed_track.artists).to eq(tracks[track][:artists])
+      end
+
+      it "returns the track name correctly" do
+        expect(parsed_track.name).to eq(tracks[track][:name])
+      end
+
+      it "returns the remixer correctly" do
+        expect(parsed_track.remixer).to eq(tracks[track][:remixer])
+      end
+
+      it "returns the remix name correctly" do
+        expect(parsed_track.remix_name).to eq(tracks[track][:remix_name])
+      end
+
+      it "returns the featured artists correctly" do
+        expect(parsed_track.featuring).to eq(tracks[track][:featuring])
+      end
+    end
+  end
+
+  context "invalid track" do
+    let(:track) { "Invalid Track" }
+
+    it "throws an exception when the track doesn't have \"-\"" do
+      expect{TrackParser::Parser.do(track)}.to raise_error(TrackParser::UnparseableTrack)
+    end
+  end
+
+  context "Hash as input" do
+    let(:track) { tracks_structured.first[:track] }
+    let(:result) { tracks_structured.first[:result]}
+
+    it "returns all the correct info" do
+      expect(parsed_track.artists).to eq(result[:artists])
+      expect(parsed_track.name).to eq(result[:name])
+      expect(parsed_track.remixer).to eq(result[:remixer])
+      expect(parsed_track.remix_name).to eq(result[:remix_name])
+      expect(parsed_track.featuring).to eq(result[:featuring])
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'track_parser'
+
+RSpec.configure do |config|
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

data/track_parser.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'track_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "track_parser"
+  spec.version       = TrackParser::VERSION
+  spec.authors       = ["Alexandre Quintino"]
+  spec.email         = ["amsquintino@gmail.com"]
+  spec.summary       = %q{Tries to parse the name of a track (eg. ArtistA - ABC (ArtistB remix)) and extract metadata from it (eg. artists = ArtistA, track-name = ABC, remixer = ArtistB)}
+  spec.description   = %q{Tries to parse the name of a track (eg. ArtistA - ABC (ArtistB remix)) and extract metadata from it (eg. artists = ArtistA, track-name = ABC, remixer = ArtistB)}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_runtime_dependency "ast"
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: track_parser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Alexandre Quintino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tries to parse the name of a track (eg. ArtistA - ABC (ArtistB remix))
+  and extract metadata from it (eg. artists = ArtistA, track-name = ABC, remixer =
+  ArtistB)
+email:
+- amsquintino@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/track_parser.rb
+- lib/track_parser/filter_pipeline.rb
+- lib/track_parser/filtered_parts.rb
+- lib/track_parser/filters/featuring_filter.rb
+- lib/track_parser/filters/filter_nodes_mapping.rb
+- lib/track_parser/filters/remix_filter.rb
+- lib/track_parser/nodes/artist_node.rb
+- lib/track_parser/nodes/artists_node.rb
+- lib/track_parser/nodes/base_node.rb
+- lib/track_parser/nodes/empty_node.rb
+- lib/track_parser/nodes/featuring_node.rb
+- lib/track_parser/nodes/name_node.rb
+- lib/track_parser/nodes/remix_node.rb
+- lib/track_parser/nodes/track_node.rb
+- lib/track_parser/nodes/trackname_node.rb
+- lib/track_parser/parser.rb
+- lib/track_parser/processor.rb
+- lib/track_parser/track.rb
+- lib/track_parser/version.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- track_parser.gemspec
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Tries to parse the name of a track (eg. ArtistA - ABC (ArtistB remix)) and
+  extract metadata from it (eg. artists = ArtistA, track-name = ABC, remixer = ArtistB)
+test_files:
+- spec/parser_spec.rb
+- spec/spec_helper.rb