wikimelon 0.0.2 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 677a3d97dca869666cc396285f938cb8c7031a8a1a0069509a19c4da03674cc1
-  data.tar.gz: 5ef0d3e678a81524ec039ae5ad1ef195fcd6d8c99f99409b664a912763a0d935
+  metadata.gz: 970d35750cfe012f2c2c05b004e6cf2b0bfcc9653e27762787a37d6d6f2b1dbb
+  data.tar.gz: 3d935812100ba31d1cdb0b25299e9a793f78cfec3b6f03aaa0f29659b43aaf18
 SHA512:
-  metadata.gz: f5355abc87792d30d7a83095ed7c03af7ccab2fb8bc582b72112cc93982d46ac054ad14f9a6ca986246fecd92e78dd13b2408ce443cead076501686222e6adc6
-  data.tar.gz: 55853e53bc9287a429a413de4dc030d5e94d3efddc37feadae5a4f481a6d2ecae38577acfc3b45848a590b2cd44f6f81d6f57af1bdc3856796f1f7f337030b54
+  metadata.gz: 4342be554828c2f669f9b9b2ef4006176ebbebb3e8a31c02cf7dd9d2caae70da229157665c188aad7ba9a8032dcbfb7aa8a7e80fe63028486f770f776d30805c
+  data.tar.gz: a23adc12cb3d590a3ea52a861f864c067548c4ca5cef22d19a8ebbf8a1bfc3fce6ca36a0565aaf4263858e737d39054fbe4bf9282f504f473e3a9b1fd64fd17f

data/.github/workflows/main.yml

@@ -5,12 +5,15 @@ on: [push,pull_request]
 jobs:
   build:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.3.4', '4.0.0']
     steps:
     - uses: actions/checkout@v2
-    - name: Set up Ruby
+    - name: Set up Ruby ${{ matrix.ruby-version }}
       uses: ruby/setup-ruby@v1
       with:
-        ruby-version: 3.3.4
+        ruby-version: ${{ matrix.ruby-version }}
         bundler-cache: true
     - name: Run the default task
       run: bundle exec rake

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [Unreleased]
- 
+
+## [0.1.1] - 2026-06-17
+ - Allow Ruby 4.0.0:
+    - Relaxed `required_ruby_version` to `>= 2.7.0, < 5.0`
+    - Added Ruby 4.0.0 to the CI matrix
+    - Bumped `faraday-follow_redirects` upper bound to allow 0.5+ (which lifts the Ruby < 4 cap)
+    - Added `rexml` and `irb` development dependencies (no longer in stdlib on Ruby 4)
+ - Fixed copy-paste residue: 503 error message said "Crossref is rate limiting your requests." (Crossref is the upstream serrano template's API) — changed to "Wikidata is rate limiting your requests."
+ - Switched `test_find_and_label` and `test_item_find_many_preserves_order` from Q42 (Douglas Adams) to Q1/Q5 because Q42's English label was vandalized on Wikidata
+
+## [0.1.0] - 2026-05-04
+- Added `Wikimelon.exists?` to check whether a P/Q ID resolves to an entity at the exact requested ID (catches missing IDs and merge/redirect cases)
+- Added `Wikimelon::Item` and `Wikimelon::Property` wrappers with helpers for `label`, `description`, `aliases`, `sitelink`, `claim(s)`, and `datatype`
+- Added `Wikimelon::Statement` for unwrapping claim values (entity-id, time, string, external-id, monolingualtext, quantity)
+- Added `Wikimelon.default_language` config (defaults to `"en"`)
+- Added `Wikimelon.request_interval` config for client-side throttling between requests
+- Added retry-on-429/503 with exponential backoff via `faraday-retry`, configurable through `Wikimelon.retry_max` (disabled by default) and `Wikimelon.retry_interval`; honors `Retry-After` headers
+- Added `revision_id:` keyword to `Item.find` / `Property.find`
+- Added `Wikimelon.api_url` and `Wikimelon.sparql_url` configs for pointing at self-hosted Wikibase instances
+- Added `Item.search` / `Property.search` (fuzzy search by label/alias via `wbsearchentities`) returning `Wikimelon::SearchResult` objects
+- Added `Item.find_many` / `Property.find_many` for batch entity fetch via `wbgetentities` (auto-chunks to the API's 50-per-request limit)
+- Dropped the `multi_json` runtime dependency in favor of stdlib `JSON`
+- Bumped the minimum Ruby version to 2.7
+
 ## [0.0.2] - 2025-03-06
 - Added entity endpoint
 

data/Gemfile

@@ -5,6 +5,4 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in wikimelon.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
-
-gem "minitest", "~> 5.0"
+gem "rake", "~> 13.0"

data/README.md

@@ -36,23 +36,105 @@ Wikimelon.query(query) #  => MultiJson object
 ```
 
 ---
-### Entities
-Fetch data on an item:
+### Items
+Fetch a Wikidata item (`Q…`). Returns a `Wikimelon::Item` with helpers for labels, descriptions, aliases, sitelinks, and claims:
 ```ruby
-entity_id = "Q13"
-Wikimelon.entity(entity_id) #  => MultiJson object
+item = Wikimelon::Item.find("Q42")
+
+item.id                         # => "Q42"
+item.exists?                    # => true
+item.label                      # => "Douglas Adams"
+item.label("de")                # => "Douglas Adams"
+item.description("en")          # => "English author and humourist (1952–2001)"
+item.aliases("en")              # => ["Douglas Noël Adams", ...]
+item.sitelink("enwiki")         # => "Douglas Adams"
+
+# Claims are returned as Wikimelon::Statement objects.
+# A property can have multiple claims (sometimes contradictory), each carrying
+# a rank: "preferred", "normal", or "deprecated". The caller decides which to use.
+item.claims("P31").map(&:value)            # => ["Q5"]   (instance of: human)
+item.claims("P569").first.value            # => "+1952-03-11T00:00:00Z"  (date of birth)
+item.claims("P106").map(&:value)           # => ["Q36180", "Q28389", ...]  (occupations)
+
+# When a property has multi-rank statements, filter explicitly:
+france = Wikimelon::Item.find("Q142")
+france.claims("P35").find { |s| s.rank == "preferred" }.value  # current head of state
+
+# Each statement carries the references that cite it.
+# A reference is a bag of snaks (property → value) pointing at a source.
+stmt = item.claims("P31").first
+ref  = stmt.references.first
+ref.properties                     # => ["P248", "P268", "P407", "P813"]
+ref.snaks("P248").first.value      # => "Q19938912"  (BnF authorities)
+
+# Escape hatch — the raw JSON Hash is still available
+item.raw                        # => { "entities" => { "Q42" => {...} } }
 ```
 
-Fetch data on a property:
+Fetch a specific revision:
 ```ruby
-entity_id = "P31"
-Wikimelon.entity(entity_id) #  => MultiJson object
+Wikimelon::Item.find("Q13", revision_id: 109)
 ```
 
-Fetch data on an entity with a specific revision ID:
+`item.exists?` returns `false` for missing IDs and for IDs that have been merged or redirected (in a redirect, the API returns the *target* entity, whose `id` differs from the requested string):
 ```ruby
-entity_id = "Q13"
-Wikimelon.entity(entity_id, revision_id: 109) #  => MultiJson object
+Wikimelon::Item.find("Q52793654").exists?    # => false  (redirects to Q336)
+Wikimelon::Item.find("Q1000000000").exists?  # => false  (well-formed but unassigned)
+```
+
+---
+### Properties
+Fetch a Wikidata property (`P…`). Returns a `Wikimelon::Property` with all the `Item` helpers plus `#datatype`:
+```ruby
+prop = Wikimelon::Property.find("P12817")
+
+prop.label       # => "Cockroach Species File taxon ID (new)"
+prop.datatype    # => "external-id"
+```
+
+---
+### Low-level access
+For most cases prefer `Item.find` / `Property.find` above. The raw endpoint is exposed for advanced use (custom JSON processing, pre-flighting an ID before constructing a wrapper):
+
+```ruby
+Wikimelon.entity("Q13")                           #  => raw Hash
+Wikimelon.entity("Q13", revision_id: 109)         #  => raw Hash at revision
+
+Wikimelon.exists?("Q42")          # => true
+Wikimelon.exists?("Q52793654")    # => false  (redirects to Q336)
+Wikimelon.exists?("Q1000000000")  # => false  (well-formed but unassigned)
+```
+
+---
+### Configuration
+Set a default language for `label`, `description`, and `aliases` (defaults to `"en"`):
+```ruby
+Wikimelon.default_language = "es"
+
+spain = Wikimelon::Item.find("Q29")
+spain.label          # => "España"   (uses the configured default)
+spain.label("en")    # => "Spain"    (explicit override still works)
+```
+
+Throttle outgoing requests by setting a minimum interval between them in seconds (defaults to `0`, no throttling). Useful when running batch jobs against Wikidata to stay polite:
+```ruby
+Wikimelon.request_interval = 0.5   # at most 2 requests/second
+
+# Subsequent calls will sleep as needed to enforce the gap
+ids.each { |id| Wikimelon::Item.find(id) }
+```
+
+Retry on transient errors (`429 Too Many Requests`, `503 Service Unavailable`) with exponential backoff. **Disabled by default** because the sleeps can stall interactive UI requests for many seconds — opt in for batch/CLI work where latency doesn't matter:
+```ruby
+Wikimelon.retry_max      = 5     # number of retries (0 = disabled)
+Wikimelon.retry_interval = 0.5   # base wait in seconds; doubles each retry
+```
+When the server provides a `Retry-After` header (Wikidata's SPARQL endpoint reliably does on 429), that value is honored instead of the exponential calculation.
+
+Point Wikimelon at a self-hosted Wikibase instance or query service:
+```ruby
+Wikimelon.api_url    = "https://wikibase.example.org"          # Special:EntityData host
+Wikimelon.sparql_url = "https://wdqs.example.org/sparql"       # SPARQL endpoint
 ```
 
 ---

data/lib/wikimelon/faraday.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "faraday"
-require "multi_json"
+require "json"
 
 # @private
 module Faraday
@@ -20,7 +20,7 @@ module Faraday
           when 502
             raise Wikimelon::BadGateway, error_message_500(response, "The server returned an invalid or incomplete response.")
           when 503
-            raise Wikimelon::ServiceUnavailable, error_message_500(response, "Crossref is rate limiting your requests.")
+            raise Wikimelon::ServiceUnavailable, error_message_500(response, "Wikidata is rate limiting your requests.")
           when 504
             raise Wikimelon::GatewayTimeout, error_message_500(response, "504 Gateway Time-out")
           end
@@ -41,7 +41,7 @@ module Faraday
       def error_body(body)
         if !body.nil? && !body.empty? && body.is_a?(String)
           if json?(body)
-            body = ::MultiJson.load(body)
+            body = ::JSON.parse(body)
             if body["message"].nil?
               body = nil
             else
@@ -62,9 +62,9 @@ module Faraday
       end
 
       def json?(string)
-        MultiJson.load(string)
+        JSON.parse(string)
         true
-      rescue MultiJson::ParseError
+      rescue JSON::ParserError
         false
       end
     end

data/lib/wikimelon/item.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Wikimelon
+  class Item < Resource
+    def sitelink(site)
+      @entity&.dig('sitelinks', site, 'title')
+    end
+  end
+end

data/lib/wikimelon/property.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Wikimelon
+  class Property < Resource
+    def datatype
+      @entity&.dig('datatype')
+    end
+  end
+end

data/lib/wikimelon/reference.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Wikimelon
+  # A citation attached to a Statement. Holds a bag of snaks keyed by property,
+  # commonly P248 ("stated in"), P854 ("reference URL"), P813 ("retrieved"),
+  # P1476 ("title"), P143 ("imported from").
+  class Reference
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def snaks(property_id)
+      (@raw.dig('snaks', property_id) || []).map { |s| Statement.new('mainsnak' => s) }
+    end
+
+    def properties
+      @raw['snaks-order'] || (@raw['snaks'] || {}).keys
+    end
+  end
+end

data/lib/wikimelon/request.rb

@@ -1,5 +1,7 @@
 require_relative "faraday" # !! Potential ruby 3.0 difference in module loading? relative differs from Serrano
 require "faraday/follow_redirects"
+require "faraday/retry"
+require "json"
 require_relative "utils"
 
 module Wikimelon
@@ -15,6 +17,7 @@ module Wikimelon
       @url = args[:url]
       @verbose = args[:verbose]
       @query = args[:query]
+      @params = args[:params]
       @limit = args[:limit]
       @offset = args[:offset]
       @options = args[:options] # TODO: not added at wikimelon.rb
@@ -22,13 +25,21 @@ module Wikimelon
 
     def perform
 
-      args = {'query': @query, 'format': 'json'}
-      opts = args.delete_if { |_k, v| v.nil? }
+      opts = @params || {'query': @query, 'format': 'json'}.delete_if { |_k, v| v.nil? }
 
       Faraday::Utils.default_space_encoding = "+"
 
+      retry_max = Wikimelon.retry_max.to_i
+
       conn = Faraday.new(url: @url) do |f|
               f.response :logger if verbose
+              if retry_max > 0
+                f.request :retry,
+                          max: retry_max,
+                          interval: Wikimelon.retry_interval.to_f,
+                          backoff_factor: 2,
+                          retry_statuses: [429, 503]
+              end
               f.use Faraday::WikimelonErrors::Middleware
               f.adapter Faraday.default_adapter
              end
@@ -37,9 +48,10 @@ module Wikimelon
       conn.headers[:user_agent] = make_user_agent
       conn.headers["X-USER-AGENT"] = make_user_agent
 
+      Wikimelon::Throttle.wait!
       res = conn.get(endpoint, opts)
 
-      MultiJson.load(res.body)      
+      JSON.parse(res.body)
     end
   end
 end

data/lib/wikimelon/resource.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Wikimelon
+  class Resource
+    attr_reader :id, :raw
+
+    def self.find(id, revision_id: nil)
+      new(id, Wikimelon.entity(id, revision_id: revision_id))
+    end
+
+    # Fetch multiple resources by ID in batches of up to 50 (the wbgetentities
+    # hard limit). Returns wrapped resources in the same order as the input.
+    def self.find_many(ids)
+      ids.each_slice(50).flat_map do |batch|
+        data = Wikimelon.entities(batch)
+        batch.map { |id| new(id, data) }
+      end
+    end
+
+    # Fuzzy-search by label or alias. Returns Array<SearchResult>.
+    def self.search(query, language: nil, limit: 10)
+      type = self == Property ? 'property' : 'item'
+      res = Wikimelon.search(query, type: type, language: language, limit: limit)
+      (res['search'] || []).map { |hit| SearchResult.new(hit) }
+    end
+
+    def initialize(id, data)
+      @id     = id
+      @raw    = data
+      @entity = data.dig('entities', id)
+    end
+
+    def exists?
+      !@entity.nil? && @entity['id'] == @id
+    end
+
+    def label(lang = nil)
+      @entity&.dig('labels', lang || Wikimelon.default_language, 'value')
+    end
+
+    def description(lang = nil)
+      @entity&.dig('descriptions', lang || Wikimelon.default_language, 'value')
+    end
+
+    def aliases(lang = nil)
+      (@entity&.dig('aliases', lang || Wikimelon.default_language) || []).map { |a| a['value'] }
+    end
+
+    def claims(property_id)
+      (@entity&.dig('claims', property_id) || []).map { |c| Statement.new(c) }
+    end
+  end
+end

data/lib/wikimelon/search_result.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Wikimelon
+  # A single hit from wbsearchentities. Lighter than a full Resource —
+  # only the fields the search endpoint returns. Call Item.find(result.id)
+  # to hydrate the full entity.
+  class SearchResult
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def id          = @raw['id']
+    def label       = @raw['label']
+    def description = @raw['description']
+    def aliases     = @raw['aliases'] || []
+    def concept_uri = @raw['concepturi']
+    def url         = @raw['url']
+  end
+end

data/lib/wikimelon/statement.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Wikimelon
+  class Statement
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw
+    end
+
+    def rank
+      @raw['rank']
+    end
+
+    def property
+      @raw.dig('mainsnak', 'property')
+    end
+
+    def value
+      snak_value(@raw['mainsnak'])
+    end
+
+    def qualifiers(property_id)
+      (@raw.dig('qualifiers', property_id) || []).map { |q| Statement.new('mainsnak' => q) }
+    end
+
+    def references
+      (@raw['references'] || []).map { |r| Reference.new(r) }
+    end
+
+    private
+
+    def snak_value(snak)
+      return nil if snak.nil? || snak['snaktype'] != 'value'
+      dv = snak['datavalue'] or return nil
+      case dv['type']
+      when 'wikibase-entityid'     then dv.dig('value', 'id')
+      when 'time'                  then dv.dig('value', 'time')
+      when 'monolingualtext'       then dv.dig('value', 'text')
+      when 'quantity'              then dv.dig('value', 'amount')
+      when 'string', 'external-id' then dv['value']
+      else dv['value']
+      end
+    end
+  end
+end

data/lib/wikimelon/throttle.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Wikimelon
+  # Enforces a minimum interval between outgoing requests when
+  # Wikimelon.request_interval is set (in seconds). Thread-safe.
+  module Throttle
+    @mutex = Mutex.new
+    @last_request_at = nil
+
+    def self.wait!
+      interval = Wikimelon.request_interval.to_f
+      return if interval <= 0
+
+      @mutex.synchronize do
+        if @last_request_at
+          elapsed = now - @last_request_at
+          sleep(interval - elapsed) if elapsed < interval
+        end
+        @last_request_at = now
+      end
+    end
+
+    def self.reset!
+      @mutex.synchronize { @last_request_at = nil }
+    end
+
+    def self.now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/wikimelon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wikimelon
-  VERSION = "0.0.2"
+  VERSION = "0.1.1"
 end

data/lib/wikimelon.rb

@@ -10,6 +10,12 @@ module Wikimelon
   extend Configuration
 
   define_setting :mailto, ENV["WIKIMELON_API_EMAIL"]
+  define_setting :default_language, 'en'
+  define_setting :request_interval, 0
+  define_setting :retry_max, 0
+  define_setting :retry_interval, 0.5
+  define_setting :api_url, 'https://www.wikidata.org'
+  define_setting :sparql_url, 'https://query.wikidata.org/sparql'
 
   # Run a Wikidata SPARQL query
   #
@@ -20,7 +26,7 @@ module Wikimelon
   # @return [Array, Boolean] An array of hashes
   def self.query(query, verbose: false)
     Request.new(
-      url: "https://query.wikidata.org/sparql",
+      url: sparql_url,
       query: query,
       verbose: verbose
     ).perform
@@ -36,11 +42,72 @@ module Wikimelon
   #
   # @return [Array, Boolean] An array of hashes
   def self.entity(entity_id, revision_id: nil, verbose: false)
-    url = "https://www.wikidata.org/wiki/Special:EntityData/#{entity_id}.json"
+    url = "#{api_url}/wiki/Special:EntityData/#{entity_id}.json"
     url = "#{url}?revision=#{revision_id}" unless revision_id.nil?
     Request.new(
       url: url,
       verbose: verbose
     ).perform
   end
+
+  # Check whether a Wikidata entity exists at the exact ID requested.
+  # Returns false for missing IDs and for IDs that have been merged or
+  # redirected (the API returns the target entity, whose id differs from
+  # the requested string).
+  #
+  # @param entity_id [String] a Wikidata entity ID
+  # @param verbose [Boolean] Print headers to STDOUT
+  #
+  # @return [Boolean]
+  def self.exists?(entity_id, verbose: false)
+    res = entity(entity_id, verbose: verbose)
+    res.dig('entities', entity_id, 'id') == entity_id
+  rescue Wikimelon::NotFound
+    false
+  end
+
+  # Fetch multiple Wikidata entities in a single request via wbgetentities.
+  # Up to 50 IDs per call (the API hard limit). Use Item.find_many or
+  # Property.find_many for the wrapped-object form.
+  #
+  # @param ids [Array<String>]
+  # @return [Hash] the raw {"entities" => {...}} response
+  def self.entities(ids, verbose: false)
+    Request.new(
+      url: "#{api_url}/w/api.php",
+      params: { action: 'wbgetentities', ids: ids.join('|'), format: 'json' },
+      verbose: verbose
+    ).perform
+  end
+
+  # Fuzzy-search Wikidata for an item, property, or other entity type
+  # via wbsearchentities. Returns the raw response hash; use
+  # Item.search / Property.search for the wrapped form.
+  #
+  # @param query [String] free-text search
+  # @param type [String] "item", "property", "lexeme", "form", "sense"
+  # @param language [String] language code; defaults to Wikimelon.default_language
+  # @param limit [Integer] 1-50
+  def self.search(query, type: 'item', language: nil, limit: 10, verbose: false)
+    Request.new(
+      url: "#{api_url}/w/api.php",
+      params: {
+        action: 'wbsearchentities',
+        search: query,
+        language: language || default_language,
+        type: type,
+        limit: limit,
+        format: 'json'
+      },
+      verbose: verbose
+    ).perform
+  end
 end
+
+require_relative "wikimelon/throttle"
+require_relative "wikimelon/reference"
+require_relative "wikimelon/statement"
+require_relative "wikimelon/search_result"
+require_relative "wikimelon/resource"
+require_relative "wikimelon/item"
+require_relative "wikimelon/property"

data/wikimelon.gemspec

@@ -5,14 +5,14 @@ require_relative "lib/wikimelon/version"
 Gem::Specification.new do |s|
   s.name          = "wikimelon"
   s.version       = Wikimelon::VERSION
-  s.authors       = ["Geoff Ower, Matt Yoder"]
+  s.authors       = ["Geoff Ower", "Matt Yoder"]
   s.email         = ["gdower@illinois.edu"]
 
   s.summary       = "Wikidata Client"
   s.description   = "Wikimelon is a low-level wrapper around the Wikidata API."
   s.homepage      = "https://github.com/SpeciesFileGroup/wikimelon"
   s.license       = "MIT"
-  s.required_ruby_version = ">= 2.5.0"
+  s.required_ruby_version = [">= 2.7.0", "< 5.0"]
 
  # s.metadata["allowed_push_host"] = "TODO: Set to 'https://mygemserver.com'"
 
@@ -32,17 +32,17 @@ Gem::Specification.new do |s|
   # Uncomment to register a new dependency of your gem
   # s.add_dependency "example-gem", "~> 1.0"
 
-  s.add_development_dependency "bundler", "~> 2.1", ">= 2.1.4"
   s.add_development_dependency "rake", "~> 13.0", ">= 13.0.1"
   s.add_development_dependency "test-unit", "~> 3.3", ">= 3.3.6"
   s.add_development_dependency "vcr", "~> 6.0"
   s.add_development_dependency "webmock", "~> 3.18"
   s.add_development_dependency "rexml", "~> 3.3", ">= 3.3.6"
+  s.add_development_dependency "irb", "~> 1.0"
   # s.add_development_dependency "byebug"
 
   s.add_runtime_dependency "faraday", "~> 2.2"
-  s.add_runtime_dependency "faraday-follow_redirects", ">= 0.1", "< 0.4"
-  s.add_runtime_dependency "multi_json", "~> 1.15"
+  s.add_runtime_dependency "faraday-follow_redirects", ">= 0.1", "< 0.6"
+  s.add_runtime_dependency "faraday-retry", "~> 2.2"
 
   #  s.add_runtime_dependency "thor", "~> 1.0", ">= 1.0.1"
 

metadata

@@ -1,35 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: wikimelon
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors:
-- Geoff Ower, Matt Yoder
-autorequire:
+- Geoff Ower
+- Matt Yoder
 bindir: exe
 cert_chain: []
-date: 2025-03-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.1.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.1.4
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -118,6 +98,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.3.6
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -141,7 +135,7 @@ dependencies:
         version: '0.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -151,21 +145,21 @@ dependencies:
         version: '0.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.6'
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: faraday-retry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '2.2'
 description: Wikimelon is a low-level wrapper around the Wikidata API.
 email:
 - gdower@illinois.edu
@@ -187,7 +181,14 @@ files:
 - lib/wikimelon/error.rb
 - lib/wikimelon/faraday.rb
 - lib/wikimelon/helpers/configuration.rb
+- lib/wikimelon/item.rb
+- lib/wikimelon/property.rb
+- lib/wikimelon/reference.rb
 - lib/wikimelon/request.rb
+- lib/wikimelon/resource.rb
+- lib/wikimelon/search_result.rb
+- lib/wikimelon/statement.rb
+- lib/wikimelon/throttle.rb
 - lib/wikimelon/utils.rb
 - lib/wikimelon/version.rb
 - wikimelon.gemspec
@@ -197,8 +198,7 @@ licenses:
 metadata:
   homepage_uri: https://github.com/SpeciesFileGroup/wikimelon
   source_code_uri: https://github.com/SpeciesFileGroup/wikimelon
-  changelog_uri: https://github.com/SpeciesFileGroup/wikimelon/releases/tag/v0.0.2
-post_install_message:
+  changelog_uri: https://github.com/SpeciesFileGroup/wikimelon/releases/tag/v0.1.1
 rdoc_options: []
 require_paths:
 - lib
@@ -206,15 +206,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '5.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Wikidata Client
 test_files: []