tmdb_client 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a992679eb8cc1ca24e7e22e99346898c04fc72eb8be46a6d33b9411c91a35f87
+  data.tar.gz: b352e9575e802db5fb9b96bd02c5fc1450b7c7294902c043da3b21bb8ec2f112
+SHA512:
+  metadata.gz: c4defc01e39e05ce85d43fb11a148dbab02a3d6992ebcf8c8eed8d744bfabcd8da17c78278e3018571851f6d56b3fe7da12f0b902b5c4a92dd4d661d10513268
+  data.tar.gz: 0e87f12e4dffd91f038a8a924b0f1dec4458653f51e4ea4ac14c848c38aa81b3d1f3f82bc1f9d86f6d92d06514c3f07e2f44a8135c7d6478502357753b409a5e

data/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0]
+
+First release. A rewrite of [`themoviedb-api`](https://github.com/18Months/themoviedb-api)
+1.4.1, which has been unmaintained since 2023, under the `TMDb` namespace. Same
+endpoints, modern stack.
+
+### Added
+
+- Faraday 2 as the HTTP layer, replacing `rest-client`.
+- `TMDb::Object`, an immutable hash-backed value object, replacing the
+  `OpenStruct` subclass the old gem returned. Reads by method, by string key and
+  by symbol key; nests recursively; answers `nil` for a key TMDb did not send.
+- An error class per HTTP status — `NotFound`, `Unauthorized`, `RateLimited`,
+  `ServerError` and the rest — all under `TMDb::Error`, each carrying the status,
+  TMDb's own `status_code` and the response body. Distinguishing a missing id
+  from a bad key no longer means matching on the message text.
+- Transport failures raised as `TMDb::ConnectionError` / `TMDb::TimeoutError`;
+  no Faraday or socket exception escapes the client.
+- Retries with exponential backoff for 429, 5xx and dropped connections,
+  honouring `Retry-After`. Connect and read timeouts, defaulting to 5s and 10s.
+- `TMDb::Page` for every paginated endpoint, `Enumerable` over its results, with
+  `fetch_next_page`, `each_page` and a lazy `auto_paginate`.
+- Instantiable clients (`TMDb::Client.new(language: 'en')`) alongside the class
+  methods, so one process can run more than one configuration.
+- v4 bearer token authentication alongside the v3 API key.
+- Endpoints TMDb added since the old gem was written: `watch_providers`,
+  `release_dates`, `aggregate_credits`, `logos`, `alternative_names`,
+  `TV.recommendations`, `Movie.external_ids`, `Find.all`, and the
+  `/configuration` sub-resources.
+
+### Fixed
+
+- `Find.tv_season` and `Find.tv_episode` read each other's result buckets.
+- The base URL was plain HTTP, sending the API key in cleartext.
+- `Search.*` mutated the filters hash it was passed.
+- No timeouts were set, so a hung connection hung the caller indefinitely.
+
+### Changed
+
+- **Breaking:** the namespace is `TMDb`, not `Tmdb`.
+- **Breaking:** configuration is `TMDb.configure { |c| c.api_key = ... }` rather
+  than `Tmdb::Api.key(...)`.
+- **Breaking:** paginated endpoints all return `TMDb::Page`, where the old gem
+  returned a different envelope class per endpoint.
+- **Breaking:** the endpoint classes are no longer value objects, so
+  `Tmdb::Person.new(id: 1)` becomes `TMDb::Object.new(id: 1)`.
+- `Tmdb::Find.tv_serie` is now `tv_series`; the old spelling remains as an alias.
+- `Tmdb::Tv::Season` is now `TMDb::TV::Season`; `TMDb::Tv` remains as an alias.
+- Ruby >= 3.2 is required.
+- No core monkeypatching. The old gem patched `Hash` and `Object` when
+  ActiveSupport was absent.
+
+### Removed
+
+- `Account`, `Authentication`, `List` and `Rating`: value structs with no
+  endpoints behind them, since the client is read-only.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cineol
+
+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,305 @@
+# tmdb-client
+
+A Ruby client for [The Movie Database](https://developer.themoviedb.org/docs) v3 API.
+
+Built on Faraday 2, with typed errors, retries, timeouts and no `OpenStruct`. It
+replaces the unmaintained [`themoviedb-api`](https://github.com/18Months/themoviedb-api)
+gem and covers the same endpoints — see [Coming from themoviedb-api](#coming-from-themoviedb-api).
+
+Requires Ruby >= 3.2.
+
+## Installation
+
+```ruby
+gem 'tmdb_client', '~> 1.0'
+```
+
+```sh
+gem install tmdb_client
+```
+
+## Configuration
+
+```ruby
+TMDb.configure do |config|
+  config.api_key = ENV['TMDB_API_KEY']   # a v3 API key
+  config.language = 'es'
+end
+```
+
+In Rails, `config/initializers/tmdb.rb` is the place for it.
+
+A v4 read access token works too, and takes precedence when both are set:
+
+```ruby
+TMDb.configure { |config| config.access_token = ENV['TMDB_ACCESS_TOKEN'] }
+```
+
+| Setting | Default | What it does |
+| --- | --- | --- |
+| `api_key` | `nil` | v3 API key, sent as a query parameter |
+| `access_token` | `nil` | v4 read access token, sent as a bearer header |
+| `language` | `nil` | Default `language` parameter, e.g. `'es'` or `'es-ES'` |
+| `region` | `nil` | Default `region` parameter, e.g. `'ES'` |
+| `base_url` | `https://api.themoviedb.org/3` | API root |
+| `timeout` | `10` | Read timeout, seconds |
+| `open_timeout` | `5` | Connect timeout, seconds |
+| `retries` | `2` | Retries for 429, 500, 502, 503, 504 and dropped connections |
+| `retry_interval` | `0.5` | First backoff wait, seconds; doubles each retry |
+| `max_retry_interval` | `10` | Longest `Retry-After` this will wait for; beyond it, give up |
+| `adapter` | Faraday's default | Faraday adapter |
+| `logger` | `nil` | A Logger; set it and requests are logged |
+| `user_agent` | `tmdb_client/VERSION` | `User-Agent` header |
+
+Missing credentials raise `TMDb::ConfigurationError` before any request is made.
+
+## Making requests
+
+Every endpoint is a class method:
+
+```ruby
+TMDb::Movie.detail(550)
+TMDb::TV.detail(1396)
+TMDb::TV::Season.detail(1396, 1)
+TMDb::TV::Episode.detail(1396, 1, 1)
+TMDb::Person.detail(287)
+```
+
+Every one takes an optional trailing hash of filters, passed straight through as
+query parameters. A filter always beats the configured default, which is how one
+call can ask for English while the client stays configured for Spanish:
+
+```ruby
+TMDb::Movie.detail(550, append_to_response: 'credits,external_ids', language: 'en')
+TMDb::Discover.movie(with_genres: 18, 'primary_release_date.gte': '2026-01-01')
+```
+
+### Several clients at once
+
+The class methods go through a shared client. For a second set of settings —
+another language, another key — build a client and pass it in:
+
+```ruby
+english = TMDb::Client.new(language: 'en')
+
+TMDb::Movie.new(english).detail(550)
+```
+
+## Reading responses
+
+Responses come back as `TMDb::Object`: immutable, hash-backed, and readable
+whichever way suits the call site.
+
+```ruby
+movie = TMDb::Movie.detail(550, append_to_response: 'credits')
+
+movie.title                  # => "Fight Club"
+movie[:title]                # => "Fight Club"
+movie['title']               # => "Fight Club"
+
+movie.credits.cast.first.character          # nested objects and arrays are wrapped
+movie.genres.map { |genre| genre[:id] }     # => [18, 53]
+movie.to_h                                  # a plain, deeply unwrapped Hash
+```
+
+A key TMDb did not send reads as `nil` rather than raising — many TMDb fields are
+conditional, and a credit has no `imdb_id`:
+
+```ruby
+movie.credits.cast.first.imdb_id   # => nil
+movie.key?(:imdb_id)               # => false, if you need to tell absent from null
+```
+
+## Pagination
+
+Every paginated endpoint returns a `TMDb::Page`, which is `Enumerable` over its
+results:
+
+```ruby
+page = TMDb::Search.movie('blade runner')
+
+page.results        # => [TMDb::Object, ...]
+page.page           # => 1
+page.total_pages    # => 3
+page.total_results  # => 47
+page.map(&:title)
+```
+
+Following pages are fetched on demand, reusing the original filters:
+
+```ruby
+page.fetch_next_page          # the next Page, or nil on the last one
+page.each_page { |p| ... }    # this page, then each following one
+page.auto_paginate.first(50)  # results across page boundaries, lazily
+```
+
+`TMDb::Find` is the exception: it returns a plain Array, because a lookup by
+external id matches at most a handful of things.
+
+## Errors
+
+Everything raised inherits from `TMDb::Error`, so one rescue catches the lot —
+including transport failures. No Faraday or socket exception escapes.
+
+```ruby
+begin
+  TMDb::Movie.detail(id)
+rescue TMDb::NotFound
+  nil                       # a wrong id
+rescue TMDb::RateLimited => e
+  retry_in(e.retry_after)   # seconds, from the Retry-After header
+rescue TMDb::Error => e
+  report(e)
+end
+```
+
+| Class | Raised for |
+| --- | --- |
+| `TMDb::BadRequest` | 400 |
+| `TMDb::Unauthorized` | 401 |
+| `TMDb::Forbidden` | 403 |
+| `TMDb::NotFound` | 404 |
+| `TMDb::MethodNotAllowed` | 405 |
+| `TMDb::NotAcceptable` | 406 |
+| `TMDb::UnprocessableEntity` | 422 |
+| `TMDb::RateLimited` | 429 |
+| `TMDb::ServerError` | 500, and any other 5xx |
+| `TMDb::ServiceUnavailable` | 502, 503, 504 |
+| `TMDb::ConnectionError` | DNS, refused connections, TLS failures |
+| `TMDb::TimeoutError` | Timeouts (a `ConnectionError`) |
+| `TMDb::ParsingError` | A 2xx body that is not JSON |
+| `TMDb::ConfigurationError` | No credentials configured |
+
+`ClientError` (4xx) and `ServerError` (5xx) sit between those and `TMDb::Error`,
+so `rescue TMDb::ServerError` means "their side" and `rescue TMDb::ClientError`
+means "ours". Every error carries what it knows:
+
+```ruby
+rescue TMDb::Error => e
+  e.status       # => 404          the HTTP status
+  e.code         # => 34           TMDb's own status_code
+  e.message      # => "The resource you requested could not be found."
+  e.body         # the raw response body
+```
+
+## Retries
+
+429s, 5xx responses and dropped connections are retried twice by default, with
+exponential backoff. `Retry-After` is honoured when TMDb sends it, up to
+`max_retry_interval`; a longer wait than that gives up rather than blocking.
+4xx responses are never retried. Set `retries` to `0` to turn it off.
+
+## Endpoints
+
+<details>
+<summary><code>TMDb::Movie</code></summary>
+
+`detail` · `alternative_titles` · `credits` · `cast` · `crew` · `director` ·
+`external_ids` · `images` · `backdrops` · `posters` · `logos` · `videos` ·
+`keywords` · `watch_providers` · `release_dates` · `releases` · `translations` ·
+`changes` · `similar` · `recommendations` · `reviews` · `lists` · `latest` ·
+`upcoming` · `now_playing` · `popular` · `top_rated`
+</details>
+
+<details>
+<summary><code>TMDb::TV</code></summary>
+
+`detail` · `alternative_titles` · `credits` · `cast` · `crew` ·
+`content_ratings` · `external_ids` · `images` · `backdrops` · `posters` ·
+`logos` · `keywords` · `videos` · `translations` · `watch_providers` ·
+`changes` · `similar` · `recommendations` · `reviews` · `latest` ·
+`on_the_air` · `airing_today` · `top_rated` · `popular`
+</details>
+
+<details>
+<summary><code>TMDb::TV::Season</code> and <code>TMDb::TV::Episode</code></summary>
+
+Season: `detail` · `credits` · `cast` · `crew` · `aggregate_credits` ·
+`external_ids` · `images` · `posters` · `videos` · `translations` · `changes`
+
+Episode: `detail` · `credits` · `cast` · `crew` · `guest_stars` ·
+`external_ids` · `images` · `stills` · `videos` · `translations` · `changes`
+</details>
+
+<details>
+<summary><code>TMDb::Person</code></summary>
+
+`detail` · `movie_credits` · `tv_credits` · `combined_credits` · `external_ids` ·
+`images` · `profiles` · `tagged_images` · `translations` · `changes` · `popular` ·
+`latest`
+</details>
+
+<details>
+<summary><code>TMDb::Search</code>, <code>TMDb::Find</code> and <code>TMDb::Discover</code></summary>
+
+Search: `movie` · `tv` · `person` · `multi` · `company` · `collection` · `keyword`
+
+Find (all take `external_source:`): `movie` · `people` · `tv_series` ·
+`tv_season` · `tv_episode` · `all`
+
+Discover: `movie` · `tv`
+</details>
+
+<details>
+<summary>The rest</summary>
+
+`TMDb::Collection` — `detail` · `images` · `backdrops` · `posters` · `translations`
+`TMDb::Company` — `detail` · `alternative_names` · `images` · `movies`
+`TMDb::Network` — `detail` · `alternative_names` · `images`
+`TMDb::Keyword` — `detail` · `movies`
+`TMDb::Genre` — `movie_list` · `tv_list` · `movies`
+`TMDb::Credit` — `detail`
+`TMDb::Review` — `detail`
+`TMDb::Certification` — `movie_list` · `tv_list`, each a Hash keyed by country
+`TMDb::Change` — `movie` · `tv` · `person`
+`TMDb::Job` — `list`
+`TMDb::Configuration` — `get` · `countries` · `languages` · `jobs` · `timezones` · `primary_translations`
+</details>
+
+## Coming from themoviedb-api
+
+The endpoints are the same. What changed:
+
+| themoviedb-api | tmdb_client |
+| --- | --- |
+| `Tmdb::` | `TMDb::` |
+| `Tmdb::Api.key(k)` / `.language(l)` | `TMDb.configure { \|c\| c.api_key = k; c.language = l }` |
+| `Tmdb::Struct` (an `OpenStruct`) | `TMDb::Object`, frozen and hash-backed |
+| `Tmdb::Result` / `Tmdb::Discover` / `Tmdb::Movie` envelopes | `TMDb::Page` everywhere |
+| One `Tmdb::Error` for every failure | A class per status, all under `TMDb::Error` |
+| `Tmdb::Tv::Season` | `TMDb::TV::Season` (`TMDb::Tv` still resolves) |
+| `Tmdb::Find.tv_serie` | `TMDb::Find.tv_series` (`tv_serie` still resolves) |
+| `Tmdb::Person.new(id: 1)` as a value | `TMDb::Object.new(id: 1)` |
+| `Movie.similar` etc. returned mixed types | Every result is a `TMDb::Object` |
+
+Reading a response is unchanged: `.title`, `['title']` and `[:title]` all work,
+nesting is still recursive, and an absent key is still `nil`.
+
+Fixed along the way:
+
+- `Find.tv_season` and `Find.tv_episode` read each other's result buckets. They
+  now read the right ones.
+- The base URL was plain `http://`, so the API key travelled in cleartext.
+- Connection failures escaped as `NoMethodError` or `TypeError` instead of a
+  `Tmdb::Error`, so `rescue Tmdb::Error` did not actually catch an outage.
+- `Search.*` mutated the filters hash it was given.
+- No timeouts, so a hung connection hung the caller indefinitely.
+- `Object` and `Hash` were monkeypatched when ActiveSupport was absent.
+
+Dropped: `Account`, `Authentication`, `List` and `Rating`. They were value
+structs with no endpoints behind them — this client, like the old one, is
+read-only.
+
+## Development
+
+The specs run in Docker, so no local Ruby is needed:
+
+```sh
+make test      # specs and RuboCop
+make spec      # specs only
+make console   # IRB with the gem loaded
+```
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/lib/tmdb/certification.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module TMDb
+  class Certification < Resource
+    # Returns a Hash keyed by country code -- `{ US: [TMDb::Object, ...] }`.
+    def movie_list(filters = {})
+      by_country('/certification/movie/list', filters)
+    end
+
+    def tv_list(filters = {})
+      by_country('/certification/tv/list', filters)
+    end
+
+    expose_class_methods
+
+    private
+
+    def by_country(path, filters)
+      fetch(path, filters)[:certifications].to_h do |country, certifications|
+        [country, objects(certifications)]
+      end
+    end
+  end
+end

data/lib/tmdb/change.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module TMDb
+  # Ids changed in a date window. Use the per-resource `changes` methods
+  # (TMDb::Movie.changes and friends) for what actually changed on one title.
+  class Change < Resource
+    def movie(filters = {})
+      page('/movie/changes', filters)
+    end
+
+    def person(filters = {})
+      page('/person/changes', filters)
+    end
+
+    def tv(filters = {})
+      page('/tv/changes', filters)
+    end
+
+    expose_class_methods
+  end
+end

data/lib/tmdb/client.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module TMDb
+  # The one place this gem talks HTTP.
+  #
+  # Instances are safe to share across threads: the Faraday connection is built
+  # once behind a mutex and Faraday itself is thread-safe for concurrent
+  # requests. Nothing here mutates the config after construction.
+  class Client
+    attr_reader :config
+
+    # Accepts a Config, or keyword overrides on top of the global one:
+    #
+    #   TMDb::Client.new                                  # global config
+    #   TMDb::Client.new(language: 'en')                  # global, but English
+    #   TMDb::Client.new(config)                          # an explicit config
+    def initialize(config = nil, **overrides)
+      @config = build_config(config, overrides)
+      @mutex = Mutex.new
+    end
+
+    def get(path, params = {})
+      raise ConfigurationError, credentials_message unless config.credentials?
+
+      handle(connection.get(path.delete_prefix('/'), query_for(params)))
+    rescue Faraday::Error => e
+      raise translate(e)
+    end
+
+    def connection
+      @connection || @mutex.synchronize { @connection ||= build_connection }
+    end
+
+    def inspect
+      "#<TMDb::Client base_url=#{config.base_url.inspect} language=#{config.language.inspect}>"
+    end
+
+    private
+
+    # No Faraday exception is allowed past here: a caller rescuing TMDb::Error
+    # should not have to know, or import, the transport this gem happens to use.
+    def translate(error)
+      case error
+      when Faraday::TimeoutError
+        TimeoutError.new("TMDb request timed out: #{error.message}")
+      when Faraday::ConnectionFailed, Faraday::SSLError
+        ConnectionError.new("Could not reach TMDb: #{error.message}")
+      when Faraday::ParsingError
+        ParsingError.new("TMDb returned a response that is not JSON: #{error.message}")
+      else
+        Error.new("TMDb request failed: #{error.message}")
+      end
+    end
+
+    def build_config(config, overrides)
+      base = (config || TMDb.config).dup
+      overrides.each { |key, value| base.public_send(:"#{key}=", value) }
+
+      base
+    end
+
+    def credentials_message
+      'No TMDb credentials configured. Set an api_key (v3) or an access_token (v4) ' \
+        'via TMDb.configure { |c| c.api_key = ... }.'
+    end
+
+    # Per-call filters win over the client's defaults, and nils drop out rather
+    # than being sent as empty parameters.
+    def query_for(params)
+      config.default_params.merge(normalize(params)).compact
+    end
+
+    def normalize(params)
+      return {} if params.nil? || params.empty?
+
+      params.to_h.transform_keys(&:to_sym)
+    end
+
+    def handle(response)
+      return parse(response.body) if response.success?
+
+      raise error_for(response)
+    end
+
+    # Parsed here rather than by Faraday's JSON middleware: that middleware
+    # passes its parser options positionally, which json 3.0 no longer accepts,
+    # and a client this small does not need a middleware to call JSON.parse.
+    def parse(body)
+      return {} if body.nil? || body.strip.empty?
+
+      ::JSON.parse(body, symbolize_names: true)
+    rescue ::JSON::ParserError => e
+      raise ParsingError, "TMDb returned a response that is not JSON: #{e.message}"
+    end
+
+    # A failing response may carry anything -- TMDb's JSON error shape, an HTML
+    # error page from a proxy, nothing at all. The status is what matters, so a
+    # body that will not parse must not mask it.
+    def parse_quietly(body)
+      parsed = parse(body)
+
+      parsed.is_a?(::Hash) ? parsed : {}
+    rescue ParsingError
+      {}
+    end
+
+    def error_for(response)
+      details = parse_quietly(response.body)
+
+      Error.class_for(response.status).new(
+        details[:status_message] || "TMDb responded with HTTP #{response.status}",
+        status: response.status,
+        code: details[:status_code],
+        body: response.body,
+        retry_after: retry_after(response)
+      )
+    end
+
+    def retry_after(response)
+      seconds = response.headers['retry-after'].to_i
+
+      seconds.positive? ? seconds : nil
+    end
+
+    def build_connection
+      Faraday.new(url: base_url, headers: config.headers) { |faraday| build_stack(faraday) }
+    end
+
+    # A trailing slash on the prefix, paired with a relative request path, is the
+    # only combination Faraday joins without dropping the "/3" version segment.
+    def base_url
+      "#{config.base_url.chomp('/')}/"
+    end
+
+    def build_stack(faraday)
+      faraday.request :retry, retry_options
+      faraday.response :logger, config.logger, headers: false, bodies: false if config.logger
+
+      faraday.options.timeout = config.timeout
+      faraday.options.open_timeout = config.open_timeout
+
+      faraday.adapter(*Array(config.adapter))
+    end
+
+    def retry_options
+      {
+        max: config.retries,
+        interval: config.retry_interval,
+        interval_randomness: 0.5,
+        backoff_factor: 2,
+        retry_statuses: Config::RETRY_STATUSES,
+        max_interval: config.max_retry_interval,
+        methods: %i[get],
+        # Faraday::RetriableResponse is what the middleware raises to itself for a
+        # retryable status; leaving it out of this list makes every retryable
+        # response escape as a bare Faraday error instead of being retried.
+        exceptions: [
+          Faraday::RetriableResponse, Faraday::ConnectionFailed, Faraday::TimeoutError,
+          Errno::ETIMEDOUT, Errno::ECONNRESET
+        ]
+      }
+    end
+  end
+end

data/lib/tmdb/collection.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module TMDb
+  class Collection < Resource
+    def detail(id, filters = {})
+      object("/collection/#{id}", filters)
+    end
+
+    def images(id, filters = {})
+      object("/collection/#{id}/images", filters)
+    end
+
+    def backdrops(id, filters = {})
+      list("/collection/#{id}/images", :backdrops, filters)
+    end
+
+    def posters(id, filters = {})
+      list("/collection/#{id}/images", :posters, filters)
+    end
+
+    def translations(id, filters = {})
+      list("/collection/#{id}/translations", :translations, filters)
+    end
+
+    expose_class_methods
+  end
+end

data/lib/tmdb/company.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module TMDb
+  class Company < Resource
+    def detail(id, filters = {})
+      object("/company/#{id}", filters)
+    end
+
+    def alternative_names(id, filters = {})
+      list("/company/#{id}/alternative_names", :results, filters)
+    end
+
+    def images(id, filters = {})
+      object("/company/#{id}/images", filters)
+    end
+
+    def movies(id, filters = {})
+      page("/company/#{id}/movies", filters)
+    end
+
+    expose_class_methods
+  end
+end