metal_archives 2.2.0 → 3.1.1

data/lib/metal_archives/parsers/artist.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'date'
-require 'countries'
-
-require 'metal_archives/middleware/rewrite_endpoint'
+require "json"
+require "date"
+require "countries"
 
 module MetalArchives
   module Parsers
@@ -22,11 +20,9 @@ module MetalArchives
         #     +Hash+
         #
         def map_params(query)
-          params = {
-            :query => query[:name] || ''
+          {
+            query: query[:name] || "",
           }
-
-          params
         end
 
         ##
@@ -38,50 +34,56 @@ module MetalArchives
         # - rdoc-ref:MetalArchives::Errors::ParserError when parsing failed. Please report this error.
         #
         def parse_html(response)
-          props = {}
+          # Set default props
+          props = {
+            name: nil,
+            aliases: [],
+
+            date_of_birth: nil,
+            date_of_death: nil,
+            cause_of_death: nil,
+            gender: nil,
+
+            country: nil,
+            location: nil,
+
+            photo: nil,
+
+            bands: [],
+          }
+
           doc = Nokogiri::HTML response
 
           # Photo
-          unless doc.css('.member_img').empty?
-            photo_uri = URI doc.css('.member_img img').first.attr('src')
-            props[:photo] = Middleware::RewriteEndpoint.rewrite photo_uri
+          unless doc.css(".member_img").empty?
+            photo_uri = URI doc.css(".member_img img").first.attr("src")
+            props[:photo] = rewrite(photo_uri)
           end
 
-          doc.css('#member_info dl').each do |dl|
-            dl.css('dt').each do |dt|
+          doc.css("#member_info dl").each do |dl|
+            dl.css("dt").each do |dt|
               content = sanitize(dt.next_element.content)
 
-              next if content == 'N/A'
+              next if content == "N/A"
 
               case sanitize(dt.content)
-              when 'Real/full name:'
+              when "Real/full name:"
                 props[:name] = content
-              when 'Age:'
-                date = content.strip.gsub(/[0-9]* *\(born ([^\)]*)\)/, '\1')
-                begin
-                  props[:date_of_birth] = NilDate.parse date
-                rescue MetalArchives::Errors::ArgumentError => e
-                  dob = Date.parse date
-                  props[:date_of_birth] = NilDate.new dob.year, dob.month, dob.day
-                end
-              when 'R.I.P.:'
-                begin
-                  dod = Date.parse content
-                  props[:date_of_death] = NilDate.new dod.year, dod.month, dod.day
-                rescue ArgumentError => e
-                  props[:date_of_death] = NilDate.parse content
-                end
-              when 'Died of:'
+              when "Age:"
+                props[:date_of_birth] = Parsers::Date.parse(content.strip.gsub(/[0-9]* *\(born ([^)]*)\)/, '\1'))
+              when "R.I.P.:"
+                props[:date_of_death] = Parsers::Date.parse(content)
+              when "Died of:"
                 props[:cause_of_death] = content
-              when 'Place of origin:'
-                props[:country] = ISO3166::Country.find_country_by_name(sanitize(dt.next_element.css('a').first.content))
-                location = dt.next_element.xpath('text()').map(&:content).join('').strip.gsub(/[()]/, '')
+              when "Place of origin:"
+                props[:country] = Country.parse(sanitize(dt.next_element.css("a").first.content))
+                location = dt.next_element.xpath("text()").map(&:content).join.strip.gsub(/[()]/, "")
                 props[:location] = location unless location.empty?
-              when 'Gender:'
+              when "Gender:"
                 case content
-                when 'Male'
+                when "Male"
                   props[:gender] = :male
-                when 'Female'
+                when "Female"
                   props[:gender] = :female
                 else
                   raise Errors::ParserError, "Unknown gender: #{content}"
@@ -93,12 +95,46 @@ module MetalArchives
           end
 
           # Aliases
-          props[:aliases] = []
-          alt = sanitize doc.css('.band_member_name').first.content
+          alt = sanitize doc.css(".band_member_name").first.content
           props[:aliases] << alt unless props[:name] == alt
 
+          # Active bands
+          proc = proc do |row|
+            link = row.css("h3 a")
+
+            name, id = nil
+
+            if link.any?
+              # Band name contains a link
+              id = Integer(link.attr("href").text.gsub(%r(^.*/([^/#]*)#.*$), '\1'))
+            else
+              # Band name does not contain a link
+              name = sanitize row.css("h3").text
+            end
+
+            r = row.css(".member_in_band_role")
+
+            range = Parsers::Year.parse(r.xpath("text()").map(&:content).join.strip.gsub(/[\n\r\t]/, "").gsub(/.*\((.*)\)/, '\1'))
+            role = sanitize r.css("strong")&.first&.content
+
+            {
+              id: id,
+              name: name,
+              years_active: range,
+              role: role,
+            }.compact
+          end
+
+          doc.css("#artist_tab_active .member_in_band").each do |row|
+            props[:bands] << proc.call(row).merge(active: true)
+          end
+
+          doc.css("#artist_tab_past .member_in_band").each do |row|
+            props[:bands] << proc.call(row).merge(active: false)
+          end
+
           props
-        rescue => e
+        rescue StandardError => e
           e.backtrace.each { |b| MetalArchives.config.logger.error b }
           raise Errors::ParserError, e
         end
@@ -119,25 +155,25 @@ module MetalArchives
           # Default to official links
           type = :official
 
-          doc.css('#linksTablemain tr').each do |row|
-            if row['id'].match /^header_/
-              type = row['id'].gsub(/^header_/, '').downcase.to_sym
+          doc.css("#linksTablemain tr").each do |row|
+            if /^header_/.match?(row["id"])
+              type = row["id"].gsub(/^header_/, "").downcase.to_sym
             else
-              a = row.css('td a').first
+              a = row.css("td a").first
 
               # No links have been added yet
               next unless a
 
               links << {
-                :url => a['href'],
-                :type => type,
-                :title => a.content
+                url: a["href"],
+                type: type,
+                title: a.content,
               }
             end
           end
 
           links
-        rescue => e
+        rescue StandardError => e
           e.backtrace.each { |b| MetalArchives.config.logger.error b }
           raise Errors::ParserError, e
         end

data/lib/metal_archives/parsers/band.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-require 'json'
-require 'date'
-require 'countries'
+
+require "json"
+require "date"
+require "countries"
 
 module MetalArchives
   module Parsers
@@ -20,22 +21,22 @@ module MetalArchives
         #
         def map_params(query)
           params = {
-            :bandName => query[:name] || '',
-            :exactBandMatch => (!!query[:exact] ? 1 : 0),
-            :genre => query[:genre] || '',
-            :yearCreationFrom => (query[:year] && query[:year].begin ? query[:year].begin.year : '') || '',
-            :yearCreationTo => (query[:year] && query[:year].end ? query[:year].end.year : '') || '',
-            :bandNotes => query[:comment] || '',
-            :status => map_status(query[:status]),
-            :themes => query[:lyrical_themes] || '',
-            :location => query[:location] || '',
-            :bandLabelName => query[:label] || '',
-            :indieLabelBand => (!!query[:independent] ? 1 : 0)
+            bandName: query[:name] || "",
+            exactBandMatch: (query[:exact] ? 1 : 0),
+            genre: query[:genre] || "",
+            yearCreationFrom: query[:year]&.begin || "",
+            yearCreationTo: query[:year]&.end || "",
+            bandNotes: query[:comment] || "",
+            status: map_status(query[:status]),
+            themes: query[:lyrical_themes] || "",
+            location: query[:location] || "",
+            bandLabelName: query[:label] || "",
+            indieLabelBand: (query[:independent] ? 1 : 0),
           }
 
           params[:country] = []
           Array(query[:country]).each do |country|
-            params[:country] << (country.is_a?(ISO3166::Country) ? country.alpha2 : (country || ''))
+            params[:country] << (country.is_a?(ISO3166::Country) ? country.alpha2 : (country || ""))
           end
           params[:country] = params[:country].first if params[:country].size == 1
 
@@ -51,77 +52,120 @@ module MetalArchives
         # - rdoc-ref:MetalArchives::Errors::ParserError when parsing failed. Please report this error.
         #
         def parse_html(response)
-          props = {}
-          doc = Nokogiri::HTML response
+          # Set default props
+          props = {
+            name: nil,
+            aliases: [],
+
+            logo: nil,
+            photo: nil,
+
+            country: nil,
+            location: nil,
+
+            status: nil,
+            date_formed: nil,
+            years_active: [],
+            independent: nil,
 
-          props[:name] = sanitize doc.css('#band_info .band_name a').first.content
+            genres: [],
+            lyrical_themes: [],
 
-          props[:aliases] = []
+            members: [],
+          }
+
+          doc = Nokogiri::HTML response
+
+          props[:name] = sanitize doc.css("#band_info .band_name a").first.content
 
           # Logo
-          unless doc.css('.band_name_img').empty?
-            logo_uri = URI doc.css('.band_name_img img').first.attr('src')
-            props[:logo] = Middleware::RewriteEndpoint.rewrite logo_uri
+          unless doc.css(".band_name_img").empty?
+            logo_uri = URI doc.css(".band_name_img img").first.attr("src")
+            props[:logo] = rewrite(logo_uri)
           end
 
           # Photo
-          unless doc.css('.band_img').empty?
-            photo_uri = URI doc.css('.band_img img').first.attr('src')
-            props[:photo] = Middleware::RewriteEndpoint.rewrite photo_uri
+          unless doc.css(".band_img").empty?
+            photo_uri = URI doc.css(".band_img img").first.attr("src")
+            props[:photo] = rewrite(photo_uri)
           end
 
-          doc.css('#band_stats dl').each do |dl|
-            dl.search('dt').each do |dt|
+          doc.css("#band_stats dl").each do |dl|
+            dl.search("dt").each do |dt|
               content = sanitize(dt.next_element.content)
 
-              next if content == 'N/A'
+              next if content == "N/A"
 
               case dt.content
-              when 'Country of origin:'
-                props[:country] = ISO3166::Country.find_country_by_name sanitize(dt.next_element.css('a').first.content)
-              when 'Location:'
+              when "Country of origin:"
+                props[:country] = Country.parse(sanitize(dt.next_element.css("a").first.content))
+              when "Location:"
                 props[:location] = content
-              when 'Status:'
-                props[:status] = content.downcase.tr(' ', '_').to_sym
-              when 'Formed in:'
-                begin
-                  dof = Date.parse content
-                  props[:date_formed] = NilDate.new dof.year, dof.month, dof.day
-                rescue ArgumentError => e
-                  props[:date_formed] = NilDate.parse content
-                end
-              when 'Genre:'
-                props[:genres] = parse_genre content
-              when 'Lyrical themes:'
-                props[:lyrical_themes] = []
-                content.split(',').each do |theme|
+              when "Status:"
+                props[:status] = content.downcase.tr(" -", "_").to_sym
+              when "Formed in:"
+                props[:date_formed] = Parsers::Date.parse(content)
+              when "Genre:"
+                props[:genres] = Parsers::Genre.parse(content)
+              when "Lyrical themes:"
+                content.split(",").each do |theme|
                   t = theme.split.map(&:capitalize)
-                  t.delete '(early)'
-                  t.delete '(later)'
-                  props[:lyrical_themes] << t.join(' ')
+                  t.delete "(early)"
+                  t.delete "(later)"
+                  props[:lyrical_themes] << t.join(" ")
                 end
               when /(Current|Last) label:/
-                props[:independent] = (content == 'Unsigned/independent')
-                # TODO
-              when 'Years active:'
-                props[:date_active] = []
-                content.split(',').each do |range|
+                props[:independent] = (content == "Unsigned/independent")
+                # TODO: label
+              when "Years active:"
+                content.split(",").each do |range|
                   # Aliases
                   range.scan(/\(as ([^)]*)\)/).each { |name| props[:aliases] << name.first }
                   # Ranges
-                  r = range.gsub(/ *\(as ([^)]*)\) */, '').strip.split('-')
-                  date_start = (r.first == '?' ? nil : Date.new(r.first.to_i))
-                  date_end = (r.last ==( '?') || r.last == 'present' ? nil : Date.new(r.first.to_i))
-                  props[:date_active] << MetalArchives::Range.new(date_start, date_end)
+                  props[:years_active] << Parsers::Year.parse(range.gsub(/ *\(as ([^)]*)\) */, ""))
                 end
               else
-                raise MetalArchives::Errors::ParserError, "Unknown token: #{dt.content}"
+                raise Errors::ParserError, "Unknown token: #{dt.content}"
               end
             end
           end
 
+          # Members
+          proc = proc do |row|
+            link = row.css("a")
+
+            if link.any?
+              # Artist name contains a link
+              id = Integer(link.attr("href").text.split("/").last)
+              name = sanitize link.text
+            else
+              # Artist name does not contain a link
+              name = sanitize row.css("h3").text
+            end
+
+            r = row.css("td").last.text
+            role, range = r.match(/(.*)\(([^(]*)\)/)&.captures
+
+            range = Parsers::Year.parse(range)
+
+            {
+              id: id,
+              name: name,
+              years_active: range,
+              role: sanitize(role),
+            }.compact
+          end
+
+          doc.css("#band_tab_members_current .lineupRow").each do |row|
+            props[:members] << proc.call(row).merge(current: true)
+          end
+
+          doc.css("#band_tab_members_past .lineupRow").each do |row|
+            props[:members] << proc.call(row).merge(current: false)
+          end
+
           props
-        rescue => e
+        rescue StandardError => e
           e.backtrace.each { |b| MetalArchives.config.logger.error b }
           raise Errors::ParserError, e
         end
@@ -138,15 +182,16 @@ module MetalArchives
           similar = []
 
           doc = Nokogiri::HTML response
-          doc.css('#artist_list tbody tr').each do |row|
+          doc.css("#artist_list tbody tr").each do |row|
             similar << {
-              :band => MetalArchives::Band.new(:id => row.css('td a').first['href'].split('/').last.to_i),
-                :score => row.css('td').last.content.strip
+              id: row.css("td a").first["href"].split("/").last.to_i,
+              score: row.css("td").last.content.strip,
             }
           end
 
           similar
-        rescue => e
+        rescue StandardError => e
+          MetalArchives.config.logger e.message
           e.backtrace.each { |b| MetalArchives.config.logger.error b }
           raise Errors::ParserError, e
         end
@@ -163,49 +208,71 @@ module MetalArchives
           links = []
 
           doc = Nokogiri::HTML response
-          doc.css('#linksTableOfficial td a').each do |a|
+          doc.css("#linksTableOfficial td a").each do |a|
             links << {
-              :url => a['href'],
-              :type => :official,
-              :title => a.content
+              url: a["href"],
+              type: :official,
+              title: a.content,
             }
           end
-          doc.css('#linksTableOfficial_merchandise td a').each do |a|
+          doc.css("#linksTableOfficial_merchandise td a").each do |a|
             links << {
-              :url => a['href'],
-              :type => :merchandise,
-              :title => a.content
+              url: a["href"],
+              type: :merchandise,
+              title: a.content,
             }
           end
 
           links
-        rescue => e
+        rescue StandardError => e
+          e.backtrace.each { |b| MetalArchives.config.logger.error b }
+          raise Errors::ParserError, e
+        end
+
+        ##
+        # Parse releases HTML page
+        #
+        # Returns +Array+
+        # [Raises]
+        # - rdoc-ref:MetalArchives::Errors::ParserError when parsing failed. Please report this error.
+        #
+        def parse_releases_html(response)
+          releases = []
+
+          doc = Nokogiri::HTML response
+          doc.css("tbody tr td:first a").each do |a|
+            id = a["href"].split("/").last.to_i
+            releases << MetalArchives::Release.find(id)
+          end
+
+          releases
+        rescue StandardError => e
           e.backtrace.each { |b| MetalArchives.config.logger.error b }
           raise Errors::ParserError, e
         end
 
         private
 
-          ##
-          # Map MA band status
-          #
-          # Returns +Symbol+
-          #
-          # [Raises]
-          # - rdoc-ref:MetalArchives::Errors::ParserError when parsing failed. Please report this error.
-          #
+        ##
+        # Map MA band status
+        #
+        # Returns +Symbol+
+        #
+        # [Raises]
+        # - rdoc-ref:MetalArchives::Errors::ParserError when parsing failed. Please report this error.
+        #
         def map_status(status)
           s = {
-            nil => '',
-            :active => 'Active',
-            :split_up => 'Split-up',
-            :on_hold => 'On hold',
-            :unknown => 'Unknown',
-            :changed_name => 'Changed name',
-            :disputed => 'Disputed'
+            nil => "",
+            :active => "Active",
+            :split_up => "Split-up",
+            :on_hold => "On hold",
+            :unknown => "Unknown",
+            :changed_name => "Changed name",
+            :disputed => "Disputed",
           }
 
-          raise MetalArchives::Errors::ParserError, "Unknown status: #{status}" unless s[status]
+          raise Errors::ParserError, "Unknown status: #{status}" unless s[status]
 
           s[status]
         end