whatsapp_sdk 0.3.2 → 0.5.0

data/lib/whatsapp_sdk/resource/org.rb

@@ -1,16 +1,28 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Org
-      attr_accessor :company, :department, :title
+      extend T::Sig
 
+      sig { returns(String) }
+      attr_accessor :company
+
+      sig { returns(String) }
+      attr_accessor :department
+
+      sig { returns(String) }
+      attr_accessor :title
+
+      sig { params(company: String, department: String, title: String).void }
       def initialize(company:, department:, title:)
         @company = company
         @department = department
         @title = title
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           company: @company,

data/lib/whatsapp_sdk/resource/parameter_object.rb

@@ -1,20 +1,37 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class ParameterObject
+      extend T::Sig
+
       class InvalidType < StandardError
+        extend T::Sig
+
+        sig { returns(String) }
         attr_accessor :message
 
+        sig { params(type: String).void }
         def initialize(type)
-          @message = "invalid type #{type}. type should be text, currency, date_time, image, document or video"
+          @message = T.let(
+            "invalid type #{type}. type should be text, currency, date_time, image, document or video",
+            String
+          )
           super
         end
       end
 
       class MissingValue < StandardError
-        attr_reader :field, :message
+        extend T::Sig
+
+        sig { returns(String) }
+        attr_reader :field
 
+        sig { returns(String) }
+        attr_reader :message
+
+        sig { params(field: String, message: String).void }
         def initialize(field, message)
           @field = field
           @message = message
@@ -25,17 +42,20 @@ module WhatsappSdk
       # Returns the parameter type.
       #
       # @returns type [String] Valid options are text, currency, date_time, image, document, video.
+      sig { returns(Type) }
       attr_accessor :type
 
-      module Type
-        TEXT = "text"
-        CURRENCY = "currency"
-        DATE_TIME = "date_time"
-        IMAGE = "image"
-        DOCUMENT = "document"
-        VIDEO = "video"
+      class Type < T::Enum
+        extend T::Sig
 
-        VALID_TYPES = [TEXT, CURRENCY, DATE_TIME, IMAGE, DOCUMENT, VIDEO].freeze
+        enums do
+          Text = new("text")
+          Currency = new("currency")
+          DateTime = new("date_time")
+          Image = new("image")
+          Document = new("document")
+          Video = new("video")
+        end
       end
 
       # Returns Text string if the parameter object type is text.
@@ -43,35 +63,47 @@ module WhatsappSdk
       # For the body component, the character limit is 1024 characters.
       #
       # @returns text [String]
+      sig { returns(T.nilable(String)) }
       attr_accessor :text
 
       # Returns Currency if the parameter object type is currency.
       #
       # @returns currency [Currency]
+      sig { returns(T.nilable(Currency)) }
       attr_accessor :currency
 
       # Returns date_time if the parameter object type is date_time.
       #
       # @returns date_time [DateTime]
+      sig { returns(T.nilable(DateTime)) }
       attr_accessor :date_time
 
       # Returns image if the parameter object type is image.
       #
       # @returns image [Media]
+      sig { returns(T.nilable(Media)) }
       attr_accessor :image
 
       # Returns document if the parameter object type is document.
       #
       # @returns document [Media]
+      sig { returns(T.nilable(Media)) }
       attr_accessor :document
 
       # Returns video if the parameter object type is video.
       #
       # @returns video [Media]
+      sig { returns(T.nilable(Media)) }
       attr_accessor :video
 
+      sig do
+        params(
+          type: T.any(Type, String), text: T.nilable(String), currency: T.nilable(Currency),
+          date_time: T.nilable(DateTime), image: T.nilable(Media), document: T.nilable(Media), video: T.nilable(Media)
+        ).void
+      end
       def initialize(type:, text: nil, currency: nil, date_time: nil, image: nil, document: nil, video: nil)
-        @type = type
+        @type = T.let(deserialize_type(type), Type)
         @text = text
         @currency = currency
         @date_time = date_time
@@ -81,52 +113,63 @@ module WhatsappSdk
         validate
       end
 
-      def to_json(*_args)
-        json = { type: type }
-        json[type.to_sym] = case type
-                            when "text"
-                              text
-                            when "currency"
-                              currency.to_json
-                            when "date_time"
-                              date_time.to_json
-                            when "image"
-                              image.to_json
-                            when "document"
-                              document.to_json
-                            when "video"
-                              video.to_json
-                            else
-                              raise "Invalid type: #{type}"
-                            end
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      def to_json
+        json = { type: type.serialize }
+        json[type.serialize.to_sym] = case type.serialize
+                                      when "text"
+                                        text
+                                      when "currency"
+                                        T.must(currency).to_json
+                                      when "date_time"
+                                        T.must(date_time).to_json
+                                      when "image"
+                                        T.must(image).to_json
+                                      when "document"
+                                        T.must(document).to_json
+                                      when "video"
+                                        T.must(video).to_json
+                                      else
+                                        raise "Invalid type: #{type}"
+                                      end
 
         json
       end
 
       private
 
+      sig { params(type: T.any(String, Type)).returns(Type) }
+      def deserialize_type(type)
+        return type if type.is_a?(Type)
+
+        Type.deserialize(type)
+      end
+
+      sig { void }
       def validate
         validate_attributes
         validate_type
       end
 
+      sig { void }
       def validate_type
-        return if Type::VALID_TYPES.include?(type)
+        return if Type.valid?(type)
 
         raise InvalidType, type
       end
 
+      sig { void }
       def validate_attributes
         [
-          [:text, text],
-          [:currency, currency],
-          [:date_time, date_time],
-          [:image, image],
-          [:document, document],
-          [:video, video]
-        ].each do |type_sym, value|
-          next unless type == type_sym
-          raise MissingValue.new(type, "#{type} is required when the type is #{type}") if value.nil?
+          [Type::Text, text],
+          [Type::Currency, currency],
+          [Type::DateTime, date_time],
+          [Type::Image, image],
+          [Type::Document, document],
+          [Type::Video, video]
+        ].each do |type_b, value|
+          next unless type == type_b
+          raise MissingValue.new(type.serialize, "#{type_b} is required when the type is #{type_b}") if value.nil?
         end
       end
     end

data/lib/whatsapp_sdk/resource/phone_number.rb

@@ -1,21 +1,28 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class PhoneNumber
-      attr_accessor :phone, :type, :wa_id
+      extend T::Sig
 
-      PHONE_NUMBER_TYPE = {
-        home: "HOME",
-        work: "WORK"
-      }.freeze
+      sig { returns(String) }
+      attr_accessor :phone
 
+      sig { returns(String) }
+      attr_accessor :wa_id
+
+      sig { returns(AddressType) }
+      attr_accessor :type
+
+      sig { params(phone: String, type: AddressType, wa_id: String).void }
       def initialize(phone:, type:, wa_id:)
         @phone = phone
         @type = type
         @wa_id = wa_id
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           phone: @phone,

data/lib/whatsapp_sdk/resource/url.rb

@@ -1,20 +1,24 @@
 # frozen_string_literal: true
+# typed: strict
 
 module WhatsappSdk
   module Resource
     class Url
-      attr_accessor :url, :type
+      extend T::Sig
 
-      ADDRESS_TYPE = {
-        home: "HOME",
-        work: "WORK"
-      }.freeze
+      sig { returns(String) }
+      attr_accessor :url
 
+      sig { returns(AddressType) }
+      attr_accessor :type
+
+      sig { params(url: String, type: AddressType).void }
       def initialize(url:, type:)
         @url = url
         @type = type
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def to_h
         {
           url: @url,

data/lib/whatsapp_sdk.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
+# typed: true
 
 require "zeitwerk"
+require "faraday"
+require "faraday/multipart"
+require "sorbet-runtime"
+
 loader = Zeitwerk::Loader.for_gem
 loader.setup
 
 module WhatsappSdk
   class << self
+    extend T::Sig
+
+    sig { returns(Configuration) }
     def configuration
       @configuration ||= Configuration.new
     end

data/sorbet/config

@@ -0,0 +1,6 @@
+--dir
+.
+--ignore=vendor/
+--ignore=testing.rb
+--ignore=example.rb
+--enable-experimental-requires-ancestor

data/sorbet/rbi/annotations/faraday.rbi

@@ -0,0 +1,17 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Faraday
+  class << self
+    sig { params(url: T.untyped, options: T::Hash[Symbol, T.untyped], block: T.nilable(T.proc.params(connection: Faraday::Connection).void)).returns(Faraday::Connection) }
+    def new(url = nil, options = {}, &block); end
+  end
+end
+
+class Faraday::Response
+  sig { returns(T::Boolean) }
+  def success?; end
+end

data/sorbet/rbi/annotations/mocha.rbi

@@ -0,0 +1,34 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Mocha::API
+  sig { params(arguments: T.untyped).returns(Mocha::Mock) }
+  def mock(*arguments); end
+
+  sig { params(arguments: T.untyped).returns(T.untyped) }
+  def stub(*arguments); end
+end
+
+module Mocha::ClassMethods
+  sig { returns(Mocha::Mock) }
+  def any_instance; end
+end
+
+class Mocha::Expectation
+  sig { params(expected_parameters: T.untyped, matching_block: T.nilable(T.proc.params(actual_parameters: T.untyped).void)).returns(Mocha::Expectation) }
+  def with(*expected_parameters, &matching_block); end
+
+  sig { params(values: T.untyped).returns(Mocha::Expectation) }
+  def returns(*values); end
+end
+
+module Mocha::ObjectMethods
+  sig { params(expected_methods_vs_return_values: T.untyped).returns(Mocha::Expectation) }
+  def expects(expected_methods_vs_return_values); end
+
+  sig { params(stubbed_methods_vs_return_values: T.untyped).returns(Mocha::Expectation) }
+  def stubs(stubbed_methods_vs_return_values); end
+end

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end