howlongtobeat 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30968d273638c5687a8f004d3af466ba21fe5c1ffb9a901b8d46bb7e0bfe9c57
-  data.tar.gz: 70cfdf898cc6adc10f3916822e4dc9b6f64db824fb45be348dd2185825c0d292
+  metadata.gz: 9c202be25ee5614c52d8334494939e9dbfb220a74e6f1fb1791b927bbf4ad1ba
+  data.tar.gz: '00268aa34aa51cd06ce4d0484f7bc380218e52ae881f5b967c03204379c48080'
 SHA512:
-  metadata.gz: 26add34fc6bc60313c3c85cd37de8f3f3e3fb116b1fd841104311080d7d2ccdbab4afbd528b85cbfc17a4707830741ba532a7d735c3708258eb710c670b35a21
-  data.tar.gz: d29ee7ade48aa6984af6eaecdad80242d464aa9d5c1ce659e1508ad3810cccbf9608db188ea16f1c721c8ed8093f884037b93ab6ef2b105912bc15109cfc3dcb
+  metadata.gz: 83c98f7ed7ef66cc500fd3f0005330371711a1b3111df321933fa7bc7b99909e720be9e95a2be354705fe674d8115065513fbe9f6cfa7644cbab01a6698c1065
+  data.tar.gz: dc27b8455d7c0d99015e9f57a3e5fe72e7efc837e6b3f7d7e528df8e15a7098d18406505064d5228b3e52784553a9ed75f6d2a68cee5ef2c8dd9c8392771076e

data/CHANGELOG.md

@@ -25,6 +25,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Security
 - None
 
+## [0.2.2] - 2026-03-24
+
+### Fixed
+- Restore search against HowLongToBeat's current API by discovering the POST search endpoint from site scripts (e.g. `/api/finder`) instead of hardcoding `/api/search`
+- Obtain the auth token from the same API base as search (`{endpoint}/init`), with fallback candidates when parsing is incomplete
+- Tolerate search response shape changes when parsing JSON (alternate root keys, camelCase field names)
+
+### Changed
+- Default search endpoint fallback is now `/api/finder`
+
 ## [0.2.1] - 2025-12-13
 
 ### Fixed

data/lib/howlongtobeat/html_requests.rb

@@ -8,7 +8,7 @@ module HowLongToBeat
     BASE_URL = 'https://howlongtobeat.com'
     REFERER_HEADER = BASE_URL
     GAME_URL = "#{BASE_URL}/game"
-    SEARCH_URL = "#{BASE_URL}/api/search"
+    SEARCH_URL = "#{BASE_URL}/api/finder"
 
     class SearchModifiers
       NONE = ""
@@ -47,15 +47,25 @@ module HowLongToBeat
       end
 
       def extract_search_url_script(script_content)
-        pattern = /fetch\(\s*["'](\/api\/[^"']*)['"]((?:\s*\.concat\(\s*["']([^"']*)['"]\s*\))+)\s*,/
-        if (matches = script_content.match(pattern))
+        # Prefer the search endpoint used in POST fetch calls, which is more stable
+        # than hardcoding "/api/search" and works with variants like "/api/finder".
+        post_fetch_pattern = /fetch\s*\(\s*["']\/api\/([a-zA-Z0-9_\/-]+)[^"']*["']\s*,\s*{[^}]*method:\s*["']POST["'][^}]*}/mi
+        if (match = script_content.match(post_fetch_pattern))
+          path_suffix = match[1]
+          base_path = path_suffix.include?('/') ? path_suffix.split('/').first : path_suffix
+          return "/api/#{base_path}"
+        end
+
+        # Legacy fallback for previous script shape using .concat(...)
+        legacy_pattern = /fetch\(\s*["'](\/api\/[^"']*)['"]((?:\s*\.concat\(\s*["']([^"']*)['"]\s*\))+)\s*,/
+        if (matches = script_content.match(legacy_pattern))
           endpoint = matches[1]
           concat_calls = matches[2]
           concat_strings = concat_calls.scan(/\.concat\(\s*["']([^"']*)['"]\s*\)/).flatten
-          concatenated_str = concat_strings.join
-          concatenated_str = concatenated_str.gsub(/["\(\)\[\]'\\]/, '')
+          concatenated_str = concat_strings.join.gsub(/["\(\)\[\]'\\]/, '')
           return endpoint if concatenated_str == @api_key
         end
+
         nil
       end
     end
@@ -117,12 +127,25 @@ module HowLongToBeat
       end
 
       def send_web_request(game_name, search_modifiers = SearchModifiers::NONE, page = 1)
-        token = fetch_search_token
-        return nil unless token
+        search_info = send_website_request_getcode(false)
+        if search_info.nil? || search_info.search_url.nil?
+          search_info = send_website_request_getcode(true)
+        end
+
+        endpoint_candidates = build_endpoint_candidates(search_info&.search_url)
 
-        headers = get_search_request_headers.merge('x-auth-token' => token)
-        payload = get_search_request_data(game_name, search_modifiers, page)
-        make_request(SEARCH_URL, headers, payload)
+        endpoint_candidates.each do |endpoint|
+          token = fetch_search_token(endpoint)
+          next unless token
+
+          headers = get_search_request_headers.merge('x-auth-token' => token)
+          payload = get_search_request_data(game_name, search_modifiers, page, search_info)
+          search_url = "#{BASE_URL}#{endpoint}"
+          response = make_request(search_url, headers, payload)
+          return response if response
+        end
+
+        nil
       end
 
       def get_game_title(game_id)
@@ -142,18 +165,42 @@ module HowLongToBeat
 
       private
 
-      def fetch_search_token
-        url = "#{BASE_URL}/api/search/init?t=#{Time.now.to_i}"
+      def fetch_search_token(parsed_search_url = nil)
+        base_endpoint = parsed_search_url.to_s.strip
+        base_endpoint = '/api/finder' if base_endpoint.empty?
+        base_endpoint = "/#{base_endpoint}" unless base_endpoint.start_with?('/')
+        base_endpoint = base_endpoint.sub(%r{/+\z}, '')
+        base_endpoint = base_endpoint.sub(%r{/init\z}, '')
+
+        url = "#{BASE_URL}#{base_endpoint}/init?t=#{Time.now.to_i}"
         headers = get_title_request_headers
         response = make_get_request(url, headers)
         return nil unless response
 
         json = JSON.parse(response) rescue nil
-        json.is_a?(Hash) ? json['token'] : nil
+        return nil unless json.is_a?(Hash)
+
+        json['token'] || json.dig('data', 'token') || json['auth_token'] || json['authToken']
       rescue StandardError
         nil
       end
 
+      def build_endpoint_candidates(parsed_endpoint = nil)
+        preferred = parsed_endpoint.to_s.strip
+        candidates = []
+        candidates << preferred unless preferred.empty?
+        candidates.concat(['/api/finder', '/api/search', '/api/s'])
+
+        normalized = candidates.map do |endpoint|
+          next nil if endpoint.nil? || endpoint.strip.empty?
+          value = endpoint.strip
+          value = "/#{value}" unless value.start_with?('/')
+          value.sub(%r{/+\z}, '')
+        end
+
+        normalized.compact.uniq
+      end
+
       def send_website_request_getcode(parse_all_scripts)
         headers = get_title_request_headers
         response = make_get_request(BASE_URL, headers)
@@ -170,7 +217,7 @@ module HowLongToBeat
           next unless script_content
 
           search_info = SearchInfo.new(script_content)
-          return search_info if search_info.api_key && !search_info.api_key.empty?
+          return search_info if (search_info.search_url && !search_info.search_url.empty?) || (search_info.api_key && !search_info.api_key.empty?)
         end
 
         nil
@@ -195,12 +242,12 @@ module HowLongToBeat
 
         response = http.request(request)
         response.body if response.is_a?(Net::HTTPSuccess)
-      rescue OpenSSL::SSL::SSLError => e
+      rescue OpenSSL::SSL::SSLError
         # SSL certificate verification failed - disable verification as fallback
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
         response = http.request(request)
         response.is_a?(Net::HTTPSuccess) ? response.body : nil
-      rescue StandardError => e
+      rescue StandardError
         nil
       end
 
@@ -217,12 +264,12 @@ module HowLongToBeat
         else
           nil
         end
-      rescue OpenSSL::SSL::SSLError => e
+      rescue OpenSSL::SSL::SSLError
         # SSL certificate verification failed - disable verification as fallback
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
         response = http.request(request)
         response.is_a?(Net::HTTPSuccess) ? response.body : nil
-      rescue StandardError => e
+      rescue StandardError
         nil
       end
 

data/lib/howlongtobeat/json_result_parser.rb

@@ -27,7 +27,10 @@ module HowLongToBeat
 
     def parse_json_result(input_json_result)
       response_result = JSON.parse(input_json_result)
-      response_result["data"].each do |game|
+      games = extract_games(response_result)
+      return if games.nil? || games.empty?
+
+      games.each do |game|
         new_game_entry = parse_json_element(game)
 
         if @game_id && new_game_entry.game_id.to_s != @game_id.to_s
@@ -42,35 +45,74 @@ module HowLongToBeat
 
     private
 
+    def extract_games(response_result)
+      return response_result if response_result.is_a?(Array)
+      return [] unless response_result.is_a?(Hash)
+
+      %w[data results result items games].each do |key|
+        value = response_result[key]
+        return value if value.is_a?(Array)
+      end
+
+      []
+    end
+
+    def field(input, *keys)
+      keys.each do |key|
+        return input[key] if input.key?(key)
+      end
+      nil
+    end
+
+    def normalize_platforms(value)
+      return value if value.is_a?(Array)
+      return nil if value.nil?
+      value.to_s.split(", ")
+    end
+
+    def normalize_time(value)
+      return nil if value.nil?
+      time_value = value.to_f
+      return nil if time_value <= 0
+
+      # Older payloads expose seconds; some variants may already use hours.
+      if time_value > 500
+        round_time(time_value)
+      else
+        time_value.round(2)
+      end
+    end
+
     def parse_json_element(input_game_element)
       current_entry = HowLongToBeatEntry.new
 
       # Base fields
-      current_entry.game_id = input_game_element["game_id"]
-      current_entry.game_name = input_game_element["game_name"]
-      current_entry.game_alias = input_game_element["game_alias"]
-      current_entry.game_type = input_game_element["game_type"]
-      current_entry.game_image_url = "#{IMAGE_URL_PREFIX}#{input_game_element['game_image']}" if input_game_element["game_image"]
+      current_entry.game_id = field(input_game_element, "game_id", "gameId", "id")
+      current_entry.game_name = field(input_game_element, "game_name", "gameName", "name")
+      current_entry.game_alias = field(input_game_element, "game_alias", "gameAlias", "alias")
+      current_entry.game_type = field(input_game_element, "game_type", "gameType", "type")
+      game_image = field(input_game_element, "game_image", "gameImage", "image")
+      current_entry.game_image_url = "#{IMAGE_URL_PREFIX}#{game_image}" if game_image
       current_entry.game_web_link = "#{GAME_URL_PREFIX}#{current_entry.game_id}"
-      current_entry.review_score = input_game_element["review_score"]
-      current_entry.profile_dev = input_game_element["profile_dev"]
-      current_entry.profile_platforms = input_game_element["profile_platform"]&.split(", ")
-      current_entry.release_world = input_game_element["release_world"]
+      current_entry.review_score = field(input_game_element, "review_score", "reviewScore", "score")
+      current_entry.profile_dev = field(input_game_element, "profile_dev", "profileDev", "developer")
+      current_entry.profile_platforms = normalize_platforms(field(input_game_element, "profile_platform", "profilePlatform", "platforms"))
+      current_entry.release_world = field(input_game_element, "release_world", "releaseWorld", "releaseYear")
       current_entry.json_content = input_game_element
 
       # Completion times
-      current_entry.main_story = round_time(input_game_element["comp_main"])
-      current_entry.main_extra = round_time(input_game_element["comp_plus"])
-      current_entry.completionist = round_time(input_game_element["comp_100"])
-      current_entry.all_styles = round_time(input_game_element["comp_all"])
-      current_entry.coop_time = round_time(input_game_element["invested_co"])
-      current_entry.mp_time = round_time(input_game_element["invested_mp"])
+      current_entry.main_story = normalize_time(field(input_game_element, "comp_main", "compMain", "main_story", "mainStory"))
+      current_entry.main_extra = normalize_time(field(input_game_element, "comp_plus", "compPlus", "main_extra", "mainExtra"))
+      current_entry.completionist = normalize_time(field(input_game_element, "comp_100", "comp100", "completionist"))
+      current_entry.all_styles = normalize_time(field(input_game_element, "comp_all", "compAll", "all_styles", "allStyles"))
+      current_entry.coop_time = normalize_time(field(input_game_element, "invested_co", "investedCo", "coop_time", "coopTime"))
+      current_entry.mp_time = normalize_time(field(input_game_element, "invested_mp", "investedMp", "mp_time", "mpTime"))
 
       # Complexity flags
-      current_entry.complexity_lvl_combine = input_game_element["comp_lvl_combine"].to_i == 1
-      current_entry.complexity_lvl_sp = input_game_element["comp_lvl_sp"].to_i == 1
-      current_entry.complexity_lvl_co = input_game_element["comp_lvl_co"].to_i == 1
-      current_entry.complexity_lvl_mp = input_game_element["comp_lvl_mp"].to_i == 1
+      current_entry.complexity_lvl_combine = field(input_game_element, "comp_lvl_combine", "compLvlCombine", "complexity_lvl_combine", "complexityLvlCombine").to_i == 1
+      current_entry.complexity_lvl_sp = field(input_game_element, "comp_lvl_sp", "compLvlSp", "complexity_lvl_sp", "complexityLvlSp").to_i == 1
+      current_entry.complexity_lvl_co = field(input_game_element, "comp_lvl_co", "compLvlCo", "complexity_lvl_co", "complexityLvlCo").to_i == 1
+      current_entry.complexity_lvl_mp = field(input_game_element, "comp_lvl_mp", "compLvlMp", "complexity_lvl_mp", "complexityLvlMp").to_i == 1
 
       # Auto-filter times based on complexity
       if @auto_filter_times

data/lib/howlongtobeat/version.rb

@@ -1,3 +1,3 @@
 module HowLongToBeat
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: howlongtobeat
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Dmitrii Pashutskii
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-13 00:00:00.000000000 Z
+date: 2026-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri