sms_traffic_sdk 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6eb747b3922af353ca77e265506afa922d1cf736d1b73e744ddaaee3fe0a2d4d
-  data.tar.gz: 261aa9a1507a0f72c438b0175f506eb2c12725dc22d27c246f5278418b609216
+  metadata.gz: c877028062a36207636853033e3e623612a7ae44daf41d91686d86840f3b75c8
+  data.tar.gz: bd57b25436c7ea9e76d0e68b213730e7f77cf271f28c170d70234a2080e38a97
 SHA512:
-  metadata.gz: 640f165d9e8ed5e9a778e6f35b2e6a735b666e50510c401c75dc28ddfb642a471cbb64fcf1ca3eacfb64fba2e8b7e3e6185a383d2c46b2957041bba73059da09
-  data.tar.gz: 27e9bad83adcce3984164a924e37cce3ae6d6e9339e465f3eb6ce394abd905b97e2708b2574233ee2c51e0cace159dcf3a19e51beb57da3f883c308fb21a8c73
+  metadata.gz: 47f4123facc0dcb03f1fbf072cc266199df3fcf7483d6189fdfcee257988d188bec2607aae674575c9efb3153b36bdf69c9a6ac8c9af972bfdc878c0ca4d8577
+  data.tar.gz: 96bf4d2e9ea69cc8d6aad0aa87165f57e88b5163b00fffd034af98ee269d87f257cffdce2731e5793bdb6c539f213f06420db805978591da118b3bcf5cf6cb6c

data/CHANGELOG.md

@@ -0,0 +1,64 @@
+# Changelog
+
+## 0.1.0 - 2026-11-03
+
+### Breaking changes
+
+- Ruby 3.1 or newer is required.
+- Zeitwerk is no longer a dependency; files are loaded with `require_relative`.
+- `SmsTraffic::Configuration` is a plain class, not a `Singleton`. Defaults changed: `logger` is `nil` (was `$stdout`),
+  new `open_timeout` (10) and `read_timeout` (30). `originator` is no longer required by `configure`.
+  `Configuration#values_at` is removed.
+- `SmsTraffic::Client::Response` is removed. `Client.deliver` returns a `DeliverReply` and `Client.status` a
+  `StatusReply` directly, and raise `SmsTraffic::ConnectionError`, `SmsTraffic::HttpError` or `SmsTraffic::ApiError`
+  (all `SmsTraffic::Error`) instead of returning a failed response.
+- `Reply#hash` no longer returns the parsed reply (it is `Object#hash` again); use `Reply#to_h`.
+- `DeliverReply#ok?` is strictly boolean and requires a queued message. `#sms_ids` is an Array of every sms id (it was
+  a Hash keyed by phone). `#message_infos` is replaced by `#messages`. `#error_description` reads
+  `"Sms has not been enqueued: <description>"`.
+- `StatusReply#sms_array` is replaced by `#entries` (`StatusReply::Entry`); `#entry`, `#error?`, `#not_found?`
+  and `#send_date` are new.
+- `Sms#response` is replaced by `Sms#reply`. `Sms#update_status` always returns the status String, and `Sms#deliver`
+  records `SmsTraffic::Error`s in `errors` instead of the HTTP code.
+- The `konsierge-sms.rb` executable is removed.
+- The default XML parser no longer typecasts (`Nori.new(advanced_typecasting: false)`): dates and `true` stay
+  provider strings.
+- `nori` 2.8 or newer is required.
+
+### Fixed
+
+- `Sms` phone validation no longer accepts a newline-separated value (`\A`/`\z` anchors).
+- `Client.status` with several ids sends a flat comma-separated `sms_id` list.
+- The client builds its URI from the current `host` on every request instead of memoizing the first one.
+- `open_timeout` and `read_timeout` are applied to every request.
+- `Reply` no longer mutates (or fails on) frozen input.
+- A multi-part SMS keeps every `sms_id`; a single `<message_info>` with a phone is parsed.
+- `require 'sms_traffic_sdk'` works with `Bundler.require`.
+- Loading the gem without a preloaded `StringIO` no longer fails with `NameError` (nori 2.7.0 missed
+  `require 'stringio'`; fixed in nori 2.8).
+
+### Changed
+
+- CI runs lint and RSpec on Ruby 3.1-3.4, smoke-tests the built gem in a clean Ruby process, uploads Cobertura
+  coverage to Codecov, and publishes to RubyGems through trusted publishing (OIDC) from a published release whose tag
+  matches the gem version. The gem package contains only `lib`, `README.md`, `LICENSE` and `CHANGELOG.md`.
+
+### Security
+
+- `Net::HTTP#set_debug_output` is no longer used, so the login, password and SMS text are never written to the logger.
+  Debug logging emits one request line with `login`, `password` and `message` filtered, and one response line with
+  the HTTP status and body size only.
+
+### Migration
+
+- Replace `Client.deliver(...).reply` / `.success?` with the returned reply and `rescue SmsTraffic::Error`.
+- Replace `reply.hash` with `reply.to_h`, and `sms.response` with `sms.reply`.
+- Treat `reply.sms_ids` as an Array; use `reply.messages` for per-phone data.
+- Set `config.logger` explicitly if you relied on the `$stdout` default with `debug = true`.
+- `Client.deliver` and `Client.status` no longer raise `SocketError`, `SystemCallError` (`Errno::*`), `IOError`,
+  `Net::OpenTimeout`, `Net::ReadTimeout` or `OpenSSL::SSL::SSLError`; rescue `SmsTraffic::ConnectionError` (the
+  original exception is in `cause`). `Sms#deliver` and `Sms#update_status` already rescue `SmsTraffic::Error` into
+  `errors`.
+- Replace `response.as_json` / `sms.response.as_json` with `reply.to_h` / `sms.reply&.to_h`.
+- Replace `response.success?` checks with `rescue SmsTraffic::Error`.
+- Replace `reply.hash["send_date"]` / `reply.hash["status"]` with `reply.send_date` / `reply.status`.

data/README.md

@@ -1,9 +1,9 @@
 # SmsTraffic
 
 [![Gem Version](https://badge.fury.io/rb/sms_traffic_sdk.svg)](https://badge.fury.io/rb/sms_traffic_sdk)
-[![Maintainability](https://api.codeclimate.com/v1/badges/bb4795be5024dd81d927/maintainability)](https://codeclimate.com/github/golifox/sms_traffic/maintainability)
-[![Coverage](https://codecov.io/github/golifox/sms_traffic/graph/badge.svg?token=74C0YBJP3F)](https://codecov.io/github/golifox/sms_traffic)
-[![CI](https://github.com/golifox/sms_traffic/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/golifox/sms_traffic/actions/workflows/ci.yml)
+[![Maintainability](https://api.codeclimate.com/v1/badges/bb4795be5024dd81d927/maintainability)](https://codeclimate.com/github/golifox/sms_traffic_sdk/maintainability)
+[![Coverage](https://codecov.io/github/golifox/sms_traffic_sdk/graph/badge.svg?token=74C0YBJP3F)](https://codecov.io/github/golifox/sms_traffic_sdk)
+[![CI](https://github.com/golifox/sms_traffic_sdk/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/golifox/sms_traffic_sdk/actions/workflows/ci.yml)
 
 Ruby Gem as a software development kit (SDK) that facilitates interaction with the SMS Traffic HTTP API (smstraffic.ru/api).
 This gem provides a convenient wrapper to integrate SMS Traffic services within Ruby applications, allowing for easy 
@@ -37,63 +37,89 @@ Or install it yourself as:
 Define settings:
 
 ```ruby
-# initializers/sms_traffic.rb
-require 'sms_traffic_sdk'
+# config/initializers/sms_traffic.rb
+require 'sms_traffic'
 
 SmsTraffic.configure do |config|
-  config.login = 'login'
-  config.password = 'password'
-  config.originator = 'default_originator'
-  config.server = 'https://api.smstraffic.ru'
-  config.debug = true
-  config.debugger = Rails.logger
+  config.login          = 'login'
+  config.password       = 'password'
+  config.host           = 'https://api.smstraffic.ru'
+  config.originator     = 'default_originator' # optional, can be given per SMS
+  config.open_timeout   = 10                   # seconds, default 10
+  config.read_timeout   = 30                   # seconds, default 30
+  config.validate_phone = true                 # default true: 11+ digits
+  config.debug          = true                 # default false
+  config.logger         = Rails.logger         # required when debug is true
 end
 ```
 
-Initialize sms:
+`login`, `password` and `host` are required; `logger` is required when `debug` is enabled.
+With `debug` on, one request line and one response line are written through `logger.debug`;
+`login`, `password` and `message` are replaced with `[FILTERED]`.
+
+Send an SMS:
+
 ```ruby
-sms = SmsTraffic::Sms.new('phone', 'text', 'originator') # initialize sms, originator by default from settings
-# =>  #<SmsTraffic::Sms:0x0000 @errors=[], @message="text", @originator="default_originator", @phone="phone", @status="not-sent">
+sms = SmsTraffic::Sms.new('79991112233', 'text', originator: 'my_brand') # originator defaults to the configured one
 
+sms.deliver      # => true when the provider enqueued it, false otherwise
+sms.status       # => 'sent' ('not-sent' until delivered)
+sms.id           # => '123456789' (the first sms id of the reply)
+sms.reply        # => #<SmsTraffic::Client::DeliverReply>
+sms.errors       # => [] (messages of failed attempts)
 ```
 
-Send it and get sent sms id and dispatch code:
+`deliver` and `update_status` never raise on provider or network failures; they append the message to `errors`
+and keep the current `status`.
+
+Refresh the status:
+
 ```ruby
-sms.deliver # send sms. returns sms id or dispatch code if something went wrong
-# => true
-sms.id # get sms id
-# => '123456789'
+sms.update_status # => 'delivered' (downcased provider status, or the unchanged status on failure)
 ```
 
-Get current sms status and update it:
+Use the client directly. It raises typed errors:
+
 ```ruby
-sms.status # get sms delivery status
-# => 'sent'
-sms.update_status # updates sms delivery status. returns status or status check response code on error
-# => 'delivered'
+reply = SmsTraffic::Client.deliver('79991112233,79261112233', 'text', 'my_brand')
+reply.ok?        # => true
+reply.sms_ids    # => ['8287366071', '8287366073']
+reply.messages   # => [{ phone: '79991112233', sms_id: '8287366071', push_id: 'a' }, ...]
+reply.sms_id('79261112233') # first sms id for the phone
+
+reply = SmsTraffic::Client.status('8287713301', '8287713303')
+reply.entries    # => [#<struct SmsTraffic::Client::StatusReply::Entry sms_id="8287713301", status="Delivered", ...>]
+reply.statuses   # => { '8287713301' => 'Delivered' }
+reply.errors     # => { '8287713303' => 'no such message or this message does not belong to you' }
+reply.entry('8287713303').not_found? # => true
+reply.status('8287713301')           # => 'Delivered'; the id may be omitted when there is one entry
 ```
 
-Get any sms status:
-```ruby
-response = SmsTraffic.status(sms_id) # status - sms delivery status unless error or return error
-reply = response.reply
-# => #<SmsTraffic::Client::StatusReply:0x0000>
-status = reply.status
-# => "Delivered"
-reply.hash
-# => 
-# {"error"=>nil,
-#  "submition_date"=>"2024-07-15 11:36:25",
-#  "send_date"=>"2024-07-15 11:36:25",
-#  "last_status_change_date"=>"2024-07-15 11:36:25",
-#  "sms_id"=>"865149797164801235",
-#  "status"=>"Delivered"}
+Each entry has `sms_id`, `status`, `error`, `submission_date`, `send_date`, `last_status_change_date`
+(strings as sent by the provider), `error?` and `not_found?`.
 
+### Errors
+
+All errors inherit from `SmsTraffic::Error`:
+
+- `SmsTraffic::ConnectionError` - network, timeout or TLS failure (the original exception is `cause`).
+- `SmsTraffic::HttpError` - non-2xx response; has `status` and `body`.
+- `SmsTraffic::ApiError` - the provider replied `ERROR`; has `code` and `description`.
+
+```ruby
+begin
+  SmsTraffic::Client.deliver('79991112233', 'text')
+rescue SmsTraffic::ApiError => e
+  e.code        # => '401'
+  e.description # => 'login param is missing'
+rescue SmsTraffic::Error => e
+  e.message
+end
 ```
 
 # Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/golifox/sms_traffic_sdk. 
+Bug reports and pull requests are welcome on GitHub at https://github.com/golifox/sms_traffic_sdk.
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 

data/lib/sms_traffic/client/deliver_reply.rb

@@ -1,62 +1,45 @@
 module SmsTraffic
   class Client
-    class DeliverReply < Client::Reply
-      OK_REPLY = 'OK'.freeze unless const_defined?(:OK_REPLY)
+    class DeliverReply < Reply
+      OK_RESULT = 'OK'.freeze
 
+      # @return [Boolean] result is OK and at least one message was queued
       def ok?
-        result == OK_REPLY && message_infos
+        result == OK_RESULT && !messages.empty?
       end
 
       def error?
         !ok?
       end
 
-      def result
-        fetch_value(hash, :result)
-      end
-
-      def code
-        fetch_value(hash, :code)
-      end
-
-      def description
-        fetch_value(hash, :description)
-      end
-
-      def message_infos
-        fetch_value(hash, :message_infos)
-      end
-
-      def sms_id(phone = nil)
-        message_info = fetch_value(message_infos, :message_info)
-        return fetch_value(message_info, :sms_id) if message_info.is_a?(Hash) || message_info.nil?
-
-        if phone
-          fetch_value(find_message_info(phone), :sms_id)
-        elsif message_info.is_a?(Array)
-          fetch_value(message_info.first, :sms_id)
+      # @return [Array<Hash>] queued messages as { phone:, sms_id:, push_id: }
+      def messages
+        @messages ||= message_infos.map do |info|
+          { phone: fetch_value(info, :phone), sms_id: fetch_value(info, :sms_id), push_id: fetch_value(info, :push_id) }
         end
       end
 
+      # @return [Array<String>] every sms id in reply order
       def sms_ids
-        message_info = fetch_value(message_infos, :message_info)
-
-        return [fetch_value(message_info, :sms_id)] if message_info&.size == 1
-        return [] if message_info.nil?
+        messages.filter_map { |message| message[:sms_id] }
+      end
 
-        message_info.each_with_object({}) do |info, hash|
-          hash[fetch_value(info, :phone)] = fetch_value(info, :sms_id)
-        end
+      # @param phone [String, nil]
+      # @return [String, nil] the first sms id, or the first one for the phone
+      def sms_id(phone = nil)
+        message = phone ? messages.find { |item| item[:phone].to_s == phone.to_s } : messages.first
+        message&.fetch(:sms_id)
       end
 
       def error_description
-        "#{result}: code: #{code}, description: #{description}" if error?
+        "Sms has not been enqueued: #{description}" if error?
       end
 
       private
 
-      def find_message_info(phone)
-        fetch_value(message_infos, :message_info).find { |info| fetch_value(info, :phone) == phone }
+      def message_infos
+        info = fetch_value(fetch_value(to_h, :message_infos), :message_info)
+        info.is_a?(Array) ? info : [info].compact
       end
     end
   end

data/lib/sms_traffic/client/reply.rb

@@ -1,19 +1,38 @@
 module SmsTraffic
   class Client
     class Reply
-      attr_reader :xml, :hash
+      ERROR_RESULT = 'ERROR'.freeze
+
+      attr_reader :xml, :to_h
 
       def initialize(xml, xml_parser: SmsTraffic.configuration.xml_parser)
-        @xml  = xml.gsub!(/\s+/, ' ')
-        @hash = fetch_value(xml_parser.parse(xml), :reply)
+        @xml = xml.gsub(/\s+/, ' ')
+        parsed = fetch_value(xml_parser.parse(@xml), :reply)
+        @to_h  = parsed.is_a?(Hash) ? parsed : {}
+      end
+
+      def result
+        fetch_value(to_h, :result)
+      end
+
+      def code
+        fetch_value(to_h, :code)
+      end
+
+      def description
+        fetch_value(to_h, :description)
+      end
+
+      def api_error?
+        result == ERROR_RESULT
       end
 
       private
 
-      def fetch_value(hash, key)
-        hash.fetch(key.to_s, nil) || hash.fetch(key.to_sym, nil)
-      rescue NoMethodError
-        nil
+      def fetch_value(source, key)
+        return unless source.is_a?(Hash)
+
+        source.fetch(key.to_s) { source[key.to_sym] }
       end
     end
   end

data/lib/sms_traffic/client/status_reply.rb

@@ -1,43 +1,77 @@
 module SmsTraffic
   class Client
     class StatusReply < Reply
-      def sms_array
-        fetch_value(hash, :sms).is_a?(Array) ? fetch_value(hash, :sms) : [hash]
+      NOT_FOUND = /no such message/i
+
+      Entry = Struct.new(
+        :sms_id, :status, :error, :submission_date, :send_date, :last_status_change_date, keyword_init: true
+      ) do
+        def error?
+          !error.nil?
+        end
+
+        def not_found?
+          error? && error.match?(NOT_FOUND)
+        end
+      end
+
+      # @return [Array<Entry>]
+      def entries
+        @entries ||= entry_sources.map { |source| build_entry(source) }
       end
 
-      def status(sms_id = nil)
-        return fetch_value(sms_array.first, :status) if sms_array.size == 1
+      # @param sms_id [String, nil] required unless the reply has exactly one entry
+      # @return [Entry, nil]
+      def entry(sms_id = nil)
+        return entries.find { |item| item.sms_id.to_s == sms_id.to_s } if sms_id
+        return entries.first if entries.size == 1
 
-        raise ArgumentError, 'sms_id is required' if sms_id.nil?
+        raise ArgumentError, 'sms_id is required'
+      end
+
+      %i[status error send_date].each do |name|
+        define_method(name) { |sms_id = nil| entry(sms_id)&.public_send(name) }
+      end
 
-        statuses[sms_id.to_s]
+      %i[error? not_found?].each do |name|
+        define_method(name) { |sms_id = nil| entry(sms_id)&.public_send(name) || false }
       end
 
-      # @return [Hash] statuses hash (key: sms_id, value: status)
-      # @example
-      #
-      #  {
-      #    '1234567890': 'DELIVERED',
-      #    '0987654321': 'FAILED'
-      #  }
+      # @return [Hash{String => String}] sms_id => status, without nil values
       def statuses
-        sms_array.each_with_object({}) do |sms, hash|
-          hash[fetch_value(sms, :sms_id)] = fetch_value(sms, :status)
-        end.compact
+        entries.to_h { |item| [item.sms_id, item.status] }.compact
       end
 
-      def error(sms_id = nil)
-        return fetch_value(sms_array.first, :error) if sms_array.size == 1
+      # @return [Hash{String => String}] sms_id => error, without nil values
+      def errors
+        entries.to_h { |item| [item.sms_id, item.error] }.compact
+      end
+
+      private
 
-        raise ArgumentError, 'sms_id is required' if sms_id.nil?
+      def entry_sources
+        sms = fetch_value(to_h, :sms)
+        return sms if sms.is_a?(Array)
+        return [sms] if sms.is_a?(Hash)
 
-        errors[sms_id.to_s]
+        to_h.empty? ? [] : [to_h]
       end
 
-      def errors
-        sms_array.each_with_object({}) do |sms, hash|
-          hash[fetch_value(sms, :sms_id)] = fetch_value(sms, :error)&.strip
-        end.compact
+      def blank_to_nil(value)
+        stripped = value&.strip
+        stripped unless stripped.nil? || stripped.empty?
+      end
+
+      def build_entry(source)
+        Entry.new(
+          sms_id:                  fetch_value(source, :sms_id),
+          status:                  fetch_value(source, :status),
+          error:                   blank_to_nil(fetch_value(source, :error)),
+          # The provider spells this field "submition_date".
+          submission_date:         fetch_value(source, :submition_date),
+          send_date:               fetch_value(source, :send_date),
+          last_status_change_date: fetch_value(source, :last_status_change_date)
+        )
       end
     end
   end

data/lib/sms_traffic/client.rb

@@ -1,77 +1,104 @@
 require 'net/http'
+require 'openssl'
+require 'uri'
+require_relative 'client/reply'
+require_relative 'client/deliver_reply'
+require_relative 'client/status_reply'
 
 module SmsTraffic
   class Client
-    class << self
-      attr_reader :uri
+    ENDPOINT = 'multi.php'.freeze
+    FILTERED = '[FILTERED]'.freeze
+    FILTERED_PARAMS = %i[login password message].freeze
+    CONNECTION_ERRORS = [
+      SocketError, SystemCallError, IOError, Net::OpenTimeout, Net::ReadTimeout, OpenSSL::SSL::SSLError
+    ].freeze
 
-      # @param phone [String] phone number
+    class << self
+      # @param phone [String] phone number or phone numbers separated by comma
       # @param message [String] message
-      # @param originator [String] originator (subject)
+      # @param originator [String] originator (subject), defaults to the configured one
       # @param options [Hash] additional options
+      # @return [DeliverReply]
+      # @raise [ConnectionError, HttpError, ApiError]
       def deliver(phone, message, originator = nil, **options)
         originator ||= SmsTraffic.configuration.originator
-        form_data = deliver_params(phone, message, originator, **options)
-        response = perform_request(form_data)
-        Response.new(response, type: :deliver)
+        build_reply(DeliverReply, post(deliver_params(phone, message, originator, **options)))
       end
 
-      # @param message_id [String] message id
-      def status(*message_ids)
-        form_data = status_params(message_ids)
-        response = perform_request(form_data)
-        Response.new(response, type: :status)
+      # @param sms_ids [Array<String>] sms ids
+      # @return [StatusReply]
+      # @raise [ConnectionError, HttpError, ApiError]
+      def status(*sms_ids)
+        build_reply(StatusReply, post(status_params(sms_ids)))
       end
 
       private
 
-      # @return [Net::HTTP]
-      def connection
-        host, logger = SmsTraffic.configuration.values_at(:host, :logger)
+      def build_reply(reply_class, body)
+        reply = reply_class.new(body)
+        raise ApiError.new(reply.code, reply.description) if reply.api_error?
 
-        @uri ||= URI.join(host, 'multi.php')
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.read_timeout = 30
-        http.use_ssl = (uri.scheme == 'https')
-        http.set_debug_output(logger)
-        http
+        reply
       end
 
       # @param form_data [Hash<Symbol, String|Integer>]
-      # @return [Net::HTTPResponse]
-      def perform_request(form_data)
-        connection.start do |http|
+      # @return [String] response body
+      def post(form_data)
+        config = SmsTraffic.configuration
+        uri    = URI.join(config.host, ENDPOINT)
+        log("request POST #{uri} #{filter(form_data)}")
+
+        response = perform(uri, form_data, config)
+        log("response #{response.code} (#{response.body.to_s.bytesize} bytes)")
+        successful_body(response)
+      rescue *CONNECTION_ERRORS => e
+        raise ConnectionError, "#{e.class}: #{e.message}"
+      end
+
+      def successful_body(response)
+        raise HttpError.new(response.code.to_i, response.body) unless response.is_a?(Net::HTTPSuccess)
+
+        response.body
+      end
+
+      def perform(uri, form_data, config)
+        options = { use_ssl: uri.scheme == 'https', open_timeout: config.open_timeout,
+                    read_timeout: config.read_timeout }
+        Net::HTTP.start(uri.host, uri.port, **options) do |http|
           request = Net::HTTP::Post.new(uri.request_uri)
           request.set_form_data(form_data)
           http.request(request)
         end
       end
 
-      # @param phone [String] phone number or phone numbers separated by comma
-      # @param message [String] message
-      # @param originator [String] originator (subject)
-      # @param options [Hash] additional options
-      # @return [Hash<Symbol, String|Integer>]
+      def log(line)
+        config = SmsTraffic.configuration
+        config.logger.debug("[SmsTraffic] #{line}") if config.debug
+      end
+
+      def filter(form_data)
+        form_data.to_h { |key, value| [key, FILTERED_PARAMS.include?(key) ? FILTERED : value] }
+      end
+
       def deliver_params(phone, message, originator, **options)
         {
           login:        SmsTraffic.configuration.login,
           password:     SmsTraffic.configuration.password,
           phones:       phone,
-          message:      message,
+          message:,
           want_sms_ids: 1,
           rus:          5,
-          originator:   originator
+          originator:
         }.merge(options)
       end
 
-      # @param message_ids [Array<String>] message ids
-      # @return [Hash<Symbol, String|Integer>]
-      def status_params(*message_ids)
+      def status_params(sms_ids)
         {
           login:     SmsTraffic.configuration.login,
           password:  SmsTraffic.configuration.password,
           operation: 'status',
-          sms_id:    message_ids.join(',')
+          sms_id:    sms_ids.join(',')
         }
       end
     end

data/lib/sms_traffic/configuration.rb

@@ -1,75 +1,39 @@
-require 'singleton'
 require 'nori'
 
 module SmsTraffic
   class Configuration
-    include Singleton
+    ATTRIBUTES = %i[
+      login password host originator debug logger open_timeout read_timeout validate_phone xml_parser
+    ].freeze
 
-    attr_accessor :login, :password, :host, :originator, :debug, :logger, :xml_parser, :validate_phone
+    attr_accessor(*ATTRIBUTES)
 
     def initialize
-      self.debug          = default_configuration[:debug]
-      self.logger         = default_configuration[:logger]
-      self.xml_parser     = default_configuration[:xml_parser]
-      self.validate_phone = default_configuration[:validate_phone]
-      super
+      reset!
     end
 
     def reset!
-      default_configuration.each do |key, value|
-        send("#{key}=", value)
-      end
+      self.login          = nil
+      self.password       = nil
+      self.host           = nil
+      self.originator     = nil
+      self.debug          = false
+      self.logger         = nil
+      self.open_timeout   = 10
+      self.read_timeout   = 30
+      self.validate_phone = true
+      self.xml_parser     = Nori.new(advanced_typecasting: false)
     end
 
     def validate!
-      validation_rules.each do |key, value|
-        raise ArgumentError, "#{key} should be defined for #{self}." if value.nil?
-      end
+      raise ArgumentError, 'login should be defined' if login.nil?
+      raise ArgumentError, 'password should be defined' if password.nil?
+      raise ArgumentError, 'host should be defined' if host.nil?
+      raise ArgumentError, 'logger should be defined when debug is enabled' if debug && logger.nil?
     end
 
     def to_h
-      {
-        login:      login,
-        password:   password,
-        host:       host,
-        originator: originator,
-        debug:      debug,
-        logger:     logger,
-        xml_parser: xml_parser
-      }
-    end
-
-    def values_at(*keys)
-      to_h.values_at(*keys)
-    end
-
-    private
-
-    def default_configuration
-      {
-        login:          nil,
-        password:       nil,
-        host:           nil,
-        originator:     nil,
-        debug:          false,
-        logger:         $stdout,
-        xml_parser:     default_xml_parser,
-        validate_phone: true
-      }
-    end
-
-    def validation_rules
-      {
-        'Login'        => login,
-        'Password'     => password,
-        'Server'       => host,
-        'Originator'   => originator,
-        'Debug logger' => debug && !logger ? nil : true
-      }
-    end
-
-    def default_xml_parser
-      @default_xml_parser ||= Nori.new(advanced_typecasting: true).freeze
+      ATTRIBUTES.to_h { |attribute| [attribute, public_send(attribute)] }
     end
   end
 end

data/lib/sms_traffic/errors.rb

@@ -0,0 +1,28 @@
+module SmsTraffic
+  class Error < StandardError; end
+
+  # Network or TLS failure; the original exception is available as +cause+.
+  class ConnectionError < Error; end
+
+  # Non-2xx HTTP status.
+  class HttpError < Error
+    attr_reader :status, :body
+
+    def initialize(status, body)
+      @status = status
+      @body   = body
+      super("HTTP #{status}")
+    end
+  end
+
+  # HTTP 200 reply whose result is ERROR.
+  class ApiError < Error
+    attr_reader :code, :description
+
+    def initialize(code, description)
+      @code        = code
+      @description = description
+      super("#{code}: #{description}")
+    end
+  end
+end

data/lib/sms_traffic/sms.rb

@@ -1,54 +1,67 @@
 module SmsTraffic
   class Sms
+    PHONE_FORMAT = /\A\d{11,}\z/
+
     attr_accessor :phone, :message, :originator
-    attr_reader :id, :status, :errors
+    attr_reader :id, :status, :errors, :reply
 
     def initialize(phone, message, originator: nil)
       @phone      = phone
       @message    = message
       @originator = originator || SmsTraffic.configuration.originator
+      @reply      = nil
       @status     = 'not-sent'
       @errors     = []
       validate!
     end
 
-    def deliver # rubocop:disable Metrics/MethodLength
-      # @type [Client::Response]
-      response = Client.deliver(phone, message, originator)
-
-      unless response.success?
-        @errors << response.error_description
-        return false
-      end
-
-      # @type [Client::Response::Reply]
-      reply = response.reply
+    # @return [Boolean] true when the provider enqueued the sms
+    def deliver
+      @reply = Client.deliver(phone, message, originator)
 
-      if reply.ok?
-        @status = 'sent'
-        @id     = reply.sms_id || reply.sms_ids.values.first
-        true
-      else
-        @errors << (reply.error_description || 'Sms has been not enqueued')
-        false
-      end
+      reply.ok? ? mark_sent : add_error(reply.error_description)
+      reply.ok?
+    rescue SmsTraffic::Error => e
+      add_error(e.message)
+      false
     end
 
+    # @return [String] the current status; unchanged when the check fails
     def update_status
       return status if id.nil?
 
-      response = Client.status(id)
-      return response.code unless response.success?
-
-      @status = response.reply.status.downcase
+      apply_entry(Client.status(id).entry(id))
+      status
+    rescue SmsTraffic::Error => e
+      add_error(e.message)
+      status
     end
 
     private
 
-    def validate! # rubocop:disable Metrics/ AbcSize
+    def mark_sent
+      @status = 'sent'
+      @id     = reply.sms_id
+    end
+
+    def add_error(error)
+      @errors << error
+    end
+
+    def apply_entry(entry)
+      if entry&.error?
+        add_error(entry.error)
+      elsif entry&.status
+        @status = entry.status.downcase
+      else
+        add_error("No status returned for sms #{id}")
+      end
+    end
+
+    def validate! # rubocop:disable Metrics/AbcSize
       raise ArgumentError, "Phone should be assigned to #{self.class}." if phone.nil?
 
-      if SmsTraffic.configuration.validate_phone && phone.to_s !~ /^[0-9]{11,}$/
+      if SmsTraffic.configuration.validate_phone && !PHONE_FORMAT.match?(phone.to_s)
         raise ArgumentError, 'Phone number should contain only numbers. Minimum length is 11.'
       end
 

data/lib/sms_traffic/version.rb

@@ -1,3 +1,3 @@
 module SmsTraffic
-  VERSION = '0.0.7'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/lib/sms_traffic.rb

@@ -1,19 +1,16 @@
-require 'zeitwerk'
-
-loader = Zeitwerk::Loader.for_gem
-loader.ignore("#{__dir__}/sms_traffic/version.rb")
-loader.enable_reloading
-loader.setup
-
 require_relative 'sms_traffic/version'
+require_relative 'sms_traffic/errors'
+require_relative 'sms_traffic/configuration'
+require_relative 'sms_traffic/client'
+require_relative 'sms_traffic/sms'
 
 module SmsTraffic
   class << self
     def configuration
-      @configuration ||= Configuration.instance
+      @configuration ||= Configuration.new
     end
 
-    def configure(&_block)
+    def configure
       yield(configuration) if block_given?
       configuration.validate!
     end

data/lib/sms_traffic_sdk.rb

@@ -0,0 +1 @@
+require_relative 'sms_traffic'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sms_traffic_sdk
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - David Rybolovlev
 autorequire:
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2024-10-18 00:00:00.000000000 Z
+date: 2026-11-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -30,68 +30,44 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
-- !ruby/object:Gem::Dependency
-  name: zeitwerk
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.8'
 description: |-
   Ruby Gem as a SDK for interacting with the SMS Traffic HTTP API (smstraffic.ru/api).
                           This gem provides a convenient way to integrate SMS Traffic services into Ruby applications,
                           enabling tasks such as sending SMS messages, checking delivery status, and others.
 email:
 - i@golifox.ru
-executables:
-- konsierge-sms.rb
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".env.template"
-- ".fasterer.yml"
-- ".github/workflows/ci.yml"
-- ".gitignore"
-- ".rspec"
-- ".rubocop.yml"
-- ".tool-versions"
-- Gemfile
+- CHANGELOG.md
 - LICENSE
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
-- exe/konsierge-sms.rb
 - lib/sms_traffic.rb
 - lib/sms_traffic/client.rb
 - lib/sms_traffic/client/deliver_reply.rb
 - lib/sms_traffic/client/reply.rb
-- lib/sms_traffic/client/response.rb
 - lib/sms_traffic/client/status_reply.rb
 - lib/sms_traffic/configuration.rb
+- lib/sms_traffic/errors.rb
 - lib/sms_traffic/sms.rb
 - lib/sms_traffic/version.rb
-- sms_traffic_sdk.gemspec
-homepage: https://github.com/golifox/sms_traffic
+- lib/sms_traffic_sdk.rb
+homepage: https://github.com/golifox/sms_traffic_sdk
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/golifox/sms_traffic_sdk
+  changelog_uri: https://github.com/golifox/sms_traffic_sdk/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -100,14 +76,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Send sms via SmsTraffic service.

data/.env.template

@@ -1,4 +0,0 @@
-SMS_TRAFFIC_HOST=SMS_TRAFFIC_HOST
-SMS_TRAFFIC_LOGIN=SMS_TRAFFIC_LOGIN
-SMS_TRAFFIC_PASSWORD=SMS_TRAFFIC_PASSWORD
-SMS_TRAFFIC_ORIGINATOR=SMS_TRAFFIC_ORIGINATOR

data/.fasterer.yml

@@ -1,2 +0,0 @@
-speedups:
-  fetch_with_argument_vs_block: false

data/.github/workflows/ci.yml

@@ -1,72 +0,0 @@
-name: Ruby Gem CI/CD
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        ruby-version: ['2.7', '3.0', '3.1', '3.2', '3.3']
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby-version }}
-
-      - name: Install Bundler for Ruby < 3.0
-        if: ${{ matrix.ruby-version < '3.0' }}
-        run: gem install bundler -v 2.4.22 --no-document
-
-      - name: Install Bundler for Ruby >= 3.0
-        if: ${{ matrix.ruby-version >= '3.0' }}
-        run: gem install bundler -v '~> 2.5' --no-document
-
-      - name: Install dependencies
-        run: bundle install --jobs 4 --retry 3
-
-      - name: Run tests and linting
-        run: bundle exec rake
-
-      - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v4.0.1
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          file: ./coverage/.resultset.json
-          fail_ci_if_error: false
-
-  publish:
-    needs: build
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/v')
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Set up Ruby for publish
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: '3.3'
-
-      - name: Install dependencies
-        run: |
-          gem install bundler --no-document
-          bundle install --jobs 4 --retry 3
-
-      - name: Build gem
-        run: |
-          gem build *.gemspec
-
-      - name: Push gem to RubyGems
-        run: |
-          gem push *.gem
-        env:
-          GEM_HOST_API_KEY: ${{secrets.GEM_HOST_API_KEY}}

data/.gitignore

@@ -1,12 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-.idea/
-.rspec_status
-.env

data/.rspec

@@ -1,2 +0,0 @@
---require spec_helper
---color

data/.rubocop.yml

@@ -1,20 +0,0 @@
-AllCops:
-  TargetRubyVersion: 2.7.4
-  NewCops: enable
-  SuggestExtensions: false
-  Exclude:
-    - 'bin/**/*'
-
-Style/Documentation:
-  Enabled: false
-
-Style/FrozenStringLiteralComment:
-  EnforcedStyle: 'never'
-
-Layout/HashAlignment:
-  EnforcedHashRocketStyle: table
-  EnforcedColonStyle: table
-
-Metrics/BlockLength:
-  Exclude:
-    - 'spec/**/*'

data/.tool-versions

@@ -1 +0,0 @@
-ruby 3.3.3

data/Gemfile

@@ -1,17 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-group :development, :test do
-  gem 'dotenv', '~> 2.7'
-  gem 'fasterer', '~> 0.9'
-  gem 'rack', '~> 3.1.7'
-  gem 'rake', '~> 13.2'
-  gem 'rspec', '~> 3.10'
-  gem 'rspec-mocks', '~> 3.10'
-  gem 'rubocop', '~> 1.18'
-  gem 'rubocop-performance', '~> 1.11'
-  gem 'rubocop-rspec', '~> 2.11'
-  gem 'simplecov', '~> 0.22'
-  gem 'webmock', '~> 3.14'
-end

data/Rakefile

@@ -1,10 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
-require 'rubocop/rake_task'
-
-RuboCop::RakeTask.new
-
-task default: %i[spec rubocop]

data/bin/console

@@ -1,18 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'dotenv'
-require 'sms_traffic'
-
-Dotenv.load('.env')
-
-SmsTraffic.configure do |config|
-  config.host       = ENV['SMS_TRAFFIC_HOST']
-  config.login      = ENV['SMS_TRAFFIC_LOGIN']
-  config.password   = ENV['SMS_TRAFFIC_PASSWORD']
-  config.originator = ENV['SMS_TRAFFIC_ORIGINATOR']
-end
-
-
-require 'irb'
-IRB.start

data/bin/setup

@@ -1,7 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-IFS=$'\n\t'
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/exe/konsierge-sms.rb

@@ -1,2 +0,0 @@
-#!/usr/bin/env ruby
-require 'konsierge/sms_traffic'

data/lib/sms_traffic/client/response.rb

@@ -1,39 +0,0 @@
-require_relative 'deliver_reply'
-require_relative 'status_reply'
-
-module SmsTraffic
-  class Client
-    class Response
-      attr_reader :origin, :reply, :code, :body, :message
-
-      REPLY_HASH_MAP = {
-        :status  => StatusReply,
-        :deliver => DeliverReply,
-        nil      => Reply
-      }.freeze
-
-      def initialize(response, type: nil)
-        @origin = response
-        @code = response.code.to_i
-        @body = response.body
-        @message = response.message
-
-        return unless success?
-
-        @reply = REPLY_HASH_MAP[type].new(body)
-      end
-
-      def success?
-        code == 200
-      end
-
-      def failure?
-        !success?
-      end
-
-      def error_description
-        "#{code}: #{message}" if failure?
-      end
-    end
-  end
-end

data/sms_traffic_sdk.gemspec

@@ -1,31 +0,0 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require_relative 'lib/sms_traffic/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'sms_traffic_sdk'
-  spec.version       = SmsTraffic::VERSION
-  spec.authors       = ['David Rybolovlev']
-  spec.email         = ['i@golifox.ru']
-
-  spec.summary       = 'Send sms via SmsTraffic service.'
-  spec.description   = 'Ruby Gem as a SDK for interacting with the SMS Traffic HTTP API (smstraffic.ru/api).
-                        This gem provides a convenient way to integrate SMS Traffic services into Ruby applications,
-                        enabling tasks such as sending SMS messages, checking delivery status, and others.'
-  spec.homepage      = 'https://github.com/golifox/sms_traffic'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.required_ruby_version = '>= 2.7.0'
-
-  spec.add_dependency 'nokogiri', '~> 1.12'
-  spec.add_dependency 'nori', '~> 2.6'
-  spec.add_dependency 'zeitwerk', '~> 2.5'
-
-  spec.metadata['rubygems_mfa_required'] = 'true'
-end