connector-ruby 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c22469b3849b241124a069729e5b127cb3459d4f9f55458a79b089fc3f33a28
+  data.tar.gz: 66fbf3cb744d58622775bed0a17840f6635984e9fc6a488ea507da5b2f5fbd6c
+SHA512:
+  metadata.gz: fef0557ed46edaf27e1c50b2e28e0cde341c8343fe394b96c51d3a46e17c1b62ccd2fbc88974abd41c3b59bf37f4b20349d2cd794ede451c7074107ebdd81824
+  data.tar.gz: 706e414863cc4f8d556166a6fd60d2a092593ded6bea22c6617768148e2c596e2121bbf6f934df5170680eeaf40d5421805db07348099a854de5466afd841d0e

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 (2026-03-09)
+
+- Initial release
+- WhatsApp Cloud API support (send text, buttons, image; parse webhooks)
+- Telegram Bot API support (send text, buttons, image; parse webhooks)
+- Unified Event model for normalized inbound messages
+- Webhook signature verification (WhatsApp HMAC-SHA256)
+- HTTP client with retry and timeout support
+- Configuration DSL

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johannes Dwi Cahyo
+
+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,59 @@
+# connector-ruby
+
+Unified channel messaging SDK for Ruby. Framework-agnostic SDK for sending/receiving messages across chat platforms.
+
+## Installation
+
+```ruby
+gem "connector-ruby", "~> 0.1"
+```
+
+## Supported Channels
+
+- WhatsApp Cloud API
+- Telegram Bot API
+
+## Usage
+
+### WhatsApp
+
+```ruby
+client = ConnectorRuby::WhatsApp.new(
+  phone_number_id: "...",
+  access_token: "..."
+)
+
+client.send_text(to: "+62812...", text: "Hello!")
+client.send_buttons(to: "+62812...", body: "Choose:", buttons: [
+  { id: "opt1", title: "Option 1" },
+  { id: "opt2", title: "Option 2" }
+])
+client.send_image(to: "+62812...", url: "https://...")
+
+event = ConnectorRuby::WhatsApp.parse_webhook(request_body)
+```
+
+### Telegram
+
+```ruby
+client = ConnectorRuby::Telegram.new(bot_token: "...")
+
+client.send_text(chat_id: 12345, text: "Hello!")
+event = ConnectorRuby::Telegram.parse_webhook(request_body)
+```
+
+### Configuration
+
+```ruby
+ConnectorRuby.configure do |config|
+  config.whatsapp_phone_number_id = ENV["WA_PHONE_ID"]
+  config.whatsapp_access_token = ENV["WA_TOKEN"]
+  config.telegram_bot_token = ENV["TG_TOKEN"]
+  config.http_timeout = 30
+  config.http_retries = 3
+end
+```
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task default: :test

data/connector-ruby.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "lib/connector_ruby/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "connector-ruby"
+  spec.version = ConnectorRuby::VERSION
+  spec.authors = ["Johannes Dwi Cahyo"]
+  spec.email = ["johannes@example.com"]
+  spec.summary = "Unified channel messaging SDK for Ruby"
+  spec.description = "Framework-agnostic SDK for sending/receiving messages across chat platforms. Supports WhatsApp Cloud API, Telegram Bot API, and more."
+  spec.homepage = "https://github.com/johannesdwicahyo/connector-ruby"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "Rakefile",
+    "connector-ruby.gemspec"
+  ]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "webmock", "~> 3.0"
+end

data/lib/connector_ruby/channels/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class Base
+      def send_text(*)
+        raise NotImplementedError, "#{self.class}#send_text not implemented"
+      end
+
+      def send_buttons(*)
+        raise NotImplementedError, "#{self.class}#send_buttons not implemented"
+      end
+
+      def send_image(*)
+        raise NotImplementedError, "#{self.class}#send_image not implemented"
+      end
+
+      def self.parse_webhook(*)
+        raise NotImplementedError, "#{self}.parse_webhook not implemented"
+      end
+
+      private
+
+      def http_client
+        @http_client ||= HttpClient.new
+      end
+    end
+  end
+end

data/lib/connector_ruby/channels/telegram.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class Telegram < Base
+      BASE_URL = "https://api.telegram.org"
+
+      def initialize(bot_token: nil)
+        @bot_token = bot_token || ConnectorRuby.configuration.telegram_bot_token
+        raise ConfigurationError, "Telegram bot_token is required" unless @bot_token
+      end
+
+      def send_text(chat_id:, text:, parse_mode: nil)
+        validate_send!(chat_id: chat_id, text: text)
+        payload = { chat_id: chat_id, text: text }
+        payload[:parse_mode] = parse_mode if parse_mode
+        api_call("sendMessage", payload)
+      end
+
+      def send_buttons(chat_id:, text:, buttons:)
+        validate_send!(chat_id: chat_id, text: text)
+        keyboard = buttons.map do |btn|
+          [{ text: btn[:title], callback_data: btn[:id] }]
+        end
+
+        payload = {
+          chat_id: chat_id,
+          text: text,
+          reply_markup: { inline_keyboard: keyboard }
+        }
+        api_call("sendMessage", payload)
+      end
+
+      def send_image(chat_id:, url:, caption: nil)
+        validate_send!(chat_id: chat_id)
+        payload = { chat_id: chat_id, photo: url }
+        payload[:caption] = caption if caption
+        api_call("sendPhoto", payload)
+      end
+
+      def self.parse_webhook(body)
+        data = body.is_a?(String) ? JSON.parse(body) : body
+
+        if data["message"]
+          parse_message(data["message"])
+        elsif data["callback_query"]
+          parse_callback(data["callback_query"])
+        end
+      end
+
+      private
+
+      def api_call(method, payload)
+        url = "#{BASE_URL}/bot#{@bot_token}/#{method}"
+        http_client.post(url, body: payload)
+      end
+
+      def validate_send!(chat_id:, text: nil)
+        raise ConnectorRuby::Error, "Recipient 'chat_id' cannot be nil or empty" if chat_id.nil? || chat_id.to_s.strip.empty?
+        if text
+          raise ConnectorRuby::Error, "Text cannot be nil or empty" if text.nil? || text.to_s.strip.empty?
+          raise ConnectorRuby::Error, "Text exceeds 4096 character limit" if text.length > 4096
+        end
+      end
+
+      def self.parse_message(msg)
+        return nil unless msg
+        Event.new(
+          type: :message,
+          channel: :telegram,
+          from: msg.dig("from", "id")&.to_s,
+          text: msg["text"],
+          timestamp: msg["date"] ? Time.at(msg["date"]) : nil,
+          message_id: msg["message_id"]&.to_s,
+          metadata: {
+            chat_id: msg.dig("chat", "id"),
+            chat_type: msg.dig("chat", "type"),
+            from_username: msg.dig("from", "username"),
+            from_first_name: msg.dig("from", "first_name")
+          }
+        )
+      end
+
+      def self.parse_callback(callback)
+        return nil unless callback
+        Event.new(
+          type: :callback,
+          channel: :telegram,
+          from: callback.dig("from", "id")&.to_s,
+          text: callback["data"],
+          message_id: callback["id"],
+          metadata: {
+            chat_id: callback.dig("message", "chat", "id"),
+            original_message_id: callback.dig("message", "message_id"),
+            from_username: callback.dig("from", "username")
+          }
+        )
+      end
+    end
+  end
+end

data/lib/connector_ruby/channels/whatsapp.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  module Channels
+    class WhatsApp < Base
+      BASE_URL = "https://graph.facebook.com/v21.0"
+
+      def initialize(phone_number_id: nil, access_token: nil)
+        @phone_number_id = phone_number_id || ConnectorRuby.configuration.whatsapp_phone_number_id
+        @access_token = access_token || ConnectorRuby.configuration.whatsapp_access_token
+
+        raise ConfigurationError, "WhatsApp phone_number_id is required" unless @phone_number_id
+        raise ConfigurationError, "WhatsApp access_token is required" unless @access_token
+      end
+
+      def send_text(to:, text:)
+        validate_send!(to: to, text: text)
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "text",
+          text: { body: text }
+        }
+        post_message(payload)
+      end
+
+      def send_buttons(to:, body:, buttons:)
+        validate_send!(to: to, text: body)
+        formatted_buttons = buttons.map do |btn|
+          { type: "reply", reply: { id: btn[:id], title: btn[:title] } }
+        end
+
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "interactive",
+          interactive: {
+            type: "button",
+            body: { text: body },
+            action: { buttons: formatted_buttons }
+          }
+        }
+        post_message(payload)
+      end
+
+      def send_image(to:, url:, caption: nil)
+        validate_send!(to: to)
+        image = { link: url }
+        image[:caption] = caption if caption
+
+        payload = {
+          messaging_product: "whatsapp",
+          to: to,
+          type: "image",
+          image: image
+        }
+        post_message(payload)
+      end
+
+      def self.parse_webhook(body, signature: nil)
+        data = body.is_a?(String) ? JSON.parse(body) : body
+
+        entry = data.dig("entry", 0)
+        return nil unless entry
+
+        changes = entry.dig("changes", 0)
+        return nil unless changes
+
+        value = changes["value"]
+        return nil unless value
+
+        if value["messages"]&.any?
+          parse_message(value)
+        elsif value["statuses"]&.any?
+          parse_status(value)
+        end
+      end
+
+      private
+
+      def post_message(payload)
+        url = "#{BASE_URL}/#{@phone_number_id}/messages"
+        http_client.post(url, body: payload, headers: auth_headers)
+      end
+
+      def auth_headers
+        { "Authorization" => "Bearer #{@access_token}" }
+      end
+
+      def validate_send!(to:, text: nil)
+        raise ConnectorRuby::Error, "Recipient 'to' cannot be nil or empty" if to.nil? || to.to_s.strip.empty?
+        if text
+          raise ConnectorRuby::Error, "Text cannot be nil or empty" if text.nil? || text.to_s.strip.empty?
+          raise ConnectorRuby::Error, "Text exceeds 4096 character limit" if text.length > 4096
+        end
+      end
+
+      def self.parse_message(value)
+        return nil unless value["messages"]&.any?
+        msg = value["messages"][0]
+        contact = value.dig("contacts", 0)
+
+        Event.new(
+          type: :message,
+          channel: :whatsapp,
+          from: msg["from"],
+          text: msg.dig("text", "body"),
+          timestamp: msg["timestamp"] ? Time.at(msg["timestamp"].to_i) : nil,
+          message_id: msg["id"],
+          metadata: {
+            contact_name: contact&.dig("profile", "name"),
+            message_type: msg["type"]
+          }
+        )
+      end
+
+      def self.parse_status(value)
+        return nil unless value["statuses"]&.any?
+        status = value["statuses"][0]
+
+        Event.new(
+          type: :status,
+          channel: :whatsapp,
+          to: status["recipient_id"],
+          message_id: status["id"],
+          metadata: {
+            status: status["status"],
+            timestamp: status["timestamp"]
+          }
+        )
+      end
+    end
+  end
+end

data/lib/connector_ruby/configuration.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  class Configuration
+    attr_accessor :whatsapp_phone_number_id, :whatsapp_access_token,
+                  :telegram_bot_token,
+                  :http_timeout, :http_retries, :http_open_timeout,
+                  :on_request, :on_response, :on_error
+
+    def initialize
+      @whatsapp_phone_number_id = nil
+      @whatsapp_access_token = nil
+      @telegram_bot_token = nil
+      @http_timeout = 30
+      @http_retries = 3
+      @http_open_timeout = 10
+      @on_request = nil
+      @on_response = nil
+      @on_error = nil
+    end
+  end
+end

data/lib/connector_ruby/error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+
+  class ApiError < Error
+    attr_reader :status, :body, :channel, :response
+
+    def initialize(message, status: nil, body: nil, channel: nil, response: nil)
+      @status = status
+      @body = body
+      @channel = channel
+      @response = response
+      super(message)
+    end
+  end
+
+  class WebhookVerificationError < Error; end
+  class RateLimitError < ApiError; end
+  class AuthenticationError < ApiError; end
+end

data/lib/connector_ruby/event.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  class Event
+    attr_reader :type, :channel, :from, :to, :text, :timestamp,
+                :message_id, :payload, :metadata
+
+    TYPES = %i[message callback status delivery read reaction].freeze
+
+    def initialize(type:, channel:, from: nil, to: nil, text: nil,
+                   timestamp: nil, message_id: nil, payload: nil, metadata: {})
+      @type = type
+      @channel = channel
+      @from = from
+      @to = to
+      @text = text
+      @timestamp = timestamp
+      @message_id = message_id
+      @payload = payload
+      @metadata = metadata
+    end
+
+    def message?
+      type == :message
+    end
+
+    def callback?
+      type == :callback
+    end
+
+    def status?
+      type == :status
+    end
+
+    def to_h
+      {
+        type: @type,
+        channel: @channel,
+        from: @from,
+        to: @to,
+        text: @text,
+        timestamp: @timestamp,
+        message_id: @message_id,
+        payload: @payload,
+        metadata: @metadata
+      }
+    end
+  end
+end

data/lib/connector_ruby/http_client.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module ConnectorRuby
+  class HttpClient
+    def initialize(timeout: nil, retries: nil, open_timeout: nil)
+      config = ConnectorRuby.configuration
+      @timeout = timeout || config.http_timeout
+      @retries = retries || config.http_retries
+      @open_timeout = open_timeout || config.http_open_timeout
+    end
+
+    def get(url, headers: {})
+      request(:get, url, headers: headers)
+    end
+
+    def post(url, body:, headers: {})
+      request(:post, url, body: body, headers: headers)
+    end
+
+    private
+
+    def request(method, url, body: nil, headers: {})
+      uri = URI.parse(url)
+      attempts = 0
+
+      begin
+        attempts += 1
+        http = build_http(uri)
+        req = build_request(method, uri, body: body, headers: headers)
+        response = http.request(req)
+        handle_response(response)
+      rescue RateLimitError => e
+        if attempts < @retries
+          sleep(2 ** (attempts - 1))
+          retry
+        end
+        raise
+      rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNRESET => e
+        retry if attempts < @retries
+        raise ConnectorRuby::Error, "HTTP request failed after #{@retries} attempts: #{e.message}"
+      end
+    end
+
+    def build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.read_timeout = @timeout
+      http.open_timeout = @open_timeout
+      http
+    end
+
+    def build_request(method, uri, body: nil, headers: {})
+      klass = case method
+              when :get then Net::HTTP::Get
+              when :post then Net::HTTP::Post
+              end
+
+      req = klass.new(uri.request_uri)
+      headers.each { |k, v| req[k] = v }
+      req["Content-Type"] ||= "application/json"
+
+      if body
+        req.body = body.is_a?(String) ? body : JSON.generate(body)
+      end
+
+      req
+    end
+
+    def handle_response(response)
+      body = begin
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        response.body
+      end
+
+      case response.code.to_i
+      when 200..299
+        body
+      when 401
+        raise AuthenticationError.new("Authentication failed", status: response.code.to_i, body: body)
+      when 429
+        raise RateLimitError.new("Rate limited", status: 429, body: body)
+      else
+        raise ApiError.new("API error: #{response.code}", status: response.code.to_i, body: body)
+      end
+    end
+  end
+end

data/lib/connector_ruby/message.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ConnectorRuby
+  class Message
+    attr_reader :type, :to, :text, :buttons, :image_url, :caption, :metadata
+
+    TYPES = %i[text buttons image template].freeze
+
+    def initialize(type:, to:, text: nil, buttons: nil, image_url: nil, caption: nil, metadata: {})
+      @type = type
+      @to = to
+      @text = text
+      @buttons = buttons
+      @image_url = image_url
+      @caption = caption
+      @metadata = metadata
+    end
+
+    def self.text(to:, text:)
+      new(type: :text, to: to, text: text)
+    end
+
+    def self.buttons(to:, body:, buttons:)
+      new(type: :buttons, to: to, text: body, buttons: buttons)
+    end
+
+    def self.image(to:, url:, caption: nil)
+      new(type: :image, to: to, image_url: url, caption: caption)
+    end
+
+    def to_h
+      {
+        type: @type,
+        to: @to,
+        text: @text,
+        buttons: @buttons,
+        image_url: @image_url,
+        caption: @caption,
+        metadata: @metadata
+      }.compact
+    end
+  end
+end

data/lib/connector_ruby/version.rb

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

data/lib/connector_ruby/webhook_verifier.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ConnectorRuby
+  class WebhookVerifier
+    def self.verify_whatsapp(payload, signature:, app_secret:)
+      expected = "sha256=#{OpenSSL::HMAC.hexdigest("SHA256", app_secret, payload)}"
+      secure_compare(expected, signature)
+    end
+
+    def self.verify_telegram(token:, payload:, secret_token: nil, header_value: nil)
+      return false unless secret_token && header_value
+      computed = OpenSSL::HMAC.hexdigest("SHA256", secret_token, payload.to_s)
+      secure_compare(computed, header_value.to_s)
+    end
+
+    def self.secure_compare(a, b)
+      a = a.to_s.downcase
+      b = b.to_s.downcase
+      return false unless a.bytesize == b.bytesize
+
+      OpenSSL.fixed_length_secure_compare(a, b)
+    end
+  end
+end

data/lib/connector_ruby.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "connector_ruby/version"
+require_relative "connector_ruby/error"
+require_relative "connector_ruby/configuration"
+require_relative "connector_ruby/event"
+require_relative "connector_ruby/message"
+require_relative "connector_ruby/http_client"
+require_relative "connector_ruby/webhook_verifier"
+require_relative "connector_ruby/channels/base"
+require_relative "connector_ruby/channels/whatsapp"
+require_relative "connector_ruby/channels/telegram"
+
+module ConnectorRuby
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+
+  # Convenience aliases
+  WhatsApp = Channels::WhatsApp
+  Telegram = Channels::Telegram
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: connector-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Johannes Dwi Cahyo
+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: webmock
+  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'
+description: Framework-agnostic SDK for sending/receiving messages across chat platforms.
+  Supports WhatsApp Cloud API, Telegram Bot API, and more.
+email:
+- johannes@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- connector-ruby.gemspec
+- lib/connector_ruby.rb
+- lib/connector_ruby/channels/base.rb
+- lib/connector_ruby/channels/telegram.rb
+- lib/connector_ruby/channels/whatsapp.rb
+- lib/connector_ruby/configuration.rb
+- lib/connector_ruby/error.rb
+- lib/connector_ruby/event.rb
+- lib/connector_ruby/http_client.rb
+- lib/connector_ruby/message.rb
+- lib/connector_ruby/version.rb
+- lib/connector_ruby/webhook_verifier.rb
+homepage: https://github.com/johannesdwicahyo/connector-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/johannesdwicahyo/connector-ruby
+  source_code_uri: https://github.com/johannesdwicahyo/connector-ruby
+  changelog_uri: https://github.com/johannesdwicahyo/connector-ruby/blob/main/CHANGELOG.md
+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: Unified channel messaging SDK for Ruby
+test_files: []