metal_archives 2.2.3 → 3.2.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

@@ -11,16 +11,28 @@ 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[:contact] = []
           doc.css("#label_contact a").each do |contact|
             props[:contact] << {
               title: contact.content,
@@ -38,26 +50,22 @@ module MetalArchives
               when "Address:"
                 props[:address] = content
               when "Country:"
-                props[:country] = ParserHelper.parse_country css("a").first.content
+                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
+                props[:specializations] = Parsers::Genre.parse(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
+                props[:date_founded] = Parsers::Date.parse(content)
               when "Sub-labels:"
                 # TODO
               when "Online shopping:"
-                if content == "Yes"
+                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,103 +1,43 @@
 # frozen_string_literal: true
 
 require "date"
-require "countries"
 
 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+
+        # Rewrite a URL
         #
-        # The following components are omitted:
-        # - Metal
-        # - (early)
-        # - (later)
+        # Return +URI+
         #
-        # All genres are capitalized.
-        #
-        # For examples on how genres are parsed, refer to +ParserTest#test_parse_genre+
-        #
-        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}" }
-
-                # 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
-
-        ##
-        # Parse year range
-        #
-        def parse_year_range(input)
-          r = input.split("-")
-          date_start = (r.first == "?" ? nil : NilDate.new(r.first.to_i))
-          date_end = if r.length > 1
-                       (r.last == "?" || r.last == "present" ? nil : NilDate.new(r.last.to_i))
-                     else
-                       date_start.dup
-                     end
+          endpoint = URI(MetalArchives.config.endpoint)
 
-          MetalArchives::Range.new date_start, date_end
+          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

@@ -71,7 +71,7 @@ module MetalArchives
         #     +Hash+
         #
         def map_params(query)
-          params = {
+          {
             bandName: query[:band_name] || "",
             releaseTitle: query[:title] || "",
             releaseYearFrom: query[:from_year] || "",
@@ -90,8 +90,6 @@ module MetalArchives
             releaseType: map_types(query[:types]),
             releaseFormat: map_formats(query[:formats]),
           }
-
-          params
         end
 
         ##
@@ -103,11 +101,29 @@ 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,
+            band: 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
 
+          # Band
+          band_doc = doc.css("#album_info .band_name a").first
+          id = Integer(band_doc.attr("href").split("/").last)
+
+          props[:band] = MetalArchives::Band.find(id)
+
           doc.css("#album_info dl").each do |dl|
             dl.search("dt").each do |dt|
               content = sanitize dt.next_element.content
@@ -118,12 +134,7 @@ module MetalArchives
               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
+                props[:date_released] = Parsers::Date.parse(content)
               when "Catalog ID:"
                 props[:catalog_id] = content
               when "Identifier:"
@@ -140,7 +151,7 @@ module MetalArchives
                 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
@@ -178,7 +189,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
@@ -192,7 +203,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
@@ -210,7 +221,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
@@ -224,11 +235,11 @@ module MetalArchives
         # Returns +Symbol+, see rdoc-ref:Release.format
         #
         def map_format(format)
-          return :cd if format =~ /CD/
-          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

data/lib/metal_archives/parsers/year.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module MetalArchives
+  module Parsers
+    ##
+    # Year range parser
+    #
+    class Year < Base
+      ##
+      # Parse year range
+      #
+      # Returns +Range+ of +Integer+
+      #
+      def self.parse(input)
+        return if input.blank?
+
+        components = input
+          .split("-")
+          .map(&:to_i)
+          .map { |y| y.zero? ? nil : y }
+
+        return if components.empty?
+
+        # Set end if only one year
+        components << components.first if components.count == 1
+
+        components[0]..components[1]
+      end
+    end
+  end
+end