metal_archives 2.2.0 → 3.1.1

data/lib/metal_archives/parsers/base.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MetalArchives
+  module Parsers
+    ##
+    # Abstract base class
+    #
+    class Base
+      def self.parse(_input)
+        raise Errors::NotImplementedError, "method .parse not implemented"
+      end
+    end
+  end
+end

data/lib/metal_archives/parsers/country.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "countries"
+
+module MetalArchives
+  module Parsers
+    ##
+    # Country parser
+    #
+    class Country < Base
+      ##
+      # Parse a country
+      #
+      # Returns +ISO3166::Country+
+      #
+      def self.parse(input)
+        ISO3166::Country.find_country_by_name(input)
+      end
+    end
+  end
+end

data/lib/metal_archives/parsers/date.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MetalArchives
+  module Parsers
+    ##
+    # Date parser
+    #
+    class Date < Base
+      ##
+      # Parse a date
+      #
+      # Returns +Date+
+      #
+      def self.parse(input)
+        ::Date.parse(input)
+      rescue ::Date::Error
+        components = input
+          .split("-")
+          .map(&:to_i)
+          .reject(&:zero?)
+          .compact
+
+        return if components.empty?
+
+        ::Date.new(*components)
+      rescue TypeError
+        nil
+      end
+    end
+  end
+end

data/lib/metal_archives/parsers/genre.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module MetalArchives
+  module Parsers
+    ##
+    # Genre parser
+    #
+    class Genre < Base
+      SUFFIXES = %w((early) (later) metal).freeze
+
+      ##
+      # Opinionated parsing of genres
+      #
+      # Returns an +Array+ of +String+
+      #
+      # The following components are omitted:
+      # - Metal
+      # - (early)
+      # - (later)
+      #
+      # All genres are capitalized.
+      #
+      # For examples on how genres are parsed, refer to +gnre_spec.rb+
+      #
+      def self.parse(input)
+        genres = []
+        # Split fields
+        input.split(/[,;]/).each do |genre|
+          ##
+          # Start with a single empty genre string. Split the genre by spaces
+          # and process each component. If a component does not have a slash,
+          # concatenate it to all genre strings present in +temp+. If it does
+          # have a slash present, duplicate all genre strings, and concatenate
+          # the first component (before the slash) to the first half, and the
+          # last component to the last half. +temp+ now has an array of genre
+          # combinations.
+          #
+          # 'Traditional Heavy/Power Metal' => ['Traditional Heavy', 'Traditional Power']
+          # 'Traditional/Classical Heavy/Power Metal' => [
+          #                                       'Traditional Heavy', 'Traditional Power',
+          #                                       'Classical Heavy', 'Classical Power']
+          #
+          temp = [""]
+
+          genre.downcase.split.reject { |g| SUFFIXES.include? g }.each do |g|
+            if g.include? "/"
+              # Duplicate all WIP genres
+              temp2 = temp.dup
+
+              # Assign first and last components to temp and temp2 respectively
+              split = g.split "/"
+              temp.map! { |t| t.empty? ? split.first.capitalize : "#{t.capitalize} #{split.first.capitalize}" }
+              temp2.map! { |t| t.empty? ? split.last.capitalize : "#{t.capitalize} #{split.last.capitalize}" }
+
+              # Add both genre trees
+              temp += temp2
+            else
+              temp.map! { |t| t.empty? ? g.capitalize : "#{t.capitalize} #{g.capitalize}" }
+            end
+          end
+          genres += temp
+        end
+        genres.uniq
+      end
+    end
+  end
+end

data/lib/metal_archives/parsers/label.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'nokogiri'
+require "date"
+require "nokogiri"
 
 module MetalArchives
   module Parsers
@@ -11,53 +11,61 @@ module MetalArchives
     class Label # :nodoc:
       class << self
         def find_endpoint(params)
-          "#{MetalArchives.config.default_endpoint}labels/#{params[:name]}/#{params[:id]}"
+          "#{MetalArchives.config.endpoint}labels/#{params[:name]}/#{params[:id]}"
         end
 
         def parse(response)
-          props = {}
+          # Set default props
+          props = {
+            name: nil,
+            contact: [],
+            address: nil,
+            country: nil,
+            phone: nil,
+            status: nil,
+            specialization: [],
+            date_founded: nil,
+
+            online_shopping: nil,
+          }
+
           doc = Nokogiri::HTML(response)
 
-          props[:name] = doc.css('#label_info .label_name').first.content
+          props[:name] = doc.css("#label_info .label_name").first.content
 
-          props[:contact] = []
-          doc.css('#label_contact a').each do |contact|
+          doc.css("#label_contact a").each do |contact|
             props[:contact] << {
-              :title => contact.content,
-              :content => contact.attr(:href)
+              title: contact.content,
+              content: contact.attr(:href),
             }
           end
 
-          doc.css('#label_info dl').each do |dl|
-            dl.search('dt').each do |dt|
+          doc.css("#label_info 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 sanitize(dt.content)
-              when 'Address:'
+              when "Address:"
                 props[:address] = content
-              when 'Country:'
-                props[:country] = ParserHelper.parse_country css('a').first.content
-              when 'Phone number:'
+              when "Country:"
+                props[:country] = Country.parse(css("a").first.content)
+              when "Phone number:"
                 props[:phone] = content
-              when 'Status:'
-                props[:status] = content.downcase.tr(' ', '_').to_sym
-              when 'Specialised in:'
-                props[:specializations] = ParserHelper.parse_genre content
-              when 'Founding date :'
-                begin
-                  dof = Date.parse content
-                  props[:date_founded] = NilDate.new dof.year, dof.month, dof.day
-                rescue ArgumentError => e
-                  props[:date_founded] = NilDate.parse content
-                end
-              when 'Sub-labels:'
+              when "Status:"
+                props[:status] = content.downcase.tr(" ", "_").to_sym
+              when "Specialised in:"
+                props[:specializations] = Parsers::Genre.parse(content)
+              when "Founding date :"
+                props[:date_founded] = Parsers::Date.parse(content)
+              when "Sub-labels:"
                 # TODO
-              when 'Online shopping:'
-                if content == 'Yes'
+              when "Online shopping:"
+                case content
+                when "Yes"
                   props[:online_shopping] = true
-                elsif content == 'No'
+                when "No"
                   props[:online_shopping] = false
                 end
               else

data/lib/metal_archives/parsers/parser.rb

@@ -1,88 +1,43 @@
 # frozen_string_literal: true
 
-require 'date'
-require 'countries'
+require "date"
 
 module MetalArchives
-  ##
-  # Mapping layer from and to MA Web Service
-  #
-  module Parsers # :nodoc:
+  module Parsers
     ##
     # Parser base class
     #
     class Parser
       class << self
-        ##
-        # Parse a country
-        #
-        # Returns +ISO3166::Country+
-        #
-        def parse_country(input)
-          ISO3166::Country.find_country_by_name input
-        end
-
         ##
         # Sanitize a string
         #
         # Return +String+
         #
         def sanitize(input)
-          input.gsub(/^"/, '').gsub(/"$/, '').strip
+          return if input.blank?
+
+          input
+            .gsub(/^"/, "")
+            .gsub(/"$/, "")
+            .gsub(/[[:space:]]/, " ")
+            .strip
         end
 
         ##
-        # Opinionated parsing of genres
-        #
-        # Returns an +Array+ of +String+
-        #
-        # The following components are omitted:
-        # - Metal
-        # - (early)
-        # - (later)
-        #
-        # All genres are capitalized.
+        # Rewrite a URL
         #
-        # For examples on how genres are parsed, refer to +ParserTest#test_parse_genre+
+        # Return +URI+
         #
-        def parse_genre(input)
-          genres = []
-          # Split fields
-          input.split(',').each do |genre|
-            ##
-            # Start with a single empty genre string. Split the genre by spaces
-            # and process each component. If a component does not have a slash,
-            # concatenate it to all genre strings present in +temp+. If it does
-            # have a slash present, duplicate all genre strings, and concatenate
-            # the first component (before the slash) to the first half, and the
-            # last component to the last half. +temp+ now has an array of genre
-            # combinations.
-            #
-            # 'Traditional Heavy/Power Metal' => ['Traditional Heavy', 'Traditional Power']
-            # 'Traditional/Classical Heavy/Power Metal' => [
-            #                                       'Traditional Heavy', 'Traditional Power',
-            #                                       'Classical Heavy', 'Classical Power']
-            #
-            temp = ['']
-            genre.downcase.split.reject { |g| ['(early)', '(later)', 'metal'].include? g }.each do |g|
-              if g.include? '/'
-                # Duplicate all WIP genres
-                temp2 = temp.dup
+        def rewrite(input)
+          return input unless MetalArchives.config.endpoint
 
-                # Assign first and last components to temp and temp2 respectively
-                split = g.split '/'
-                temp.map! { |t| t.empty? ? split.first.capitalize : "#{t.capitalize} #{split.first.capitalize}" }
-                temp2.map! { |t| t.empty? ? split.last.capitalize : "#{t.capitalize} #{split.last.capitalize}" }
+          endpoint = URI(MetalArchives.config.endpoint)
 
-                # Add both genre trees
-                temp += temp2
-              else
-                temp.map! { |t| t.empty? ? g.capitalize : "#{t.capitalize} #{g.capitalize}" }
-              end
-            end
-            genres += temp
-          end
-          genres.uniq
+          URI(input)
+            .tap { |u| u.host = endpoint.host }
+            .tap { |u| u.scheme = endpoint.scheme }
+            .to_s
         end
       end
     end

data/lib/metal_archives/parsers/release.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'date'
+require "json"
+require "date"
 
 module MetalArchives
   module Parsers
@@ -11,52 +11,56 @@ module MetalArchives
     class Release < Parser # :nodoc:
       class << self
         TYPE_TO_QUERY = {
-          :full_length => 1,
-          :live => 2,
-          :demo => 3,
-          :single => 4,
-          :ep => 5,
-          :video => 6,
-          :boxed_set => 7,
-          :split => 8,
-          :compilation => 10,
-          :split_video => 12,
-          :collaboration => 13
+          full_length: 1,
+          live: 2,
+          demo: 3,
+          single: 4,
+          ep: 5,
+          video: 6,
+          boxed_set: 7,
+          split: 8,
+          compilation: 10,
+          split_video: 12,
+          collaboration: 13,
         }.freeze
 
         TYPE_TO_SYM = {
-          'Full-length' => :full_length,
-          'Live album' => :live,
-          'Demo' => :demo,
-          'Single' => :single,
-          'EP' => :ep,
-          'Video' => :video,
-          'Boxed set' => :boxed_set,
-          'Split' => :split,
-          'Compilation' => :compilation,
-          'Split video' => :split_video,
-          'Collaboration' => :collaboration
+          "Full-length" => :full_length,
+          "Live album" => :live,
+          "Demo" => :demo,
+          "Single" => :single,
+          "EP" => :ep,
+          "Video" => :video,
+          "Boxed set" => :boxed_set,
+          "Split" => :split,
+          "Compilation" => :compilation,
+          "Split video" => :split_video,
+          "Collaboration" => :collaboration,
         }.freeze
 
         FORMAT_TO_QUERY = {
-          :cd => 'CD',
-          :cassette => 'Cassette',
-          :vinyl => 'Vinyl*',
-          :vhs => 'VHS',
-          :dvd => 'DVD',
-          :digital => 'Digital',
-          :blu_ray => 'Blu-ray*',
-          :other => 'Other'
+          cd: "CD",
+          cassette: "Cassette",
+          vinyl: "Vinyl*",
+          vhs: "VHS",
+          dvd: "DVD",
+          "2dvd": "2DVD",
+          digital: "Digital",
+          blu_ray: "Blu-ray*",
+          other: "Other",
+          unknown: "Unknown",
         }.freeze
 
         FORMAT_TO_SYM = {
-          'CD' => :cd,
-          'Cassette' => :cassette,
-          'VHS' => :vhs,
-          'DVD' => :dvd,
-          'Digital' => :digital,
-          'Other' => :other
-        }
+          "CD" => :cd,
+          "Cassette" => :cassette,
+          "VHS" => :vhs,
+          "DVD" => :dvd,
+          "2DVD" => :"2dvd",
+          "Digital" => :digital,
+          "Other" => :other,
+          "Unknown" => :unknown,
+        }.freeze
 
         ##
         # Map attributes to MA attributes
@@ -67,27 +71,25 @@ module MetalArchives
         #     +Hash+
         #
         def map_params(query)
-          params = {
-            :bandName => query[:band_name] || '',
-            :releaseTitle => query[:title] || '',
-            :releaseYearFrom => query[:from_year] || '',
-            :releaseMonthFrom => query[:from_month] || '',
-            :releaseYearTo => query[:to_year] || '',
-            :releaseMonthTo => query[:to_month] || '',
-            :country => map_countries(query[:country]) || '',
-            :location => query[:location] || '',
-            :releaseLabelName => query[:label_name] || '',
-            :releaseCatalogNumber => query[:catalog_id] || '',
-            :releaseIdentifiers => query[:identifier] || '',
-            :releaseRecordingInfo => query[:recording_info] || '',
-            :releaseDescription => query[:version_description] || '',
-            :releaseNotes => query[:notes] || '',
-            :genre => query[:genre] || '',
-            :releaseType => map_types(query[:types]),
-            :releaseFormat => map_formats(query[:formats])
+          {
+            bandName: query[:band_name] || "",
+            releaseTitle: query[:title] || "",
+            releaseYearFrom: query[:from_year] || "",
+            releaseMonthFrom: query[:from_month] || "",
+            releaseYearTo: query[:to_year] || "",
+            releaseMonthTo: query[:to_month] || "",
+            country: map_countries(query[:country]) || "",
+            location: query[:location] || "",
+            releaseLabelName: query[:label_name] || "",
+            releaseCatalogNumber: query[:catalog_id] || "",
+            releaseIdentifiers: query[:identifier] || "",
+            releaseRecordingInfo: query[:recording_info] || "",
+            releaseDescription: query[:version_description] || "",
+            releaseNotes: query[:notes] || "",
+            genre: query[:genre] || "",
+            releaseType: map_types(query[:types]),
+            releaseFormat: map_formats(query[:formats]),
           }
-
-          params
         end
 
         ##
@@ -99,50 +101,56 @@ module MetalArchives
         # - rdoc-ref:MetalArchives::Errors::ParserError when parsing failed. Please report this error.
         #
         def parse_html(response)
-          props = {}
+          # Set default props
+          props = {
+            title: nil,
+            type: nil,
+            date_released: nil,
+            catalog_id: nil,
+            identifier: nil,
+            version_description: nil,
+            format: nil,
+            limitation: nil,
+          }
+
           doc = Nokogiri::HTML response
 
-          props[:title] = sanitize doc.css('#album_info .album_name a').first.content
+          props[:title] = sanitize doc.css("#album_info .album_name a").first.content
 
-          doc.css('#album_info dl').each do |dl|
-            dl.search('dt').each do |dt|
+          doc.css("#album_info 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 sanitize(dt.content)
-              when 'Type:'
+              when "Type:"
                 props[:type] = map_type content
-              when 'Release date:'
-                begin
-                  props[:date_released] = NilDate.parse content
-                rescue MetalArchives::Errors::ArgumentError => e
-                  dr = Date.parse content
-                  props[:date_released] = NilDate.new dr.year, dr.month, dr.day
-                end
-              when 'Catalog ID:'
+              when "Release date:"
+                props[:date_released] = Parsers::Date.parse(content)
+              when "Catalog ID:"
                 props[:catalog_id] = content
-              when 'Identifier:'
+              when "Identifier:"
                 props[:identifier] = content
-              when 'Version desc.:'
+              when "Version desc.:"
                 props[:version_description] = content
-              when 'Label:'
+              when "Label:"
                 # TODO: label
-              when 'Format:'
+              when "Format:"
                 props[:format] = map_format content
-              when 'Limitation:'
+              when "Limitation:"
                 props[:limitation] = content.to_i
-              when 'Reviews:'
-                next if content == 'None yet'
+              when "Reviews:"
+                next if content == "None yet"
                 # TODO: reviews
               else
-                raise MetalArchives::Errors::ParserError, "Unknown token: #{dt.content}"
+                raise Errors::ParserError, "Unknown token: #{dt.content}"
               end
             end
           end
 
           props
-        rescue => e
+        rescue StandardError => e
           e.backtrace.each { |b| MetalArchives.config.logger.error b }
           raise Errors::ParserError, e
         end
@@ -158,7 +166,7 @@ module MetalArchives
         #     +Array+ containing one or more +String+s
         #
         def map_countries(countries)
-          countries && countries.map { |c| c.alpha2 }
+          countries&.map(&:alpha2)
         end
 
         ##
@@ -174,7 +182,7 @@ module MetalArchives
 
           types = []
           type_syms.each do |type|
-            raise MetalArchives::Errors::ParserError, "Unknown type: #{type}" unless TYPE_TO_QUERY[type]
+            raise Errors::ParserError, "Unknown type: #{type}" unless TYPE_TO_QUERY[type]
 
             types << TYPE_TO_QUERY[type]
           end
@@ -188,7 +196,7 @@ module MetalArchives
         # Returns +Symbol+, see rdoc-ref:Release.type
         #
         def map_type(type)
-          raise MetalArchives::Errors::ParserError, "Unknown type: #{type}" unless TYPE_TO_SYM[type]
+          raise Errors::ParserError, "Unknown type: #{type}" unless TYPE_TO_SYM[type]
 
           TYPE_TO_SYM[type]
         end
@@ -206,7 +214,7 @@ module MetalArchives
 
           formats = []
           format_syms.each do |format|
-            raise MetalArchives::Errors::ParserError, "Unknown format: #{format}" unless FORMAT_TO_QUERY[format]
+            raise Errors::ParserError, "Unknown format: #{format}" unless FORMAT_TO_QUERY[format]
 
             formats << FORMAT_TO_QUERY[format]
           end
@@ -220,10 +228,11 @@ module MetalArchives
         # Returns +Symbol+, see rdoc-ref:Release.format
         #
         def map_format(format)
-          return :vinyl if format =~ /[Vv]inyl/
-          return :blu_ray if format =~ /[Bb]lu.?[Rr]ay/
+          return :cd if /CD/.match?(format)
+          return :vinyl if /[Vv]inyl/.match?(format)
+          return :blu_ray if /[Bb]lu.?[Rr]ay/.match?(format)
 
-          raise MetalArchives::Errors::ParserError, "Unknown format: #{format}" unless FORMAT_TO_SYM[format]
+          raise Errors::ParserError, "Unknown format: #{format}" unless FORMAT_TO_SYM[format]
 
           FORMAT_TO_SYM[format]
         end