activesalesforce 0.0.4 → 0.0.5

data/lib/rforce.rb

@@ -54,7 +54,7 @@ require_gem 'builder'
 #    binding.create 'sObject {"xsi:type" => "Opportunity"}' => opportunity
 #
 module RForce
-
+  
   #Allows indexing hashes like method calls: hash.key
   #to supplement the traditional way of indexing: hash[key]
   module FlashHash
@@ -62,65 +62,68 @@ module RForce
       self[method]
     end
   end
-
+  
   #Turns an XML response from the server into a Ruby
   #object whose methods correspond to nested XML elements.
   class SoapResponse
     include FlashHash
-
+    
     #Parses an XML string into structured data.
     def initialize(content)
       document = REXML::Document.new content
       node = REXML::XPath.first document, '//soapenv:Body'
       @parsed = SoapResponse.parse node
     end
-
+    
     #Allows this object to act like a hash (and therefore
     #as a FlashHash via the include above).
     def [](symbol)
       @parsed[symbol]
     end
-  
+    
     #Digests an XML DOM node into nested Ruby types.
     def SoapResponse.parse(node)
       #Convert text nodes into simple strings.
       return node.text unless node.has_elements?
-
+      
       #Convert nodes with children into FlashHashes.
       elements = {}
       class << elements
         include FlashHash
       end
-    
+      
       #Add all the element's children to the hash.
       node.each_element do |e|
         name = e.name.to_sym
         
         case elements[name]
           #The most common case: unique child element tags.
-          when NilClass: elements[name] = parse(e)
+        when NilClass: elements[name] = parse(e)
           
           #Non-unique child elements become arrays:
           
           #We've already created the array: just
           #add the element.
-          when Array: elements[name] << parse(e)
+        when Array: elements[name] << parse(e)
           
           #We haven't created the array yet: do so,
           #then put the existing element in, followed
           #by the new one.
-          else
-            elements[name] = [elements[name]]
-            elements[name] << parse(e)
+        else
+          elements[name] = [elements[name]]
+          elements[name] << parse(e)
         end
       end
-    
+      
       return elements
     end
   end
-
+  
   #Implements the connection to the SalesForce server.
   class Binding
+    DEFAULT_BATCH_SIZE = 10
+    attr_accessor :batch_size
+    
     #Fill in the guts of this typical SOAP envelope
     #with the session ID and the body of the SOAP request.
     Envelope = <<-HERE
@@ -132,13 +135,16 @@ module RForce
     <SessionHeader>
       <sessionId>%s</sessionId>
     </SessionHeader>
+    <QueryOptions>
+      <batchSize>%d</batchSize>
+    </QueryOptions>
   </env:Header>
   <env:Body>
     %s
   </env:Body>
 </env:Envelope>
     HERE
-
+    
     #Connect to the server securely.
     def initialize(url)
       @url = URI.parse(url)
@@ -146,21 +152,24 @@ module RForce
       @server.use_ssl = @url.scheme == 'https'
       
       # run ruby with -d to see SOAP wiredumps.
-      @server.set_debug_output $stderr if $DEBUG
+      @server.set_debug_output $stderr #if $DEBUG
       
       @session_id = ''
+      @batch_size = DEFAULT_BATCH_SIZE      
     end
-  
+    
+    
     #Log in to the server and remember the session ID
     #returned to us by SalesForce.
     def login(user, pass)
       response = call_remote(:login, [:username, user, :password, pass])
-
+      
       raise "Incorrect user name / password [#{response.fault}]" unless response.loginResponse
       @session_id = response.loginResponse.result.sessionId
+      
       response
     end
-  
+    
     #Call a method on the remote server.  Arguments can be
     #a hash or (if order is important) an array of alternating
     #keys and values.
@@ -169,56 +178,59 @@ module RForce
       expanded = ''
       @builder = Builder::XmlMarkup.new(:target => expanded)
       expand({method => args}, 'urn:partner.soap.sforce.com')
-
+      
       #Fill in the blanks of the SOAP envelope with our
       #session ID and the expanded XML of our request.
-      request = (Envelope % [@session_id, expanded])
-
+      request = (Envelope % [@session_id, @batch_size, expanded])
+      
+      # reset the batch size for the next request
+      @batch_size = DEFAULT_BATCH_SIZE
+      
       #Send the request to the server and read the response.    
       response = @server.post2(@url.path, request, {'SOAPAction' => method.to_s, 'content-type' => 'text/xml'})
       SoapResponse.new(response.body)
     end
-  
+    
     #Turns method calls on this object into remote SOAP calls.
     def method_missing(method, *args)
       unless args.size == 1 && [Hash, Array].include?(args[0].class)
         raise 'Expected 1 Hash or Array argument'
       end
-
+      
       call_remote method, args[0]    
     end
-  
+    
     #Expand Ruby data structures into XML.
     def expand(args, xmlns = nil)
       #Nest arrays: [:a, 1, :b, 2] => [[:a, 1], [:b, 2]]
       if (args.class == Array)
         args.each_index{|i| args[i, 2] = [args[i, 2]]}
       end
-    
+      
       args.each do |key, value|
         attributes = xmlns ? {:xmlns => xmlns} : {}
-
-		#If the XML tag requires attributes,
-		#the tag name will contain a space
-		#followed by a string representation
-		#of a hash of attributes.
-		#
-		#e.g. 'sObject {"xsi:type" => "Opportunity"}'
-		#becomes <sObject xsi:type="Opportunity>...</sObject>
+        
+        #If the XML tag requires attributes,
+        #the tag name will contain a space
+        #followed by a string representation
+        #of a hash of attributes.
+        #
+        #e.g. 'sObject {"xsi:type" => "Opportunity"}'
+        #becomes <sObject xsi:type="Opportunity>...</sObject>
         if key.is_a? String
-           key, modifier = key.split(' ', 2)
-           
-           attributes.merge!(eval(modifier)) if modifier
+          key, modifier = key.split(' ', 2)
+          
+          attributes.merge!(eval(modifier)) if modifier
         end
         
         #Create an XML element and fill it with this
         #value's sub-items.
         case value
-          when Hash, Array
-            @builder.tag!(key, attributes) do expand value; end
+        when Hash, Array
+          @builder.tag!(key, attributes) do expand value; end
           
-          when String
-            @builder.tag!(key, attributes) { @builder.text! value }
+        when String
+          @builder.tag!(key, attributes) { @builder.text! value }
         end
       end
     end

data/lib/salesforce_active_record.rb

@@ -133,6 +133,7 @@ module ActiveRecord
     end
     
     def self.count_by_sql(soql)
+      connection.batch_size = 1
       connection.select_all(soql, "#{name} Count").length
     end     
           

data/lib/salesforce_connection_adapter.rb

@@ -68,6 +68,7 @@ module ActiveRecord
     end
     
     class SalesforceAdapter < AbstractAdapter
+      attr_accessor :batch_size
       
       def initialize(connection, logger, connection_options, config)
         super(connection, logger)
@@ -131,7 +132,10 @@ module ActiveRecord
       def select_all(soql, name = nil) #:nodoc:
         log(soql, name)
         
-        records = @connection.query(:queryString => soql).queryResponse.result.records
+        @connection.batch_size = @batch_size if @batch_size
+        @batch_size = nil
+        
+        records = get_result(@connection.query(:queryString => soql), :query).records
         
         records = [ records ] unless records.is_a?(Array)
         
@@ -150,30 +154,31 @@ module ActiveRecord
       end
       
       def create(sobject, name = nil) #:nodoc:
-        result = @connection.create(sobject).createResponse.result
-        
-        raise SalesforceError, result[:errors].message  unless result[:success] == "true"
-        
-        result[:id]
+        check_result(get_result(@connection.create(sobject), :create))[:id]
       end
       
       def update(sobject, name = nil) #:nodoc:
-        result = @connection.update(sobject).updateResponse.result
-        
-        raise SalesforceError, result[:errors].message  unless result[:success] == "true"
-        
-        # @connection.affected_rows
+        check_result(get_result(@connection.update(sobject), :update))
       end
 
       def delete(ids)
         puts "Delete #{ids}"
+        check_result(get_result(@connection.delete(:ids => ids), :delete))
+      end
         
+      def get_result(response, method)
+        responseName = (method.to_s + "Response").to_sym
+        finalResponse = response[responseName]
+        raise SalesforceError, response.fault unless finalResponse
         
-        result = @connection.delete(:ids => ids).deleteResponse.result
-        
+        result = finalResponse[:result]
+      end        
+      
+      def check_result(result)
         raise SalesforceError, result[:errors].message  unless result[:success] == "true"
+        result
       end
-            
+                    
       def columns(table_name, name = nil)
         cached_columns = @columns_map[table_name]
         return cached_columns if cached_columns
@@ -182,8 +187,8 @@ module ActiveRecord
         
         cached_columns = []
         @columns_map[table_name] = cached_columns
-        
-        metadata = @connection.describeSObject(:sObjectType => table_name).describeSObjectResponse.result
+
+        metadata = get_result(@connection.describeSObject(:sObjectType => table_name), :describeSObject)
         
         metadata.fields.each do |field| 
           cached_columns << SalesforceColumn.new(field) 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: activesalesforce
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
-date: 2006-01-22 00:00:00 -05:00
+  version: 0.0.5
+date: 2006-01-23 00:00:00 -05:00
 summary: ActiveSalesforce is an extension to the Rails Framework that allows for the dynamic creation and management of ActiveRecord objects through the use of Salesforce meta-data and uses a Salesforce.com organization as the backing store.
 require_paths: 
 - lib