rumeme 0.1.3 → 0.1.4

data/CHANGELOG

@@ -1,3 +1,12 @@
+Version 0.1.4 - 2010-03-12
+===============================================================================
+
+antlypls (3):
+      reimplement SmsReply.parse
+      minor refactoring of constructor code
+      refactoring
+
+
 Version 0.1.3 - 2010-03-11
 ===============================================================================
 
@@ -33,3 +42,4 @@ antlypls (5):
 
 
 
+

data/lib/rumeme/configuration.rb

@@ -5,6 +5,7 @@ module Rumeme
     attr_accessor :password
     attr_accessor :use_message_id
     attr_accessor :secure
+    attr_accessor :replies_auto_confirm
 
     #
     # possible values
@@ -12,6 +13,10 @@ module Rumeme
     # :split - splits messages into small (less than 160 ch) messages
     # :cut - sends only first 160 symbols 
     attr_accessor :long_messages_strategy
+
+    def initialize
+      @replies_auto_confirm = true
+    end
   end
 end
 

data/lib/rumeme/sms_interface.rb

@@ -20,55 +20,32 @@ module Rumeme
     # characters to be sent as special concatenated messages. For this
     # to take effect, the allowSplitting parameter must be set to false.
     def initialize
-      @username = Rumeme.configuration.username
-      @password = Rumeme.configuration.password
-      @use_message_id = Rumeme.configuration.use_message_id
-      @secure = Rumeme.configuration.secure
-      @long_messages_strategy = Rumeme.configuration.long_messages_strategy
+      Rumeme.configuration.tap{ |cfg|
+        @username = cfg.username
+        @password = cfg.password
+        @use_message_id = cfg.use_message_id
+        @secure = cfg.secure
+        @long_messages_strategy = cfg.long_messages_strategy
+        @replies_auto_confirm = cfg.replies_auto_confirm
+      }
       
       @response_code = -1
       @response_message = nil
       @message_list = []
-      @http_proxy = nil
-      @http_proxy_port = 80
-      @http_proxy_auth = nil
-      @https_proxy = nil
-      @https_proxy_port = 443
-      @https_proxy_auth = nil
-      @text_buffer = nil
       @server_list = ["smsmaster.m4u.com.au", "smsmaster1.m4u.com.au", "smsmaster2.m4u.com.au"]
     end
 
-
-    # Set the HTTP proxy server, if one is being used.
-    # Also specify an optional proxy username and password.
-    # only for php version
-    def set_http_proxy proxy, port = 80, username = nil, password = nil
-      @http_proxy, @http_proxy_port = proxy, port
-      @http_proxy_username, @http_proxy_password = username, password
-      @http_proxy_auth = Base64.encode64("#{username}:#{password}").chop unless username.nil? || password.nil?
-      raise 'proxy is not supported'
-    end
-
-    # Set the HTTPS proxy server, if one is being used.
-    # Also specify an optional proxy username and password.
-    # only for php version
-    def set_https_proxy proxy, port = 443, username = nil, password = nil
-      @https_proxy, @https_proxy_port = proxy, port
-      @https_proxy_auth = Base64.encode64("#{username}:#{password}").chop unless username.nil? || password.nil?
-      raise 'proxy is not supported'
-    end
-
     # Add a message to be sent.
     def add_message args
       p 'in add_message '
-      args[:phone_number] = strip_invalid(args[:phone_number]) #not good idea, modifying original args, from outer scope (antlypls)
+      phone_number = self.class.strip_invalid(args[:phone_number]) #not good idea, modifying original args, from outer scope (antlypls)
+      message = args[:message]
 
-      raise ArgumentError.new("phone_number is empty") if args[:phone_number].nil? || args[:phone_number].empty?
-      raise ArgumentError.new("message is empty") if args[:message].nil? || args[:message].empty?
+      raise ArgumentError.new("phone_number is empty") if phone_number.nil? || phone_number.empty?
+      raise ArgumentError.new("message is empty") if message.nil? || message.empty?
 
-      messages = process_long_message(args[:message])
-      @message_list.concat(messages.map{|m| SmsMessage.new(args.merge({:message => m}))})
+      messages = process_long_message(message)
+      @message_list.concat(messages.map{|msg| SmsMessage.new(args.merge({:message => msg, :phone_number => phone_number}))})
     end
 
     # Clear all the messages from the list.
@@ -76,8 +53,8 @@ module Rumeme
       @message_list.clear
     end
 
-    def open_server_connection server, secure
-      port, use_ssl = secure ? [443, true] : [80, false]
+    def open_server_connection server
+      port, use_ssl = @secure ? [443, true] : [80, false]
 
       http_connection =  Net::HTTP.new(server, port)
       http_connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
@@ -92,14 +69,14 @@ module Rumeme
     end
 
     # Return the list of replies we have received.
-    def check_replies auto_confirm = true
+    def check_replies
       p 'in check_replies'
 
       response_message, response_code = post_data_to_server("CHECKREPLY2.0\r\n.\r\n")
       return if response_code != 150
 
-      messages = response_message.split("\r\n")[1..-2].map{|message_line| SmsReply.parse(message_line, @use_message_id)}
-      confirm_replies_received if auto_confirm && messages.size > 0
+      messages = response_message.split("\r\n")[1..-2].map{|message_line| SmsReply.parse(message_line)} # check @use_message_id
+      confirm_replies_received if @replies_auto_confirm && messages.size > 0
 
       return messages
     end
@@ -131,16 +108,11 @@ module Rumeme
     # Sends all the messages that have been added with the
     # add_message command.
     def send_messages
-      text_buffer = "MESSAGES2.0\r\n"
-
-      @message_list.each {|sm|
-        s = "#{sm.message_id} #{sm.phone_number} #{sm.delay} #{sm.validity_period} "
-        s << (sm.delivery_report ? "1 " : "0 ")
-        s << "#{sm.message}\r\n"
-        text_buffer << s
-      }
-      text_buffer << ".\r\n"
+      post_string = @message_list.map{ |message|
+        "#{message.message_id} #{message.phone_number} #{message.delay} #{message.validity_period} #{message.delivery_report ? 1 : 0} #{message.message}\r\n"
+      }.join
 
+      text_buffer = "MESSAGES2.0\r\n#{post_string}.\r\n"
       response_message, response_code = post_data_to_server(text_buffer)
 
       return response_code == 100 ? true : false
@@ -148,24 +120,11 @@ module Rumeme
 
     private
 
-    def process_long_message message
-      return [message] if message.length <= 160
-      case @long_messages_strategy
-        when :send
-          [message]
-        when :cut
-          [message[0..160]]
-        when :split
-          SmsInterface.split_message message
-        else
-          raise 'unknown long_messages_strategy'
-      end
-    end
-
-    def self.split_message message
-      messages = split_message_internal message
-      i = 1
-      ["#{messages[0]}...(1/#{messages.size})"].concat(messages[1..-1].map {|m| "(#{i+=1}/#{messages.size})#{m}"})
+    def self.head_tail_split message, max_len
+      return [message, nil] if message.length < max_len
+      pattern = /\s\.,!;:-\)/
+      index = message[0..max_len].rindex(pattern) || max_len
+      [message[0..index], message[index+1 .. -1]]
     end
 
     def self.split_message_internal message
@@ -182,23 +141,36 @@ module Rumeme
       list
     end
 
-    def self.head_tail_split message, max_len
-      return [message, nil] if message.length < max_len
-      pattern = /\s\.,!;:-\)/
-      index = message[0..max_len].rindex(pattern) || max_len
-      [message[0..index], message[index+1 .. -1]]
+    def self.split_message message
+      messages = split_message_internal message
+      message_index = 1
+      ["#{messages[0]}...(1/#{messages.size})"].concat(messages[1..-1].map {|msg| "(#{message_index+=1}/#{messages.size})#{msg}"})
+    end
+
+    def process_long_message message
+      return [message] if message.length <= 160
+      case @long_messages_strategy
+        when :send
+          [message]
+        when :cut
+          [message[0..160]]
+        when :split
+          split_message message
+        else
+          raise 'unknown long_messages_strategy'
+      end
     end
 
     # Strip invalid characters from the phone number.
-    def strip_invalid phone
-      return if phone.nil?
+    def self.strip_invalid phone
+      return nil if phone.nil?
       "+#{phone.gsub(/[^0-9]/, '')}"
     end
 
     def post_data_to_server data
       p 'post_data_to_server'
 
-      http_connection = open_server_connection(@server_list[0], @secure)
+      http_connection = open_server_connection(@server_list[0])
 
       text_buffer = "m4u\r\nUSER=#{@username}"
       if @use_message_id

data/lib/rumeme/sms_message.rb

@@ -8,7 +8,7 @@ module Rumeme
       # this defaults must be moved to global configuration
       defaults = {:phone_number => nil, :message => nil, :message_id => 0, :delay => 0, :validity_period => ValidityPeriod::THREE_DAYS, :delivery_report => false}
       params = defaults.merge args
-      defaults.keys.each {|k| instance_variable_set("@#{k.to_s}".to_sym, params[k])}
+      defaults.keys.each {|key| instance_variable_set("@#{key.to_s}".to_sym, params[key])}
 
       raise ArgumentError.new("phone_number is empty") if @phone_number.nil? || @phone_number.empty?
       raise ArgumentError.new("message is empty") if @message.nil? || @message.empty?

data/lib/rumeme/sms_reply.rb

@@ -14,60 +14,28 @@ module Rumeme
       line.nil? ? nil : line.gsub('\n', "\n").gsub('\r', "\r").gsub('\\\\', "\\")
     end
 
-    #Parse a reply from a string.
-    # Format is: messageID phone when message
-    # Or if no message ID: phone when message
-    # Or if delivery receipt: messageID messageStatus when
-    # php suxx. reimplement using regex
-    def self.parse line, use_message_id
-      p "parsing line: #{line}. #{use_message_id}."
-      message_id = nil;
-      status = MessageStatus::NONE
-
-      prev_idx = 0;
-      if (idx = line.index(' ')) == nil
-        return nil
-      end
-
-      if (use_message_id)
-        if line[0..idx] =~ /\d+/
-          message_id = line[0..idx].to_i
+    # Parse a reply from a string.
+    # Format is: messageID phone when message /(\d+)\s(\d+)\s(\d+)\s(.+)/
+    # Or if no message ID: phone when message /(\d+)\s(\d+)\s(.+)/
+    # Or if delivery receipt: messageID messageStatus when /(\d+)\s(\d)\s(\d+)/
+    # current implementation ignores use_message_id setting (as original code)
+    def self.parse line
+      p "parsing line: #{line}"
+
+      message_id, status, message, phone, when_ = case line
+        when /(\d+)\s(\d)\s(\d+)/
+          #process delivery report
+          [$1.to_i, $2.to_i, nil, nil, $3.to_i]
+        when /(\d+)\s(\d+)\s(\d+)\s(.+)/
+          #process message with id
+          [$1.to_i, MessageStatus::NONE, unescape($4), $2, $3.to_i]
+        when /(\d+)\s(\d+)\s(.+)/
+          #process message without id
+          [nil, MessageStatus::NONE, unescape($3), $1, $2.to_i]
         else
-          return nil
-        end
-
-        prev_idx = idx + 1
-        if (idx = line.index(' ', idx + 1)) == nil
-          return nil
-        end
-      end
-
-      phone = line[prev_idx .. idx - 1]
-
-      if phone.length == 1
-        status = case phone  # why not use to_i ??
-          when "1"
-            MessageStatus::PENDING
-          when "2"
-            MessageStatus::DELIVERED
-          when "3"
-            MessageStatus::FAILED
-          else
-            nil
-        end
-        phone = ""
-      end
-
-      prev_idx = idx + 1;
-      idx = line.index(' ', idx + 1) || line.length
-
-      if line[prev_idx .. idx-1] =~ /\d+/
-        when_ = $&.to_i
-      else
-        return nil
+          raise ArgumentError.new("can't parse line: #{line}")
       end
 
-      message = (status != MessageStatus::NONE) || (line.length < idx + 2) ? "" : unescape(line[idx + 1 .. -1])
       return SmsReply.new(phone, message, message_id, when_, status)
     end
 

data/lib/rumeme/version.rb

@@ -1,3 +1,3 @@
 module Rumeme
-  VERSION = "0.1.3".freeze
+  VERSION = "0.1.4".freeze
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - antlypls
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-11 00:00:00 +04:00
+date: 2010-03-12 00:00:00 +04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency