squake 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7860b4b9cfbf3110355582ab95ce9faee0055fc6ea852b00093703fbcf8f7c8d
+  data.tar.gz: 6f05154a58469f7f52f9730bf808a3005961b7ba29e7f6ce8fe47e47b27cc651
+SHA512:
+  metadata.gz: d2065bbbe6bbbffa5067acf0810dbfe2c3ef32b50b5bce14b949f170a138f29ec16d2897093d9305af615e768ebcaa6da24873660572c24141e09f11b896cf08
+  data.tar.gz: 53f6a57201c32df605f6d30932baa4408bc3eafd7c02fb6f2dff6f55d0313c1e0b0f501980aa93e17bcea5ecd3bc11491f81639d138aa4c60005e62237689e92

data/README.md

@@ -0,0 +1,100 @@
+# SQUAKE
+
+Find the documentation here: [docs](https://docs.squake.earth/).
+
+## Installation
+
+Via git:
+
+```ruby
+# Gemfile
+
+gem 'squake', git: 'git@github.com:squake-earth/squake-ruby'
+```
+
+Via rubygems:
+
+```ruby
+# Gemfile
+
+gem 'squake', '~> 0.1.0'
+```
+
+## Auth
+
+An API Key can be generated on the [dashboard](https://dashboard.squake.earth/.)
+You need a different API Key for production and sandbox.
+
+## Functionality
+
+* compute emission values
+* request a price quote (with a product id)
+* place a purchase order (with a price quote id)
+* get a list of all available products (includes price information)
+
+## Usage
+
+Calculate emissions and include a price quote:
+
+```ruby
+config = Squake::Config.new(
+  api_key: 'Your API Key',     # required
+  sandbox_mode: true,          # optional, default: true
+  keep_alive_timeout: 30,      # optional, default: 30
+  logger: Logger.new($stdout), # optional, default: Logger.new($stdout)
+  enforced_api_base: nil,      # optional, default: nil. If given, overrides the API base URL.
+)
+
+# the SQUAKE client emits canonical log lines, e.g.
+#   Request started http_method=get http_path=/api/v2/calculations
+client = Squake::Client.new(config: config)
+
+# Find all available item types and methodologies here:
+#   https://docs-v2.squake.earth/group/endpoint-calculations
+items = [
+  {
+    type: 'flight',
+    methodology: 'ICAO',
+    origin: 'BER',
+    destination: 'SIN',
+    booking_class: 'economy',
+    number_of_travellers: 2,
+    aircraft_type: '350',
+    external_reference: 'booking-id',
+  }
+]
+
+# returns Squake::Model::Pricing
+pricing = Squake::CalculationWithPricing.quote(
+  client: client,        # required
+  items: items,          # required
+  product: 'product-id', # required
+  currency: 'EUR',       # optional, default: 'EUR'
+  carbon_unit: 'gram',   # optional, default: 'gram', other options: 'kilogram', 'tonne'
+)
+```
+
+Place a purchase order; by default the library injects a `SecureRandom.uuid` as `external_reference` to ensure idempotency, i.e. you can safely retry the request if it fails.
+
+```ruby
+uuid = SecureRandom.uuid
+
+# returns Squake::Model::Purchase
+purchase = Squake::Purchase.create(
+  client: client,           # required
+  pricing: pricing.id,      # required, from above
+  external_reference: uuid, # optional, default: SecureRandom.uuid, used for idempotency, if given, MUST be unique
+)
+
+# retrieve the purchase later
+Squake::Purchase.retrieve(
+  client: client,  # required
+  id: purchase.id, # required
+)
+
+# within 14 days, you can cancel the purchase worry-free
+Squake::Purchase.cancel(
+  client: client,  # required
+  id: purchase.id, # required
+)
+```

data/lib/squake/api_error.rb

@@ -0,0 +1,17 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Squake
+  class APIError < StandardError
+    extend T::Sig
+
+    sig { returns(Squake::Response) }
+    attr_reader :response
+
+    sig { params(response: Squake::Response).void }
+    def initialize(response:)
+      @response = response
+      super(T.must(response.error_message))
+    end
+  end
+end

data/lib/squake/calculation_with_pricing.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+# https://docs-v2.squake.earth/group/endpoint-combined-calculation-pricing
+module Squake
+  class CalculationWithPricing
+    extend T::Sig
+
+    ENDPOINT = T.let('/v2/calculations-with-pricing', String)
+
+    sig do
+      params(
+        client: Squake::Client,
+        items: T::Array[Squake::Model::Items::BaseType],
+        product: String,
+        currency: String,
+        carbon_unit: String,
+        expand: T::Array[String],
+      ).returns(Squake::Model::Pricing)
+    end
+    def self.quote(client:, items:, product:, currency: 'EUR', carbon_unit: 'gram', expand: [])
+      result = client.call(
+        path: ENDPOINT,
+        method: :post,
+        params: {
+          items: items.map(&:serialize),
+          product: product,
+          currency: currency,
+          carbon_unit: carbon_unit,
+          expand: expand,
+        },
+      )
+      raise Squake::APIError.new(response: result) unless result.success?
+
+      Squake::Model::Pricing.from_api_response(
+        T.cast(result.body, T::Hash[Symbol, T.untyped]),
+      )
+    end
+  end
+end

data/lib/squake/client.rb

@@ -0,0 +1,132 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'oj'
+
+module Squake
+  class Client
+    extend T::Sig
+
+    JsonResponseBody = T.type_alias do
+      T.any(
+        T::Array[T::Hash[Symbol, T.untyped]],
+        T::Hash[Symbol, T.untyped],
+      )
+    end
+
+    sig { params(config: Squake::Config).void }
+    def initialize(config:)
+      @config = config
+    end
+
+    sig do
+      params(
+        path: String,
+        headers: T::Hash[String, String],
+        method: Symbol,
+        params: T.nilable(T::Hash[Symbol, String]),
+        api_base: T.nilable(String),
+        api_key: T.nilable(String),
+      ).returns(Squake::Response)
+    end
+    def call(path:, headers: {}, method: :get, params: nil, api_base: nil, api_key: nil)
+      execute_request(
+        method: method,
+        path: path,
+        headers: headers,
+        params: params,
+        api_base: api_base,
+        api_key: api_key,
+      )
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+    sig do
+      params(
+        method: Symbol,
+        path: String,
+        headers: T::Hash[String, String],
+        params: T.nilable(T::Hash[Symbol, String]),
+        api_base: T.nilable(String),
+        api_key: T.nilable(String),
+      ).returns(Squake::Response)
+    end
+    private def execute_request(method:, path:, headers: {}, params: nil, api_base: nil, api_key: nil)
+      api_base ||= @config.api_base
+      api_key ||= @config.api_key
+
+      body_params = nil
+      query_params = nil
+      case method
+      when :get, :head, :delete
+        query_params = params
+      when :post
+        body_params = params
+      else
+        raise "Unrecognized HTTP method: #{method}. Expected one of: get, head, delete, post"
+      end
+
+      headers = request_headers(api_key).update(headers)
+      query = query_params ? Util.encode_parameters(query_params) : nil
+      body = body_params ? ::Oj.dump(body_params) : nil
+      sanitized_path = path[0] == '/' ? path : "/#{path}"
+      uri = URI.parse(api_base + sanitized_path)
+
+      connection = connection(uri)
+
+      method_name = method.to_s.upcase
+      has_response_body = method_name != 'HEAD'
+      request = Net::HTTPGenericRequest.new(
+        method_name,
+        (body_params ? true : false),
+        has_response_body,
+        (query ? [uri.path, query].join('?') : uri.path),
+        headers,
+      )
+
+      # https://stripe.com/blog/canonical-log-lines
+      canonical_request_line = <<~TXT
+        Request started
+          http_method=#{request.method}
+          http_path=#{request.path}
+          http_headers=#{request.to_hash}
+      TXT
+      canonical_request_line.gsub!(api_key, 'API_KEY_REDACTED')
+      @config.logger.info(canonical_request_line)
+
+      result = connection.request(request, body)
+
+      Squake::Response.new(
+        original_request: request,
+        code: Integer(result.code),
+        body: try_parse_json(result.body),
+        headers: result.to_hash,
+      )
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+
+    sig { params(api_key: String).returns(T::Hash[String, String]) }
+    private def request_headers(api_key)
+      {
+        'Authorization' => "Bearer #{api_key}",
+        'Content-Type' => 'application/json',
+      }
+    end
+
+    sig { params(result_body: T.untyped).returns(JsonResponseBody) }
+    private def try_parse_json(result_body)
+      ::Oj.load(result_body, symbol_keys: true)
+    rescue ::Oj::ParseError, TypeError, JSON::ParserError, EncodingError => e
+      # in case of an error, Squake's response body is HTML not JSON
+      { 'error' => { 'message' => e.message, 'body' => result_body } }
+    end
+
+    sig { params(uri: URI::Generic).returns(Net::HTTP) }
+    private def connection(uri)
+      connection = Net::HTTP.new(uri.host, uri.port)
+      connection.keep_alive_timeout = @config.keep_alive_timeout
+      connection.use_ssl = uri.scheme == 'https'
+      connection
+    end
+  end
+end

data/lib/squake/config.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Squake
+  class Config < T::Struct
+    extend T::Sig
+
+    DEFAULT_BASE_URL = T.let('https://api.squake.earth', String)
+    SANDBOX_BASE_URL = T.let('https://api.sandbox.squake.earth', String)
+
+    const :api_key, String
+    const :keep_alive_timeout, Integer, default: 30
+    const :logger, Logger, factory: -> { Logger.new($stdout) }
+    const :sandbox_mode, T::Boolean, default: true
+    const :enforced_api_base, T.nilable(String)
+
+    sig { returns(String) }
+    def api_base
+      return T.must(enforced_api_base) unless enforced_api_base.nil?
+
+      sandbox_mode ? SANDBOX_BASE_URL : DEFAULT_BASE_URL
+    end
+  end
+end

data/lib/squake/model/items/base_type.rb

@@ -0,0 +1,13 @@
+# typed: strict
+
+module Squake
+  module Model
+    module Items
+      extend T::Helpers
+
+      BaseType = T.type_alias do
+        Squake::Model::Items::PrivateJet::Squake
+      end
+    end
+  end
+end

data/lib/squake/model/items/private_jet/squake.rb

@@ -0,0 +1,21 @@
+# typed: strict
+
+module Squake
+  module Model
+    module Items
+      module PrivateJet
+        class Squake < T::Struct
+          extend T::Sig
+
+          const :type, String, default: 'private_jet'
+          const :methodology, String, default: 'SQUAKE'
+          const :origin, String
+          const :destination, String
+          const :identifier, String
+          const :identifier_kind, String, default: 'ICAO'
+          const :external_reference, T.nilable(String)
+        end
+      end
+    end
+  end
+end

data/lib/squake/model/price.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Squake
+  module Model
+    class Price < T::Struct
+      extend T::Sig
+
+      const :id, String
+      const :product, String
+      const :unit_amount, BigDecimal
+      const :valid_from, T.nilable(Date)
+      const :carbon_unit, String
+      const :currency, String
+
+      sig { params(response_body: T::Hash[Symbol, T.untyped]).returns(Squake::Model::Price) }
+      def self.from_api_response(response_body)
+        product = response_body.fetch(:price, {})
+
+        Squake::Model::Price.new(
+          id: product.fetch(:id),
+          product: product.fetch(:product),
+          unit_amount: product.fetch(:unit_amount).to_d,
+          valid_from: Date.parse(product.fetch(:valid_from, nil)),
+          carbon_unit: product.fetch(:carbon_unit),
+          currency: product.fetch(:currency),
+        )
+      end
+    end
+  end
+end

data/lib/squake/model/pricing.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative 'price'
+require_relative 'product'
+
+module Squake
+  module Model
+    class Pricing < T::Struct
+      extend T::Sig
+
+      class Item < T::Struct
+        extend T::Sig
+        const :carbon_quantity, BigDecimal
+        const :carbon_unit, String
+        const :distance, BigDecimal
+        const :distance_unit, String
+        const :external_reference, T.nilable(String)
+        const :type, String
+        const :methodology, String
+      end
+
+      const :id, String
+      const :carbon_quantity, BigDecimal
+      const :carbon_unit, String
+      const :payment_link, T.nilable(String)
+      const :price, Squake::Model::Price
+      const :product, Squake::Model::Product
+      const :valid_until, Date
+      const :currency, String, default: 'EUR'
+      const :total, Integer
+      const :items, T::Array[Pricing::Item] # when constructing this, construct nested items first explicitly
+
+      sig { params(response_body: T::Hash[Symbol, T.untyped]).returns(Squake::Model::Pricing) }
+      def self.from_api_response(response_body)
+        price = Squake::Model::Price.from_api_response(response_body)
+        product = Squake::Model::Product.from_api_response(response_body)
+
+        items = response_body.fetch(:items, [])
+        items.map! do |item|
+          item[:carbon_quantity] = item.fetch(:carbon_quantity).to_d
+          item[:distance] = item.fetch(:distance).to_d
+          Item.new(item)
+        end
+
+        Squake::Model::Pricing.new(
+          id: response_body.fetch(:id),
+          items: items,
+          carbon_quantity: response_body.fetch(:carbon_quantity).to_d,
+          carbon_unit: response_body.fetch(:carbon_unit),
+          payment_link: response_body.fetch(:payment_link, nil),
+          price: price,
+          product: product,
+          valid_until: Date.parse(response_body.fetch(:valid_until, nil)),
+          currency: response_body.fetch(:currency),
+          total: response_body.fetch(:total),
+        )
+      end
+    end
+  end
+end

data/lib/squake/model/product.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Squake
+  module Model
+    class Product < T::Struct
+      extend T::Sig
+
+      const :id, String
+      const :title, String
+
+      sig { params(response_body: T::Hash[Symbol, T.untyped]).returns(Squake::Model::Product) }
+      def self.from_api_response(response_body)
+        product = response_body.fetch(:product, {})
+
+        Squake::Model::Product.new(
+          id: product.fetch(:id),
+          title: product.fetch(:title),
+        )
+      end
+    end
+  end
+end

data/lib/squake/model/purchase.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Squake
+  module Model
+    class Purchase < T::Struct
+      extend T::Sig
+
+      const :id, String
+      const :files, T::Array[String] # TODO: optional object, typed?
+      const :payment_method, String
+      const :state, String
+      const :metadata, T::Hash[Symbol, T.untyped], default: {}
+      const :checkout_page, T.nilable(T::Hash[Symbol, T.untyped])
+      const :carbon_quantity, BigDecimal
+      const :carbon_unit, String
+      const :total, Integer
+      const :currency, String
+      const :external_reference, T.nilable(String)
+
+      sig { params(response_body: T::Hash[Symbol, T.untyped]).returns(Squake::Model::Purchase) }
+      def self.from_api_response(response_body)
+        Squake::Model::Purchase.new(
+          id: response_body.fetch(:id),
+          files: response_body.fetch(:files),
+          payment_method: response_body.fetch(:payment_method),
+          state: response_body.fetch(:state),
+          metadata: response_body.fetch(:metadata),
+          checkout_page: response_body.fetch(:checkout_page, nil),
+          carbon_quantity: BigDecimal(response_body.fetch(:carbon_quantity).to_s),
+          carbon_unit: response_body.fetch(:carbon_unit),
+          total: response_body.fetch(:total),
+          currency: response_body.fetch(:currency),
+          external_reference: response_body.fetch(:external_reference, nil),
+        )
+      end
+    end
+  end
+end

data/lib/squake/products.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+# https://docs-v2.squake.earth/operation/operation-get-products
+module Squake
+  class Products
+    extend T::Sig
+
+    ENDPOINT = T.let('/v2/products', String)
+    DEFAULT_LOCALE = T.let('en', String)
+
+    sig do
+      params(
+        client: Squake::Client,
+        locale: String,
+        product_id: T.nilable(String),
+      ).returns(T::Array[Squake::Model::Product])
+    end
+    def self.get(client:, locale: DEFAULT_LOCALE, product_id: nil)
+      path = product_id.nil? ? ENDPOINT : "#{ENDPOINT}/#{product_id}"
+
+      result = client.call(
+        path: path,
+        method: :get,
+        params: {
+          locale: locale,
+        },
+      )
+      raise Squake::APIError.new(response: result) unless result.success?
+
+      Array(result.body).map do |product_data|
+        Squake::Model::Product.from_api_response({ product: product_data })
+      end
+    end
+  end
+end

data/lib/squake/purchase.rb

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+# https://docs-v2.squake.earth/operation/operation-post-purchases
+module Squake
+  class Purchase
+    extend T::Sig
+
+    ENDPOINT = T.let('/v2/purchases', String)
+
+    # rubocop:disable Metrics/ParameterLists,  Layout/LineLength
+    sig do
+      params(
+        client: Squake::Client,
+        pricing: String,
+        confirmation_document: T.nilable(T::Hash[Symbol, T.untyped]),
+        certificate_document: T.nilable(T::Hash[Symbol, T.untyped]),
+        metadata: T.nilable(T::Hash[Symbol, T.untyped]),
+        external_reference: String, # used for idempotency, if given, MUST be unique
+        expand: T::Array[String],
+      ).returns(Squake::Model::Purchase)
+    end
+    def self.create(client:, pricing:, confirmation_document: nil, certificate_document: nil, metadata: nil, external_reference: SecureRandom.uuid, expand: [])
+      result = client.call(
+        path: ENDPOINT,
+        method: :post,
+        params: {
+          pricing: pricing,
+          confirmation_document: confirmation_document,
+          certificate_document: certificate_document,
+          metadata: metadata,
+          external_reference: external_reference,
+          expand: expand,
+        },
+      )
+      raise Squake::APIError.new(response: result) unless result.success?
+
+      Squake::Model::Purchase.from_api_response(
+        T.cast(result.body, T::Hash[Symbol, T.untyped]),
+      )
+    end
+    # rubocop:enable Metrics/ParameterLists,  Layout/LineLength
+
+    sig do
+      params(
+        client: Squake::Client,
+        id: String,
+      ).returns(T.nilable(Squake::Model::Purchase))
+    end
+    def self.retrieve(client:, id:)
+      result = client.call(
+        path: "#{ENDPOINT}/#{id}",
+      )
+      return nil if result.code == 404
+      raise Squake::APIError.new(response: result) unless result.success?
+
+      Squake::Model::Purchase.from_api_response(
+        T.cast(result.body, T::Hash[Symbol, T.untyped]),
+      )
+    end
+
+    sig do
+      params(
+        client: Squake::Client,
+        id: String,
+      ).returns(T.nilable(Squake::Model::Purchase))
+    end
+    def self.cancel(client:, id:)
+      result = client.call(
+        path: "#{ENDPOINT}/#{id}/cancel",
+        method: :post,
+      )
+      raise Squake::APIError.new(response: result) unless result.success?
+
+      Squake::Model::Purchase.from_api_response(
+        T.cast(result.body, T::Hash[Symbol, T.untyped]),
+      )
+    end
+  end
+end

data/lib/squake/response.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'oj'
+
+module Squake
+  class Response < T::Struct
+    extend T::Sig
+
+    const :original_request, Net::HTTPGenericRequest
+    const :code, Integer
+    const :body, Squake::Client::JsonResponseBody
+    const :headers, T::Hash[String, T.untyped]
+
+    sig { returns(T::Boolean) }
+    def success?
+      code >= 200 && code < 300
+    end
+
+    sig { returns(T::Boolean) }
+    def failure?
+      !success?
+    end
+
+    sig { returns(T.nilable(Squake::APIError)) }
+    def error
+      return if success?
+
+      Squake::APIError.new(response: self)
+    end
+
+    sig { returns(T.nilable(String)) }
+    def error_message
+      return if success?
+
+      <<~TXT
+        Failed Request
+          http_code=#{code}
+          body=#{::Oj.dump(body)}
+          original_request_http_method=#{original_request.method}
+          original_request_http_path=#{original_request.path}
+      TXT
+    end
+  end
+end

data/lib/squake/util.rb

@@ -0,0 +1,29 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Squake
+  class Util
+    extend T::Sig
+
+    # Encodes a hash of parameters in a way that's suitable for use as query
+    # parameters in a URI or as form parameters in a request body. This mainly
+    # involves escaping special characters from parameter keys and values (e.g.
+    # `&`).
+    sig { params(params: T::Hash[Symbol, String]).returns(String) }
+    def self.encode_parameters(params)
+      params.map { |k, v| "#{url_encode(k.to_s)}=#{url_encode(v)}" }.join('&')
+    end
+
+    # Encodes a string in a way that makes it suitable for use in a set of
+    # query parameters in a URI or in a set of form parameters in a request
+    # body.
+    sig { params(key: String).returns(String) }
+    def self.url_encode(key)
+      CGI.escape(key.to_s).
+        # Don't use strict form encoding by changing the square bracket control
+        # characters back to their literals. This is fine by the server, and
+        # makes these parameter strings easier to read.
+        gsub('%5B', '[').gsub('%5D', ']')
+    end
+  end
+end

data/lib/squake/version.rb

@@ -0,0 +1,6 @@
+# typed: true
+# frozen_string_literal: true
+
+module Squake
+  VERSION = '0.1.0'
+end

data/lib/squake.rb

@@ -0,0 +1,7 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'oj'
+
+require_relative 'squake/version'

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: squake
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- 'Team SQUAKE :rocket:'
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-dbl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: spoom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides an interface for the SQUAKE API to calculate and compensate
+  carbon emissions.
+email: oss@squake.earth
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/squake.rb
+- lib/squake/api_error.rb
+- lib/squake/calculation_with_pricing.rb
+- lib/squake/client.rb
+- lib/squake/config.rb
+- lib/squake/model/items/base_type.rb
+- lib/squake/model/items/private_jet/squake.rb
+- lib/squake/model/price.rb
+- lib/squake/model/pricing.rb
+- lib/squake/model/product.rb
+- lib/squake/model/purchase.rb
+- lib/squake/products.rb
+- lib/squake/purchase.rb
+- lib/squake/response.rb
+- lib/squake/util.rb
+- lib/squake/version.rb
+homepage: https://github.com/squake-earth/squake-ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.13
+signing_key:
+specification_version: 4
+summary: The industry solution for sustainable travel and logistics.
+test_files: []