knockapi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df2a97ad8702bbb6843e12eeca370179e4ce14e1c591312d8bc6462c9114fd07
+  data.tar.gz: bdaae5b1b47ef4e022ff4fa81f59250705880801ef6075af337b41ee657ef79a
+SHA512:
+  metadata.gz: 799e436d7ca5514f82b76f789f7fcf031fb67ed1d5f2705b34c9313c3a9369b04b450bd72e4e18c1d29d4119cf65a353729a5102fabfb1be3ef3ade48a9bd047
+  data.tar.gz: aec1077db54be921685100263417cc360af0ede27c382282a0f117bf59bce26d41d1af7db4775dadfb7b19b27e3b53ceae1fab1c8b4c73b43f56dbd045ebc3a8

data/.gitignore

@@ -0,0 +1,49 @@
+*.gem
+*.rbc
+*.DS_Store
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/.ruby-version

@@ -0,0 +1 @@
+3.0.2

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    knockapi (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    parallel (1.20.1)
+    parser (3.0.2.0)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (13.0.6)
+    regexp_parser (2.1.1)
+    rexml (3.2.5)
+    rubocop (1.18.4)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.8.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.10.0)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.11.4)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.1.7)
+      rubocop (= 1.18.4)
+      rubocop-performance (= 1.11.4)
+    unicode-display_width (2.0.0)
+
+PLATFORMS
+  x86_64-darwin-19
+
+DEPENDENCIES
+  bundler (>= 2.0.1)
+  knockapi!
+  rake
+  standard
+
+BUNDLED WITH
+   2.2.22

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Knock Labs, Inc.
+
+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,151 @@
+# Knock Ruby library
+
+Knock API access for applications written in Ruby.
+
+## Documentation
+
+See the documentation for Ruby usage examples.
+
+## Installation
+
+```bash
+gem install knockapi
+```
+
+## Configuration
+
+To use the library you must provide a secret API key, provided in the Knock dashboard.
+
+You can set it as an environment variable:
+
+```bash
+KNOCK_API_KEY="sk_12345"
+```
+
+Or, you may set the key yourself in an initializer:
+
+```ruby
+# /config/initializers/knock.rb
+Knock.key = 'sk_12345'
+```
+
+## Usage
+
+### Identifying users
+
+```ruby
+require "knockapi"
+
+Knock.key = "sk_12345"
+
+Knock::Users.identify(
+  id: "jhammond",
+  data: {
+    name: "John Hammond",
+    email: "jhammond@ingen.net",
+  }
+)
+```
+
+### Sending notifies (triggering workflows)
+
+```ruby
+require "knockapi"
+
+Knock.key = "sk_12345"
+
+# The key of the workflow (from Knock dashboard)
+Knock::Workflows.trigger(
+  key: "dinosaurs-loose",
+  # user id of who performed the action
+  actor: "dnedry",
+  # list of user ids for who should receive the notif
+  recipients: ["jhammond", "agrant", "imalcolm", "esattler"],
+  # data payload to send through
+  data: {
+    type: "trex",
+    priority: 1,
+  },
+  # an optional key to provide to cancel a notify
+  cancellation_key: trigger_alert.id,
+)
+```
+
+### Retrieving users
+
+```ruby
+require "knockapi"
+
+Knock.key = "sk_12345"
+
+Knock::Users.get(id: "jhammond")
+```
+
+### Deleting users
+
+```ruby
+require "knockapi"
+
+Knock.key = "sk_12345"
+
+Knock::Users.delete(id: "jhammond")
+```
+
+### Preferences
+
+```ruby
+require "knockapi"
+Knock.key = "sk_12345"
+
+# Set an entire preference set
+Knock::Preferences.set(
+  user_id: "jhammond",
+  channel_types: { email: true, sms: false },
+  workflows: {
+    'dinosaurs-loose': {
+      channel_types: { email: false, in_app_feed: false }
+    }
+  }
+)
+
+# Get an entire preference set
+Knock::Preferences.get(user_id: "jhammond")
+```
+
+### Cancelling workflows
+
+```ruby
+require "knockapi"
+Knock.key = "sk_12345"
+
+Knock::Workflows.cancel(
+  key: "dinosaurs-loose",
+  cancellation_key: trigger_alert.id,
+  # Optionally, you can provide recipients to cancel for
+  recipients: ["jhammond"]
+)
+```
+
+### Signing JWTs
+
+You can use the `jwt` gem to sign JWTs easily. You will need to generate an environment specific signing key, which you can find in the Knock dashboard.
+
+If you're using a signing token you will need to pass this to your client to perform authentication. You can read more about [clientside authentication here](https://docs.knock.app/client-integration/authenticating-users).
+
+```ruby
+require 'jwt'
+
+secret = ENV['KNOCK_SIGNING_KEY']
+now = Time.now.to_i
+
+payload = {
+  # The subject of the token
+  sub: 'jhammond',
+  # When the token was issued
+  iat: now,
+  # Expire the token in 1 week
+  exp: now + (24 * 7 * 3600)
+}
+
+JWT.encode(payload, secret, 'RS256')
+```

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "knock"
+
+require "irb"
+IRB.start(__FILE__)

data/knockapi.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "knock/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "knockapi"
+  spec.version = Knock::VERSION
+  spec.authors = ["Knock Labs, Inc."]
+  spec.email = ["support@knock.app"]
+  spec.description = "API client for Knock"
+  spec.summary = "API client for Knock"
+  spec.homepage = "https://github.com/knocklabs/knock-ruby"
+  spec.license = "MIT"
+  spec.metadata = {
+    "documentation_uri" => "https://docs.knock.app"
+  }
+
+  spec.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", ">= 2.0.1"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "standard"
+
+  spec.required_ruby_version = ">= 2.5"
+end

data/lib/knock.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "knock/version"
+require "json"
+
+module Knock
+  API_HOSTNAME = ENV["KNOCK_API_HOSTNAME"] || "api.knock.app"
+
+  def self.key=(value)
+    Base.key = value
+  end
+
+  def self.key
+    Base.key
+  end
+
+  def self.key!
+    key || raise("Knock.key not set")
+  end
+
+  autoload :Base, "knock/base"
+  autoload :Client, "knock/client"
+
+  # Resources
+  autoload :Preferences, "knock/preferences"
+  autoload :Users, "knock/users"
+  autoload :Workflows, "knock/workflows"
+
+  # Errors
+  autoload :APIError, "knock/errors"
+  autoload :AuthenticationError, "knock/errors"
+  autoload :InvalidRequestError, "knock/errors"
+
+  key = ENV["KNOCK_API_KEY"]
+  Knock.key = key unless key.nil?
+
+  # Triggers the workflow with the given key
+  #
+  # @param [String] key The workflow key
+  # @param [String] actor The actor ID
+  # @param [Array<String>] recipients The recipient IDs
+  # @param [Hash] data The data to pass to the workflow
+  # @param [String] cancellation_key An optional key to identify this workflow
+  #  invocation for cancelling
+  # @param [String] tenant An optional tenant identifier
+  #
+  # @return [Hash] A workflow trigger result
+  def self.notify(**args)
+    Knock::Workflows.trigger(**args)
+  end
+end

data/lib/knock/base.rb

@@ -0,0 +1,11 @@
+module Knock
+  ## The Base class handles setting and reading the Knock API Key for authentication
+  module Base
+    attr_accessor :key
+
+    class << self
+      attr_writer :key
+      attr_reader :key
+    end
+  end
+end

data/lib/knock/client.rb

@@ -0,0 +1,116 @@
+module Knock
+  # A Net::HTTP based API client for interacting with the Knock API
+  module Client
+    include Kernel
+
+    def client
+      return @client if defined?(@client)
+
+      @client = Net::HTTP.new(Knock::API_HOSTNAME, 443)
+      @client.use_ssl = true
+
+      @client
+    end
+
+    def execute_request(request:)
+      response = client.request(request)
+
+      http_status = response.code.to_i
+      handle_error_response(response: response) if http_status >= 400
+
+      JSON.parse(response.body)
+    end
+
+    def get_request(path:, auth: false, params: {}, access_token: nil)
+      uri = URI(path)
+      uri.query = URI.encode_www_form(params) if params
+
+      request = Net::HTTP::Get.new(
+        uri.to_s,
+        "Content-Type" => "application/json"
+      )
+
+      request["Authorization"] = "Bearer #{access_token || Knock.key!}" if auth
+      request["User-Agent"] = user_agent
+      request
+    end
+
+    def post_request(path:, auth: false, idempotency_key: nil, body: nil)
+      request = Net::HTTP::Post.new(path, "Content-Type" => "application/json")
+      request.body = body.to_json if body
+      request["Authorization"] = "Bearer #{Knock.key!}" if auth
+      request["User-Agent"] = user_agent
+      request
+    end
+
+    def delete_request(path:, auth: false, params: {})
+      uri = URI(path)
+      uri.query = URI.encode_www_form(params) if params
+
+      request = Net::HTTP::Delete.new(
+        uri.to_s,
+        "Content-Type" => "application/json"
+      )
+
+      request["Authorization"] = "Bearer #{Knock.key!}" if auth
+      request["User-Agent"] = user_agent
+      request
+    end
+
+    def put_request(path:, auth: false, idempotency_key: nil, body: nil)
+      request = Net::HTTP::Put.new(path, "Content-Type" => "application/json")
+      request.body = body.to_json if body
+      request["Authorization"] = "Bearer #{Knock.key!}" if auth
+      request["User-Agent"] = user_agent
+      request
+    end
+
+    def user_agent
+      "Knock Ruby - v#{Knock::VERSION}"
+    end
+
+    def handle_error_response(response:)
+      http_status = response.code.to_i
+      json = JSON.parse(response.body)
+
+      case http_status
+      when 400
+        raise InvalidRequestError.new(
+          message: json["message"],
+          http_status: http_status,
+          request_id: response["x-request-id"]
+        )
+      when 401
+        raise AuthenticationError.new(
+          message: json["message"],
+          http_status: http_status,
+          request_id: response["x-request-id"]
+        )
+      when 404
+        raise APIError.new(
+          message: json["message"],
+          http_status: http_status,
+          request_id: response["x-request-id"]
+        )
+      when 422
+        message = json["message"]
+        errors = extract_error(json["errors"]) if json["errors"]
+        message += " (#{errors})" if errors
+
+        raise InvalidRequestError.new(
+          message: message,
+          http_status: http_status,
+          request_id: response["x-request-id"]
+        )
+      end
+    end
+
+    private
+
+    def extract_error(errors)
+      errors.map do |error|
+        "#{error["field"]}: #{error["message"]} (#{error["type"]})"
+      end.join("; ")
+    end
+  end
+end

data/lib/knock/errors.rb

@@ -0,0 +1,42 @@
+module Knock
+  class KnockError < StandardError
+    attr_reader :http_status
+    attr_reader :request_id
+
+    def initialize(message: nil, error: nil, error_description: nil, http_status: nil, request_id: nil)
+      @message = message
+      @error = error
+      @error_description = error_description
+      @http_status = http_status
+      @request_id = request_id
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "Status #{@http_status}, "
+      id_string = @request_id.nil? ? "" : " - request ID: #{@request_id}"
+
+      if @error && @error_description
+        error_string = "error: #{@error}, error_description: #{@error_description}"
+        "#{status_string}#{error_string}#{id_string}"
+      elsif @error
+        "#{status_string}#{@error}#{id_string}"
+      else
+        "#{status_string}#{@message}#{id_string}"
+      end
+    end
+  end
+
+  # APIError is a generic error that may be raised in cases where none of the
+  # other named errors cover the problem. It could also be raised in the case
+  # that a new error has been introduced in the API, but this version of the
+  # Ruby SDK doesn't know how to handle it.
+  class APIError < KnockError; end
+
+  # AuthenticationError is raised when invalid credentials are used to connect
+  # to Knock's servers.
+  class AuthenticationError < KnockError; end
+
+  # InvalidRequestError is raised when a request is initiated with invalid
+  # parameters.
+  class InvalidRequestError < KnockError; end
+end

data/lib/knock/preferences.rb

@@ -0,0 +1,141 @@
+require "net/http"
+require "uri"
+
+module Knock
+  # Provides convienience methods for working with preferences
+  module Preferences
+    class << self
+      include Base
+      include Client
+
+      DEFAULT_SET_ID = "default"
+
+      # Returns all preference sets for the user
+      #
+      # @param [String] user_id The ID of the user to retrieve preferences for
+      #
+      # @return [Hash] The preference sets
+      def get_all(user_id:)
+        endpoint = "/v1/users/#{user_id}/preferences"
+
+        request = get_request(
+          auth: true,
+          path: endpoint
+        )
+
+        execute_request(request: request)
+      end
+
+      # Gets a single preference set, defaults to the 'default' set
+      # for the user given.
+      #
+      # @param [String] user_id The ID of the user to retrieve preferences for
+      # @param [String] preference_set The preference set ID (defaults to `default`)
+      #
+      # @return [Hash] The preference set (if it exists)
+      def get(user_id:, preference_set: DEFAULT_SET_ID)
+        endpoint = "/v1/users/#{user_id}/preferences/#{preference_set}"
+
+        request = get_request(
+          auth: true,
+          path: endpoint
+        )
+
+        execute_request(request: request)
+      end
+
+      # Sets multiple preferences at once for the preference set.
+      #
+      # @param [String] user_id The ID of the user to set preferences for
+      # @param [String] preference_set The preference set ID (defaults to `default`)
+      # @param [Hash] preferences The preferences hash to set
+      #
+      #  @return [Hash] The preference set
+      def update(
+        user_id:,
+        channel_types: nil,
+        workflows: nil,
+        categories: nil,
+        preference_set: DEFAULT_SET_ID
+      )
+        endpoint = "/v1/users/#{user_id}/preferences/#{preference_set}"
+
+        request = put_request(
+          auth: true,
+          path: endpoint,
+          body: {
+            channel_types: channel_types,
+            workflows: workflows,
+            categories: categories
+          }
+        )
+
+        execute_request(request: request)
+      end
+
+      # Sets preferences for the given channel type
+      #
+      # @param [String] user_id The ID of the user to set preferences for
+      # @param [String] preference_set The preference set ID (defaults to `default`)
+      # @param [String] channel_type The channel type to set
+      # @param [Bool] setting Whether the channel type is enabled or not
+      #
+      #  @return [Hash] The preference set
+      def set_channel_type(user_id:, channel_type:, setting:, preference_set: DEFAULT_SET_ID)
+        endpoint = "/v1/users/#{user_id}/preferences/#{preference_set}/channel_types/#{channel_type}"
+
+        request = put_request(
+          auth: true,
+          path: endpoint,
+          body: {subscribed: setting}
+        )
+
+        execute_request(request: request)
+      end
+
+      # Sets preferences for the given workflow
+      #
+      # @param [String] user_id The ID of the user to set preferences for
+      # @param [String] preference_set The preference set ID (defaults to `default`)
+      # @param [String] workflow The workflow to set preferences for
+      # @param [Bool | Hash] setting Either a boolean to indicate if the type is enabled
+      #  or a hash containing channel types and settings
+      #
+      #  @return [Hash] The preference set
+      def set_workflow(user_id:, workflow:, setting:, preference_set: DEFAULT_SET_ID)
+        params = setting.is_a?(Hash) ? setting : {subscribed: setting}
+        endpoint = "/v1/users/#{user_id}/preferences/#{preference_set}/workflows/#{workflow}"
+
+        request = put_request(
+          auth: true,
+          path: endpoint,
+          body: params
+        )
+
+        execute_request(request: request)
+      end
+
+      # Sets preferences for the given category
+      #
+      # @param [String] user_id The ID of the user to set preferences for
+      # @param [String] preference_set The preference set ID (defaults to `default`)
+      # @param [String] category The category to set preferences for
+      # @param [Bool | Hash] setting Either a boolean to indicate if the type is enabled
+      #  or a hash containing channel types and settings
+      #
+      #  @return [Hash] The preference set
+      def set_category(user_id:, category:, setting:, preference_set: DEFAULT_SET_ID)
+        params = setting.is_a?(Hash) ? setting : {subscribed: setting}
+        endpoint = "/v1/users/#{user_id}/preferences/#{preference_set}/categories/#{category}"
+
+        request = put_request(
+          auth: true,
+          path: endpoint,
+          body: params
+        )
+
+        execute_request(request: request)
+      end
+    end
+  end
+end

data/lib/knock/users.rb

@@ -0,0 +1,56 @@
+require "net/http"
+require "uri"
+
+module Knock
+  # Provides convienience methods for working with users
+  module Users
+    class << self
+      include Base
+      include Client
+
+      # Identifies the user
+      #
+      # @param [String] id The user ID
+      # @param [Hash] data The traits to attach to the user
+      #
+      # @return [Hash] The user
+      def identify(id:, data: {})
+        request = put_request(
+          auth: true,
+          path: "/v1/users/#{id}",
+          body: data
+        )
+
+        execute_request(request: request)
+      end
+
+      # Retrieves the given user
+      #
+      # @param [String] id The user ID
+      #
+      # @return [Hash] The user
+      def get(id:)
+        request = get_request(
+          auth: true,
+          path: "/v1/users/#{id}"
+        )
+
+        execute_request(request: request)
+      end
+
+      # Deletes the user
+      #
+      # @param [String] id the user ID
+      #
+      # @return [Hash] the user
+      def delete(id:)
+        request = delete_request(
+          auth: true,
+          path: "/v1/users/#{id}"
+        )
+
+        execute_request(request: request)
+      end
+    end
+  end
+end

data/lib/knock/version.rb

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

data/lib/knock/workflows.rb

@@ -0,0 +1,63 @@
+require "net/http"
+require "uri"
+
+module Knock
+  # Methods for interacting with workflows in Knock
+  module Workflows
+    class << self
+      include Base
+      include Client
+
+      # Triggers the workflow with the given key
+      #
+      # @param [String] key The workflow key
+      # @param [String] actor The actor ID
+      # @param [Array<String>] recipients The recipient IDs
+      # @param [Hash] data The data to pass to the workflow
+      # @param [String] cancellation_key An optional key to identify this workflow
+      #  invocation for cancelling
+      # @param [String] tenant An optional tenant identifier
+      #
+      # @return [Hash] A workflow trigger result
+      def trigger(key:, actor:, recipients:, data: {}, cancellation_key: nil, tenant: nil)
+        attrs = {
+          actor: actor,
+          recipients: recipients,
+          data: data,
+          cancellation_key: cancellation_key,
+          tenant: tenant
+        }
+
+        request = post_request(
+          auth: true,
+          path: "/v1/workflows/#{key}/trigger",
+          body: attrs
+        )
+
+        execute_request(request: request)
+      end
+
+      # Cancels the workflow with the given key and cancellation key
+      #
+      # @param [String] key The workflow key
+      # @param [String] cancellation_key The cancellation key
+      # @param [Array<String>] recipients The recipient IDs to cancel for
+      #
+      # @return [Hash] - Cancellation result
+      def cancel(key:, cancellation_key:, recipients: nil)
+        attrs = {
+          cancellation_key: cancellation_key,
+          recipients: recipients
+        }
+
+        request = post_request(
+          auth: true,
+          path: "/v1/workflows/#{key}/cancel",
+          body: attrs
+        )
+
+        execute_request(request: request)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: knockapi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Knock Labs, Inc.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: standard
+  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: API client for Knock
+email:
+- support@knock.app
+executables:
+- console
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- bin/console
+- knockapi.gemspec
+- lib/knock.rb
+- lib/knock/base.rb
+- lib/knock/client.rb
+- lib/knock/errors.rb
+- lib/knock/preferences.rb
+- lib/knock/users.rb
+- lib/knock/version.rb
+- lib/knock/workflows.rb
+homepage: https://github.com/knocklabs/knock-ruby
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://docs.knock.app
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: API client for Knock
+test_files: []