lol_data_fetcher 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d5d6c8fcc2a14a1aa67e0271e7c837d31445e93f1791c9e471d587339e4f2bec
+  data.tar.gz: 45e513368cc422fd4cf82080d3f61af7b3ef4cd65fd8c28f50f00ad9e434b9d1
+SHA512:
+  metadata.gz: 25b31cb500270ae2d41c8423a13aa59493d11208083dd4c81df9479c61a2f894f0236094cdfcc98946d2f609cbc896f07fd0d8aa48498735f63a6d68524a057b
+  data.tar.gz: 66cc593f2038aaf3673d8c06ef93625249703f74c17105595bcc47a5ed7e1d09f18ba88048917a67fd031b260ce695eeb3ecb92388ff464fc013967a4e9803de

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# 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).
+
+## [0.1.0] - 2025-11-20
+
+### Added
+- Initial release of lol_data_fetcher gem
+- Client class for interacting with League of Legends Data Dragon API
+- Champions resource for fetching champion data and skills
+- Items resource for fetching and searching items
+- Skins resource for fetching champion skins with image URLs
+- Versions resource for managing Data Dragon versions
+- Configuration system for setting default language and version
+- Thor-based CLI with commands for champions, items, skins, and versions
+- Comprehensive RSpec test suite with VCR for HTTP recording
+- Support for multiple languages (en_US, ko_KR, ja_JP, etc.)
+- Error handling with custom exception classes
+- Detailed README with usage examples
+- SimpleCov integration for code coverage tracking
+
+### Features
+- Fetch all champions with detailed information
+- Get champion skills and abilities
+- Search items by name
+- Retrieve champion skins with splash and loading screen URLs
+- Support for all Data Dragon versions
+- Command-line interface for quick data access
+- 87.88% code coverage with automated tests

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Mark Chavez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,344 @@
+# LolDataFetcher
+
+A Ruby client for the League of Legends Data Dragon API. Fetch champions, items, skins, and other static game data with ease.
+
+## Features
+
+- Fetch all champions with detailed information including skills/spells
+- Get all items and search by name
+- Retrieve champion skins with image URLs
+- Support for multiple game versions and languages
+- Command-line interface (CLI) for quick data access
+- Comprehensive test coverage with RSpec
+- VCR cassettes for fast, repeatable tests
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lol_data_fetcher'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install lol_data_fetcher
+```
+
+## Usage
+
+### Ruby API
+
+#### Basic Usage
+
+```ruby
+require 'lol_data_fetcher'
+
+# Create a client (automatically fetches the latest version)
+client = LolDataFetcher::Client.new
+
+# Or specify a version and language
+client = LolDataFetcher::Client.new(
+  version: "15.23.1",
+  language: "ko_KR"
+)
+```
+
+#### Fetching Champions
+
+```ruby
+# Get all champions (overview)
+champions = client.champions.all
+champions["data"].each do |key, champion|
+  puts "#{champion['name']}: #{champion['title']}"
+end
+
+# Get detailed champion data including skills
+ahri = client.champions.find("Ahri")
+ahri_data = ahri["data"]["Ahri"]
+
+puts ahri_data["name"]  # => "Ahri"
+puts ahri_data["title"] # => "the Nine-Tailed Fox"
+
+# Access champion spells/skills
+ahri_data["spells"].each do |spell|
+  puts "#{spell['name']}: #{spell['description']}"
+end
+
+# List all champion names
+names = client.champions.list_names
+# => ["Aatrox", "Ahri", "Akali", ...]
+
+# Find champion by ID
+champion = client.champions.find_by_id("103") # Ahri
+```
+
+#### Fetching Items
+
+```ruby
+# Get all items
+items = client.items.all
+items["data"].each do |id, item|
+  puts "#{item['name']} - #{item['gold']['total']}g"
+end
+
+# Find specific item by ID
+boots = client.items.find("1001")
+puts boots["name"] # => "Boots"
+
+# Search items by name
+swords = client.items.search("sword")
+swords.each do |item|
+  puts item["name"]
+end
+
+# List all item IDs
+ids = client.items.list_ids
+```
+
+#### Fetching Skins
+
+```ruby
+# Get all skins for a specific champion
+skins = client.skins.for_champion("Ahri")
+skins.each do |skin|
+  puts skin["name"]
+  puts "Splash: #{skin['splash_url']}"
+  puts "Loading: #{skin['loading_url']}"
+end
+```
+
+#### Version Management
+
+```ruby
+# Get all available versions
+versions = client.versions.all
+# => ["15.23.1", "15.23.0", ...]
+
+# Get the latest version
+latest = client.versions.latest
+# => "15.23.1"
+
+# Check if a version exists
+client.versions.exists?("15.23.1") # => true
+```
+
+#### Global Configuration
+
+```ruby
+# Configure default settings
+LolDataFetcher.configure do |config|
+  config.default_language = "ja_JP"
+  config.default_version = "15.23.1"
+  config.timeout = 15
+end
+
+# Use the configured client
+client = LolDataFetcher.client
+
+# Reset configuration
+LolDataFetcher.reset!
+```
+
+### Command Line Interface
+
+The gem includes a powerful CLI for quick data access.
+
+#### View Help
+
+```bash
+lol_data_fetcher help
+```
+
+#### Get Version Information
+
+```bash
+# Gem version
+lol_data_fetcher version
+
+# Latest Data Dragon version
+lol_data_fetcher latest_version
+```
+
+#### List Champions
+
+```bash
+# List all champions
+lol_data_fetcher champions
+
+# Limit results
+lol_data_fetcher champions --limit 10
+
+# Use specific version and language
+lol_data_fetcher champions -v 15.23.1 -l ko_KR
+```
+
+#### Get Champion Details
+
+```bash
+# Get champion info with skills
+lol_data_fetcher champion Ahri
+
+# Without skills
+lol_data_fetcher champion Ahri --no-skills
+
+# With skins
+lol_data_fetcher champion Ahri --skins
+
+# Use specific version
+lol_data_fetcher champion Ahri -v 15.23.1
+```
+
+#### List Items
+
+```bash
+# List all items
+lol_data_fetcher items
+
+# Search items
+lol_data_fetcher items --search "sword"
+
+# Limit results
+lol_data_fetcher items --limit 20
+
+# Use specific version
+lol_data_fetcher items -v 15.23.1 -l es_ES
+```
+
+#### Get Champion Skins
+
+```bash
+# List skins for a champion
+lol_data_fetcher skins Ahri
+
+# Show image URLs
+lol_data_fetcher skins Ahri --urls
+```
+
+### Available Languages
+
+The Data Dragon API supports multiple languages:
+- `en_US` - English (United States)
+- `ko_KR` - Korean
+- `ja_JP` - Japanese
+- `es_ES` - Spanish (Spain)
+- `es_MX` - Spanish (Mexico)
+- `fr_FR` - French
+- `de_DE` - German
+- `it_IT` - Italian
+- `pl_PL` - Polish
+- `pt_BR` - Portuguese (Brazil)
+- `ru_RU` - Russian
+- `tr_TR` - Turkish
+- `zh_CN` - Chinese (China)
+- `zh_TW` - Chinese (Taiwan)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## API Reference
+
+### Client
+
+The main client class for interacting with the Data Dragon API.
+
+```ruby
+client = LolDataFetcher::Client.new(version: "15.23.1", language: "en_US")
+```
+
+**Methods:**
+- `champions` - Access the Champions resource
+- `items` - Access the Items resource
+- `skins` - Access the Skins resource
+- `versions` - Access the Versions resource
+
+### Champions Resource
+
+```ruby
+client.champions.all                  # Get all champions (overview)
+client.champions.find("Ahri")         # Get detailed champion data
+client.champions.list_names           # List all champion names
+client.champions.find_by_id("103")    # Find champion by ID
+```
+
+### Items Resource
+
+```ruby
+client.items.all                      # Get all items
+client.items.find("1001")             # Find item by ID
+client.items.list_ids                 # List all item IDs
+client.items.search("sword")          # Search items by name
+```
+
+### Skins Resource
+
+```ruby
+client.skins.for_champion("Ahri")     # Get skins for a champion
+```
+
+### Versions Resource
+
+```ruby
+client.versions.all                   # Get all available versions
+client.versions.latest                # Get latest version
+client.versions.exists?("15.23.1")    # Check if version exists
+```
+
+## Error Handling
+
+The gem defines several error classes:
+
+- `LolDataFetcher::Error` - Base error class
+- `LolDataFetcher::ApiError` - API request failures
+- `LolDataFetcher::NotFoundError` - Resource not found
+- `LolDataFetcher::ConfigurationError` - Configuration issues
+
+```ruby
+begin
+  client.champions.find("NonExistentChampion")
+rescue LolDataFetcher::NotFoundError => e
+  puts "Champion not found: #{e.message}"
+rescue LolDataFetcher::ApiError => e
+  puts "API error: #{e.message}"
+end
+```
+
+## Testing
+
+The gem uses RSpec for testing with VCR for recording HTTP interactions:
+
+```bash
+# Run all tests
+bundle exec rspec
+
+# Run specific test file
+bundle exec rspec spec/lol_data_fetcher/client_spec.rb
+
+# Run with coverage report
+bundle exec rspec
+# Coverage report will be in coverage/index.html
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/markchavez/lol_data_fetcher.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/lol_data_fetcher

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "lol_data_fetcher"
+require "lol_data_fetcher/cli"
+
+LolDataFetcher::CLI.start(ARGV)

data/lib/lol_data_fetcher/cli.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module LolDataFetcher
+  # Command-line interface for LolDataFetcher
+  class CLI < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "version", "Display the gem version"
+    def version
+      puts "lol_data_fetcher version #{LolDataFetcher::VERSION}"
+    end
+
+    desc "latest_version", "Show the latest game version"
+    def latest_version
+      client = LolDataFetcher::Client.new
+      puts "Latest Data Dragon version: #{client.version}"
+    rescue LolDataFetcher::Error => e
+      error("Failed to fetch latest version: #{e.message}")
+    end
+
+    desc "champions", "List all champions"
+    method_option :version, aliases: "-v", desc: "Game version to use"
+    method_option :language, aliases: "-l", default: "en_US", desc: "Language code (e.g., en_US, ko_KR)"
+    method_option :limit, aliases: "-n", type: :numeric, desc: "Limit number of results"
+    def champions
+      client = create_client
+      data = client.champions.all
+
+      champions = data["data"].values
+      champions = champions.first(options[:limit]) if options[:limit]
+
+      champions.each do |champion|
+        puts format_champion(champion)
+      end
+
+      puts "\nTotal: #{champions.length} champions"
+    rescue LolDataFetcher::Error => e
+      error("Failed to fetch champions: #{e.message}")
+    end
+
+    desc "champion NAME", "Get details for a specific champion"
+    method_option :version, aliases: "-v", desc: "Game version to use"
+    method_option :language, aliases: "-l", default: "en_US", desc: "Language code"
+    method_option :skills, aliases: "-s", type: :boolean, default: true, desc: "Show champion skills"
+    method_option :skins, type: :boolean, default: false, desc: "Show champion skins"
+    def champion(name)
+      client = create_client
+      data = client.champions.find(name)
+
+      champion_data = data.dig("data", name)
+      unless champion_data
+        error("Champion '#{name}' not found")
+        return
+      end
+
+      puts "\n#{champion_data['name']} - #{champion_data['title']}"
+      puts "=" * 50
+      puts "\nLore:"
+      puts word_wrap(champion_data["lore"])
+
+      if options[:skills] && champion_data["spells"]
+        puts "\n#{champion_data['name']}'s Skills:"
+        puts "-" * 50
+        champion_data["spells"].each_with_index do |spell, idx|
+          puts "\n#{idx + 1}. #{spell['name']}"
+          puts "   #{word_wrap(strip_html(spell['description']), 3)}"
+        end
+      end
+
+      if options[:skins]
+        puts "\n#{champion_data['name']}'s Skins:"
+        puts "-" * 50
+        skins = client.skins.for_champion(name)
+        skins.each do |skin|
+          puts "  - #{skin['name']}"
+        end
+      end
+    rescue LolDataFetcher::NotFoundError => e
+      error("Champion not found: #{e.message}")
+    rescue LolDataFetcher::Error => e
+      error("Failed to fetch champion: #{e.message}")
+    end
+
+    desc "items", "List all items"
+    method_option :version, aliases: "-v", desc: "Game version to use"
+    method_option :language, aliases: "-l", default: "en_US", desc: "Language code"
+    method_option :search, aliases: "-s", desc: "Search items by name"
+    method_option :limit, aliases: "-n", type: :numeric, desc: "Limit number of results"
+    def items
+      client = create_client
+
+      if options[:search]
+        items_list = client.items.search(options[:search])
+      else
+        data = client.items.all
+        items_list = data["data"].values
+      end
+
+      items_list = items_list.first(options[:limit]) if options[:limit]
+
+      items_list.each do |item|
+        gold = item.dig("gold", "total") || 0
+        puts "#{item['name']} - #{gold}g"
+      end
+
+      puts "\nTotal: #{items_list.length} items"
+    rescue LolDataFetcher::Error => e
+      error("Failed to fetch items: #{e.message}")
+    end
+
+    desc "skins CHAMPION", "List all skins for a champion"
+    method_option :version, aliases: "-v", desc: "Game version to use"
+    method_option :language, aliases: "-l", default: "en_US", desc: "Language code"
+    method_option :urls, aliases: "-u", type: :boolean, default: false, desc: "Show image URLs"
+    def skins(champion_name)
+      client = create_client
+      skins = client.skins.for_champion(champion_name)
+
+      puts "\n#{champion_name}'s Skins:"
+      puts "=" * 50
+
+      skins.each do |skin|
+        puts "\n#{skin['name']}"
+        if options[:urls]
+          puts "  Splash: #{skin['splash_url']}"
+          puts "  Loading: #{skin['loading_url']}"
+        end
+      end
+
+      puts "\nTotal: #{skins.length} skins"
+    rescue LolDataFetcher::NotFoundError => e
+      error("Champion not found: #{e.message}")
+    rescue LolDataFetcher::Error => e
+      error("Failed to fetch skins: #{e.message}")
+    end
+
+    private
+
+    def create_client
+      LolDataFetcher::Client.new(
+        version: options[:version],
+        language: options[:language]
+      )
+    end
+
+    def format_champion(champion)
+      "#{champion['name'].ljust(20)} - #{champion['title']}"
+    end
+
+    def strip_html(text)
+      text.gsub(/<[^>]*>/, "")
+    end
+
+    def word_wrap(text, indent = 0)
+      return "" unless text
+
+      prefix = " " * indent
+      text.gsub(/(.{1,#{78 - indent}})(\s+|$)/, "#{prefix}\\1\n").strip
+    end
+
+    def error(message)
+      warn "\nError: #{message}"
+      exit 1
+    end
+  end
+end

data/lib/lol_data_fetcher/client.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/retry"
+
+module LolDataFetcher
+  # Main client class for interacting with the Data Dragon API
+  class Client
+    BASE_URL = "https://ddragon.leagueoflegends.com"
+
+    attr_reader :version, :language
+
+    # Initialize a new client
+    # @param version [String, nil] Game version to use (nil = fetch latest)
+    # @param language [String] Language code (default: "en_US")
+    def initialize(version: nil, language: nil)
+      @language = language || LolDataFetcher.configuration.default_language
+      @version = version || LolDataFetcher.configuration.default_version || fetch_latest_version
+    end
+
+    # Access the champions resource
+    # @return [LolDataFetcher::Resources::Champions]
+    def champions
+      @champions ||= Resources::Champions.new(self)
+    end
+
+    # Access the items resource
+    # @return [LolDataFetcher::Resources::Items]
+    def items
+      @items ||= Resources::Items.new(self)
+    end
+
+    # Access the skins resource
+    # @return [LolDataFetcher::Resources::Skins]
+    def skins
+      @skins ||= Resources::Skins.new(self)
+    end
+
+    # Access the versions resource
+    # @return [LolDataFetcher::Resources::Versions]
+    def versions
+      @versions ||= Resources::Versions.new(self)
+    end
+
+    # Returns the Faraday connection object
+    # @return [Faraday::Connection]
+    def connection
+      @connection ||= Faraday.new(url: BASE_URL) do |faraday|
+        faraday.request :retry, max: 3, interval: 0.5, backoff_factor: 2
+        faraday.response :json, content_type: /\bjson$/
+        faraday.response :raise_error
+        faraday.options.timeout = LolDataFetcher.configuration.timeout
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    private
+
+    def fetch_latest_version
+      versions.latest
+    rescue StandardError => e
+      raise ConfigurationError, "Failed to fetch latest version: #{e.message}"
+    end
+  end
+end
+
+# Require resources after client is defined
+require_relative "resources/base"
+require_relative "resources/versions"
+require_relative "resources/champions"
+require_relative "resources/items"
+require_relative "resources/skins"

data/lib/lol_data_fetcher/configuration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  # Configuration class for global settings
+  class Configuration
+    attr_accessor :default_version, :default_language, :cache_enabled, :cache_ttl, :timeout
+
+    def initialize
+      @default_version = nil # nil = fetch latest
+      @default_language = "en_US"
+      @cache_enabled = false
+      @cache_ttl = 3600 # 1 hour in seconds
+      @timeout = 10 # seconds
+    end
+  end
+end

data/lib/lol_data_fetcher/errors.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  # Base error class for all LolDataFetcher errors
+  class Error < StandardError; end
+
+  # Raised when an API request fails
+  class ApiError < Error; end
+
+  # Raised when a requested resource is not found
+  class NotFoundError < ApiError; end
+
+  # Raised when rate limit is exceeded
+  class RateLimitError < ApiError; end
+
+  # Raised when there's a configuration issue
+  class ConfigurationError < Error; end
+end

data/lib/lol_data_fetcher/resources/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  module Resources
+    # Base class for all resource classes
+    class Base
+      attr_reader :client
+
+      # Initialize a new resource
+      # @param client [LolDataFetcher::Client] The client instance
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      # Make a GET request to the API
+      # @param path [String] The API path
+      # @param params [Hash] Query parameters
+      # @return [Hash] Parsed JSON response
+      # @raise [LolDataFetcher::ApiError] If the request fails
+      def get(path, params = {})
+        response = client.connection.get(path, params)
+        response.body
+      rescue Faraday::ResourceNotFound => e
+        raise NotFoundError, "Resource not found: #{path}"
+      rescue Faraday::Error => e
+        raise ApiError, "API request failed: #{e.message}"
+      end
+
+      # Build a CDN path for data resources
+      # @param resource [String] The resource name (e.g., "champion", "item")
+      # @return [String] The full CDN path
+      def cdn_path(resource)
+        "/cdn/#{client.version}/data/#{client.language}/#{resource}.json"
+      end
+
+      # Build a CDN path for image resources
+      # @param type [String] Image type (e.g., "champion/splash")
+      # @param filename [String] The image filename
+      # @return [String] The full CDN image path
+      def cdn_image_path(type, filename)
+        "/cdn/img/#{type}/#{filename}"
+      end
+    end
+  end
+end

data/lib/lol_data_fetcher/resources/champions.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  module Resources
+    # Resource for fetching champion data
+    class Champions < Base
+      # Fetch all champions (overview data)
+      # @return [Hash] Hash containing all champions data
+      def all
+        get(cdn_path("champion"))
+      end
+
+      # Fetch detailed data for a specific champion including skills
+      # @param name [String] Champion name (e.g., "Ahri", "MasterYi")
+      # @return [Hash] Detailed champion data including spells/skills
+      def find(name)
+        get(cdn_path("champion/#{name}"))
+      end
+
+      # List all champion names
+      # @return [Array<String>] Array of champion names
+      def list_names
+        all.dig("data")&.keys || []
+      end
+
+      # Get champion by ID
+      # @param id [String, Integer] Champion ID
+      # @return [Hash, nil] Champion data or nil if not found
+      def find_by_id(id)
+        all.dig("data")&.find { |_key, champ| champ["key"] == id.to_s }&.last
+      end
+    end
+  end
+end

data/lib/lol_data_fetcher/resources/items.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  module Resources
+    # Resource for fetching item data
+    class Items < Base
+      # Fetch all items
+      # @return [Hash] Hash containing all items data
+      def all
+        get(cdn_path("item"))
+      end
+
+      # Find a specific item by ID
+      # @param id [String, Integer] Item ID
+      # @return [Hash, nil] Item data or nil if not found
+      def find(id)
+        all.dig("data", id.to_s)
+      end
+
+      # List all item IDs
+      # @return [Array<String>] Array of item IDs
+      def list_ids
+        all.dig("data")&.keys || []
+      end
+
+      # Search items by name
+      # @param query [String] Search query
+      # @return [Array<Hash>] Array of matching items
+      def search(query)
+        items = all.dig("data") || {}
+        items.select { |_id, item| item["name"]&.downcase&.include?(query.downcase) }.values
+      end
+    end
+  end
+end

data/lib/lol_data_fetcher/resources/skins.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  module Resources
+    # Resource for fetching champion skin data
+    class Skins < Base
+      # Fetch skins for a specific champion
+      # @param champion_name [String] Champion name (e.g., "Ahri")
+      # @return [Array<Hash>] Array of skin data with image URLs
+      def for_champion(champion_name)
+        champion_data = get(cdn_path("champion/#{champion_name}"))
+        skins = champion_data.dig("data", champion_name, "skins") || []
+
+        skins.map do |skin|
+          {
+            "id" => skin["id"],
+            "num" => skin["num"],
+            "name" => skin["name"],
+            "splash_url" => splash_url(champion_name, skin["num"]),
+            "loading_url" => loading_url(champion_name, skin["num"]),
+            "chromas" => skin["chromas"] || false
+          }
+        end
+      end
+
+      # Get all skins across all champions
+      # @return [Hash] Hash of champion names to their skins
+      def all
+        champions_data = client.champions.all
+        skins = {}
+
+        champions_data.dig("data")&.each do |name, _champion|
+          skins[name] = for_champion(name)
+        rescue NotFoundError
+          # Skip champions without detailed data
+          next
+        end
+
+        skins
+      end
+
+      private
+
+      # Build splash art URL for a skin
+      # @param champion_name [String] Champion name
+      # @param skin_num [Integer] Skin number
+      # @return [String] Full URL to splash art
+      def splash_url(champion_name, skin_num)
+        "#{Client::BASE_URL}#{cdn_image_path('champion/splash', "#{champion_name}_#{skin_num}.jpg")}"
+      end
+
+      # Build loading screen URL for a skin
+      # @param champion_name [String] Champion name
+      # @param skin_num [Integer] Skin number
+      # @return [String] Full URL to loading screen
+      def loading_url(champion_name, skin_num)
+        "#{Client::BASE_URL}#{cdn_image_path('champion/loading', "#{champion_name}_#{skin_num}.jpg")}"
+      end
+    end
+  end
+end

data/lib/lol_data_fetcher/resources/versions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  module Resources
+    # Resource for fetching game version information
+    class Versions < Base
+      # Fetch all available versions
+      # @return [Array<String>] List of version strings
+      def all
+        get("/api/versions.json")
+      end
+
+      # Fetch the latest version
+      # @return [String] Latest version string
+      def latest
+        all.first
+      end
+
+      # Check if a version exists
+      # @param version [String] Version to check
+      # @return [Boolean] True if version exists
+      def exists?(version)
+        all.include?(version)
+      end
+    end
+  end
+end

data/lib/lol_data_fetcher/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LolDataFetcher
+  VERSION = "0.1.0"
+end

data/lib/lol_data_fetcher.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lol_data_fetcher/version"
+require_relative "lol_data_fetcher/errors"
+require_relative "lol_data_fetcher/configuration"
+
+module LolDataFetcher
+  class << self
+    attr_writer :configuration
+
+    # Returns the global configuration object
+    # @return [LolDataFetcher::Configuration]
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Yields the configuration object for setup
+    # @yield [LolDataFetcher::Configuration]
+    def configure
+      yield(configuration)
+    end
+
+    # Returns a new client instance
+    # @return [LolDataFetcher::Client]
+    def client
+      @client ||= Client.new
+    end
+
+    # Resets the configuration and client to defaults
+    def reset!
+      @configuration = Configuration.new
+      @client = nil
+    end
+  end
+end
+
+# Require client and resources after module is defined
+require_relative "lol_data_fetcher/client"

data/sig/lol_data_fetcher.rbs

@@ -0,0 +1,4 @@
+module LolDataFetcher
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,207 @@
+--- !ruby/object:Gem::Specification
+name: lol_data_fetcher
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Chavez
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-11-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: faraday-retry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.20'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.2'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.19'
+description: Fetch champions, items, skins, and other static data from League of Legends
+  Data Dragon API
+email:
+- mjfchavez@gmail.com
+executables:
+- lol_data_fetcher
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/lol_data_fetcher
+- lib/lol_data_fetcher.rb
+- lib/lol_data_fetcher/cli.rb
+- lib/lol_data_fetcher/client.rb
+- lib/lol_data_fetcher/configuration.rb
+- lib/lol_data_fetcher/errors.rb
+- lib/lol_data_fetcher/resources/base.rb
+- lib/lol_data_fetcher/resources/champions.rb
+- lib/lol_data_fetcher/resources/items.rb
+- lib/lol_data_fetcher/resources/skins.rb
+- lib/lol_data_fetcher/resources/versions.rb
+- lib/lol_data_fetcher/version.rb
+- sig/lol_data_fetcher.rbs
+homepage: https://github.com/markchavez/lol_data_fetcher
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/markchavez/lol_data_fetcher
+  source_code_uri: https://github.com/markchavez/lol_data_fetcher
+  changelog_uri: https://github.com/markchavez/lol_data_fetcher/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A Ruby client for League of Legends Data Dragon API
+test_files: []