pinterest-ads 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 739ce285547b3fa9389e1c0d249bd02bc7d7451cda3481227e8232e217ecc58f
+  data.tar.gz: f3cdfcf37725494e02ef16193a114420bb4827141dbd480f9b97b8ebe0584c64
+SHA512:
+  metadata.gz: '09f64ca58d1dc980b50fe01b11655f30bc34e307ab02a0e9f7afc6dd084abcd6c77ade4920e9f65a4ac97732bddd45b1f4d3fa9b8bdd2eaccb60f98ef6b8b7f9'
+  data.tar.gz: 7678b6122e14f6e2e34b4c887583410b2a585ba5bf08087a63ecd5870b6fdaeeae5122d19dc455ab984b5ed4c08d43f570114cd7f401d176741d4d997458847e

data/README.md

@@ -0,0 +1,230 @@
+# Pinterest API
+
+Ruby wrapper for the [Pinterest REST API v5](https://developers.pinterest.com/docs/api/v5/).
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "pinterest-ads", git: "https://github.com/stitchfix/pinterest-api"
+```
+
+Then run:
+
+```sh
+bundle install
+```
+
+## Configuration
+
+### Global configuration
+
+```ruby
+Pinterest.configure do |c|
+  c.client_id     = ENV["PINTEREST_CLIENT_ID"]
+  c.client_secret = ENV["PINTEREST_CLIENT_SECRET"]
+  c.access_token  = ENV["PINTEREST_ACCESS_TOKEN"]
+  c.redirect_uri  = ENV["PINTEREST_REDIRECT_URI"]
+end
+```
+
+### Per-client configuration
+
+You can also pass credentials directly when instantiating a client. Per-client values take precedence over the global configuration.
+
+```ruby
+client = Pinterest::Client.new(
+  client_id:     "your_app_id",
+  client_secret: "your_app_secret",
+  access_token:  "your_bearer_token",
+  redirect_uri:  "https://example.com/callback"
+)
+```
+
+### Optional settings
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `base_url` | `https://api.pinterest.com/v5` | API base URL |
+| `auth_url` | `https://www.pinterest.com/oauth/` | OAuth authorization URL |
+| `timeout` | `30` | Request timeout in seconds |
+| `open_timeout` | `10` | Connection open timeout in seconds |
+
+These can be set via `Pinterest.configure` or passed as keyword arguments to `Pinterest::Client.new`.
+
+## Usage
+
+### OAuth
+
+#### 1. Generate the authorization URL
+
+```ruby
+url = client.oauth.authorization_url(
+  redirect_uri: "https://example.com/callback",
+  scope: %w[ads:read ads:write],
+  state: SecureRandom.hex(16)
+)
+# Redirect the user to this URL
+```
+
+#### 2. Exchange the authorization code for tokens
+
+```ruby
+tokens = client.oauth.exchange_code(
+  code: params[:code],
+  redirect_uri: "https://example.com/callback"
+)
+# tokens => { "access_token" => "...", "refresh_token" => "...", "expires_in" => 86400, ... }
+```
+
+#### 3. Refresh an access token
+
+```ruby
+tokens = client.oauth.refresh(refresh_token: "your_refresh_token")
+client.access_token = tokens["access_token"]
+```
+
+#### 4. Revoke a token
+
+```ruby
+client.oauth.revoke(token: "token_to_revoke", token_type_hint: "access_token")
+```
+
+#### 5. Generate a conversion API token
+
+```ruby
+result = client.oauth.conversion_token
+# result => { "access_token" => "...", "token_type" => "conversion" }
+```
+
+### Audiences
+
+All audience methods require an `ad_account_id`.
+
+```ruby
+# List audiences
+audiences = client.audiences.list(ad_account_id: "123456")
+# audiences => { "items" => [...], "bookmark" => "..." }
+
+# Create an audience
+audience = client.audiences.create(
+  ad_account_id: "123456",
+  name: "My Audience",
+  audience_type: "CUSTOMER_LIST",
+  rule: { ... }
+)
+
+# Get a specific audience
+audience = client.audiences.find(ad_account_id: "123456", audience_id: "789")
+
+# Update an audience
+client.audiences.update(ad_account_id: "123456", audience_id: "789", name: "New Name")
+```
+
+### Customer Lists
+
+```ruby
+# List customer lists
+lists = client.customer_lists.list(ad_account_id: "123456")
+
+# Create a customer list
+list = client.customer_lists.create(
+  ad_account_id: "123456",
+  name: "Email Subscribers",
+  list_type: "EMAIL",
+  records: "user1@example.com\nuser2@example.com"
+)
+
+# Get a specific customer list
+list = client.customer_lists.find(ad_account_id: "123456", customer_list_id: "789")
+
+# Add or remove records
+client.customer_lists.update(
+  ad_account_id: "123456",
+  customer_list_id: "789",
+  operation_type: "ADD",
+  records: "user3@example.com"
+)
+```
+
+### Customer List Uploads (Multipart S3)
+
+For large customer lists, use the multipart upload workflow:
+
+```ruby
+# 1. Create the upload (returns presigned S3 URLs)
+upload = client.customer_list_uploads.create(
+  ad_account_id: "123456",
+  customer_list_id: "789",
+  operation: "ADD",
+  total_parts: 3
+)
+# upload => { "customer_list_upload" => {...}, "s3_multipart_upload_data" => {...} }
+
+# 2. Upload parts to S3 using the presigned URLs (outside this gem)
+
+# 3. Trigger processing
+client.customer_list_uploads.run(
+  ad_account_id: "123456",
+  customer_list_id: "789",
+  customer_list_upload_id: upload.dig("customer_list_upload", "id")
+)
+
+# Check upload status
+status = client.customer_list_uploads.find(
+  ad_account_id: "123456",
+  customer_list_id: "789",
+  customer_list_upload_id: "upload_id"
+)
+```
+
+## Pagination
+
+List endpoints return a `bookmark` value for cursor-based pagination:
+
+```ruby
+all_audiences = []
+bookmark = nil
+
+loop do
+  result = client.audiences.list(ad_account_id: "123456", bookmark: bookmark, page_size: 25)
+  all_audiences.concat(result["items"])
+  bookmark = result["bookmark"]
+  break if bookmark.nil?
+end
+```
+
+## Error Handling
+
+The gem raises typed exceptions for HTTP errors:
+
+| Status | Exception |
+|--------|-----------|
+| 400 | `Pinterest::BadRequestError` |
+| 401 | `Pinterest::AuthenticationError` |
+| 403 | `Pinterest::ForbiddenError` |
+| 404 | `Pinterest::NotFoundError` |
+| 429 | `Pinterest::RateLimitError` |
+| 5xx | `Pinterest::ServerError` |
+
+All exceptions inherit from `Pinterest::Error` and expose `status`, `code`, and `response` attributes.
+
+```ruby
+begin
+  client.audiences.find(ad_account_id: "123", audience_id: "bad_id")
+rescue Pinterest::NotFoundError => e
+  puts e.message # API error message
+  puts e.status  # 404
+rescue Pinterest::Error => e
+  puts "Unexpected error: #{e.message} (HTTP #{e.status})"
+end
+```
+
+## Requirements
+
+- Ruby >= 3.0.0
+
+## License
+
+MIT

data/lib/pinterest/client.rb

@@ -0,0 +1,54 @@
+require_relative "resources/base"
+require_relative "resources/oauth"
+require_relative "resources/audiences"
+require_relative "resources/customer_lists"
+require_relative "resources/customer_list_uploads"
+
+module Pinterest
+  class Client
+    # @param client_id [String] Pinterest app ID (required for OAuth token calls)
+    # @param client_secret [String] Pinterest app secret (required for OAuth token calls)
+    # @param access_token [String] Bearer token (required for authenticated API calls)
+    # @param redirect_uri [String] default redirect URI for authorization_url
+    # @param options [Hash] overrides for timeout, open_timeout, base_url, auth_url
+    def initialize(client_id: nil, client_secret: nil, access_token: nil,
+                   redirect_uri: nil, default_scope: nil, **options)
+      @config = Configuration.new
+      @config.client_id     = client_id     || Pinterest.configuration.client_id
+      @config.client_secret = client_secret || Pinterest.configuration.client_secret
+      @config.access_token  = access_token  || Pinterest.configuration.access_token
+      @config.redirect_uri  = redirect_uri  || Pinterest.configuration.redirect_uri
+      @config.default_scope = default_scope || Pinterest.configuration.default_scope
+
+      options.each do |key, value|
+        @config.public_send(:"#{key}=", value) if @config.respond_to?(:"#{key}=")
+      end
+    end
+
+    # @return [Resources::OAuth]
+    def oauth
+      @oauth ||= Resources::OAuth.new(@config)
+    end
+
+    # @return [Resources::Audiences]
+    def audiences
+      @audiences ||= Resources::Audiences.new(@config)
+    end
+
+    # @return [Resources::CustomerLists]
+    def customer_lists
+      @customer_lists ||= Resources::CustomerLists.new(@config)
+    end
+
+    # @return [Resources::CustomerListUploads]
+    def customer_list_uploads
+      @customer_list_uploads ||= Resources::CustomerListUploads.new(@config)
+    end
+
+    # Update the stored access token (e.g. after a refresh).
+    def access_token=(token)
+      @config.access_token = token
+      @oauth = nil  # reset memoized resource so it picks up the new token
+    end
+  end
+end

data/lib/pinterest/configuration.rb

@@ -0,0 +1,16 @@
+module Pinterest
+  class Configuration
+    PINTEREST_BASE_URL  = "https://api.pinterest.com/v5"
+    PINTEREST_AUTH_URL  = "https://www.pinterest.com/oauth/"
+
+    attr_accessor :client_id, :client_secret, :access_token, :redirect_uri,
+                  :base_url, :auth_url, :timeout, :open_timeout, :default_scope
+
+    def initialize
+      @base_url     = PINTEREST_BASE_URL
+      @auth_url     = PINTEREST_AUTH_URL
+      @timeout      = 30
+      @open_timeout = 10
+    end
+  end
+end

data/lib/pinterest/connection.rb

@@ -0,0 +1,100 @@
+require "faraday"
+require "faraday/net_http"
+require "json"
+
+module Pinterest
+  module Connection
+    private
+
+    # Bearer-authed connection for standard API calls.
+    def api_connection
+      @api_connection ||= build_connection(config.base_url) do |conn|
+        conn.request :authorization, "Bearer", -> { config.access_token }
+      end
+    end
+
+    # Basic-authed connection used exclusively for token-endpoint calls.
+    def auth_connection
+      @auth_connection ||= build_connection(config.base_url) do |conn|
+        conn.request :authorization, :basic, config.client_id, config.client_secret
+      end
+    end
+
+    def build_connection(url)
+      url = "#{url.chomp("/")}/"
+      Faraday.new(url: url) do |conn|
+        yield conn if block_given?
+        conn.options.timeout      = config.timeout
+        conn.options.open_timeout = config.open_timeout
+        conn.response :raise_error
+        conn.adapter :net_http
+      end
+    end
+
+    # Faraday treats paths beginning with "/" as root-relative, stripping the
+    # /v5 prefix from the base URL. Strip leading slashes so Faraday appends
+    # them to the full base URL instead.
+    def normalize_path(path)
+      path.delete_prefix("/")
+    end
+
+    def get(path, params = {})
+      handle { api_connection.get(normalize_path(path), params) }
+    end
+
+    def post(path, body = {}, json: true, basic_auth: false)
+      conn = basic_auth ? auth_connection : api_connection
+      path = normalize_path(path)
+      handle do
+        if json
+          conn.post(path) do |req|
+            req.headers["Content-Type"] = "application/json"
+            req.headers["Accept"]       = "application/json"
+            req.body = JSON.generate(body)
+          end
+        else
+          conn.post(path) do |req|
+            req.headers["Content-Type"] = "application/x-www-form-urlencoded"
+            req.headers["Accept"]       = "application/json"
+            req.body = URI.encode_www_form(body.compact)
+          end
+        end
+      end
+    end
+
+    def patch(path, body = {})
+      handle do
+        api_connection.patch(normalize_path(path)) do |req|
+          req.headers["Content-Type"] = "application/json"
+          req.headers["Accept"]       = "application/json"
+          req.body = JSON.generate(body)
+        end
+      end
+    end
+
+    def delete(path, params = {})
+      handle { api_connection.delete(normalize_path(path), params) }
+    end
+
+    def handle
+      raw      = yield
+      response = Response.new(raw)
+      body     = parse_body(raw.body)
+      raise Pinterest.error_for(raw.status, body, response) unless response.success?
+      body
+    rescue Faraday::ClientError, Faraday::ServerError => e
+      status = e.response&.dig(:status)
+      body   = safe_parse(e.response&.dig(:body))
+      raise Pinterest.error_for(status || 0, body, nil)
+    end
+
+    def parse_body(raw)
+      return nil if raw.nil? || raw.empty?
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      raw
+    end
+
+    alias safe_parse parse_body
+  end
+end

data/lib/pinterest/error.rb

@@ -0,0 +1,33 @@
+module Pinterest
+  class Error < StandardError
+    attr_reader :status, :code, :response
+
+    def initialize(message = nil, status: nil, code: nil, response: nil)
+      @status   = status
+      @code     = code
+      @response = response
+      super(message)
+    end
+  end
+
+  class BadRequestError      < Error; end  # 400
+  class AuthenticationError  < Error; end  # 401
+  class ForbiddenError       < Error; end  # 403
+  class NotFoundError        < Error; end  # 404
+  class RateLimitError       < Error; end  # 429
+  class ServerError          < Error; end  # 5xx
+
+  HTTP_ERROR_MAP = {
+    400 => BadRequestError,
+    401 => AuthenticationError,
+    403 => ForbiddenError,
+    404 => NotFoundError,
+    429 => RateLimitError,
+  }.freeze
+
+  def self.error_for(status, body, response)
+    klass = HTTP_ERROR_MAP.fetch(status) { status >= 500 ? ServerError : Error }
+    message = body.is_a?(Hash) ? body["message"] : body.to_s
+    klass.new(message, status: status, code: body.is_a?(Hash) ? body["code"] : nil, response: response)
+  end
+end

data/lib/pinterest/resources/audiences.rb

@@ -0,0 +1,41 @@
+module Pinterest
+  module Resources
+    class Audiences < Base
+      # @param ad_account_id [String]
+      # @param params [Hash] audience attributes (ad_account_id, audience_type, name, rule, …)
+      # @return [Hash]
+      def create(ad_account_id:, **params)
+        post("/ad_accounts/#{ad_account_id}/audiences", params)
+      end
+
+      # @param ad_account_id [String]
+      # @param bookmark [String, nil]
+      # @param page_size [Integer, nil]
+      # @param order [String, nil] "ASCENDING" or "DESCENDING"
+      # @param ownership_type [String, nil] "OWNED" or "RECEIVED"
+      # @param exclude_nca [Boolean, nil]
+      # @return [Hash] { "items" => [...], "bookmark" => "..." }
+      def list(ad_account_id:, bookmark: nil, page_size: nil, order: nil,
+               ownership_type: nil, exclude_nca: nil)
+        get("/ad_accounts/#{ad_account_id}/audiences",
+            { bookmark: bookmark, page_size: page_size, order: order,
+              ownership_type: ownership_type, exclude_nca: exclude_nca }.compact)
+      end
+
+      # @param ad_account_id [String]
+      # @param audience_id [String]
+      # @return [Hash]
+      def find(ad_account_id:, audience_id:)
+        get("/ad_accounts/#{ad_account_id}/audiences/#{audience_id}")
+      end
+
+      # @param ad_account_id [String]
+      # @param audience_id [String]
+      # @param params [Hash] fields to update
+      # @return [Hash]
+      def update(ad_account_id:, audience_id:, **params)
+        patch("/ad_accounts/#{ad_account_id}/audiences/#{audience_id}", params)
+      end
+    end
+  end
+end

data/lib/pinterest/resources/base.rb

@@ -0,0 +1,15 @@
+module Pinterest
+  module Resources
+    class Base
+      include Connection
+
+      def initialize(config)
+        @config = config
+      end
+
+      private
+
+      attr_reader :config
+    end
+  end
+end

data/lib/pinterest/resources/customer_list_uploads.rb

@@ -0,0 +1,40 @@
+module Pinterest
+  module Resources
+    # Handles multipart S3 upload lifecycle for customer list records.
+    # Workflow: create → (upload parts to S3 presigned URLs) → run
+    class CustomerListUploads < Base
+      # Request a multipart S3 upload for a customer list.
+      # Each part must be ≥ 5 MB except the final part.
+      #
+      # @param ad_account_id [String]
+      # @param customer_list_id [String]
+      # @param operation [String] "ADD" or "REMOVE"
+      # @param total_parts [Integer] number of S3 parts
+      # @return [Hash] { "customer_list_upload" => {...}, "s3_multipart_upload_data" => {...} }
+      def create(ad_account_id:, customer_list_id:, operation:, total_parts:)
+        post("/ad_accounts/#{ad_account_id}/customer_lists/#{customer_list_id}/uploads",
+             { operation: operation, total_parts: total_parts })
+      end
+
+      # @param ad_account_id [String]
+      # @param customer_list_id [String]
+      # @param customer_list_upload_id [String]
+      # @return [Hash]
+      def find(ad_account_id:, customer_list_id:, customer_list_upload_id:)
+        get("/ad_accounts/#{ad_account_id}/customer_lists/#{customer_list_id}" \
+            "/uploads/#{customer_list_upload_id}")
+      end
+
+      # Begin processing a customer list upload after all S3 parts are uploaded.
+      #
+      # @param ad_account_id [String]
+      # @param customer_list_id [String]
+      # @param customer_list_upload_id [String]
+      # @return [Hash]
+      def run(ad_account_id:, customer_list_id:, customer_list_upload_id:)
+        post("/ad_accounts/#{ad_account_id}/customer_lists/#{customer_list_id}" \
+             "/uploads/#{customer_list_upload_id}/run")
+      end
+    end
+  end
+end

data/lib/pinterest/resources/customer_lists.rb

@@ -0,0 +1,40 @@
+module Pinterest
+  module Resources
+    class CustomerLists < Base
+      # @param ad_account_id [String]
+      # @param bookmark [String, nil]
+      # @param page_size [Integer, nil]
+      # @param order [String, nil] "ASCENDING" or "DESCENDING"
+      # @param exclude_nca [Boolean, nil]
+      # @return [Hash] { "items" => [...], "bookmark" => "..." }
+      def list(ad_account_id:, bookmark: nil, page_size: nil, order: nil, exclude_nca: nil)
+        get("/ad_accounts/#{ad_account_id}/customer_lists",
+            { bookmark: bookmark, page_size: page_size,
+              order: order, exclude_nca: exclude_nca }.compact)
+      end
+
+      # @param ad_account_id [String]
+      # @param params [Hash] name, list_type, records, records_v2, is_nca
+      # @return [Hash]
+      def create(ad_account_id:, **params)
+        post("/ad_accounts/#{ad_account_id}/customer_lists", params)
+      end
+
+      # @param ad_account_id [String]
+      # @param customer_list_id [String]
+      # @return [Hash]
+      def find(ad_account_id:, customer_list_id:)
+        get("/ad_accounts/#{ad_account_id}/customer_lists/#{customer_list_id}")
+      end
+
+      # Append or remove records from an existing customer list.
+      # @param ad_account_id [String]
+      # @param customer_list_id [String]
+      # @param params [Hash] operation_type ("ADD"/"REMOVE"), records or records_v2
+      # @return [Hash]
+      def update(ad_account_id:, customer_list_id:, **params)
+        patch("/ad_accounts/#{ad_account_id}/customer_lists/#{customer_list_id}", params)
+      end
+    end
+  end
+end

data/lib/pinterest/resources/oauth.rb

@@ -0,0 +1,93 @@
+module Pinterest
+  module Resources
+    # Wraps POST /oauth/token, /oauth/token/revoke, and /oauth/conversion_token.
+    # Token-endpoint calls use HTTP Basic auth (client_id:client_secret).
+    # The conversion-token call requires a valid Bearer access_token.
+    class OAuth < Base
+      # Exchange an authorization code for access + refresh tokens.
+      #
+      # @param code [String] the code returned by the Pinterest OAuth redirect
+      # @param redirect_uri [String] must match the URI used in the auth request
+      # @param continuous_refresh [Boolean, nil] set true for apps created before
+      #   2025-09-25 to opt into the 60-day continuous refresh token
+      # @return [Hash] access_token, refresh_token, expires_in, scope, …
+      def exchange_code(code:, redirect_uri: config.redirect_uri, continuous_refresh: nil)
+        resp = post("/oauth/token",
+          {
+            grant_type: "authorization_code",
+            code: code,
+            redirect_uri: redirect_uri,
+            continuous_refresh: continuous_refresh
+          },
+          json: false,
+          basic_auth: true
+        )
+        config.access_token = resp["access_token"]
+        resp
+      end
+
+      # Refresh an existing access token using a continuous refresh token.
+      #
+      # @param refresh_token [String]
+      # @param scope [String, nil] space-separated scope string; omit to keep current scope
+      # @param continuous_refresh [Boolean, nil] same semantics as #exchange_code
+      # @return [Hash] new access_token, refresh_token, expires_in, …
+      def refresh(refresh_token:, scope: nil, continuous_refresh: nil)
+        resp = post("/oauth/token",
+          { grant_type: "refresh_token",
+            refresh_token: refresh_token,
+            scope: scope,
+            continuous_refresh: continuous_refresh
+          },
+          json: false,
+          basic_auth: true
+        )
+        config.access_token = resp["access_token"]
+        resp
+      end
+
+      # Generate a long-lived conversion API token from the current access token.
+      # Requires config.access_token to be set (Bearer auth).
+      #
+      # @return [Hash] access_token, token_type: "conversion"
+      def conversion_token
+        post("/oauth/conversion_token", {})
+      end
+
+      # Revoke an access or refresh token.
+      # Only tokens issued for system users are supported.
+      #
+      # @param token [String] the token to revoke
+      # @param token_type_hint [String, nil] "access_token" or "refresh_token"
+      # @return [nil]
+      def revoke(token:, token_type_hint: nil)
+        post("/oauth/token/revoke",
+          {
+            token: token,
+            token_type_hint: token_type_hint
+          },
+          json: false, basic_auth: true
+        )
+      end
+
+      # Build the authorization URL users visit to grant permissions.
+      #
+      # @param redirect_uri [String]
+      # @param scope [Array<String>, String] required scopes
+      # @param state [String] CSRF token you generate and later verify
+      # @param response_type [String] always "code" for the auth-code flow
+      # @return [String] full URL
+      def authorization_url(scope: config.default_scope, redirect_uri: config.redirect_uri, state: SecureRandom.hex(16), response_type: "code")
+        scope_str = Array(scope).join(" ")
+        params = URI.encode_www_form(
+          response_type: response_type,
+          client_id: config.client_id,
+          redirect_uri: redirect_uri,
+          scope: scope_str,
+          state: state
+        )
+        "#{config.auth_url}?#{params}"
+      end
+    end
+  end
+end

data/lib/pinterest/response.rb

@@ -0,0 +1,15 @@
+module Pinterest
+  class Response
+    attr_reader :status, :headers, :body
+
+    def initialize(faraday_response)
+      @status  = faraday_response.status
+      @headers = faraday_response.headers
+      @body    = faraday_response.body
+    end
+
+    def success?
+      status.between?(200, 299)
+    end
+  end
+end

data/lib/pinterest/version.rb

@@ -0,0 +1,3 @@
+module Pinterest
+  VERSION = "0.1.0"
+end

data/lib/pinterest-ads.rb

@@ -0,0 +1 @@
+require_relative "pinterest"

data/lib/pinterest.rb

@@ -0,0 +1,28 @@
+require_relative "pinterest/version"
+require_relative "pinterest/configuration"
+require_relative "pinterest/error"
+require_relative "pinterest/response"
+require_relative "pinterest/connection"
+require_relative "pinterest/client"
+
+module Pinterest
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Configure the gem globally.
+    #
+    #   Pinterest.configure do |c|
+    #     c.client_id     = ENV["PINTEREST_CLIENT_ID"]
+    #     c.client_secret = ENV["PINTEREST_CLIENT_SECRET"]
+    #   end
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/pinterest-ads.gemspec

@@ -0,0 +1,21 @@
+require_relative "lib/pinterest/version"
+
+Gem::Specification.new do |spec|
+  spec.name    = "pinterest-ads"
+  spec.version = Pinterest::VERSION
+  spec.authors = ["johndavid400"]
+  spec.summary = "Ruby wrapper for the Pinterest REST API v5"
+  spec.homepage = "https://github.com/johndavid400/pinterest"
+  spec.license  = "MIT"
+
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.files = Dir["lib/**/*.rb", "pinterest-ads.gemspec", "LICENSE", "README.md"]
+
+  spec.add_dependency "faraday",          "~> 2.0"
+  spec.add_dependency "faraday-net_http", "~> 3.0"
+
+  spec.add_development_dependency "rspec",    "~> 3.13"
+  spec.add_development_dependency "webmock",  "~> 3.23"
+  spec.add_development_dependency "dotenv",   "~> 3.0"
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: pinterest-ads
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- johndavid400
+bindir: bin
+cert_chain: []
+date: 1980-01-02 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-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  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'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/pinterest-ads.rb
+- lib/pinterest.rb
+- lib/pinterest/client.rb
+- lib/pinterest/configuration.rb
+- lib/pinterest/connection.rb
+- lib/pinterest/error.rb
+- lib/pinterest/resources/audiences.rb
+- lib/pinterest/resources/base.rb
+- lib/pinterest/resources/customer_list_uploads.rb
+- lib/pinterest/resources/customer_lists.rb
+- lib/pinterest/resources/oauth.rb
+- lib/pinterest/response.rb
+- lib/pinterest/version.rb
+- pinterest-ads.gemspec
+homepage: https://github.com/johndavid400/pinterest
+licenses:
+- MIT
+metadata: {}
+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.6.9
+specification_version: 4
+summary: Ruby wrapper for the Pinterest REST API v5
+test_files: []