buzzrb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 77debe2be42e0aaef64398c094531219d7a7bebaa5be3855035f8047f7ff5807
+  data.tar.gz: 4d34d129f1d710eb5f5f87a849aefe0853a91c4be6659f2161610feb32b44656
+SHA512:
+  metadata.gz: 88998110007260bf612ece0a21f5674f2d6ecb87db008ea183ec0ecba4c32a0d42f49038b1552ed97d03ae5b4155ff2b37ebe6def2521f7fe3beeda82ae777c8
+  data.tar.gz: 81d7ef463ce8eda9c599932037c5bd7236e9907d2d38831baadcc4ddec7aecaa581163c0a928d4b309309d1cc84b8f9fef6704f36b05fb76a29b1e4bde2e07b5

data/LICENSE.md

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright © 2026 swlkr
+
+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/buzzrb.gemspec

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "lib/buzz/version"
+
+Gem::Specification.new do |spec|
+  spec.name    = "buzzrb"
+  spec.version = Buzz::VERSION
+  spec.authors = ["Letterpress"]
+  spec.summary = "Ruby client for the Buzz/Freewheel Advertiser API v2.0"
+  spec.homepage = "https://github.com/getletterpress/buzzrb"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0"
+
+  spec.files = Dir["lib/**/*.rb"] + ["buzzrb.gemspec", "LICENSE.md"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "webrick", "~> 1.8"
+end

data/lib/buzz/client.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Buzz
+  class Client
+    attr_reader :config, :cookie_jar
+
+    def initialize(buzz_key: nil, email: nil, password: nil, **options)
+      @config = if buzz_key
+        Configuration.new.tap do |c|
+          c.buzz_key = buzz_key
+          c.email = email
+          c.password = password
+          options.each { |k, v| c.public_send(:"#{k}=", v) }
+        end
+      else
+        Buzz.configuration.dup
+      end
+      @config.validate!
+      @cookie_jar = CookieJar.new
+      @http = nil
+      @authenticated = false
+      @mutex = Mutex.new
+    end
+
+    def get(path, params = {})
+      request(:get, path, params: params)
+    end
+
+    def post(path, body = {})
+      request(:post, path, body: body)
+    end
+
+    def put(path, body = {})
+      request(:put, path, body: body)
+    end
+
+    def delete(path, params = {})
+      request(:delete, path, params: params)
+    end
+
+    def authenticate
+      uri = build_uri("/rest/v2/authenticate")
+      body = { email: config.email, password: config.password }
+      body[:account_id] = config.account_id if config.account_id
+
+      req = build_request(:post, uri)
+      req.body = JSON.generate(body)
+
+      response = execute(uri, req)
+
+      unless response.success?
+        raise AuthenticationError.new(
+          "Authentication failed: #{response.body}",
+          status: response.status,
+          body: response.data
+        )
+      end
+
+      @authenticated = true
+
+      if config.keep_logged_in
+        keep_logged_in
+      end
+
+      response
+    end
+
+    def authenticated?
+      @authenticated
+    end
+
+    # Resource accessors
+    def advertisers
+      Resources::Advertiser.new(self)
+    end
+
+    def campaigns
+      Resources::Campaign.new(self)
+    end
+
+    def line_items
+      Resources::LineItem.new(self)
+    end
+
+    def creatives
+      Resources::Creative.new(self)
+    end
+
+    def segments
+      Resources::Segment.new(self)
+    end
+
+    def targeting
+      Resources::Targeting.new(self)
+    end
+
+    def creative_assets
+      Resources::CreativeAsset.new(self)
+    end
+
+    def creative_line_items(line_item_id)
+      Resources::CreativeLineItem.new(self, line_item_id)
+    end
+
+    def reporting
+      Resources::Reporting.new(self)
+    end
+
+    def search(query:, types: nil)
+      params = { q: query }
+      params[:entity_types] = Array(types).map(&:to_s).join(",") if types
+      get("/rest/v2/search", params)
+    end
+
+    private
+
+    def keep_logged_in
+      uri = build_uri("/rest/v2/authenticate/keep_logged_in")
+      req = build_request(:post, uri)
+      req.body = JSON.generate({})
+      execute(uri, req)
+    end
+
+    def request(method, path, params: {}, body: nil)
+      ensure_authenticated
+
+      uri = build_uri(path, params)
+      req = build_request(method, uri)
+      req.body = JSON.generate(body) if body
+
+      response = execute(uri, req)
+
+      if response.status == 401
+        @authenticated = false
+        authenticate
+        uri = build_uri(path, params)
+        req = build_request(method, uri)
+        req.body = JSON.generate(body) if body
+        response = execute(uri, req)
+      end
+
+      handle_errors(response)
+      response
+    end
+
+    def ensure_authenticated
+      authenticate unless @authenticated
+    end
+
+    def build_uri(path, params = {})
+      uri = URI.parse("#{config.base_url}#{path}")
+      if params && !params.empty?
+        query = params.map { |k, v| "#{URI.encode_www_form_component(k)}=#{URI.encode_www_form_component(v)}" }
+        uri.query = query.join("&")
+      end
+      uri
+    end
+
+    def build_request(method, uri)
+      klass = case method
+              when :get    then Net::HTTP::Get
+              when :post   then Net::HTTP::Post
+              when :put    then Net::HTTP::Put
+              when :delete then Net::HTTP::Delete
+              end
+
+      req = klass.new(uri)
+      req["Content-Type"] = "application/json"
+      req["Accept"] = "application/json"
+      req["X-Timezone"] = config.timezone if config.timezone
+
+      cookie = cookie_jar.cookie_header(uri)
+      req["Cookie"] = cookie if cookie
+
+      req
+    end
+
+    def execute(uri, req)
+      http = connection_for(uri)
+      raw = http.request(req)
+
+      # Parse cookies from response
+      if raw.get_fields("Set-Cookie")
+        raw.get_fields("Set-Cookie").each do |cookie_str|
+          cookie_jar.parse(cookie_str, uri)
+        end
+      end
+
+      Response.new(raw)
+    end
+
+    def connection_for(uri)
+      @mutex.synchronize do
+        if @http.nil? || !@http.started?
+          @http = Net::HTTP.new(uri.host, uri.port)
+          @http.use_ssl = uri.scheme == "https"
+          @http.open_timeout = config.open_timeout
+          @http.read_timeout = config.read_timeout
+          @http.keep_alive_timeout = 30
+          @http.start
+        end
+        @http
+      end
+    end
+
+    def handle_errors(response)
+      case response.status
+      when 200..299
+        # success
+      when 400
+        raise ValidationError.new(error_message(response), status: 400, body: response.data)
+      when 401
+        raise AuthenticationError.new(error_message(response), status: 401, body: response.data)
+      when 404
+        raise NotFoundError.new(error_message(response), status: 404, body: response.data)
+      when 429
+        retry_after = response.headers["retry-after"]&.first&.to_i
+        raise RateLimitError.new(error_message(response), status: 429, body: response.data, retry_after: retry_after)
+      when 500..599
+        raise ServerError.new(error_message(response), status: response.status, body: response.data)
+      else
+        raise Error.new(error_message(response), status: response.status, body: response.data)
+      end
+    end
+
+    def error_message(response)
+      if response.data.is_a?(Hash) && response.data["message"]
+        response.data["message"]
+      elsif response.data.is_a?(Hash) && response.data["detail"]
+        response.data["detail"]
+      else
+        "HTTP #{response.status}"
+      end
+    end
+  end
+end

data/lib/buzz/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Buzz
+  class Configuration
+    attr_accessor :buzz_key, :email, :password, :keep_logged_in,
+                  :account_id, :timezone, :open_timeout, :read_timeout
+    attr_writer :base_url
+
+    def initialize
+      @keep_logged_in = true
+      @open_timeout = 10
+      @read_timeout = 30
+    end
+
+    def base_url
+      @base_url || "https://#{buzz_key}.api.beeswax.com"
+    end
+
+    def validate!
+      raise ArgumentError, "buzz_key is required" unless buzz_key && !buzz_key.empty?
+      raise ArgumentError, "email is required" unless email && !email.empty?
+      raise ArgumentError, "password is required" unless password && !password.empty?
+    end
+  end
+end

data/lib/buzz/cookie_jar.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "uri"
+require "time"
+
+module Buzz
+  class CookieJar
+    Cookie = Struct.new(:name, :value, :domain, :path, :expires, :secure, :httponly, keyword_init: true)
+
+    def initialize
+      @cookies = {}
+      @mutex = Mutex.new
+    end
+
+    def parse(set_cookie_header, request_uri)
+      return unless set_cookie_header
+
+      headers = set_cookie_header.is_a?(Array) ? set_cookie_header : [set_cookie_header]
+      uri = request_uri.is_a?(URI) ? request_uri : URI.parse(request_uri)
+
+      @mutex.synchronize do
+        headers.each do |header|
+          cookie = parse_cookie(header, uri)
+          @cookies[cookie.name] = cookie if cookie
+        end
+      end
+    end
+
+    def cookie_header(uri)
+      uri = uri.is_a?(URI) ? uri : URI.parse(uri)
+      now = Time.now
+
+      @mutex.synchronize do
+        matching = @cookies.values.select do |cookie|
+          next false if cookie.expires && cookie.expires < now
+          next false if cookie.secure && uri.scheme != "https"
+          path_matches?(uri.path, cookie.path)
+        end
+
+        return nil if matching.empty?
+        matching.map { |c| "#{c.name}=#{c.value}" }.join("; ")
+      end
+    end
+
+    def clear
+      @mutex.synchronize { @cookies.clear }
+    end
+
+    def empty?
+      @mutex.synchronize { @cookies.empty? }
+    end
+
+    def size
+      @mutex.synchronize { @cookies.size }
+    end
+
+    private
+
+    def parse_cookie(header, uri)
+      parts = header.split(";").map(&:strip)
+      return nil if parts.empty?
+
+      name_value = parts.shift
+      eq_index = name_value.index("=")
+      return nil unless eq_index
+
+      name = name_value[0...eq_index].strip
+      value = name_value[(eq_index + 1)..].strip
+      return nil if name.empty?
+
+      attrs = { name: name, value: value, domain: uri.host, path: "/", secure: false, httponly: false }
+
+      parts.each do |part|
+        key, val = part.split("=", 2).map(&:strip)
+        case key.downcase
+        when "domain"
+          attrs[:domain] = val&.delete_prefix(".") if val
+        when "path"
+          attrs[:path] = val if val
+        when "expires"
+          attrs[:expires] = Time.parse(val) rescue nil if val
+        when "max-age"
+          attrs[:expires] = Time.now + val.to_i if val
+        when "secure"
+          attrs[:secure] = true
+        when "httponly"
+          attrs[:httponly] = true
+        end
+      end
+
+      Cookie.new(**attrs)
+    end
+
+    def path_matches?(request_path, cookie_path)
+      request_path = "/" if request_path.nil? || request_path.empty?
+      cookie_path = "/" if cookie_path.nil? || cookie_path.empty?
+      request_path.start_with?(cookie_path)
+    end
+  end
+end

data/lib/buzz/error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Buzz
+  class Error < StandardError
+    attr_reader :status, :body
+
+    def initialize(message = nil, status: nil, body: nil)
+      @status = status
+      @body = body
+      super(message)
+    end
+  end
+
+  class AuthenticationError < Error; end
+  class RateLimitError < Error
+    attr_reader :retry_after
+
+    def initialize(message = nil, status: nil, body: nil, retry_after: nil)
+      @retry_after = retry_after
+      super(message, status: status, body: body)
+    end
+  end
+  class NotFoundError < Error; end
+  class ValidationError < Error; end
+  class ServerError < Error; end
+end

data/lib/buzz/paginator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Buzz
+  class Paginator
+    include Enumerable
+
+    attr_reader :response
+
+    def initialize(client, path, params = {})
+      @client = client
+      @path = path
+      @params = params
+      @response = nil
+    end
+
+    def each_page
+      return enum_for(:each_page) unless block_given?
+
+      @response = @client.get(@path, @params)
+      yield @response
+
+      while @response.next_url
+        next_path = URI.parse(@response.next_url).path
+        next_params = parse_query(URI.parse(@response.next_url).query)
+        @response = @client.get(next_path, next_params)
+        yield @response
+      end
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      each_page do |page|
+        results = page.results || []
+        results.each(&block)
+      end
+    end
+
+    def to_a
+      entries = []
+      each { |item| entries << item }
+      entries
+    end
+
+    private
+
+    def parse_query(query_string)
+      return {} if query_string.nil? || query_string.empty?
+      URI.decode_www_form(query_string).to_h.transform_keys(&:to_sym)
+    end
+  end
+end

data/lib/buzz/resource.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Buzz
+  class Resource
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def list(params = {})
+      Paginator.new(client, resource_path, params)
+    end
+
+    def find(id)
+      response = client.get("#{resource_path}/#{id}")
+      response.data
+    end
+
+    def create(attributes = {})
+      response = client.post(resource_path, attributes)
+      response.data
+    end
+
+    def update(id, attributes = {})
+      response = client.put("#{resource_path}/#{id}", attributes)
+      response.data
+    end
+
+    def delete(id)
+      response = client.delete("#{resource_path}/#{id}")
+      response.data
+    end
+
+    private
+
+    def resource_path
+      raise NotImplementedError, "#{self.class} must implement #resource_path"
+    end
+  end
+end

data/lib/buzz/resources/advertiser.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class Advertiser < Resource
+      private
+
+      def resource_path
+        "/rest/v2/advertisers"
+      end
+    end
+  end
+end

data/lib/buzz/resources/campaign.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class Campaign < Resource
+      private
+
+      def resource_path
+        "/rest/v2/campaigns"
+      end
+    end
+  end
+end

data/lib/buzz/resources/creative.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class Creative < Resource
+      private
+
+      def resource_path
+        "/rest/v2/creatives"
+      end
+    end
+  end
+end

data/lib/buzz/resources/creative_asset.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class CreativeAsset < Resource
+      private
+
+      def resource_path
+        "/rest/v2/creative-assets"
+      end
+    end
+  end
+end

data/lib/buzz/resources/creative_line_item.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class CreativeLineItem
+      attr_reader :client, :line_item_id
+
+      def initialize(client, line_item_id)
+        @client = client
+        @line_item_id = line_item_id
+      end
+
+      def list(params = {})
+        Paginator.new(client, base_path, params)
+      end
+
+      def create(attributes = {})
+        response = client.post(base_path, attributes)
+        response.data
+      end
+
+      def find(id)
+        response = client.get("#{base_path}/#{id}")
+        response.data
+      end
+
+      def delete(id)
+        response = client.delete("#{base_path}/#{id}")
+        response.data
+      end
+
+      private
+
+      def base_path
+        "/rest/v2/line-items/#{line_item_id}/creatives"
+      end
+    end
+  end
+end

data/lib/buzz/resources/line_item.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class LineItem < Resource
+      private
+
+      def resource_path
+        "/rest/v2/line-items"
+      end
+    end
+  end
+end

data/lib/buzz/resources/reporting.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class Reporting
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      # Query performance data (spend, impressions, clicks, etc.)
+      def query(dimensions: [], metrics: [], **params)
+        body = { dimensions: dimensions, metrics: metrics }.merge(params)
+        response = client.post("/rest/v2/report-data", body)
+        response.data["results"]
+      end
+
+      # CRUD on saved report definitions
+      def list(params = {})
+        Paginator.new(client, "/rest/v2/reports", params)
+      end
+
+      def find(id)
+        client.get("/rest/v2/reports/#{id}").data
+      end
+
+      def create(attributes = {})
+        client.post("/rest/v2/reports", attributes).data
+      end
+
+      def delete(id)
+        client.delete("/rest/v2/reports/#{id}").data
+      end
+    end
+  end
+end

data/lib/buzz/resources/search.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class Search < Resource
+      private
+
+      def resource_path
+        "/rest/v2/search"
+      end
+    end
+  end
+end

data/lib/buzz/resources/segment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class Segment < Resource
+      private
+
+      def resource_path
+        "/rest/v2/segments"
+      end
+    end
+  end
+end

data/lib/buzz/resources/targeting.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Buzz
+  module Resources
+    class Targeting < Resource
+      private
+
+      def resource_path
+        "/rest/v2/targeting-expressions"
+      end
+    end
+  end
+end

data/lib/buzz/response.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Buzz
+  class Response
+    attr_reader :status, :headers, :body, :data
+
+    def initialize(http_response)
+      @status = http_response.code.to_i
+      @headers = http_response.to_hash
+      @body = http_response.body
+      @data = parse_body
+    end
+
+    def success?
+      status >= 200 && status < 300
+    end
+
+    def results
+      data["results"] if data.is_a?(Hash)
+    end
+
+    def count
+      data["count"] if data.is_a?(Hash)
+    end
+
+    def next_url
+      data["next"] if data.is_a?(Hash)
+    end
+
+    def previous_url
+      data["previous"] if data.is_a?(Hash)
+    end
+
+    private
+
+    def parse_body
+      return nil if body.nil? || body.empty?
+      JSON.parse(body)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/buzz/version.rb

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

data/lib/buzz.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "buzz/version"
+require_relative "buzz/configuration"
+require_relative "buzz/error"
+require_relative "buzz/cookie_jar"
+require_relative "buzz/response"
+require_relative "buzz/paginator"
+require_relative "buzz/resource"
+require_relative "buzz/resources/advertiser"
+require_relative "buzz/resources/campaign"
+require_relative "buzz/resources/line_item"
+require_relative "buzz/resources/creative"
+require_relative "buzz/resources/segment"
+require_relative "buzz/resources/targeting"
+require_relative "buzz/resources/creative_asset"
+require_relative "buzz/resources/creative_line_item"
+require_relative "buzz/resources/search"
+require_relative "buzz/resources/reporting"
+require_relative "buzz/client"
+
+module Buzz
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: buzzrb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Letterpress
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- buzzrb.gemspec
+- lib/buzz.rb
+- lib/buzz/client.rb
+- lib/buzz/configuration.rb
+- lib/buzz/cookie_jar.rb
+- lib/buzz/error.rb
+- lib/buzz/paginator.rb
+- lib/buzz/resource.rb
+- lib/buzz/resources/advertiser.rb
+- lib/buzz/resources/campaign.rb
+- lib/buzz/resources/creative.rb
+- lib/buzz/resources/creative_asset.rb
+- lib/buzz/resources/creative_line_item.rb
+- lib/buzz/resources/line_item.rb
+- lib/buzz/resources/reporting.rb
+- lib/buzz/resources/search.rb
+- lib/buzz/resources/segment.rb
+- lib/buzz/resources/targeting.rb
+- lib/buzz/response.rb
+- lib/buzz/version.rb
+homepage: https://github.com/getletterpress/buzzrb
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Ruby client for the Buzz/Freewheel Advertiser API v2.0
+test_files: []