wittyflow 0.1.0 → 1.0.1

data/examples/rails_initializer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# config/initializers/wittyflow.rb
+#
+# Wittyflow SMS Gem Configuration
+# This initializer sets up the Wittyflow SMS service for your Rails application
+
+Wittyflow.configure do |config|
+  # Required: Your Wittyflow API credentials
+  # Get these from your Wittyflow dashboard
+  config.app_id = Rails.application.credentials.wittyflow_app_id || ENV.fetch("WITTYFLOW_APP_ID", nil)
+  config.app_secret = Rails.application.credentials.wittyflow_app_secret || ENV.fetch("WITTYFLOW_APP_SECRET", nil)
+
+  # Optional: API endpoint (default is production endpoint)
+  # config.api_endpoint = "https://api.wittyflow.com/v1"
+
+  # Optional: Request timeout in seconds (default: 30)
+  config.timeout = 30
+
+  # Optional: Number of retries for failed requests (default: 3)
+  config.retries = 3
+
+  # Optional: Delay between retries in seconds (default: 1)
+  config.retry_delay = 1
+
+  # Optional: Default country code for phone number formatting (default: "233" for Ghana)
+  config.default_country_code = "233"
+
+  # Optional: Custom logger (default: Logger to STDOUT)
+  # Use Rails logger in Rails applications
+  config.logger = Rails.logger
+
+  # Optional: Set log level for Wittyflow-specific logs
+  # config.logger.level = Logger::INFO
+end
+
+# Validate configuration in development and production
+if (Rails.env.development? || Rails.env.production?) && !Wittyflow.config.valid?
+  Rails.logger.warn "Wittyflow configuration is invalid. SMS functionality will not work."
+  Rails.logger.warn "Please ensure WITTYFLOW_APP_ID and WITTYFLOW_APP_SECRET are set."
+end
+
+# Example: Test the configuration in development
+if Rails.env.development? && Wittyflow.config.valid?
+  Rails.application.configure do
+    config.after_initialize do
+      Wittyflow::Client.new
+      # You can uncomment the line below to test account balance on startup
+      # balance = client.account_balance
+      # Rails.logger.info "Wittyflow account balance: #{balance}"
+      Rails.logger.info "Wittyflow SMS gem initialized successfully"
+    rescue Wittyflow::Error => e
+      Rails.logger.warn "Wittyflow initialization test failed: #{e.message}"
+    end
+  end
+end

data/lib/wittyflow/client.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "timeout"
+
+module Wittyflow
+  class Client
+    include HTTParty
+
+    attr_reader :app_id, :app_secret, :config
+
+    def initialize(app_id: nil, app_secret: nil, **options)
+      @app_id = app_id || Wittyflow.config.app_id
+      @app_secret = app_secret || Wittyflow.config.app_secret
+      @config = build_config(options)
+
+      validate_credentials!
+      setup_httparty
+    end
+
+    # Send regular SMS
+    def send_sms(from:, to:, message:)
+      send_message(from: from, to: to, message: message, type: :regular)
+    end
+
+    # Send flash SMS (appears directly on screen)
+    def send_flash_sms(from:, to:, message:)
+      send_message(from: from, to: to, message: message, type: :flash)
+    end
+
+    # Check SMS delivery status
+    def message_status(message_id)
+      validate_presence!(:message_id, message_id)
+
+      url = "#{config.api_endpoint}/messages/#{message_id}/retrieve"
+      params = auth_params
+
+      with_error_handling do
+        response = self.class.get(url, query: params, timeout: config.timeout)
+        parse_response(response)
+      end
+    end
+
+    # Get account balance
+    def account_balance
+      url = "#{config.api_endpoint}/account/balance"
+      params = auth_params
+
+      with_error_handling do
+        response = self.class.get(url, query: params, timeout: config.timeout)
+        parse_response(response)
+      end
+    end
+
+    # Send bulk SMS to multiple recipients
+    def send_bulk_sms(from:, to:, message:, type: :regular)
+      validate_presence!(:from, from)
+      validate_presence!(:to, to)
+      validate_presence!(:message, message)
+
+      recipients = Array(to).map { |phone| format_phone_number(phone) }
+
+      recipients.map do |recipient|
+        send_message(from: from, to: recipient, message: message, type: type)
+      end
+    end
+
+    private
+
+    def build_config(options)
+      config = Configuration.new
+      config.api_endpoint = options[:api_endpoint] || Wittyflow.config.api_endpoint
+      config.timeout = options[:timeout] || Wittyflow.config.timeout
+      config.retries = options[:retries] || Wittyflow.config.retries
+      config.retry_delay = options[:retry_delay] || Wittyflow.config.retry_delay
+      config.logger = options[:logger] || Wittyflow.config.logger
+      config.default_country_code = options[:default_country_code] || Wittyflow.config.default_country_code
+      config
+    end
+
+    def setup_httparty
+      self.class.base_uri config.api_endpoint
+      self.class.headers({
+                           "Content-Type" => "application/x-www-form-urlencoded",
+                           "Accept" => "application/json",
+                           "User-Agent" => "Wittyflow Ruby Gem #{Wittyflow::VERSION}"
+                         })
+    end
+
+    def validate_credentials!
+      raise ConfigurationError, "app_id is required" if app_id.nil? || app_id.empty?
+      raise ConfigurationError, "app_secret is required" if app_secret.nil? || app_secret.empty?
+    end
+
+    def validate_presence!(field, value)
+      raise ValidationError, "#{field} is required" if value.nil? || value.to_s.empty?
+    end
+
+    def send_message(from:, to:, message:, type:)
+      validate_presence!(:from, from)
+      validate_presence!(:to, to)
+      validate_presence!(:message, message)
+
+      formatted_to = format_phone_number(to)
+
+      body = {
+        from: from.to_s,
+        to: formatted_to,
+        message: message.to_s,
+        type: type == :flash ? 0 : 1,
+        app_id: app_id,
+        app_secret: app_secret
+      }
+
+      url = "#{config.api_endpoint}/messages/send"
+
+      with_error_handling do
+        response = self.class.post(url, body: body, timeout: config.timeout)
+        parse_response(response)
+      end
+    end
+
+    def format_phone_number(phone)
+      phone_str = phone.to_s.strip
+
+      # Remove any non-digit characters except +
+      phone_str = phone_str.gsub(/[^\d+]/, "")
+
+      # Handle different phone number formats
+      case phone_str
+      when /^\+233/ # International format for Ghana
+        phone_str.sub(/^\+/, "")
+      when /^233/ # Ghana country code without +
+        phone_str
+      when /^0/ # Local format starting with 0
+        "#{config.default_country_code}#{phone_str[1..]}"
+      else # Assume it's a local number without leading 0
+        "#{config.default_country_code}#{phone_str}"
+      end
+    end
+
+    def auth_params
+      {
+        app_id: app_id,
+        app_secret: app_secret
+      }
+    end
+
+    def with_error_handling
+      attempts = 0
+      begin
+        attempts += 1
+        yield
+      rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout, Timeout::Error => e
+        raise NetworkError, "Network timeout: #{e.message}"
+      rescue HTTParty::Error, SocketError => e
+        unless attempts < config.retries
+          raise NetworkError, "Network error after #{config.retries} attempts: #{e.message}"
+        end
+
+        config.logger&.warn(
+          "Request failed (attempt #{attempts}/#{config.retries}), " \
+          "retrying in #{config.retry_delay}s: #{e.message}"
+        )
+        sleep(config.retry_delay)
+        retry
+      rescue Wittyflow::Error => e
+        # Re-raise our custom errors without modification
+        raise e
+      rescue StandardError => e
+        raise APIError, "Unexpected error: #{e.message}"
+      end
+    end
+
+    def parse_response(response)
+      case response.code
+      when 200..299
+        response.parsed_response
+      when 401
+        raise AuthenticationError, "Invalid app_id or app_secret"
+      when 400
+        error_message = response.parsed_response&.dig("message") || "Bad request"
+        raise ValidationError, error_message
+      when 429
+        raise APIError, "Rate limit exceeded"
+      when 500..599
+        raise APIError, "Server error (#{response.code})"
+      else
+        raise APIError, "Unexpected response (#{response.code}): #{response.body}"
+      end
+    end
+  end
+end

data/lib/wittyflow/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Wittyflow
+  class Configuration
+    attr_accessor :app_id, :app_secret, :api_endpoint, :timeout, :retries, :retry_delay, :logger, :default_country_code
+
+    def initialize
+      @api_endpoint = "https://api.wittyflow.com/v1"
+      @timeout = 30
+      @retries = 3
+      @retry_delay = 1
+      @logger = Logger.new($stdout, level: Logger::INFO)
+      @default_country_code = "233" # Ghana
+    end
+
+    def valid?
+      !app_id.nil? && !app_secret.nil? && !app_id.empty? && !app_secret.empty?
+    end
+  end
+end

data/lib/wittyflow/sms.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Wittyflow
+  # Backward compatibility wrapper for the old Sms class
+  # @deprecated Use Wittyflow::Client instead
+  class Sms
+    def initialize(app_id, app_secret)
+      warn "[DEPRECATION] Wittyflow::Sms is deprecated. Use Wittyflow::Client instead."
+      @client = Client.new(app_id: app_id, app_secret: app_secret)
+    end
+
+    def send_sms(sender, receiver_phone_number, message_to_send)
+      @client.send_sms(from: sender, to: receiver_phone_number, message: message_to_send)
+    end
+
+    def send_flash_sms(sender, receiver_phone_number, message_to_send)
+      @client.send_flash_sms(from: sender, to: receiver_phone_number, message: message_to_send)
+    end
+
+    def check_sms_status(sms_id)
+      @client.message_status(sms_id)
+    end
+
+    def account_balance
+      @client.account_balance
+    end
+
+    private
+
+    attr_reader :client
+  end
+end

data/lib/wittyflow/version.rb

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

data/lib/wittyflow.rb

@@ -1,76 +1,36 @@
 # frozen_string_literal: true
 
-require_relative "wittyflow/version"
-require 'httparty'
+require "zeitwerk"
+require "httparty"
+require "logger"
 
-module Wittyflow
-
-  class Sms
-    attr_accessor :app_id, :app_secret, :api_endpoint
-
-    def initialize(app_id, app_secret)
-      @app_id       = app_id
-      @app_secret   = app_secret
-      @api_endpoint = "https://api.wittyflow.com/v1"
-    end
-
-    def send_sms(sender, receiver_phone_number, message_to_send)
-      send_general_sms(sender, receiver_phone_number, message_to_send)
-    end
-
-    def send_flash_sms(sender, receiver_phone_number, message_to_send)
-      send_general_sms(sender, receiver_phone_number, message_to_send, is_flash=true)
-    end
-
-    def check_sms_status(sms_id)
-      make_request(form_sms_status_check_url(sms_id), {}, "get")
-    end
-
-    def account_balance
-      make_request(account_balance_url, {}, "get")
-    end
+loader = Zeitwerk::Loader.for_gem
+loader.setup
 
-    private
-
-      def make_request(url, body, type="post")
-        options = {
-        	body: body
-        }
-        requ_hash = {
-          "post" => -> (url, options) {HTTParty.post(url, options)},
-          "get"  => -> (url, options) {HTTParty.get(url, {})},
-        }
-        results = requ_hash[type].call(url, options)
-      rescue => e
-        puts "ERROR: #{e}"
-      end
-
-      def form_send_sms_body(sender, receiver_phone_number, message_to_send, is_flash=false)
-        res = {
-          from: "#{sender}",
-          to:  "233#{receiver_phone_number[1..-1]}",
-          type: 1,
-          message: "#{message_to_send}",
-          app_id: "#{@app_id}",
-          app_secret: "#{@app_secret}"
-        }
-        res[:type] = 0 if is_flash
-        res
-      end
-
-      def send_general_sms(sender, receiver_phone_number, message_to_send, is_flash=false)
-        body_to_send = form_send_sms_body(sender, receiver_phone_number, message_to_send, is_flash)
-        send_sms_endpoint = "#{@api_endpoint}/messages/send"
-        make_request(send_sms_endpoint, body_to_send)
-      end
+module Wittyflow
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class APIError < Error; end
+  class NetworkError < Error; end
+  class AuthenticationError < Error; end
+  class ValidationError < Error; end
+
+  class << self
+    attr_accessor :configuration
+  end
 
-      def account_balance_url
-        "#{@api_endpoint}/account/balance?app_id=#{@app_id}&app_secret=#{@app_secret}"
-      end
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+    configuration
+  end
 
-      def form_sms_status_check_url(sms_id)
-        "#{@api_endpoint}/messages/#{sms_id}/retrieve?app_id=#{@app_id}&app_secret=#{@app_secret}"
-      end
+  def self.config
+    configuration || configure
   end
 
+  # For backward compatibility
+  def self.new(app_id, app_secret, options = {})
+    Client.new(app_id: app_id, app_secret: app_secret, **options)
+  end
 end

data/wittyflow.gemspec

@@ -8,28 +8,51 @@ Gem::Specification.new do |spec|
   spec.authors       = ["charlesagyemang"]
   spec.email         = ["micnkru@gmail.com"]
 
-  spec.summary       = "Send Sms To Any Number In Ghana Using Wittyflow"
-  spec.description   = "Send Sms To Any Number In Ghana Using Wittyflow"
+  spec.summary       = "A production-ready Ruby gem for sending SMS via Wittyflow API"
+  spec.description   = "Wittyflow is a robust, well-tested Ruby gem for integrating with the Wittyflow SMS service. " \
+                       "Features include SMS sending, delivery tracking, account balance checking, retry logic, " \
+                       "and comprehensive error handling."
   spec.homepage      = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem"
   spec.license       = "MIT"
-  spec.required_ruby_version = ">= 2.0.0"
-
-  # spec.metadata["allowed_push_host"] = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem"
+  spec.required_ruby_version = ">= 3.0.0"
 
+  spec.metadata["allowed_push_host"] = "https://rubygems.org"
   spec.metadata["homepage_uri"] = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem"
   spec.metadata["source_code_uri"] = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem"
-  spec.metadata["changelog_uri"] = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem"
+  spec.metadata["changelog_uri"] = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem/blob/master/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem/issues"
+  spec.metadata["documentation_uri"] = "https://github.com/charlesagyemang/wittyflow_sms_ruby_gem/blob/master/README.md"
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject do |f|
+      f.match(%r{\A(?:test|spec|features)/}) ||
+        f.start_with?(".") ||
+        f.match(/\A(Gemfile|Rakefile)/)
+    end
   end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  spec.add_dependency "httparty", "~> 0.17.3"
-
+  # Runtime dependencies (alphabetically ordered)
+  spec.add_dependency "csv", "~> 3.2"
+  spec.add_dependency "httparty", "~> 0.21.0"
+  spec.add_dependency "zeitwerk", "~> 2.6"
+
+  # Development dependencies
+  spec.add_development_dependency "guard", "~> 2.18"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "pry", "~> 0.14"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.12"
+  spec.add_development_dependency "rubocop", "~> 1.50"
+  spec.add_development_dependency "rubocop-performance", "~> 1.16"
+  spec.add_development_dependency "rubocop-rspec", "~> 2.20"
+  spec.add_development_dependency "simplecov", "~> 0.22"
+  spec.add_development_dependency "vcr", "~> 6.1"
+  spec.add_development_dependency "webmock", "~> 3.18"
+  spec.add_development_dependency "yard", "~> 0.9"
 end