whatsapp_sdk 0.12.1 → 0.13.0

data/lib/whatsapp_sdk/resource/template.rb

@@ -1,56 +1,43 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class Template
-      extend T::Sig
+      module Status
+        PENDING_DELETION = "PENDING_DELETION"
+        APPROVED = "APPROVED"
+        PENDING = "PENDING"
+        REJECTED = "REJECTED"
 
-      sig { returns(String) }
-      attr_accessor :id
+        STATUSES = [PENDING_DELETION, APPROVED, PENDING, REJECTED].freeze
 
-      class Status < T::Enum
-        extend T::Sig
+        def valid?(status)
+          STATUSES.include?(status)
+        end
 
-        enums do
-          PENDING_DELETION = new("PENDING_DELETION")
-          APPROVED = new("APPROVED")
-          PENDING = new("PENDING")
-          REJECTED = new("REJECTED")
+        def serialize(status)
+          STATUSES.include?(status) ? status : nil
         end
       end
 
-      sig { returns(Status) }
-      attr_accessor :status
+      module Category
+        AUTHENTICATION = "AUTHENTICATION"
+        MARKETING = "MARKETING"
+        UTILITY = "UTILITY"
 
-      class Category < T::Enum
-        extend T::Sig
+        CATEGORIES = [AUTHENTICATION, MARKETING, UTILITY].freeze
 
-        enums do
-          AUTHENTICATION = new("AUTHENTICATION")
-          MARKETING = new("MARKETING")
-          UTILITY = new("UTILITY")
+        def self.valid?(category)
+          CATEGORIES.include?(category)
         end
-      end
-
-      sig { returns(Category) }
-      attr_accessor :category
-
-      sig { returns(T.nilable(String)) }
-      attr_accessor :language
 
-      sig { returns(T.nilable(String)) }
-      attr_accessor :name
+        def self.serialize(category)
+          CATEGORIES.include?(category) ? category : nil
+        end
+      end
 
-      sig { returns(T.nilable(T::Array[T::Hash[T.untyped, T.untyped]])) }
-      attr_accessor :components_json
+      attr_accessor :id, :status, :category, :language, :name, :components_json
 
-      sig do
-        params(
-          id: String, status: Status, category: Category, language: T.nilable(String), name: T.nilable(String),
-          components_json: T.nilable(T::Array[T::Hash[T.untyped, T.untyped]])
-        ).void
-      end
       def initialize(id:, status:, category:, language: nil, name: nil, components_json: nil)
         @id = id
         @status = status

data/lib/whatsapp_sdk/resource/url.rb

@@ -1,24 +1,15 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
   module Resource
     class Url
-      extend T::Sig
+      attr_accessor :url, :type
 
-      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/version.rb

@@ -1,6 +1,5 @@
-# typed: strict
 # frozen_string_literal: true
 
 module WhatsappSdk
-  VERSION = "0.12.1"
+  VERSION = "0.13.0"
 end

data/lib/whatsapp_sdk.rb

@@ -4,16 +4,12 @@
 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/whatsapp_sdk.gemspec

@@ -43,9 +43,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency("bundler", "~> 2.3")
   spec.add_development_dependency("minitest", "~> 5.0")
   spec.add_development_dependency("rake", "~> 12.3")
-  spec.add_development_dependency('sorbet', "~>0.5")
-
-  spec.add_runtime_dependency('sorbet-runtime', "~>0.5")
 
   spec.add_dependency("faraday", "~> 2")
   spec.add_dependency("faraday-multipart", "~> 1")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: whatsapp_sdk
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
 platform: ruby
 authors:
 - ignacio-chiazzo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-04 00:00:00.000000000 Z
+date: 2024-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,34 +52,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '12.3'
-- !ruby/object:Gem::Dependency
-  name: sorbet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
@@ -148,6 +120,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- SECURITY.md
 - bin/console
 - bin/setup
 - bin/tapioca
@@ -198,6 +171,7 @@ files:
 - lib/whatsapp_sdk/resource/interactive_footer.rb
 - lib/whatsapp_sdk/resource/interactive_header.rb
 - lib/whatsapp_sdk/resource/languages.rb
+- lib/whatsapp_sdk/resource/location.rb
 - lib/whatsapp_sdk/resource/media.rb
 - lib/whatsapp_sdk/resource/media_types.rb
 - lib/whatsapp_sdk/resource/message.rb
@@ -208,24 +182,6 @@ files:
 - lib/whatsapp_sdk/resource/template.rb
 - lib/whatsapp_sdk/resource/url.rb
 - lib/whatsapp_sdk/version.rb
-- sorbet/config
-- sorbet/rbi/annotations/faraday.rbi
-- sorbet/rbi/annotations/mocha.rbi
-- sorbet/rbi/annotations/rainbow.rbi
-- sorbet/rbi/gems/faraday-multipart@1.0.4.rbi
-- sorbet/rbi/gems/faraday-net_http@2.0.3.rbi
-- sorbet/rbi/gems/faraday@2.3.0.rbi
-- sorbet/rbi/gems/method_source@1.0.0.rbi
-- sorbet/rbi/gems/minitest@5.16.1.rbi
-- sorbet/rbi/gems/mocha@1.14.0.rbi
-- sorbet/rbi/gems/multipart-post@2.2.3.rbi
-- sorbet/rbi/gems/netrc@0.11.0.rbi
-- sorbet/rbi/gems/oj@3.13.14.rbi
-- sorbet/rbi/gems/zeitwerk@2.6.0.rbi
-- sorbet/rbi/todo.rbi
-- sorbet/shims/request.rbi
-- sorbet/tapioca/config.yml
-- sorbet/tapioca/require.rb
 - tmp/whatsapp.png
 - whatsapp_sdk.gemspec
 homepage: https://github.com/ignacio-chiazzo/ruby_whatsapp_sdk
@@ -251,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Use the Ruby Whatsapp SDK to communicate with Whatsapp API using the Cloud

data/sorbet/config

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

data/sorbet/rbi/annotations/faraday.rbi

@@ -1,17 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,269 +0,0 @@
-# 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