howlongtobeat 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ef5a11f2d4eb82426ed1c0e6312a824381798af62a77425fa3bd39671a9d7080
+  data.tar.gz: b16931671e18bfd16a02a4072dd124a089549fa9dbd0af7bcddb76e693bbe388
+SHA512:
+  metadata.gz: b39fcf8b55b15bac316188010468528576b2c0abbec0ca69c9a29eed9fa3be32cfc38fdfb5c03425705522a9807f87da76170821cb0adbb7eb2c0bca0835e8cc
+  data.tar.gz: 77bfcbc196915c9c253db36313ed97ed404d627d14232fd2ca1439307d46a367b7dc8a29865d6deff8a68bf2b4662bc720487dfd41e72958a7f317231f82475d

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial release
+- Basic search functionality
+- Search by ID functionality
+- Search modifiers support
+- Similarity filtering
+
+### Changed
+- None
+
+### Deprecated
+- None
+
+### Removed
+- None
+
+### Fixed
+- None
+
+### Security
+- None
+
+## [0.1.0] - 2025-03-06
+
+- Initial release
+
+## [0.1.2] - 2025-03-06
+
+- Update Ruby requirement version

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/README.md

@@ -0,0 +1,98 @@
+# HowLongToBeat Ruby API
+
+A simple Ruby API to read data from howlongtobeat.com.
+
+It is inspired by [ScrappyCocco's HowLongToBeat Python API](https://github.com/ScrappyCocco/HowLongToBeat-PythonAPI).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'howlongtobeat'
+```
+
+And then execute:
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+```bash
+$ gem install howlongtobeat
+```
+
+## Usage
+
+### Basic Search
+
+```ruby
+require 'howlongtobeat'
+
+hltb = HowLongToBeat::HowLongToBeat.new
+results = hltb.search("The Witcher 3")
+```
+
+The `search` method returns an array of possible games, or `nil` if no results were found or there was an error in the request.
+
+Each result is a `HowLongToBeat::Entry` object containing:
+- `id`: The game's ID on HowLongToBeat
+- `name`: The game's name
+- `description`: Game description
+- `main_story`: Main story completion time
+- `main_plus_sides`: Main story + side quests completion time
+- `completionist`: 100% completion time
+- `all_styles`: Average time across all playstyles
+- `similarity`: How closely the game name matches the search query (0.0 to 1.0)
+
+### Search by ID
+
+You can also search for a game using its HowLongToBeat ID:
+
+```ruby
+result = hltb.search_from_id(10270)  # The Witcher 3: Wild Hunt
+```
+
+This returns a single `Entry` object or `nil` if not found.
+
+### Search Modifiers
+
+You can filter your search results using modifiers:
+
+```ruby
+hltb = HowLongToBeat::HowLongToBeat.new
+results = hltb.search("The Witcher 3", HowLongToBeat::HTMLRequests::SearchModifiers::HIDE_DLC)
+```
+
+Available modifiers:
+- `NONE`: Default search (includes DLCs)
+- `ISOLATE_DLC`: Show only DLCs
+- `ISOLATE_MODS`: Show only mods
+- `ISOLATE_HACKS`: Show only hacks
+- `HIDE_DLC`: Hide DLCs and show only games
+
+### Similarity Filtering
+
+By default, the search filters results with a similarity score greater than 0.4. You can adjust this threshold:
+
+```ruby
+# Return all results without filtering
+hltb = HowLongToBeat::HowLongToBeat.new(0.0)
+results = hltb.search("The Witcher 3")
+
+# Use a higher threshold for stricter matching
+hltb = HowLongToBeat::HowLongToBeat.new(0.7)
+results = hltb.search("The Witcher 3")
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## License
+
+The gem is available as open source under the terms of the MIT License.

data/lib/howlongtobeat/how_long_to_beat.rb

@@ -0,0 +1,49 @@
+module HowLongToBeat
+  class HowLongToBeat
+    def initialize(input_minimum_similarity = 0.4, input_auto_filter_times = false)
+      @minimum_similarity = input_minimum_similarity
+      @auto_filter_times = input_auto_filter_times
+    end
+
+    def search(game_name, search_modifiers = HTMLRequests::SearchModifiers::NONE,
+              similarity_case_sensitive = true)
+      return nil if game_name.nil? || game_name.empty?
+
+      html_result = HTMLRequests.send_web_request(game_name, search_modifiers)
+      return nil unless html_result
+
+      parse_web_result(game_name, html_result, nil, similarity_case_sensitive)
+    end
+
+    def search_from_id(game_id)
+      return nil if game_id.nil? || game_id == 0
+
+      game_title = HTMLRequests.get_game_title(game_id)
+      return nil unless game_title
+
+      html_result = HTMLRequests.send_web_request(game_title)
+      return nil unless html_result
+
+      result_list = parse_web_result(game_title, html_result, game_id)
+      return nil unless result_list && result_list.size == 1
+
+      result_list.first
+    end
+
+    private
+
+    def parse_web_result(game_name, html_result, game_id = nil, similarity_case_sensitive = true)
+      parser = JSONResultParser.new(
+        game_name,
+        HTMLRequests::GAME_URL,
+        @minimum_similarity,
+        game_id,
+        similarity_case_sensitive,
+        @auto_filter_times
+      )
+
+      parser.parse_json_result(html_result)
+      parser.results
+    end
+  end
+end

data/lib/howlongtobeat/how_long_to_beat_entry.rb

@@ -0,0 +1,58 @@
+module HowLongToBeat
+  class HowLongToBeatEntry
+    # Base Game Details
+    attr_accessor :game_id, :game_name, :game_alias, :game_type, :game_image_url,
+                 :game_web_link, :review_score, :profile_dev, :profile_platforms,
+                 :release_world, :similarity, :json_content
+
+    # Completion times
+    attr_accessor :main_story, :main_extra, :completionist, :all_styles,
+                 :coop_time, :mp_time
+
+    # Complexity flags
+    attr_accessor :complexity_lvl_combine, :complexity_lvl_sp,
+                 :complexity_lvl_co, :complexity_lvl_mp
+
+    def initialize
+      # Initialize with default values
+      @game_id = -1
+      @game_name = nil
+      @game_alias = nil
+      @game_type = nil
+      @game_image_url = nil
+      @game_web_link = nil
+      @review_score = nil
+      @profile_dev = nil
+      @profile_platforms = nil
+      @release_world = nil
+      @similarity = -1
+      @json_content = nil
+
+      # Completion times
+      @main_story = nil
+      @main_extra = nil
+      @completionist = nil
+      @all_styles = nil
+      @coop_time = nil
+      @mp_time = nil
+
+      # Complexity flags
+      @complexity_lvl_combine = false
+      @complexity_lvl_sp = false
+      @complexity_lvl_co = false
+      @complexity_lvl_mp = false
+    end
+
+    def to_s
+      times = []
+      times << "Main Story: #{main_story}h" if main_story
+      times << "Main + Extra: #{main_extra}h" if main_extra
+      times << "Completionist: #{completionist}h" if completionist
+      times << "All Styles: #{all_styles}h" if all_styles
+      times << "Co-op: #{coop_time}h" if coop_time
+      times << "Multiplayer: #{mp_time}h" if mp_time
+
+      "#{game_name} (ID: #{game_id}) - #{times.join(', ')}"
+    end
+  end
+end

data/lib/howlongtobeat/html_requests.rb

@@ -0,0 +1,224 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'nokogiri'
+
+module HowLongToBeat
+  class HTMLRequests
+    BASE_URL = 'https://howlongtobeat.com'
+    REFERER_HEADER = BASE_URL
+    GAME_URL = "#{BASE_URL}/game"
+    SEARCH_URL = "#{BASE_URL}/api/search"
+
+    class SearchModifiers
+      NONE = ""
+      ISOLATE_DLC = "only_dlc"
+      ISOLATE_MODS = "only_mods"
+      ISOLATE_HACKS = "only_hacks"
+      HIDE_DLC = "hide_dlc"
+    end
+
+    class SearchInfo
+      attr_accessor :search_url, :api_key
+
+      def initialize(script_content)
+        @api_key = extract_api_from_script(script_content)
+        @search_url = extract_search_url_script(script_content)
+        @search_url = @search_url&.strip&.gsub(/^\/+|\/+$/, '')
+      end
+
+      private
+
+      def extract_api_from_script(script_content)
+        if (matches = script_content.scan(/users\s*:\s*{\s*id\s*:\s*"([^"]+)"/))
+          key = matches.flatten.first
+          return key if key && !key.empty?
+        end
+
+        if (matches = script_content.scan(/\/api\/\w+\/"(?:\.concat\("[^"]*"\))*/))
+          matches_str = matches.to_s
+          concat_parts = matches_str.split('.concat')[1..]
+          concat_parts = concat_parts.map { |part| part.gsub(/["\(\)\[\]'\\]/, '') }
+          key = concat_parts.join
+          return key if key && !key.empty?
+        end
+
+        nil
+      end
+
+      def extract_search_url_script(script_content)
+        pattern = /fetch\(\s*["'](\/api\/[^"']*)['"]((?:\s*\.concat\(\s*["']([^"']*)['"]\s*\))+)\s*,/
+        if (matches = script_content.match(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(/["\(\)\[\]'\\]/, '')
+          return endpoint if concatenated_str == @api_key
+        end
+        nil
+      end
+    end
+
+    class << self
+      def get_search_request_headers
+        {
+          'content-type' => 'application/json',
+          'accept' => '*/*',
+          'User-Agent' => random_user_agent,
+          'referer' => REFERER_HEADER
+        }
+      end
+
+      def get_search_request_data(game_name, search_modifiers = SearchModifiers::NONE, page = 1, search_info = nil)
+        payload = {
+          searchType: 'games',
+          searchTerms: game_name.split,
+          searchPage: page,
+          size: 20,
+          searchOptions: {
+            games: {
+              userId: 0,
+              platform: '',
+              sortCategory: 'popular',
+              rangeCategory: 'main',
+              rangeTime: { min: 0, max: 0 },
+              gameplay: {
+                perspective: '',
+                flow: '',
+                genre: '',
+                difficulty: ''
+              },
+              rangeYear: {
+                max: '',
+                min: ''
+              },
+              modifier: search_modifiers
+            },
+            users: {
+              sortCategory: 'postcount'
+            },
+            lists: {
+              sortCategory: 'follows'
+            },
+            filter: '',
+            sort: 0,
+            randomizer: 0
+          },
+          useCache: true
+        }
+
+        if search_info&.api_key
+          payload[:searchOptions][:users][:id] = search_info.api_key
+        end
+
+        payload.to_json
+      end
+
+      def send_web_request(game_name, search_modifiers = SearchModifiers::NONE, page = 1)
+        headers = get_search_request_headers
+        search_info = send_website_request_getcode(false)
+        search_info ||= send_website_request_getcode(true)
+
+        return nil unless search_info&.api_key
+
+        if search_info.search_url
+          search_url = "#{BASE_URL}/#{search_info.search_url}"
+        else
+          search_url = SEARCH_URL
+        end
+
+        # Try with API key in URL
+        search_url_with_key = "#{search_url}/#{search_info.api_key}"
+        payload = get_search_request_data(game_name, search_modifiers, page)
+        response = make_request(search_url_with_key, headers, payload)
+        return response if response
+
+        # Fallback to standard search with API key in payload
+        payload = get_search_request_data(game_name, search_modifiers, page, search_info)
+        make_request(search_url, headers, payload)
+      end
+
+      def get_game_title(game_id)
+        url = "#{GAME_URL}/#{game_id}"
+        headers = get_title_request_headers
+
+        contents = make_get_request(url, headers)
+        return nil unless contents
+
+        doc = Nokogiri::HTML(contents)
+        title_tag = doc.title
+        return nil unless title_tag
+
+        title_text = title_tag
+        title_text[12...-17]&.strip
+      end
+
+      private
+
+      def send_website_request_getcode(parse_all_scripts)
+        headers = get_title_request_headers
+        response = make_get_request(BASE_URL, headers)
+        return nil unless response
+
+        doc = Nokogiri::HTML(response)
+        script_urls = doc.css('script[src]').map { |script| script['src'] }
+
+        scripts = parse_all_scripts ? script_urls : script_urls.select { |url| url.include?('_app-') }
+
+        scripts.each do |script_url|
+          url = script_url.start_with?('http') ? script_url : "#{BASE_URL}#{script_url}"
+          script_content = make_get_request(url, headers)
+          next unless script_content
+
+          search_info = SearchInfo.new(script_content)
+          return search_info if search_info.api_key && !search_info.api_key.empty?
+        end
+
+        nil
+      end
+
+      def get_title_request_headers
+        {
+          'User-Agent' => random_user_agent,
+          'referer' => REFERER_HEADER
+        }
+      end
+
+      def make_request(url, headers, payload)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Post.new(uri.path, headers)
+        request.body = payload
+
+        response = http.request(request)
+        response.body if response.is_a?(Net::HTTPSuccess)
+      rescue StandardError => e
+        nil
+      end
+
+      def make_get_request(url, headers)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Get.new(uri.request_uri, headers)
+        response = http.request(request)
+
+        if response.is_a?(Net::HTTPSuccess)
+          response.body
+        else
+          nil
+        end
+      rescue StandardError => e
+        nil
+      end
+
+      def random_user_agent
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+      end
+    end
+  end
+end

data/lib/howlongtobeat/json_result_parser.rb

@@ -0,0 +1,151 @@
+require 'json'
+require 'set'
+
+module HowLongToBeat
+  class JSONResultParser
+    IMAGE_URL_PREFIX = "https://howlongtobeat.com/games/"
+    GAME_URL_PREFIX = "https://howlongtobeat.com/game/"
+
+    attr_reader :results
+
+    def initialize(input_game_name, input_game_url, input_minimum_similarity, input_game_id = nil,
+                 input_similarity_case_sensitive = true, input_auto_filter_times = false)
+      @results = []
+      @minimum_similarity = input_minimum_similarity
+      @similarity_case_sensitive = input_similarity_case_sensitive
+      @auto_filter_times = input_auto_filter_times
+      @game_id = input_game_id
+      @base_game_url = input_game_url
+      @game_name = input_game_name
+      @game_name_numbers = @game_name.split(" ").select { |word| word.match?(/^\d+$/) }
+
+      if @game_id
+        @minimum_similarity = 0
+        @similarity_case_sensitive = false
+      end
+    end
+
+    def parse_json_result(input_json_result)
+      response_result = JSON.parse(input_json_result)
+      response_result["data"].each do |game|
+        new_game_entry = parse_json_element(game)
+
+        if @game_id && new_game_entry.game_id.to_s != @game_id.to_s
+          next
+        elsif @minimum_similarity == 0.0
+          @results << new_game_entry
+        elsif new_game_entry.similarity >= @minimum_similarity
+          @results << new_game_entry
+        end
+      end
+    end
+
+    private
+
+    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_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.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"])
+
+      # 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
+
+      # Auto-filter times based on complexity
+      if @auto_filter_times
+        if !current_entry.complexity_lvl_sp
+          current_entry.main_story = nil
+          current_entry.main_extra = nil
+          current_entry.completionist = nil
+          current_entry.all_styles = nil
+        end
+        current_entry.coop_time = nil unless current_entry.complexity_lvl_co
+        current_entry.mp_time = nil unless current_entry.complexity_lvl_mp
+      end
+
+      # Calculate similarity
+      game_name_similarity = similar(@game_name, current_entry.game_name)
+      game_alias_similarity = similar(@game_name, current_entry.game_alias)
+      current_entry.similarity = [game_name_similarity, game_alias_similarity].max
+
+      current_entry
+    end
+
+    def similar(a, b)
+      return 0 if a.nil? || b.nil?
+
+      a = a.downcase unless @similarity_case_sensitive
+      b = b.downcase unless @similarity_case_sensitive
+
+      # Simple Levenshtein distance for similarity
+      distance = levenshtein_distance(a, b)
+      max_length = [a.length, b.length].max
+      similarity = 1 - (distance.to_f / max_length)
+
+      # Additional check for numbers
+      if @game_name_numbers.any?
+        cleaned = b.gsub(/[^\w\s]/, '')
+        number_found = cleaned.split.any? do |word|
+          word.match?(/^\d+$/) && @game_name_numbers.include?(word)
+        end
+        similarity -= 0.1 unless number_found
+      end
+
+      similarity
+    end
+
+    def levenshtein_distance(str1, str2)
+      m = str1.length
+      n = str2.length
+      return m if n == 0
+      return n if m == 0
+
+      matrix = Array.new(m + 1) { Array.new(n + 1) }
+
+      (0..m).each { |i| matrix[i][0] = i }
+      (0..n).each { |j| matrix[0][j] = j }
+
+      (1..n).each do |j|
+        (1..m).each do |i|
+          if str1[i-1] == str2[j-1]
+            matrix[i][j] = matrix[i-1][j-1]
+          else
+            matrix[i][j] = [
+              matrix[i-1][j] + 1,
+              matrix[i][j-1] + 1,
+              matrix[i-1][j-1] + 1
+            ].min
+          end
+        end
+      end
+
+      matrix[m][n]
+    end
+
+    def round_time(seconds)
+      return nil if seconds.nil?
+      (seconds / 3600.0).round(2)
+    end
+  end
+end

data/lib/howlongtobeat/version.rb

@@ -0,0 +1,3 @@
+module HowLongToBeat
+  VERSION = "0.1.2"
+end

data/lib/howlongtobeat.rb

@@ -0,0 +1,9 @@
+require_relative 'howlongtobeat/version'
+require_relative 'howlongtobeat/how_long_to_beat'
+require_relative 'howlongtobeat/how_long_to_beat_entry'
+require_relative 'howlongtobeat/html_requests'
+require_relative 'howlongtobeat/json_result_parser'
+
+module HowLongToBeat
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: howlongtobeat
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Dmitrii Pashutskii
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A simple Ruby gem to fetch game completion times from HowLongToBeat.com
+email:
+- dpashutskii@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- README.md
+- lib/howlongtobeat.rb
+- lib/howlongtobeat/how_long_to_beat.rb
+- lib/howlongtobeat/how_long_to_beat_entry.rb
+- lib/howlongtobeat/html_requests.rb
+- lib/howlongtobeat/json_result_parser.rb
+- lib/howlongtobeat/version.rb
+homepage: https://github.com/dpashutskii/howlongtobeat
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dpashutskii/howlongtobeat
+  source_code_uri: https://github.com/dpashutskii/howlongtobeat
+  changelog_uri: https://github.com/dpashutskii/howlongtobeat/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/dpashutskii/howlongtobeat/issues
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Ruby client for HowLongToBeat.com
+test_files: []