activesalesforce 0.1.1 → 0.1.2

data/lib/active_salesforce.rb

@@ -22,3 +22,21 @@
 =end
 
 require 'salesforce_connection_adapter'
+
+module ActionView
+  module Helpers
+    # Provides a set of methods for making easy links and getting urls that depend on the controller and action. This means that
+    # you can use the same format for links in the views that you do in the controller. The different methods are even named
+    # synchronously, so link_to uses that same url as is generated by url_for, which again is the same url used for
+    # redirection in redirect_to.
+    module UrlHelper
+      def link_to_asf(active_record, column)
+        if column.reference_to
+          link_to(column.reference_to, { :action => 'show', :controller => column.reference_to.pluralize, :id => active_record.send(column.name) } )
+        else
+          active_record.send(column.name)
+        end
+      end
+    end
+  end
+end

data/lib/column_definition.rb

@@ -28,12 +28,22 @@ require 'pp'
 
 
 module ActiveRecord  
+  module StringHelper
+    def column_nameize(s)
+      #s ? s.first.downcase + s[1 .. s.length] : nil
+      s.underscore
+    end
+  end
+  
   module ConnectionAdapters
     class SalesforceColumn < Column
-      attr_reader :label, :readonly, :reference_to
+      include StringHelper
+      
+      attr_reader :api_name, :label, :readonly, :reference_to
       
       def initialize(field)
-        @name = field[:name]
+        @api_name = field[:name]
+        @name = column_nameize(@api_name)
         @type = get_type(field[:type])
         @limit = field[:length]
         @label = field[:label]
@@ -82,28 +92,34 @@ module ActiveRecord
     end
     
     class SalesforceRelationship
-      attr_reader :name, :foreign_key, :label, :reference_to, :one_to_many, :cascade_delete
+      include StringHelper
+    
+      attr_reader :name, :api_name, :foreign_key, :label, :reference_to, :one_to_many, :cascade_delete
       
       def initialize(source)
         if source[:childSObject]
           relationship = source
           
-          @name = relationship[:relationshipName] ? relationship[:relationshipName] : relationship[:field].chop.chop
+          @api_name = relationship[:relationshipName] ? relationship[:relationshipName] : relationship[:field].chop.chop
           @one_to_many = relationship[:relationshipName] != nil
           @cascade_delete = relationship[:cascadeDelete] == "true"
           @reference_to = relationship[:childSObject]
           @label = @name
-          @foreign_key = relationship[:field]
+          @foreign_key = column_nameize(relationship[:field])
         else
           field = source
           
-          @name = field[:name].chop.chop
+          @api_name = field[:name].chop.chop
           @label = field[:label]
           @readonly = (field[:updateable] != "true" or field[:createable] != "true")          
           @reference_to = field[:referenceTo]
           @one_to_many = false
           @cascade_delete = false
+          @foreign_key = column_nameize(field[:name])
         end
+
+        @name = column_nameize(@api_name)
+
       end
     end
     

data/lib/rforce.rb

@@ -202,13 +202,16 @@ module RForce
       request = encode(request)
 
       headers = {
-        'Accept-Encoding' => 'gzip',
         'Connection' => 'Keep-Alive',
-        'Content-Encoding' => 'gzip',
         'Content-Type' => 'text/xml',
         'SOAPAction' => '""',
         'User-Agent' => 'ActiveSalesforce RForce'
       }
+      
+      unless $DEBUG
+        headers['Accept-Encoding'] = 'gzip'
+        headers['Content-Encoding'] = 'gzip'
+      end
 
       #Send the request to the server and read the response.
       response = @server.post2(@url.path, request, headers)
@@ -255,6 +258,8 @@ module RForce
 
     # encode gzip
     def encode(request)
+      return request if $DEBUG
+      
       begin
         ostream = StringIO.new
         gzw = Zlib::GzipWriter.new(ostream)

data/lib/salesforce_connection_adapter.rb

@@ -27,14 +27,8 @@ require_gem 'rails', ">= 1.0.0"
 require 'thread'
 
 require File.dirname(__FILE__) + '/salesforce_login'
-require File.dirname(__FILE__) + '/sobject_attributes'
-require File.dirname(__FILE__) + '/salesforce_active_record'
 require File.dirname(__FILE__) + '/column_definition'
 
-ActiveRecord::Base.class_eval do
-  include ActiveRecord::SalesforceRecord
-end
-
 
 module ActiveRecord    
   class Base   
@@ -75,6 +69,8 @@ module ActiveRecord
     end
     
     class SalesforceAdapter < AbstractAdapter
+      include StringHelper
+      
       attr_accessor :batch_size
       
       def initialize(connection, logger, connection_options, config)
@@ -84,7 +80,7 @@ module ActiveRecord
         
         @columns_map = {}
         @columns_name_map = {}
-
+        
         @relationships_map = {}
       end
       
@@ -109,7 +105,8 @@ module ActiveRecord
       end
       
       def quote_column_name(name) #:nodoc:
-        "`#{name}`"
+        # Mark the column name to make it easier to find later
+        "@@#{name}"
       end
       
       def quote_string(string) #:nodoc:
@@ -138,45 +135,124 @@ module ActiveRecord
       
       # DATABASE STATEMENTS ======================================
       
-      def select_all(soql, name = nil) #:nodoc:
+      def select_all(sql, name = nil) #:nodoc:
+        table_name = table_name_from_sql(sql)
+        entity_name = entity_name_from_table(table_name)
+        column_names = api_column_names(table_name)
+        
+        soql = sql.sub(/SELECT \* FROM/, "SELECT #{column_names.join(', ')} FROM")
+        
+        # Look for a LIMIT clause
+        soql.sub!(/LIMIT 1/, "")
+        
+        # Fixup column references to use api names
+        columns = columns_map(table_name)
+        while soql =~ /@@(\w+)/
+          column = columns[$~[1]]
+          soql = $~.pre_match + column.api_name + $~.post_match
+        end
+        
         log(soql, name)
         
         @connection.batch_size = @batch_size if @batch_size
         @batch_size = nil
         
         records = get_result(@connection.query(:queryString => soql), :query).records
-
+        
         result = []        
         return result unless records
         
         records = [ records ] unless records.is_a?(Array)
         
         records.each do |record|
-          attributes = Salesforce::SObjectAttributes.new(columns_map(record[:type]), record)
-          result << attributes
+          row = {}
+          
+          record.each do |name, value| 
+            name = column_nameize(name.to_s)
+            
+            # Replace nil element with nil
+            value = nil if value.respond_to?(:xmlattr_nil) and value.xmlattr_nil
+            
+            # Ids are returned in an array with 2 duplicate entries...
+            value = value[0] if name == "id"
+            
+            row[name] = value
+          end  
+          
+          result << row        
         end
         
         result
       end
       
       def select_one(sql, name = nil) #:nodoc:
+        @connection.batch_size = 1
         result = select_all(sql, name)
         result.nil? ? nil : result.first
       end
       
-      def create(sobject, name = nil) #:nodoc:
-        check_result(get_result(@connection.create(sobject), :create))[:id]
-      end
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        tokens = sql.scan(/[0-9A-Za-z._]+/)
+        
+        # Convert sql to sobject
+        table_name = tokens[2]
+        entity_name = entity_name_from_table(table_name)
+        columns = columns_map(table_name)
+        
+        # Extract array of [column_name, value] pairs
+        names = tokens[3 .. tokens.length / 2]
+        values = tokens[(tokens.length / 2) + 2 ..  tokens.length]
+        
+        fields = {}
+        names.length.times do | n | 
+          name = names[n]
+          value = values[n]
+          column = columns[name]
+          
+          fields[column.api_name] = value if not column.readonly and value != "NULL"
+        end
+        
+        sobject = create_sobject(entity_name, nil, fields)
+        
+        check_result(get_result(@connection.create(:sObjects => sobject), :create))[0][:id]
+      end      
       
-      def update(sobject, name = nil) #:nodoc:
-        check_result(get_result(@connection.update(sobject), :update))
+      def update(sql, name = nil) #:nodoc:
+        # Convert sql to sobject
+        table_name = sql.match(/UPDATE (\w+) /)[1]
+        entity_name = entity_name_from_table(table_name)
+        columns = columns_map(table_name)
+        
+        # Extract array of [column_name, value] pairs
+        raw_fields = sql.scan(/(\w+) = '([^']*)'/)
+        
+        fields = {}
+        raw_fields.each do | name, value | 
+          column = columns[name]
+          fields[column.api_name] = value if not column.readonly or name == "id"
+        end
+        
+        id = fields["Id"].match(/[a-zA-Z0-9]+/)[0]
+        fields.delete("Id")
+        
+        sobject = create_sobject(entity_name, id, fields)
+        
+        check_result(get_result(@connection.update(:sObjects => sobject), :update))
       end
+      
+      def delete(sql, name = nil) 
+        # Extract the ids from the IN () clause
+        match = sql.match(/IN \(([^\)]*)\)/)
 
-      def delete(ids)
-        puts "Delete #{ids}"
-        check_result(get_result(@connection.delete(:ids => ids), :delete))
-      end
+        # If the IN clause was not found fall back to WHERE id = 'blah'
+        ids = match ? match[1].scan(/\w+/) : [ sql.match(/WHERE id = '([^\']*)'/)[1] ]
+
+        ids_element = []        
+        ids.each { |id| ids_element << :ids << id }
         
+        check_result(get_result(@connection.delete(ids_element), :delete))
+      end
+      
       def get_result(response, method)
         responseName = (method.to_s + "Response").to_sym
         finalResponse = response[responseName]
@@ -187,21 +263,28 @@ module ActiveRecord
       end        
       
       def check_result(result)
-        raise SalesforceError.new(result[:Errors], result[:Errors].Message) unless result[:success] == "true"
+        result = [ result ] unless result.is_a?(Array)
+        
+        result.each do |r|
+          raise SalesforceError.new(r[:errors], r[:errors].Message) unless r[:success] == "true"
+        end
+        
         result
       end
-                    
+      
       def columns(table_name, name = nil)
-        cached_columns = @columns_map[table_name]
+        entity_name = entity_name_from_table(table_name)
+        
+        cached_columns = @columns_map[entity_name]
         return cached_columns if cached_columns
         
         cached_columns = []
-        @columns_map[table_name] = cached_columns
-
+        @columns_map[entity_name] = cached_columns
+        
         cached_relationships = []
-        @relationships_map[table_name] = cached_relationships
-
-        metadata = get_result(@connection.describeSObject(:sObjectType => table_name), :describeSObject)
+        @relationships_map[entity_name] = cached_relationships
+        
+        metadata = get_result(@connection.describeSObject(:sObjectType => entity_name), :describeSObject)
         
         metadata.fields.each do |field| 
           column = SalesforceColumn.new(field) 
@@ -209,54 +292,109 @@ module ActiveRecord
           
           cached_relationships << SalesforceRelationship.new(field) if field[:type] =~ /reference/i
         end
-
+        
         if metadata.childRelationships
           metadata.childRelationships.each do |relationship|
-            cached_relationships << SalesforceRelationship.new(relationship)
+          
+            if relationship[:childSObject].casecmp(entity_name) == 0
+              r = SalesforceRelationship.new(relationship)
+              cached_relationships << r
+            end
           end
         end
-                
+        
+        configure_active_record entity_name
+        
         cached_columns
       end
       
+      def configure_active_record(entity_name)
+        klass = entity_name.constantize
+        
+        klass.table_name = entity_name
+        klass.pluralize_table_names = false
+        klass.set_inheritance_column nil
+        klass.lock_optimistically = false
+        klass.record_timestamps = false
+        klass.default_timezone = :utc
+        
+        # Create relationships for any reference field
+        @relationships_map[entity_name].each do |relationship|
+          referenceName = relationship.name
+          unless self.respond_to? referenceName.to_sym or relationship.reference_to == "Profile"
+            one_to_many = relationship.one_to_many
+            foreign_key = relationship.foreign_key
+            
+            if one_to_many
+              klass.has_many referenceName.to_sym, :class_name => relationship.reference_to, :foreign_key => foreign_key, :dependent => false
+            else
+              klass.belongs_to referenceName.to_sym, :class_name => relationship.reference_to, :foreign_key => foreign_key, :dependent => false
+            end
+            
+            puts "Created one-to-#{one_to_many ? 'many' : 'one' } relationship '#{referenceName}' from #{entity_name} to #{relationship.reference_to} using #{foreign_key}"
+            
+          end
+        end
+        
+      end
+      
       def relationships(table_name)
-        cached_relationships = @relationships_map[table_name]
-        return cached_relationships if cached_relationships
-
-        # This will load column and relationship metadata        
-        columns(table_name)
-
-        @relationships_map[table_name]
+        entity_name = entity_name_from_table(table_name)
+        
+        cached_relationships = @relationships_map[entity_name]
+        
+        unless cached_relationships
+          # This will load column and relationship metadata        
+          columns(table_name)
+        end
+        
+        @relationships_map[entity_name]
       end
       
       def columns_map(table_name, name = nil)
-        columns_map = @columns_name_map[table_name]
-        return columns_map if columns_map
+        entity_name = entity_name_from_table(table_name)
         
-        columns_map = {}
-        @columns_name_map[table_name] = columns_map
-        
-        columns(table_name).each { |column| columns_map[column.name] = column }
+        columns_map = @columns_name_map[entity_name]
+        unless columns_map 
+          columns_map = {}
+          @columns_name_map[entity_name] = columns_map
+          
+          columns(entity_name).each { |column| columns_map[column.name] = column }
+        end
         
         columns_map
       end
       
-      private
+      def entity_name_from_table(table_name)
+        return table_name.singularize.camelize
+      end
+      
       
-      def select(sql, name = nil)
-        puts "select(#{sql}, (#{name}))"
-        @connection.query_with_result = true
-        result = execute(sql, name)
-        rows = []
-        if @null_values_in_each_hash
-          result.each_hash { |row| rows << row }
-        else
-          all_fields = result.fetch_fields.inject({}) { |fields, f| fields[f.name] = nil; fields }
-          result.each_hash { |row| rows << all_fields.dup.update(row) }
+      def create_sobject(entity_name, id, fields)
+        sobj = [ 'type { :xmlns => "urn:sobject.partner.soap.sforce.com" }', entity_name ]
+        sobj << 'Id { :xmlns => "urn:sobject.partner.soap.sforce.com" }' << id if id    
+        
+        # now add any changed fields
+        fieldValues = {}
+        fields.each do | name, value |
+          sobj << name.to_sym << value if value
         end
-        result.free
-        rows
+        
+        sobj
+      end
+      
+      def table_name_from_sql(sql)
+        sql.match(/FROM (\w+) /)[1]
+      end
+      
+      def column_names(table_name)
+        columns(table_name).map { |column| column.name }
+      end
+      
+      def api_column_names(table_name)
+        columns(table_name).map { |column| column.api_name }
       end
     end
+    
   end
 end

data/test/unit/account_test.rb

@@ -8,85 +8,102 @@ class AccountTest < Test::Unit::TestCase
     ActiveRecord::Base.allow_concurrency = true
   end
 
- 
+if false  
+  def test_create_account
+    dutchCo = Account.new 
+    dutchCo.name = "DutchCo"
+    dutchCo.website = "www.dutchco.com"
+    dutchCo.save
+    
+    dutchCo2 = Account.new(:name => "DutchCo2", :website => "www.dutchco2.com") 
+    dutchCo2.save
+    
+    dutchCo3 = Account.create(:name => "DutchCo3", :website => "www.dutchco3.com") 
+    
+    accounts = Account.create([ 
+                              { :name => "DutchCo4", :website => "www.dutchco4.com" },
+    { :name => "DutchCo5", :website => "www.dutchco5.com" }])
+  end 
+  
+  def test_create_a_contact
+    contact = Contact.find_by_id("0033000000B1LKpAAN")
+    contact.first_name = "DutchieBoy"
+    contact.save
+  end
+  
+  
+  def test_create_a_contact
+    contact = Contact.new
+  end
+  
+  
   def test_get_a_case_comment
-    comment = CaseComment.find_by_ParentId('500300000011inJAAQ')
+    comment = CaseComment.find_by_parent_id('500300000011inJAAQ')
   end
   
-
+  
   def test_one_to_many_relationship
-    contact = Contact.find_by_Id('0033000000B1LKrAAN')
+    contact = Contact.find_by_id('0033000000B1LKrAAN')
     
-    cases = contact.Cases
+    cases = contact.cases
     
     cases.each do |c| 
-      puts "Case('#{c.Id}', '#{c.Subject}')"
-      
-      comments = c.CaseComments
+      puts "Case('#{c.id}', '#{c.subject}')"
       
+      comments = c.case_comments      
       comments.each do |comment|
-        puts "   CaseComment('#{comment.Id}', '#{comment.CommentBody}')"
+        puts "   CaseComment('#{comment.id}', '#{comment.comment_body}')"
       end
-      
     end
   end
-
-
+  
   def test_get_account 
     accounts = Account.find(:all)
-
-    #accounts.each { |account| puts "#{account.Name}, #{account.Id}, #{account.LastModifiedById}" }
-  
-    acme = Account.find(:first, :conditions => ["Name = 'Acme'"])
-  
-    acme = Account.find_by_Id(acme.Id)
-
-    acme = Account.find_by_Name_and_LastModifiedById('salesforce.com', acme.LastModifiedById)
+    
+    accounts.each { |account| puts "#{account.name}, #{account.id}, #{account.last_modified_by_id}" }
+    
+    acme = Account.find(:first, :conditions => ["name = 'Acme'"])
+    
+    acme = Account.find_by_id(acme.id)
+    
+    acme = Account.find_by_name_and_last_modified_by_id('salesforce.com', acme.last_modified_by_id)
   end
-
-   
+  
   def test_update_account
     acme = Account.new 
-    acme.Name = "Acme"
+    acme.name = "Acme"
     acme.save
     
-    acme = Account.find_by_Name('Acme')
-        
-    acme.Website = "http://www.dutchforce.com/#{Time.now}.jpg"
-    acme.LastModifiedDate = Time.now
+    acme = Account.find_by_name('Acme')
+    
+    acme.website = "http://www.dutchforce.com/#{Time.now}.jpg"
+    acme.last_modified_date = Time.now
     
     acme.save
   end
-
- 
-  def test_create_account
-    dutchCo = Account.new 
-    dutchCo.Name = "DutchCo"
-    dutchCo.Website = "www.dutchco.com"
-    dutchCo.save
-
-    dutchCo2 = Account.new(:Name => "DutchCo2", :Website => "www.dutchco2.com") 
-    dutchCo2.save
-    
-    dutchCo3 = Account.create(:Name => "DutchCo3", :Website => "www.dutchco3.com") 
-
-    accounts = Account.create([ 
-      { :Name => "DutchCo4", :Website => "www.dutchco4.com" },
-      { :Name => "DutchCo5", :Website => "www.dutchco5.com" }])
-  end 
-
+end  
+  
   def test_destroy_account
-    account = Account.create(:Name => "DutchADelete", :Website => "www.dutchcodelete.com") 
-    account = Account.find_by_Id(account.Id)
+    Account.new
     
-    pp account.Parent
+    account = Account.create(:name => "DutchADelete", :website => "www.dutchcodelete.com") 
+    account2 = Account.create(:name => "DutchADelete2", :website => "www.dutchcodelete2.com") 
+    
+    #pp account
+    
+    account = Account.find_by_id(account.id)
+    
+    pp account.parent
     
     puts "Getting CreatedBy"
-    createdBy = account.CreatedBy
-    createdBy = User.find_by_Id(account.CreatedById);
-    puts createdBy.Email
-        
-    Account.delete(account.Id)
+    createdBy = account.created_by
+    createdBy = User.find_by_id(account.created_by_id);
+    puts createdBy.email
+    
+    Account.delete([account.id, account2.id])
+    
+    account3 = Account.create(:name => "DutchADelete3", :website => "www.dutchcodelete3.com") 
+    account3.destroy
   end
-     
+  
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: activesalesforce
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2006-01-30 00:00:00 -05:00
+  version: 0.1.2
+date: 2006-02-02 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
@@ -29,14 +29,11 @@ authors:
 - Doug Chasman
 files: 
 - lib/salesforce_login.rb
-- lib/salesforce_active_record.rb
 - lib/column_definition.rb
 - lib/active_salesforce.rb
 - lib/rforce.rb
-- lib/sobject_attributes.rb
 - lib/salesforce_connection_adapter.rb
 - test/unit
-- test/unit/sobject_attributes_test.rb
 - test/unit/account_test.rb
 - README
 test_files: []

data/lib/salesforce_active_record.rb

@@ -1,151 +0,0 @@
-=begin
-  ActiveSalesforce
-  Copyright (c) 2006 Doug Chasman
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-=end
-
-require File.dirname(__FILE__) + '/sobject_attributes'
-
-
-module ActiveRecord
-  # Active Records will automatically record creation and/or update timestamps of database objects
-  # if fields of the names created_at/created_on or updated_at/updated_on are present. This module is
-  # automatically included, so you don't need to do that manually.
-  #
-  # This behavior can be turned off by setting <tt>ActiveRecord::Base.record_timestamps = false</tt>.
-  # This behavior can use GMT by setting <tt>ActiveRecord::Base.timestamps_gmt = true</tt>
-  module SalesforceRecord 
-
-    def self.append_features(base) # :nodoc:
-      super
-      
-      base.class_eval do
-        alias_method :create, :create_with_sforce_api
-        alias_method :update, :update_with_sforce_api
-      end
-    end    
-    
-    def create_with_sforce_api
-      return if not @attributes.changed?
-      puts "create_with_sforce_api creating #{self.class}"
-      id = connection.create(:sObjects => create_sobject())
-      self.Id = id
-      @attributes.clear_changed!
-    end
-    
-    def update_with_sforce_api
-      return if not @attributes.changed?
-      puts "update_with_sforce_api updating #{self.class}('#{self.Id}')"
-      connection.update(:sObjects => create_sobject())
-      @attributes.clear_changed!
-    end
-    
-    def create_sobject()
-      fields = @attributes.changed_fields
-      
-      sobj = [ 'type { :xmlns => "urn:sobject.partner.soap.sforce.com" }', self.class.table_name ]
-      sobj << 'Id { :xmlns => "urn:sobject.partner.soap.sforce.com" }' << self.Id if self.Id    
-      
-      # now add any changed fields
-      fieldValues = {}
-      fields.each do |fieldName|
-        value = @attributes[fieldName]
-        sobj << fieldName.to_sym << value if value
-      end
-      
-      sobj
-    end
-    
-  end 
-  
-  class Base
-    set_inheritance_column nil
-    lock_optimistically = false
-    record_timestamps = false
-    default_timezone = :utc
-    
-    def after_initialize() 
-      sfdcObjectName = self.class.table_name
-      if not @attributes.is_a?(Salesforce::SObjectAttributes)
-        # Insure that SObjectAttributes is always used for our attributes
-        originalAttributes = @attributes 
-        
-        @attributes = Salesforce::SObjectAttributes.new(connection.columns_map(sfdcObjectName))
-        
-        originalAttributes.each { |name, value| self[name] = value }
-      end
-      
-      # Create relationships for any reference field
-      connection.relationships(sfdcObjectName).each do |relationship|
-        referenceName = relationship.name
-        unless self.respond_to? referenceName.to_sym or relationship.reference_to == "Profile"
-          one_to_many = relationship.one_to_many
-          
-          puts "Creating one-to-#{one_to_many ? 'many' : 'one' } relationship '#{referenceName}' from #{sfdcObjectName} to #{relationship.reference_to}"
-          
-          if one_to_many
-            self.class.has_many referenceName.to_sym, :class_name => relationship.reference_to, :foreign_key => relationship.foreign_key, :dependent => false
-          else
-            self.class.belongs_to referenceName.to_sym, :class_name => relationship.reference_to, :foreign_key => relationship.name, :dependent => false
-          end
-        end
-      end
-    end
-    
-    def self.table_name
-        # Undo weird camilization that messes with custom object names
-        name = self.name
-        name.last(6) == "Custom" ? name.first(name.length - 6) << "__c" : name
-    end
-    
-    def self.primary_key
-      "Id"
-    end
-    
-    def self.construct_finder_sql(options)
-      soql = "SELECT #{column_names.join(', ')} FROM #{table_name} "
-      add_conditions!(soql, options[:conditions])
-      soql
-    end
-    
-    def self.construct_conditions_from_arguments(attribute_names, arguments)
-      conditions = []
-      attribute_names.each_with_index { |name, idx| conditions << "#{name} #{attribute_condition(arguments[idx])} " }
-      [ conditions.join(" AND "), *arguments[0...attribute_names.length] ]
-    end
-    
-    def self.count(conditions = nil, joins = nil)
-      soql  = "SELECT Id FROM #{table_name} "
-      add_conditions!(soql, conditions)
-      
-      count_by_sql(soql)
-    end
-    
-    def self.count_by_sql(soql)
-      connection.batch_size = 1
-      connection.select_all(soql, "#{name} Count").length
-    end     
-          
-    def self.delete(ids)
-      connection.delete(ids)
-    end
-    
-  end
-end

data/lib/sobject_attributes.rb

@@ -1,132 +0,0 @@
-=begin
-  ActiveSalesforce
-  Copyright (c) 2006 Doug Chasman
-
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-=end
-
-require 'set'
-
-
-module Salesforce
-
-  class SObjectAttributes 
-    include Enumerable
-    
-    def initialize(columns, record = nil)
-      @columns = columns
-      @values = {}
-      
-      if record 
-        record.each do |name, value| 
-          # Replace nil element with nil
-          value = nil if value.respond_to?(:xmlattr_nil) and value.xmlattr_nil
-                             
-          # Ids are returned in an array with 2 duplicate entries...
-          value = value[0] if name == :Id
-              
-          self[name.to_s] = value
-        end
-      else
-        columns.values.each { |column| self[column.name] = nil }
-      end
-                 
-      clear_changed!
-    end
-    
-    def [](key)
-      @values[key].freeze
-    end
-    
-    def []=(key, value)
-      column = @columns[key]
-      return unless column
-      
-      value = nil if value == ""
-
-      return if @values[key] == value and @values.include?(key)
-      
-      originalClass = value.class
-      originalValue = value
-      
-      if value 
-        # Convert strings representation of dates and datetimes to date and time objects
-        case column.type
-          when :date
-            value = value.is_a?(Date) ? value : Date.parse(value)
-          when :datetime
-            value = value.is_a?(Time) ? value : Time.parse(value)
-          else
-            value = column.type_cast(value)
-        end
-      end
-
-      @values[key] = value
-      
-      #puts "setting #{key} = #{value} [#{originalValue}] (#{originalClass}, #{value.class})"
-      
-      if not column.readonly
-        @changed = Set.new unless @changed
-        @changed.add(key)
-      end
-    end
-    
-    def include?(key)
-      @values.include?(key)
-    end
-    
-    def has_key?(key)
-      @values.has_key?(key)
-    end
-    
-    def length
-      @values.length
-    end
-    
-    def keys
-      @values.keys
-    end
-    
-    def clear
-      @values.clear
-      clear_changed
-    end
-    
-    def clear_changed!
-      @changed = nil
-    end
-    
-    def changed?
-      @changed != nil
-    end
-    
-    def changed_fields
-      @changed
-    end
-    
-    
-    # Enumerable support
-    
-    def each(&block)
-      @values.each(&block)
-    end
-    
-  end
-
-end

data/test/unit/sobject_attributes_test.rb

@@ -1,38 +0,0 @@
-puts "Yahoo"
-
-require 'test/unit'
-require File.dirname(__FILE__) + '/../../src/sobject_attributes'
-
-class SobjectAttributesTest < Test::Unit::TestCase
-
-  def setup 
-    @attributes = Salesforce::SObjectAttributes.new 
-  end
-  
-  def test_add_values() 
-    assert((not @attributes.changed?))
-    
-    @attributes['name'] = 'value'    
-    assert(@attributes.changed?)
-    
-    assert_equal('value', @attributes['name'])
-    
-    assert_equal(Set.new('name'), @attributes.changed_fields)
-
-    @attributes.clear_changed!    
-    assert((not @attributes.changed?))
-    
-    assert_equal('value', @attributes['name'])
-  end
-  
-  def test_enumeration
-    10.times { |n| @attributes["name_#{n}"] = "value_#{n}" }
-    
-    assert_equal(10, @attributes.length)
-    
-    5.times { |n| @attributes["name_#{n + 10}"] = "value_#{n + 10}" }
-    
-    @attributes.each { |name, value| assert_equal(name[/_\d/],  value[/_\d/]) }
-  end
-  
-end