stupid_sms 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 102162e4e03f1a19d7c0789be9ba66bc3ea0872e
-  data.tar.gz: 3af112e48be4bdd1667acc744b38e8fa75bae4fd
+  metadata.gz: a0b87a32085a57c4adefbdf28a65b4498a1912b7
+  data.tar.gz: f2d7876d4c69253cadae3b72ec958ce3e8311016
 SHA512:
-  metadata.gz: 9ca8187ea5be40096b1082a9da92753140bd2b1ba5807d4bab91b03da0249cb5ec2b0fce1bb4d07cf75c0b945d19099196b5bcc2d0bfc57c635bfa602da5ec1d
-  data.tar.gz: c8092d88c92a3c9a1d2def37ff394a22b3f17a4c31a2e73b08cc576bd499338cab4fe28ffe0545824cbed6c1a1f414a1872a83f27eec7a0eee91e224e3dcbda8
+  metadata.gz: bbad66bf6664694aa07e9dcd83e707258d6b700fc4defe16ccdce43bc3f8e69e6b263c461e7ec1b1349589572a006f7060cdae200b1d85e6692ea335df2662a3
+  data.tar.gz: 38d80f91f2f0ade3834b0a49193fbb5129e40656a10adaeb44bebe16fa00c24f8307062287a0510a272cafff788cc7c46d496ff1f26b1c5d42b24bec7c269ab9

data/.gitignore

@@ -8,6 +8,9 @@
 /spec/reports/
 /tmp/
 
+
+.byebug_history
+
 .env
 test.csv
 test1.csv

data/README.md

@@ -1,6 +1,6 @@
 # StupidSMS
 
-Send text SMS using Twilio.
+Send bulk SMS using Twilio.
 
 ## Installation
 
@@ -23,15 +23,18 @@ Or install it yourself as:
 __Configuration__
 
 ```ruby
-StupidSMS.from_number = '...' # or set env var TWILIO_ACCOUNT_SID
-StupidSMS.auth_token  = '...' # or set env var TWILIO_AUTH_TOKEN
-StupidSMS.account_sid = '...' # or set env var TWILIO_NUMBER
+StupidSMS.configure do |config|
+  config.from_number  = '...' # or set env var TWILIO_ACCOUNT_SID
+  config.auth_token   = '...' # or set env var TWILIO_AUTH_TOKEN
+  config.account_sid  = '...' # or set env var TWILIO_NUMBER
+  config.country_code = 'SE' # two character country code (SE is the default)
+end
 ```
 
 __Send one SMS__:
 
 ```ruby
-StupidSMS.send_message(recipient: recipient, body: body)
+StupidSMS.send(recipient: recipient, body: body)
 ```
 
 __Send SMS in bulk__:
@@ -46,18 +49,48 @@ name `first_name`.
 `file.csv`:
 
 ```csv
-phone, first_name
-+46735000000, Jacob
+phone,first_name
++46735000000,Jacob
 ```
 
 ```ruby
 csv = File.read('file.csv')
 template = 'Hi %{first_name}!'
-StupidSMS.send_bulk_message(csv_string: csv, template: template)
+StupidSMS.send_in_bulk(csv_string: csv, template: template)
 ```
 
+full options:
+
+```ruby
+csv = File.read('file.csv')
+StupidSMS.send_in_bulk(
+  csv_string: csv,
+  template: 'Hello World!',
+  delimiter: ',',
+  dry_run: false,
+  max_threads: 5
+)
+```
+
+__CLI__
+
 ```bash
-stupid_sms --csv testfile.csv --delimiter=, --template template.txt --dry-run=true
+stupid_sms --csv testfile.csv --template template.txt --dry-run=true
+```
+
+
+```
+Usage: stupid_sms [options]
+        --csv=file.csv               CSV file path (a phone header column is required)
+        --template=template.txt      Template file path (note: you need to escape % with %%)
+        --delimiter=;                CSV delimiter (default: ,)
+        --country-code=se            Country code (default: se)
+        --max-threads=5              Max parallel threads (default: 5)
+        --from-number="+46735000000" Twilio from number
+        --account-sid=se             Twilio account SID
+        --auth-token=XXXYYYZZZ       Twilio auth token
+        --[no-]dry-run               Dry run (default: true)
+    -h, --help                       How to use
 ```
 
 ## Development

data/exe/stupid_sms

@@ -1,12 +1,19 @@
 #!/usr/bin/env ruby
 
-require 'bundler/setup' # TODO: Remove!
 require 'stupid_sms'
 
+# Defaults
 csv_filename = nil
 template_filename = nil
 dry_run = true
 delimiter = ','
+country_code = 'se'
+max_threads = StupidSMS::MAX_THREADS
+
+# Twilio Auth
+from_number = nil
+auth_token = nil
+account_sid = nil
 
 optparse = OptionParser.new do |parser|
   parser.on('--csv=file.csv', String, 'CSV file path (a phone header column is required)') do |value|
@@ -21,6 +28,26 @@ optparse = OptionParser.new do |parser|
     delimiter = value
   end
 
+  parser.on('--country-code=se', String, 'Country code (default: se)') do |value|
+    country_code = value
+  end
+
+  parser.on('--max-threads=5', Integer, "Max parallel threads (default: #{StupidSMS::MAX_THREADS})") do |value|
+    max_threads = value
+  end
+
+  parser.on('--from-number="+46735000000"', String, 'Twilio from number') do |value|
+    from_number = value.strip
+  end
+
+  parser.on('--account-sid=se', String, 'Twilio account SID') do |value|
+    account_sid = value.strip
+  end
+
+  parser.on('--auth-token=XXXYYYZZZ', String, 'Twilio auth token') do |value|
+    auth_token = value.strip
+  end
+
   parser.on('--[no-]dry-run', 'Dry run (default: true)') do |value|
     dry_run = value
   end
@@ -41,12 +68,20 @@ if template_filename.nil? || template_filename.strip.empty?
   raise OptionParser::MissingArgument, "'--template' 'Is required"
 end
 
+StupidSMS.configure do |config|
+  config.from_number = from_number if from_number
+  config.auth_token = auth_token if auth_token
+  config.account_sid = account_sid if account_sid
+  config.country_code = country_code if country_code
+end
+
 csv = File.read(csv_filename)
 template = File.read(template_filename)
 
-StupidSMS.send_bulk_message(
+StupidSMS.send_in_bulk(
   csv_string: csv,
   delimiter: delimiter,
   template: template,
-  dry_run: dry_run
+  dry_run: dry_run,
+  max_threads: max_threads
 )

data/lib/stupid_sms.rb

@@ -1,90 +1,74 @@
-require 'stupid_sms/version'
-require 'stupid_sms/sms_client'
+# Stlib
+require 'thread'
 
-require 'global_phone'
+# Gems
 require 'honey_format'
 
-module StupidSMS
-  GlobalPhone.db_path = 'global_phone.json'
+# Local
+require 'stupid_sms/version'
+require 'stupid_sms/sms_client'
+require 'stupid_sms/sms'
+require 'stupid_sms/phone'
+require 'stupid_sms/process_queue'
 
-  MAX_SMS_LENGTH = 160.0
+module StupidSMS
+  MAX_THREADS = 5
 
-  def self.send_bulk_message(csv_string:, delimiter: ',', template:, dry_run: false)
+  def self.send_in_bulk(csv_string:, template:, delimiter: ',', dry_run: false, max_threads: MAX_THREADS)
     csv = HoneyFormat::CSV.new(csv_string, delimiter: delimiter)
 
-    longest_body = 0
-    successfully_sent_count = 0
-    csv.each_row do |person|
-      phone = normalize_phone(person.phone)
-      if invalid_phone?(phone)
-        puts "[StupidSMS ERROR] Couldn't send SMS to phone number: #{person.phone}"
-        next
-      end
+    sms_queue = Queue.new
+    csv.each_row { |person| sms_queue << person }
 
-      body = template % person.to_h
-      longest_body = body.length if body.length > longest_body
-
-      send_status = if dry_run
-                      true
-                    else
-                      send_message(recipient: phone, body: body)
-                    end
-
-      if send_status
-        sms_count = (body.length / MAX_SMS_LENGTH).floor + 1 # Number of SMS sent
-        successfully_sent_count += sms_count
-      end
-    end
+    summary = ProcessQueue.call(
+      sms_queue: sms_queue,
+      template: template,
+      dry_run: dry_run,
+      max_threads: max_threads
+    )
 
     puts '============================'
+    puts "Thread count:  #{max_threads}"
     puts "Dry run:       #{dry_run}"
-    puts "Longest sms:   #{longest_body}"
-    puts "Recipients:    #{csv.rows.length}"
-    puts "Sent messages: #{successfully_sent_count}"
+    puts "Longest sms:   #{summary.fetch(:longest_body)}"
+    puts "Recipients:    #{summary.fetch(:recipients_count)}"
+    puts "Failed count:  #{summary.fetch(:failed_count)}"
+    puts "Sent messages: #{summary.fetch(:successfully_sent_count)}"
   end
 
-  def self.send_message(recipient:, body:)
-    client.send_message(from: from_number, to: recipient, body: body)
-    true
-  rescue Twilio::REST::RequestError => e # the user has unsubscribed
-    puts "[StupidSMS ERROR] Twilio::REST::RequestError to: #{recipient} body: #{body}"
-    puts e
-    false
+  def send(crecipient:, body:)
+    SMS.send(recipient: recipient, body: body)
   end
 
-  def self.invalid_phone?(phone)
-    GlobalPhone.validate(phone, :se) ? false : true
+  class << self
+    attr_accessor :configuration
   end
 
-  def self.normalize_phone(phone)
-    GlobalPhone.normalize(phone, :se)
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
   end
 
-  def self.client
-    @client ||= SMSClient.new(account_sid: account_sid, auth_token: auth_token)
-  end
+  class Configuration
+    attr_accessor :from_number, :account_sid, :auth_token, :country_code
 
-  def self.from_number=(from_number)
-    @from_number = from_number
-  end
-
-  def self.auth_token=(auth_token)
-    @auth_token = auth_token
-  end
-
-  def self.account_sid=(account_sid)
-    @account_sid = account_sid
-  end
+    def initialize
+      @from_number = nil
+      @auth_token = nil
+      @account_sid = nil
+      @country_code = :se
+    end
 
-  def self.from_number
-    @from_number || ENV.fetch('TWILIO_NUMBER')
-  end
+    def from_number
+      @from_number || ENV.fetch('TWILIO_NUMBER')
+    end
 
-  def self.auth_token
-    @auth_token || ENV.fetch('TWILIO_AUTH_TOKEN')
-  end
+    def auth_token
+      @auth_token || ENV.fetch('TWILIO_AUTH_TOKEN')
+    end
 
-  def self.account_sid
-    @account_sid || ENV.fetch('TWILIO_ACCOUNT_SID')
+    def account_sid
+      @account_sid || ENV.fetch('TWILIO_ACCOUNT_SID')
+    end
   end
 end

data/lib/stupid_sms/phone.rb

@@ -0,0 +1,15 @@
+require 'global_phone'
+
+module StupidSMS
+  module Phone
+    GlobalPhone.db_path = 'global_phone.json'
+
+    def self.invalid?(phone, country_code: StupidSMS.configuration.country_code)
+      GlobalPhone.validate(phone, country_code) ? false : true
+    end
+
+    def self.normalize(phone, country_code: StupidSMS.configuration.country_code)
+      GlobalPhone.normalize(phone, country_code)
+    end
+  end
+end

data/lib/stupid_sms/process_queue.rb

@@ -0,0 +1,97 @@
+module StupidSMS
+  class ProcessQueue
+    MAX_SMS_LENGTH = 160.0
+
+    def self.call(**args)
+      new(**args).call
+    end
+
+    def initialize(sms_queue:, template:, dry_run:, max_threads:)
+      @sms_queue = sms_queue
+      @template = template
+      @dry_run = dry_run
+      @max_threads = Integer(max_threads)
+
+      # Stats
+      @recipients_count = @sms_queue.length
+    end
+
+    def call
+      threads = @max_threads.times.map do
+        Thread.new do
+          # We need one client per Thread since the Twilio client is not thread safe
+          client = SMSClient.new
+
+          results = { send_count: 0, longest_body: 0, failed_count: 0 }
+          until @sms_queue.empty?
+            # TODO: Consider capturing all errors and only log them
+            sms_result = process_sms(
+              client: client,
+              person: @sms_queue.pop
+            )
+
+            results[:send_count] += sms_result.fetch(:send_count)
+            results[:failed_count] += 1 unless sms_result.fetch(:success)
+
+            body_length = sms_result.fetch(:length)
+            if body_length > results[:longest_body]
+              results[:longest_body] = body_length
+            end
+          end
+
+          results
+        end
+      end
+
+      threads.map(&:join) # Wait for each thread
+      calculate_summary(threads: threads)
+    end
+
+    private
+
+    def process_sms(client:, person:)
+      failed_result = { send_count: 0, length: 0, success: false }
+
+      phone = Phone.normalize(person.phone)
+      if Phone.invalid?(phone)
+        puts "[StupidSMS ERROR] Invalid phone number: #{person.phone}"
+        return failed_result
+      end
+
+      body = @template % person.to_h
+
+      send_status = if @dry_run
+                      true
+                    else
+                      SMS.send(client: client, recipient: phone, body: body)
+                    end
+
+      if send_status
+        sms_count = (body.length / (MAX_SMS_LENGTH - 1)).floor + 1 # Number of SMS sent
+        return { send_count: sms_count, length: body.length, success: true }
+      end
+
+      failed_result
+    end
+
+    def calculate_summary(threads:)
+      longest_body = 0
+      successfully_sent_count = 0
+      failed_count = 0
+
+      threads.map do |thread|
+        result = thread.value
+        longest_body = result[:longest_body] if result.fetch(:longest_body) > longest_body
+        successfully_sent_count += result.fetch(:send_count)
+        failed_count += result.fetch(:failed_count)
+      end
+
+      {
+        longest_body: longest_body,
+        successfully_sent_count: successfully_sent_count,
+        failed_count: failed_count,
+        recipients_count: @recipients_count
+      }
+    end
+  end
+end

data/lib/stupid_sms/sms.rb

@@ -0,0 +1,13 @@
+module StupidSMS
+  module SMS
+    def self.send(client: SMSClient.new, recipient:, body:)
+      from_number = StupidSMS.configuration.from_number
+      client.send_message(from: from_number, to: recipient, body: body)
+      true
+    rescue Twilio::REST::RequestError => e # the user has unsubscribed
+      puts "[StupidSMS ERROR] Twilio::REST::RequestError to: #{recipient} body: #{body}"
+      puts e
+      false
+    end
+  end
+end

data/lib/stupid_sms/sms_client.rb

@@ -2,7 +2,7 @@ require 'twilio-ruby'
 
 module StupidSMS
   class SMSClient
-    def initialize(account_sid:, auth_token:)
+    def initialize(account_sid: StupidSMS.configuration.account_sid, auth_token: StupidSMS.configuration.auth_token)
       @client = Twilio::REST::Client.new(account_sid, auth_token)
     end
 

data/lib/stupid_sms/version.rb

@@ -1,3 +1,3 @@
 module StupidSMS
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/stupid_sms.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Send SMS with ease.}
   spec.description   = %q{Send SMS with ease, either one by one or in bulk.}
-  spec.homepage      = 'https://github.com/young-skilled/stupid_sms'
+  spec.homepage      = 'https://github.com/buren/stupid_sms'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stupid_sms
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jacob Burenstam
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-24 00:00:00.000000000 Z
+date: 2017-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: twilio-ruby
@@ -112,10 +112,13 @@ files:
 - exe/stupid_sms
 - global_phone.json
 - lib/stupid_sms.rb
+- lib/stupid_sms/phone.rb
+- lib/stupid_sms/process_queue.rb
+- lib/stupid_sms/sms.rb
 - lib/stupid_sms/sms_client.rb
 - lib/stupid_sms/version.rb
 - stupid_sms.gemspec
-homepage: https://github.com/young-skilled/stupid_sms
+homepage: https://github.com/buren/stupid_sms
 licenses:
 - MIT
 metadata: {}
@@ -135,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Send SMS with ease.