rumeme 0.1.2 → 0.1.3

data/CHANGELOG

@@ -1,3 +1,14 @@
+Version 0.1.3 - 2010-03-11
+===============================================================================
+
+antlypls (5):
+      fix rake file
+      change long messages settings
+      minor code cleanup
+      refactor internals
+      code cleanup
+
+
 Version 0.1.2 - 2010-03-11
 ===============================================================================
 
@@ -21,3 +32,4 @@ antlypls (5):
 
 
 
+

data/Rakefile

@@ -132,12 +132,12 @@ task :push_gem do
   system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
 end
 
-desc 'release gem'
-task :release, :part do |t, args|
+desc 'Preparing release'
+task :prepare_release, :part do |t, args|
   Rake::Task['bump'].invoke(args[:part])
   Rake::Task['change'].invoke
   Rake::Task['push'].invoke
-  Rake::Task['gem'].invoke
-  Rake::Task['push_gem'].invoke
 end
 
+desc 'Building and publishing gem'
+task :publish_release => [:gem, :push_gem]

data/lib/rumeme/configuration.rb

@@ -1,11 +1,17 @@
 module Rumeme
+  # Holds configuration attributes for sms interface
   class Configuration
     attr_accessor :username
     attr_accessor :password
     attr_accessor :use_message_id
     attr_accessor :secure
-    attr_accessor :allow_splitting
-    attr_accessor :allow_long_messages
+
+    #
+    # possible values
+    # :send - sends messages as is without any modification
+    # :split - splits messages into small (less than 160 ch) messages
+    # :cut - sends only first 160 symbols 
+    attr_accessor :long_messages_strategy
   end
 end
 

data/lib/rumeme/sms_interface.rb

@@ -7,6 +7,7 @@ module Rumeme
 
   # This is the main class used to interface with the M4U SMS messaging server.
   class SmsInterface
+
     # allow_splitting, allow_long_messages, response_code, response_message, username, password, use_message_id, secure, http_connection, server_list, message_list,
     # http_proxy, http_proxy_port, http_proxy_auth, https_proxy, https_proxy_port, https_proxy_auth, text_buffer,
 
@@ -18,24 +19,21 @@ module Rumeme
     # The allowLongMessages parameter enables messages longer than 160
     # 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
       
-      @allow_splitting, @allow_long_messages = Rumeme.configuration.allow_splitting, Rumeme.configuration.allow_long_messages
-
       @response_code = -1
       @response_message = nil
       @message_list = []
-      @http_connection = nil
       @http_proxy = nil
       @http_proxy_port = 80
       @http_proxy_auth = nil
       @https_proxy = nil
-      @https_proxy_port = 443;
+      @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"]
@@ -61,67 +59,16 @@ module Rumeme
       raise 'proxy is not supported'
     end
 
-    # Return the response code received from calls to
-    # changePassword, getCreditsRemaining, sendMessages, and
-    # checkReplies.
-    attr_reader :response_code
-
-    # Return the message that was returned with the response code.
-    attr_reader :response_message
-
     # Add a message to be sent.
-    def  add_message args
-      p 'in  add_message '
+    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)
 
       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?
 
-      if args[:message].length <= 160
-        @message_list << SmsMessage.new(args)
-        return
-      end
-
-      if (@allow_long_messages) # Use concatenation.
-        args[:message] = args[:message][0..1071] # 1071??? WTF ??? see php code (antlypls)
-        @message_list << SmsMessage.new(args)
-        return
-      end
-
-      if !@allow_splitting
-        args[:message] = args[:message][0..160] # maybe 159 ? (antlypls)
-        @message_list << SmsMessage.new(args)
-        return
-      end
-
-      ml = []
-      maxlen = 152
-      message_text = args[:message]
-      while message_text.length > maxlen
-        if (pos = message_text[0..maxlen].rindex(" ")) == 0
-          pos = maxlen - 1
-        end
-
-        ml << message_text[0..pos+1]
-        message_text = message_text[pos + 1 .. -1]
-        maxlen = 147;
-      end
-      ml << message_text
-
-      ml.each_index {|i|
-        ni = i + 1
-        if (i == 0)
-          m = ml[i]
-        else
-          m = "(#{ni}/#{ml.size})#{ml[i]}"
-        end
-
-        if (ni != ml.size )
-          m << "...(#{ni}/#{ml.size})"
-        end
-
-        @message_list << SmsMessage.new(args.merge({:message => m, :delay => args[:delay] + 30*i}))
-      }
+      messages = process_long_message(args[:message])
+      @message_list.concat(messages.map{|m| SmsMessage.new(args.merge({:message => m}))})
     end
 
     # Clear all the messages from the list.
@@ -129,26 +76,13 @@ module Rumeme
       @message_list.clear
     end
 
-    # Open a connection to the specified server.
-    # proxy is not supported
     def open_server_connection server, secure
-      p "in open_server_connection: #{server} #{secure}"
-      if secure
-        @http_connection =  Net::HTTP.new(server, 443)
-        @http_connection.use_ssl = true
-
-      else
-        @http_connection =  Net::HTTP.new(server, 80)
-      end
+      port, use_ssl = secure ? [443, true] : [80, false]
 
-      p @http_connection.inspect
-
-      @http_connection.nil? ? false : true
-    end
-
-    # 4 php api compatibility, returns response code from latest http flush
-    def read_response_code
-      @latest_response_code
+      http_connection =  Net::HTTP.new(server, port)
+      http_connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http_connection.use_ssl = use_ssl
+      http_connection
     end
 
     # Change the password on the local machine and server.
@@ -159,60 +93,31 @@ module Rumeme
 
     # Return the list of replies we have received.
     def check_replies auto_confirm = true
-      connect
       p 'in check_replies'
-      return nil if @http_connection.nil?
-      @text_buffer << "CHECKREPLY2.0\r\n.\r\n"
-
-      if (!flush_buffer || read_response_code != 150)
-        close
-        return nil
-      end
 
-      p @response_message
+      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)}
-
-      close
-
-      if auto_confirm && messages.size > 0
-        confirm_replies_received
-      end
+      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
 
       return messages
     end
 
     # sends confirmation to server
     def confirm_replies_received
-      connect
       p 'in confirm_replies_received'
-      return nil if @http_connection.nil?
-      ok = true
-
-      @text_buffer << "CONFIRM_RECEIVED\r\n.\r\n";
-      if !flush_buffer
-        ok = false
-      end
-
-      close
-      p "result: #{ok}"
-      
-      return ok;
+      post_data_to_server "CONFIRM_RECEIVED\r\n.\r\n"
     end
 
     # Returns the credits remaining (for prepaid users only).
     def get_credits_remaining
-      connect
-      return -2 if @http_connection.nil?
-      @text_buffer << "MESSAGES\r\n.\r\n"
+      p 'in get_credits_remaining'
 
-      if (!flush_buffer)
-        close
-        return -2
-      end
+      response_message, response_code = post_data_to_server("MESSAGES\r\n.\r\n")
 
       if response_message =~ /^(\d+)\s+OK\s+(\d+).+/
-        if $1.to_i != 100
+        if response_code != 100
           p 'M4U code is not 100'
           return -1
         end
@@ -226,70 +131,90 @@ module Rumeme
     # Sends all the messages that have been added with the
     # add_message command.
     def send_messages
-      connect
-      return false if @http_connection.nil?
-      @text_buffer << "MESSAGES2.0\r\n"
+      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
+        s << "#{sm.message}\r\n"
+        text_buffer << s
       }
+      text_buffer << ".\r\n"
 
-      ok = true
-      @text_buffer << ".\r\n";
-      if (!flush_buffer || (read_response_code / 100) != 1)
-        ok = false;
-      end
+      response_message, response_code = post_data_to_server(text_buffer)
 
-      close
-      return ok
+      return response_code == 100 ? true : false
     end
 
     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}"})
+    end
+
+    def self.split_message_internal message
+      list =[]
+
+      head, message = head_tail_split(message, 152)
+      list << head
+
+      while !message.nil? do
+        head, message = head_tail_split(message, 155)
+        list << head
+      end
+
+      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]]
+    end
+
     # Strip invalid characters from the phone number.
     def strip_invalid phone
       return if phone.nil?
       "+#{phone.gsub(/[^0-9]/, '')}"
     end
 
-    # Connect to the M4U server
-    def connect
-      p 'in connect'
-      return unless @http_connection.nil?
-
-      @server_list.all? {|server| !open_server_connection(server, @secure)} # unusefull code open_server_connection,
-                                                                            # does not connect to server, just creates http object,
-                                                                            # so we can't check availability of the server at this moment (antlypls)
+    def post_data_to_server data
+      p 'post_data_to_server'
 
-      return if @http_connection.nil?
+      http_connection = open_server_connection(@server_list[0], @secure)
 
-      @text_buffer = "m4u\r\nUSER=#{@username}"
+      text_buffer = "m4u\r\nUSER=#{@username}"
       if @use_message_id
-        @text_buffer << "#"
+        text_buffer << "#"
       end
-      @text_buffer << "\r\nPASSWORD=#{@password}\r\nVER=PHP1.0\r\n";
-    end
+      text_buffer << "\r\nPASSWORD=#{@password}\r\nVER=PHP1.0\r\n"
 
-    # only for php compatibility, just free object reference
-    def close
-      @http_connection = nil unless @http_connection.nil?
-    end
+      text_buffer << data
 
-    # Flush the text buffer to the HTTP connection.
-    def flush_buffer
-      p 'in flush_buffer'
-      p "buffer: #{@text_buffer}"
-      headers = {
-              'Content-Length' => @text_buffer.length.to_s
-      }
+      p "buffer: #{text_buffer}"
+      headers = {'Content-Length' => text_buffer.length.to_s}
 
       path = '/'
 
       begin
-        resp, data = @http_connection.post(path, @text_buffer, headers)
+        resp, data = http_connection.post(path, text_buffer, headers)
         p resp.inspect
         p data.inspect
       rescue
@@ -297,28 +222,25 @@ module Rumeme
         return false
       end
 
-
       if resp.code.to_i != 200
         p 'http response code != 200'
         return false
       end
 
-      @latest_response_code = @response_code = resp.code.to_i
-
       doc = Nokogiri::HTML(data)
 
       return false if doc.xpath('//title').text != "M4U SMSMASTER"
 
-      @response_message = @latest_response = doc.xpath('//body').text.strip
-      if @response_message =~ /^(\d+)\s+/
-        @latest_response_code = @response_code = $1.to_i
+      response_message = doc.xpath('//body').text.strip
+      response_code = nil
+      if response_message =~ /^(\d+)\s+/
+        response_code = $1.to_i
       end
 
-      p "latest response code: #{ @latest_response_code}"
-      p "response #{@response_message.inspect}"
+      p "latest response code: #{response_code}"
+      p "response #{response_message }"
 
-      @text_buffer = ''
-      return true
+      [response_message, response_code]
     end
   end
 end

data/lib/rumeme/version.rb

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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 2
-  version: 0.1.2
+  - 3
+  version: 0.1.3
 platform: ruby
 authors: 
 - antlypls