metal_archives 2.1.1 → 3.1.0

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,41 @@
 # 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
+          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

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "json"
+require "date"
+
+module MetalArchives
+  module Parsers
+    ##
+    # Release parser
+    #
+    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,
+        }.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,
+        }.freeze
+
+        FORMAT_TO_QUERY = {
+          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,
+          "2DVD" => :"2dvd",
+          "Digital" => :digital,
+          "Other" => :other,
+          "Unknown" => :unknown,
+        }.freeze
+
+        ##
+        # Map attributes to MA attributes
+        #
+        # Returns +Hash+
+        #
+        # [+params+]
+        #     +Hash+
+        #
+        def map_params(query)
+          {
+            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]),
+          }
+        end
+
+        ##
+        # Parse main HTML page
+        #
+        # Returns +Hash+
+        #
+        # [Raises]
+        # - rdoc-ref:MetalArchives::Errors::ParserError when parsing failed. Please report this error.
+        #
+        def parse_html(response)
+          # 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
+
+          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"
+
+              case sanitize(dt.content)
+              when "Type:"
+                props[:type] = map_type content
+              when "Release date:"
+                props[:date_released] = Parsers::Date.parse(content)
+              when "Catalog ID:"
+                props[:catalog_id] = content
+              when "Identifier:"
+                props[:identifier] = content
+              when "Version desc.:"
+                props[:version_description] = content
+              when "Label:"
+                # TODO: label
+              when "Format:"
+                props[:format] = map_format content
+              when "Limitation:"
+                props[:limitation] = content.to_i
+              when "Reviews:"
+                next if content == "None yet"
+                # TODO: reviews
+              else
+                raise Errors::ParserError, "Unknown token: #{dt.content}"
+              end
+            end
+          end
+
+          props
+        rescue StandardError => e
+          e.backtrace.each { |b| MetalArchives.config.logger.error b }
+          raise Errors::ParserError, e
+        end
+
+        private
+
+        ##
+        # Map MA countries to query parameters
+        #
+        # Returns +Array+ of +ISO3166::Country+
+        #
+        # [+types+]
+        #     +Array+ containing one or more +String+s
+        #
+        def map_countries(countries)
+          countries&.map(&:alpha2)
+        end
+
+        ##
+        # Map MA release type to query parameters
+        #
+        # Returns +Array+ of +Integer+
+        #
+        # [+types+]
+        #     +Array+ containing one or more +Symbol+, see rdoc-ref:Release.type
+        #
+        def map_types(type_syms)
+          return unless type_syms
+
+          types = []
+          type_syms.each do |type|
+            raise Errors::ParserError, "Unknown type: #{type}" unless TYPE_TO_QUERY[type]
+
+            types << TYPE_TO_QUERY[type]
+          end
+
+          types
+        end
+
+        ##
+        # Map MA release type to +Symbol+
+        #
+        # Returns +Symbol+, see rdoc-ref:Release.type
+        #
+        def map_type(type)
+          raise Errors::ParserError, "Unknown type: #{type}" unless TYPE_TO_SYM[type]
+
+          TYPE_TO_SYM[type]
+        end
+
+        ##
+        # Map MA release format to query parameters
+        #
+        # Returns +Array+ of +Integer+
+        #
+        # [+types+]
+        #     +Array+ containing one or more +Symbol+, see rdoc-ref:Release.type
+        #
+        def map_formats(format_syms)
+          return unless format_syms
+
+          formats = []
+          format_syms.each do |format|
+            raise Errors::ParserError, "Unknown format: #{format}" unless FORMAT_TO_QUERY[format]
+
+            formats << FORMAT_TO_QUERY[format]
+          end
+
+          formats
+        end
+
+        ##
+        # Map MA release format to +Symbol+
+        #
+        # Returns +Symbol+, see rdoc-ref:Release.format
+        #
+        def map_format(format)
+          return :cd if /CD/.match?(format)
+          return :vinyl if /[Vv]inyl/.match?(format)
+          return :blu_ray if /[Bb]lu.?[Rr]ay/.match?(format)
+
+          raise Errors::ParserError, "Unknown format: #{format}" unless FORMAT_TO_SYM[format]
+
+          FORMAT_TO_SYM[format]
+        end
+      end
+    end
+  end
+end