clickatell 0.3.0 → 0.4.0

data/History.txt

@@ -1,3 +1,12 @@
+== 0.4.0
+
+* Added API debug mode and --debug option to sms utility
+* Restructured API classes into individual files
+* Refactored command execution into a separate object (CommandExecutor).
+* Major refactoring of API module - converted it to a class with API methods
+implemented as instance methods. Code is much cleaner and Connection class 
+becomes redundant. See updated documentation.
+
 == 0.3.0
 
 * Display proper message status, not just the code

data/Manifest.txt

@@ -6,7 +6,10 @@ Rakefile
 bin/sms
 lib/clickatell.rb
 lib/clickatell/api.rb
-lib/clickatell/connection.rb
+lib/clickatell/api/command.rb
+lib/clickatell/api/command_executor.rb
+lib/clickatell/api/error.rb
+lib/clickatell/api/message_status.rb
 lib/clickatell/response.rb
 lib/clickatell/utility.rb
 lib/clickatell/utility/options.rb
@@ -15,7 +18,6 @@ lib/core-ext/hash.rb
 scripts/txt2html
 setup.rb
 spec/api_spec.rb
-spec/connection_spec.rb
 spec/hash_ext_spec.rb
 spec/response_spec.rb
 spec/spec.opts

data/README.txt

@@ -10,12 +10,8 @@ account username and password.
   require 'rubygems'
   require 'clickatell'
   
-  connection = Clickatell::Connection.new(
-    'your_api_id',
-    'your_username',
-    'your_password'
-  )
-  connection.send_message('447771234567', 'Hello from clickatell')
+  api = Clickatell::API.authenticate('your_api_id', 'your_username', 'your_password')
+  api.send_message('447771234567', 'Hello from clickatell')
 
   
 == Command-line SMS Utility

data/bin/sms

@@ -13,24 +13,30 @@ else
   require 'clickatell/utility'
 end
 
+# parse command line options
 options = Clickatell::Utility::Options.parse(ARGV)
-connection = Clickatell::Connection.new(options.api_key, options.username, options.password)
+
+# enable debugging if specified
+Clickatell::API.debug_mode = true if options.debugging_enabled
+
+# authenticate and load the API
+api = Clickatell::API.authenticate(options.api_key, options.username, options.password)
 
 begin
   if options.show_balance
     puts "Retrieving account balance..."
-    puts "You have #{connection.account_balance} credits remaining."
+    puts "You have #{api.account_balance} credits remaining."
     exit 0
   elsif options.show_status
     puts "Getting status of message ##{options.message_id}."
-    status = connection.message_status(options.message_id)
+    status = api.message_status(options.message_id)
     puts "Status: #{Clickatell::API::MessageStatus[status]} (##{status})."
     exit 0
   else
     puts "Sending '#{options.message}' to #{options.recipient}..."
     additional_opts = {}
     additional_opts[:from] = options.from if options.from
-    msg_id = connection.send_message(options.recipient, options.message, additional_opts)
+    msg_id = api.send_message(options.recipient, options.message, additional_opts)
     puts "Message sent successfully (message id: #{msg_id})."
     exit 0
   end
@@ -51,4 +57,9 @@ rescue Clickatell::API::Error => e
     puts "Please contact the author (contact@lukeredpath.co.uk) with the above error."
     exit 1
   end
+  
+rescue Timeout::Error
+  puts "The connection the the Clickatell service timed out"
+  puts "Please check your network settings and try again."
+  exit 1
 end

data/lib/clickatell.rb

@@ -1,8 +1,10 @@
-module Clickatell
-end
+module Clickatelll end
 
-require File.join(File.dirname(__FILE__), *%w[core-ext/hash])
-require File.join(File.dirname(__FILE__), *%w[clickatell/version])
-require File.join(File.dirname(__FILE__), *%w[clickatell/api])
-require File.join(File.dirname(__FILE__), *%w[clickatell/response])
-require File.join(File.dirname(__FILE__), *%w[clickatell/connection])
+%w( core-ext/hash
+    clickatell/version 
+    clickatell/api 
+    clickatell/response
+    
+).each do |lib|
+    require File.join(File.dirname(__FILE__), lib)
+end

data/lib/clickatell/api.rb

@@ -1,160 +1,111 @@
-require 'net/http'
-
 module Clickatell
-  # This module provides the core implementation of the Clickatell 
+  # This module provides the core implementation of the Clickatell
   # HTTP service.
-  module API
+  class API
+    attr_accessor :auth_options
     
     class << self
-      
-      # Authenticates using the specified credentials. Returns
-      # a session_id if successful which can be used in subsequent
-      # API calls.
+      # Authenticates using the given credentials and returns an 
+      # API instance with the authentication options set to use the 
+      # resulting session_id.
       def authenticate(api_id, username, password)
-        response = execute_command('auth',
-          :api_id => api_id,
-          :user => username,
-          :password => password
-        )
-        parse_response(response)['OK']
-      end
-      
-      # Pings the service with the specified session_id to keep the
-      # session alive.
-      def ping(session_id)
-        execute_command('ping', :session_id => session_id)
-      end
-      
-      # Sends a message +message_text+ to +recipient+. Recipient
-      # number should have an international dialing prefix and
-      # no leading zeros (unless you have set a default prefix
-      # in your clickatell account centre).
-      #
-      # Takes a hash of auth_options to be used in this
-      # API call. Either api_id/username/password or session_id
-      # for an existing authenticated session.
-      #
-      # Additional options:
-      #    :from - the from number/name
-      #
-      # Returns a new message ID if successful.
-      def send_message(recipient, message_text, auth_options, opts={})
-        valid_options = opts.only(:from)
-        response = execute_command('sendmsg', {
-          :to => recipient,
-          :text => message_text
-        }.merge(auth_hash(auth_options)).merge(valid_options)) 
-        parse_response(response)['ID']
-      end
-      
-      # Returns the status of a message. Use message ID returned
-      # from original send_message call. See send_message() for
-      # auth_options.
-      def message_status(message_id, auth_options)
-        response = execute_command('querymsg', {
-          :apimsgid => message_id 
-        }.merge( auth_hash(auth_options) ))
-        parse_response(response)['Status']
-      end
-      
-      # Returns the number of credits remaining as a float. 
-      # See send_message() for auth_options.
-      def account_balance(auth_options)
-        response = execute_command('getbalance', auth_hash(auth_options))
-        parse_response(response)['Credit'].to_f
-      end
-
-      protected
-        # Builds a command and sends it via HTTP GET.
-        def execute_command(command_name, parameters)
-          Net::HTTP.get_response(
-            Command.new(command_name).with_params(parameters)
-          )
-        end
-        
-        def parse_response(raw_response) #:nodoc:
-          Clickatell::Response.parse(raw_response)
-        end
-        
-        def auth_hash(options) #:nodoc:
-          if options[:session_id]
-            return {
-              :session_id => options[:session_id]
-            }
-          else
-            return {
-              :user => options[:username],
-              :password => options[:password],
-              :api_id => options[:api_key]
-            }
-          end
+        api = self.new
+        session_id = api.authenticate(api_id, username, password)
+        api.auth_options = { :session_id => session_id }
+        api
       end
       
+      # Set to true to enable debugging (off by default)
+      attr_accessor :debug_mode
     end
     
-    # Represents a Clickatell HTTP gateway command in the form 
-    # of a complete URL (the raw, low-level request).
-    class Command
-      API_SERVICE_HOST = 'api.clickatell.com'
-
-      def initialize(command_name, opts={})
-        @command_name = command_name
-        @options = { :secure => false }.merge(opts)
-      end
-      
-      # Returns a URL for the given parameters (a hash).
-      def with_params(param_hash)
-        param_string = '?' + param_hash.map { |key, value| "#{key}=#{value}" }.sort.join('&')
-        return URI.parse(File.join(api_service_uri, @command_name + URI.encode(param_string)))
-      end
-
-      protected
-        def api_service_uri
-          protocol = @options[:secure] ? 'https' : 'http'
-          return "#{protocol}://#{API_SERVICE_HOST}/http/"
-        end
+    # Creates a new API instance using the specified +auth options+.
+    # +auth_options+ is a hash containing either a :session_id or 
+    # :username, :password and :api_key.
+    #
+    # Some API calls (authenticate, ping etc.) do not require any 
+    # +auth_options+. +auth_options+ can be updated using the accessor methods.
+    def initialize(auth_options={})
+      @auth_options = auth_options
     end
     
-    # Clickatell API Error exception.
-    class Error < StandardError
-      attr_reader :code, :message
-      
-      def initialize(code, message)
-        @code, @message = code, message
-      end
-      
-      # Creates a new Error from a Clickatell HTTP response string
-      # e.g.:
-      #
-      #  Error.parse("ERR: 001, Authentication error")
-      #  # =>  #<Clickatell::API::Error code='001' message='Authentication error'>
-      def self.parse(error_string)
-        error_details = error_string.split(':').last.strip
-        code, message = error_details.split(',').map { |s| s.strip }
-        self.new(code, message)
-      end
+    # Authenticates using the specified credentials. Returns
+    # a session_id if successful which can be used in subsequent
+    # API calls.
+    def authenticate(api_id, username, password)
+      response = execute_command('auth',
+        :api_id => api_id,
+        :user => username,
+        :password => password
+      )
+      parse_response(response)['OK']
+    end
+    
+    # Pings the service with the specified session_id to keep the
+    # session alive.
+    def ping(session_id)
+      execute_command('ping', :session_id => session_id)
+    end
+    
+    # Sends a message +message_text+ to +recipient+. Recipient
+    # number should have an international dialing prefix and
+    # no leading zeros (unless you have set a default prefix
+    # in your clickatell account centre).
+    #
+    # Additional options:
+    #    :from - the from number/name
+    #
+    # Returns a new message ID if successful.
+    def send_message(recipient, message_text, opts={})
+      valid_options = opts.only(:from)
+      response = execute_command('sendmsg',
+        {:to => recipient, :text => message_text}.merge(valid_options)
+      ) 
+      parse_response(response)['ID']
+    end
+    
+    # Returns the status of a message. Use message ID returned
+    # from original send_message call.
+    def message_status(message_id)
+      response = execute_command('querymsg', :apimsgid => message_id)
+      parse_response(response)['Status']
     end
     
-    class MessageStatus
-      STATUS_MAP = {
-        1  => 'Message unknown',
-        2  => 'Message queued',
-        3  => 'Delivered to gateway',
-        4  => 'Received by recipient',
-        5  => 'Error with message',
-        6  => 'User cancelled messaged delivery',
-        7  => 'Error delivering message',
-        8  => 'OK',
-        9  => 'Routing error',
-        10 => 'Message expired',
-        11 => 'Message queued for later delivery',
-        12 => 'Out of credit'
-      }
+    # Returns the number of credits remaining as a float.
+    def account_balance
+      response = execute_command('getbalance')
+      parse_response(response)['Credit'].to_f
+    end
+
+    protected
+      def execute_command(command_name, parameters={}) #:nodoc:
+        CommandExecutor.new(auth_hash, self.class.debug_mode).execute(command_name, parameters)
+      end
+
+      def parse_response(raw_response) #:nodoc:
+        Clickatell::Response.parse(raw_response)
+      end
       
-      def self.[](code)
-        STATUS_MAP[code]
+      def auth_hash #:nodoc:
+        if @auth_options[:session_id]
+          { :session_id => @auth_options[:session_id] }
+        elsif @auth_options[:api_id]
+          { :user => @auth_options[:username],
+            :password => @auth_options[:password],
+            :api_id => @auth_options[:api_key] }
+        else
+          {}
+        end
       end
-    end
     
   end
+end
+
+%w( api/command
+    api/command_executor
+    api/error
+    api/message_status
+    
+).each do |lib|
+    require File.join(File.dirname(__FILE__), lib)
 end

data/lib/clickatell/api/command.rb

@@ -0,0 +1,28 @@
+module Clickatell
+  class API
+
+    # Represents a Clickatell HTTP gateway command in the form 
+    # of a complete URL (the raw, low-level request).
+    class Command
+      API_SERVICE_HOST = 'api.clickatell.com'
+
+      def initialize(command_name, opts={})
+        @command_name = command_name
+        @options = { :secure => false }.merge(opts)
+      end
+  
+      # Returns a URL for the given parameters (a hash).
+      def with_params(param_hash)
+        param_string = '?' + param_hash.map { |key, value| "#{key}=#{value}" }.sort.join('&')
+        return URI.parse(File.join(api_service_uri, @command_name + URI.encode(param_string)))
+      end
+
+      protected
+        def api_service_uri
+          protocol = @options[:secure] ? 'https' : 'http'
+          return "#{protocol}://#{API_SERVICE_HOST}/http/"
+        end
+    end
+    
+  end
+end

data/lib/clickatell/api/command_executor.rb

@@ -0,0 +1,31 @@
+require 'net/http'
+
+module Clickatell
+  class API
+   
+    # Used to run commands agains the Clickatell gateway.
+    class CommandExecutor
+      def initialize(authentication_hash, debug=false)
+        @authentication_hash = authentication_hash
+        @debug = debug
+      end
+      
+      # Builds a command object and sends it using HTTP GET. 
+      # Will output URLs as they are requested to stdout when 
+      # debugging is enabled.
+      def execute(command_name, parameters={})
+        request_uri = command(command_name, parameters)
+        puts "[debug] Sending request to #{request_uri}" if @debug
+        Net::HTTP.get_response(request_uri)
+      end
+      
+      protected
+        def command(command_name, parameters) #:nodoc:
+          Command.new(command_name).with_params(
+            parameters.merge(@authentication_hash)
+          )
+        end
+    end 
+  
+  end
+end

data/lib/clickatell/api/error.rb

@@ -0,0 +1,25 @@
+module Clickatell
+  class API
+  
+    # Clickatell API Error exception.
+    class Error < StandardError
+      attr_reader :code, :message
+      
+      def initialize(code, message)
+        @code, @message = code, message
+      end
+      
+      # Creates a new Error from a Clickatell HTTP response string
+      # e.g.:
+      #
+      #  Error.parse("ERR: 001, Authentication error")
+      #  # =>  #<Clickatell::API::Error code='001' message='Authentication error'>
+      def self.parse(error_string)
+        error_details = error_string.split(':').last.strip
+        code, message = error_details.split(',').map { |s| s.strip }
+        self.new(code, message)
+      end
+    end
+  
+  end
+end

data/lib/clickatell/api/message_status.rb

@@ -0,0 +1,26 @@
+module Clickatell
+  class API
+   
+    class MessageStatus
+      STATUS_MAP = {
+        1  => 'Message unknown',
+        2  => 'Message queued',
+        3  => 'Delivered to gateway',
+        4  => 'Received by recipient',
+        5  => 'Error with message',
+        6  => 'User cancelled messaged delivery',
+        7  => 'Error delivering message',
+        8  => 'OK',
+        9  => 'Routing error',
+        10 => 'Message expired',
+        11 => 'Message queued for later delivery',
+        12 => 'Out of credit'
+      }
+      
+      def self.[](code)
+        STATUS_MAP[code]
+      end
+    end 
+  
+  end
+end

data/lib/clickatell/utility/options.rb

@@ -43,6 +43,10 @@ module Clickatell
                @options.message_id = message_id
                @options.show_status = true  
             end
+            
+            opts.on('-d', '--debug') do
+               @options.debugging_enabled = true
+            end
           
             opts.on_tail('-h', '--help', "Show this message") do
               puts opts

data/lib/clickatell/version.rb

@@ -1,7 +1,7 @@
 module Clickatell #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/lib/core-ext/hash.rb

@@ -7,7 +7,7 @@ class Hash
   #
   # Keys that do not exist in the original hash are ignored.
   def only(*keys)
-    self.inject({}) do |new_hash, (key, value)|
+    inject( {} ) do |new_hash, (key, value)|
       new_hash[key] = value if keys.include?(key)
       new_hash
     end

data/spec/api_spec.rb

@@ -31,120 +31,103 @@ module Clickatell
   end
   
   describe "Command executor" do
-    it "should create an API command and send it via HTTP get, returning the raw http response" do
+    it "should create an API command with auth params and send it via HTTP get, returning the raw http response" do
+      executor = API::CommandExecutor.new(:session_id => '12345')
       API::Command.should_receive(:new).with('cmdname').and_return(cmd=mock('command'))
-      cmd.should_receive(:with_params).with(:param_one => 'foo').and_return(uri=mock('uri'))
+      cmd.should_receive(:with_params).with(:param_one => 'foo', :session_id => '12345').and_return(uri=mock('uri'))
       Net::HTTP.should_receive(:get_response).with(uri).and_return(raw_response=mock('http response'))
-      API.send(:execute_command, 'cmdname', :param_one => 'foo').should == raw_response
+      executor.execute('cmdname', :param_one => 'foo').should == raw_response
     end
   end
   
   describe "API" do
+    before do
+      API.debug_mode = false
+      API::CommandExecutor.should_receive(:new).with({:session_id => '1234'}, false).and_return(@executor = mock('command executor'))
+      @api = API.new(:session_id => '1234')
+    end
+    
     it "should return session_id for successful authentication" do
-      API.should_receive(:execute_command).with('auth',
+      @executor.should_receive(:execute).with('auth',
         :api_id => '1234',
         :user => 'joebloggs',
         :password => 'superpass'
       ).and_return(response=mock('response'))
       Response.should_receive(:parse).with(response).and_return('OK' => 'new_session_id')        
-      API.authenticate('1234', 'joebloggs', 'superpass').should == 'new_session_id'
+      @api.authenticate('1234', 'joebloggs', 'superpass').should == 'new_session_id'
     end
     
     it "should support ping" do
-      API.should_receive(:execute_command).with('ping', :session_id => 'abcdefg').and_return(response=mock('response'))
-      API.ping('abcdefg').should == response
+      @executor.should_receive(:execute).with('ping', :session_id => 'abcdefg').and_return(response=mock('response'))
+      @api.ping('abcdefg').should == response
     end
     
-    it "should support sending messages with authentication, returning the message id" do
-      API.should_receive(:execute_command).with('sendmsg',
-        :api_id => '1234',
-        :user => 'joebloggs',
-        :password => 'superpass',
+    it "should support sending messages, returning the message id" do
+      @executor.should_receive(:execute).with('sendmsg',
         :to => '4477791234567',
         :text => 'hello world'
       ).and_return(response=mock('response'))
       Response.should_receive(:parse).with(response).and_return('ID' => 'message_id')      
-      API.send_message('4477791234567', 'hello world',
-        :username => 'joebloggs', :password => 'superpass', :api_key => '1234'
-      ).should == 'message_id'
-    end
-    
-    it "should support sending messages with pre-auth, returning the message id" do
-      API.should_receive(:execute_command).with('sendmsg',
-        :session_id => 'abcde',
-        :to => '4477791234567',
-        :text => 'hello world'
-      ).and_return(response=mock('response'))
-      Response.should_receive(:parse).with(response).and_return('ID' => 'message_id')
-      API.send_message('4477791234567', 'hello world', :session_id => 'abcde').should == 'message_id'
+      @api.send_message('4477791234567', 'hello world').should == 'message_id'
     end
     
     it "should support sending messages with custom from number, returning the message id" do
-      API.should_receive(:execute_command).with('sendmsg',
-        :session_id => 'abcde',
+      @executor.should_receive(:execute).with('sendmsg',
         :to => '4477791234567',
         :text => 'hello world',
         :from => 'LUKE'
       ).and_return(response=mock('response'))
       Response.should_receive(:parse).with(response).and_return('ID' => 'message_id')
-      API.send_message('4477791234567', 'hello world', {:session_id => 'abcde'}, :from => 'LUKE')
+      @api.send_message('4477791234567', 'hello world', :from => 'LUKE')
     end
     
     it "should ignore any invalid parameters when sending message" do
-      API.should_receive(:execute_command).with('sendmsg',
-        :session_id => 'abcde',
+      @executor.should_receive(:execute).with('sendmsg',
         :to => '4477791234567',
         :text => 'hello world',
         :from => 'LUKE'
       ).and_return(response=mock('response'))
       Response.stub!(:parse).and_return('ID' => 'foo')
-       API.send_message('4477791234567', 'hello world', {:session_id => 'abcde'}, :from => 'LUKE', :any_old_param => 'test')
+      @api.send_message('4477791234567', 'hello world', :from => 'LUKE', :any_old_param => 'test')
     end
     
-    it "should support message status query with authentication, returning message status" do
-      API.should_receive(:execute_command).with('querymsg',
-        :api_id => '1234',
-        :user => 'joebloggs',
-        :password => 'superpass',
-        :apimsgid => 'messageid'
-      ).and_return(response=mock('response'))
-      Response.should_receive(:parse).with(response).and_return('ID' => 'message_id', 'Status' => 'message_status')
-      API.message_status('messageid',
-        :username => 'joebloggs', :password => 'superpass', :api_key => '1234'
-      ).should == 'message_status'
-    end
-      
-    it "should support message status query with pre-auth" do
-      API.should_receive(:execute_command).with('querymsg',
-        :session_id => 'abcde',
+    it "should support message status query, returning message status" do
+      @executor.should_receive(:execute).with('querymsg',
         :apimsgid => 'messageid'
       ).and_return(response=mock('response'))
       Response.should_receive(:parse).with(response).and_return('ID' => 'message_id', 'Status' => 'message_status')
-      API.message_status('messageid', :session_id => 'abcde').should == 'message_status'
+      @api.message_status('messageid').should == 'message_status'
     end
     
-    it "should support balance query with authentication, returning number of credits as a float" do
-      API.should_receive(:execute_command).with('getbalance',
-        :api_id => '1234',
-        :user => 'joebloggs',
-        :password => 'superpass'
-      ).and_return(response=mock('response'))
+    it "should support balance query, returning number of credits as a float" do
+      @executor.should_receive(:execute).with('getbalance', {}).and_return(response=mock('response'))
       Response.should_receive(:parse).with(response).and_return('Credit' => '10.0')
-      API.account_balance(:username => 'joebloggs', :password => 'superpass', :api_key => '1234').should == 10.0
-    end
-    
-    it "should support balance query with pre-auth, returning number of credits as a float" do
-      API.should_receive(:execute_command).with('getbalance',
-        :session_id => 'abcde'
-      ).and_return(response=mock('response'))
-      Response.should_receive(:parse).with(response).and_return('Credit' => '10.0')
-      API.account_balance(:session_id => 'abcde').should == 10.0
+      @api.account_balance.should == 10.0
     end
     
     it "should raise an API::Error if the response parser raises" do
-      API.stub!(:execute_command)
+      @executor.stub!(:execute)
       Response.stub!(:parse).and_raise(Clickatell::API::Error.new('', ''))
-      proc { API.account_balance({}) }.should raise_error(Clickatell::API::Error)
+      proc { @api.account_balance }.should raise_error(Clickatell::API::Error)
+    end
+  end
+  
+  describe API, ' when authenticating' do
+    it "should authenticate to retrieve a session_id and return a new API instance using that session id" do
+      API.stub!(:new).and_return(api=mock('api'))
+      api.should_receive(:authenticate).with('my_api_key', 'joebloggs', 'mypassword').and_return('new_session_id')
+      api.should_receive(:auth_options=).with(:session_id => 'new_session_id')
+      API.authenticate('my_api_key', 'joebloggs', 'mypassword')
+    end
+  end
+  
+  describe API, ' with no authentication options set' do
+    it "should build commands with no authentication options" do
+      API.debug_mode = false
+      api = API.new
+      API::CommandExecutor.should_receive(:new).with({}, false).and_return(executor=mock('command executor'))
+      executor.stub!(:execute)
+      api.ping('1234')
     end
   end
   

data/website/index.txt

@@ -29,11 +29,17 @@ account username and password.
 require 'rubygems'
 require 'clickatell'
 
-connection = Clickatell::Connection.new('your_api_id', 'your_username', 'your_password')
-connection.send_message('447771234567', 'Hello from clickatell')
+api = Clickatell::API.authenticate('your_api_id', 'your_username', 'your_password')
+api.send_message('447771234567', 'Hello from clickatell')
 </code></pre>
 
 Full documentation for the API is available in the <a href="rdoc/">RDocs</a>.
+
+For debugging purposes, the API allows you to view gateway URIs as they are requested, printed to $stdout. You can enable this by turning on +debug_mode+.
+
+<pre><code class="ruby">
+Clickatell::API.debug_mode = true
+</code></pre>
   
 h4. Command-line SMS Utility
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: clickatell
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
-date: 2007-08-23 00:00:00 +01:00
+  version: 0.4.0
+date: 2007-08-29 00:00:00 +01:00
 summary: Ruby interface to the Clickatell SMS gateway service.
 require_paths: 
 - lib
@@ -37,7 +37,10 @@ files:
 - bin/sms
 - lib/clickatell.rb
 - lib/clickatell/api.rb
-- lib/clickatell/connection.rb
+- lib/clickatell/api/command.rb
+- lib/clickatell/api/command_executor.rb
+- lib/clickatell/api/error.rb
+- lib/clickatell/api/message_status.rb
 - lib/clickatell/response.rb
 - lib/clickatell/utility.rb
 - lib/clickatell/utility/options.rb
@@ -46,7 +49,6 @@ files:
 - scripts/txt2html
 - setup.rb
 - spec/api_spec.rb
-- spec/connection_spec.rb
 - spec/hash_ext_spec.rb
 - spec/response_spec.rb
 - spec/spec.opts

data/lib/clickatell/connection.rb

@@ -1,62 +0,0 @@
-module Clickatell
-  
-  # The Connection object provides a high-level interface to the
-  # Clickatell API, handling authentication across multiple API
-  # requests.
-  #
-  # Example:
-  #   conn = Clickatell::Connection.new('your_api_key', 'joebloggs', 'secret')
-  #   message_id = conn.send_message('44777123456', 'This is a test message')
-  #   status = conn.message_status(message_id)
-  #
-  # The Connection object provides all of the public methods implemented in 
-  # Clickatell::API but handles the passing of authentication options 
-  # automatically so it is not required to pass any authentication_option hashes
-  # into API methods that require them.
-  class Connection
-    
-    # Returns the current Clickatell session ID.
-    attr_reader :session_id
-    
-    # +api_key+: Your Clickatell API ID/key.
-    # +username+: Your Clickatell account username.
-    # +password+: Your Clickatell account password.
-    def initialize(api_key, username, password)
-      @api_key = api_key
-      @username = username
-      @password = password
-    end
-    
-    # Manual authentication. Will create a new Clickatell session 
-    # and store the session ID.
-    def authenticate!
-      @session_id = API.authenticate(@api_key, @username, @password)
-    end
-    
-    protected
-      # Executes the given +api_method+ by delegating to the API 
-      # module, using the current session_id for authentication.
-      def execute_api_call(api_method, params, additional_options)
-        params << {:session_id => current_session_id}
-        params << additional_options if additional_options
-        API.send(api_method, *params)
-      end
-      
-      # Returns the current_session_id, authenticating if one doesn't exist
-      def current_session_id
-        authenticate! if session_id.nil?
-        session_id
-      end
-    
-      # Dispatch any API methods to the API module.
-      def method_missing(method, *args, &block)
-        if API.respond_to?(method)
-          additional_options = args.pop if args.last.is_a?(Hash)
-          execute_api_call(method, args, additional_options)
-        else
-          super(method, args, &block)
-        end
-      end
-  end
-    
-end

data/spec/connection_spec.rb

@@ -1,33 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-require File.dirname(__FILE__) + '/../lib/clickatell'
-
-module Clickatell
-
-  describe Connection, ' when unauthenticated' do
-    it "should authenticate and store session_id before sending command" do
-      connection = Connection.new('my_api_key', 'myusername', 'mypassword')
-      API.should_receive(:authenticate).with('my_api_key', 'myusername', 'mypassword').and_return('new_session_id')
-      API.should_receive(:send_message).with('4477791234567', 'hello world', :session_id => 'new_session_id')
-      connection.send_message('4477791234567', 'hello world')
-    end
-  end
-  
-  describe Connection, ' when authenticated' do
-    before do
-      @connection = Connection.new('my_api_key', 'myusername', 'mypassword')
-      @connection.stub!(:session_id).and_return('session_id')
-    end
-    
-    it "should send command with session_id without re-authenticating" do
-      API.should_receive(:authenticate).never
-      API.should_receive(:send_message).with('4477791234567', 'hello world', :session_id => 'session_id')
-      @connection.send_message('4477791234567', 'hello world')
-    end
-    
-    it "should support API calls with additional opts, passing them after auth options" do
-      API.should_receive(:send_message).with('4477791234567', 'hello world', {:session_id => 'session_id'}, :from => 'LUKE')
-      @connection.send_message('4477791234567', 'hello world', {:from => 'LUKE'})
-    end
-  end
-  
-end