martinemde-dm-salesforce-adapter 1.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz
+
+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.

data/README.markdown

@@ -0,0 +1,121 @@
+dm-salesforce-adapter
+=====================
+
+This gem provides a Salesforce Adapter under DataMapper 1.0.x.  A version of
+this adapter supporting DM 0.10.x exists under the name "dm-salesforce".  Older
+versions of DM (0.9.x) are no longer supported.
+
+What it looks like
+==================
+
+    class Account
+      include DataMapper::Adapters::SalesforceAdapter::Resource
+
+      def self.default_repository_name
+        :salesforce
+      end
+
+      property :id,          Serial
+      property :name,        String
+      property :description, String
+      property :fax,         String
+      property :phone,       String
+      property :type,        String
+      property :website,     String
+      property :is_awesome,  Boolean
+
+      has 0..n, :contacts
+    end
+
+    class Contact
+      include DataMapper::Adapters::SalesforceAdapter::Resource
+
+      def self.default_repository_name
+        :salesforce
+      end
+
+      property :id,         Serial
+      property :first_name, String
+      property :last_name,  String
+      property :email,      String
+
+      belongs_to :account
+    end
+
+    DataMapper.setup(:salesforce, {:adapter  => 'salesforce',
+                                   :username => 'salesforceuser@mydomain.com',
+                                   :password => 'skateboardsf938915c9cdc36ff5498881b',
+                                   :path     => '/path/to/wsdl.xml',
+                                   :host     => ''})
+
+    account = Account.first
+    account.is_awesome = true
+    account.save
+
+See [the fixtures](http://github.com/cloudcrowd/dm-salesforce-adapter/tree/master/spec/fixtures) for more examples.
+
+How it works
+============
+
+Salesforce provides an XML-based WSDL definition of an existing schema/object
+model for download.  dm-salesforce-adapter uses this WSDL to auto-generate a
+SOAP-based Ruby driver and classes, which is then used to implement a basic,
+low-level DataMapper Adapter.
+
+Upon first access, the driver and classes are cached locally on disk in one of
+the following locations (in order of precedence):
+
+  * In `apidir`, defined in `database.yml` (see included database.yml-example)
+  * In `ENV['SALESFORCE_DIR']`
+  * In `ENV['HOME']/.salesforce/`
+
+Getting set up
+==============
+
+1. Obtain a working salesforce.com account
+
+2. Get a valid security token (if you don't already have one)
+    * Login to `https://login.salesforce.com`
+    * [Click "Setup"][setup]
+    * [Click "Personal Setup" / "My Personal Information" / "Reset My Security Token"][gettoken]
+        * This will send a message to your account's email address with an "API key"
+          (looks like a 24 character token)
+
+3. Get the Enterprise WSDL for your object model
+    * Login to `https://login.salesforce.com`
+    * [Click "Setup"][setup]
+    * [Click "App Setup" / "Develop" / "API"][getwsdl]
+    * Click "Generate Enterprise WSDL", then click the "Generate" button
+    * Save that to an .xml file somewhere (path/extension doesn't matter - you specify it
+      in database.yml / DataMapper.setup)
+
+4. Copy and modify config/example.rb to use your info
+    * The :password field is the concatenation of your login password and the API key
+    * If your password is 'skateboards' and API key is 'f938915c9cdc36ff5498881b', then
+      the :password field you specify to DataMapper.setup should be
+      'skateboardsf938915c9cdc36ff5498881b'
+
+Run 'ruby example.rb' and you should have access to the Account and Contact models (schema
+differences withstanding).
+
+**Don't forget to:**
+
+* Retrieve a new copy of your WSDL anytime you make changes to your Salesforce schema
+* Wipe the auto-generated SOAP classes anytime you update your WSDL
+
+
+Special Thanks to those who helped
+==================================================
+* Yehuda Katz
+* Corey Donohoe
+* Tim Carey-Smith
+* Andy Delcambre
+* Ben Burkert
+* Larry Diehl
+* Jordan Ritter
+* Martin Emde
+* Jason Snell
+
+[setup]: http://img.skitch.com/20090204-gaxdfxbi1emfita5dax48ids4m.jpg "Click on Setup"
+[getwsdl]: http://img.skitch.com/20090204-nhurnuxwf5g3ufnjk2xkfjc5n4.jpg "Expand and Save"
+[gettoken]: http://img.skitch.com/20090204-mnt182ce7bc4seecqbrjjxjbef.jpg "You can reset your token here"

data/Rakefile

@@ -0,0 +1,16 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w[--color]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rspec_opts = %w[--color]
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rcov = true
+  t.rcov_opts = %w[--exclude spec/,gems/,Library/,.bundle]
+end

data/lib/dm-salesforce-adapter.rb

@@ -0,0 +1,17 @@
+require 'dm-do-adapter'
+
+module DataObjects
+  module Salesforce
+  end
+end
+
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+    end
+
+    const_added(:SalesforceAdapter)
+  end
+end
+
+require 'dm-salesforce-adapter/adapter'

data/lib/dm-salesforce-adapter/adapter.rb

@@ -0,0 +1,193 @@
+require 'dm-do-adapter'
+require 'dm-core'
+require 'dm-types'
+require 'dm-validations'
+
+require 'soap/wsdlDriver'
+require 'soap/header/simplehandler'
+require 'rexml/element'
+
+require 'dm-salesforce-adapter/connection'
+require 'dm-salesforce-adapter/sql'
+require 'dm-salesforce-adapter/property'
+require 'dm-salesforce-adapter/resource'
+require 'dm-salesforce-adapter/soap_wrapper'
+
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+
+      include DataMapper::Adapters::SalesforceAdapter::SQL
+
+      def initialize(name, uri_or_options)
+        super
+        @resource_naming_convention = proc do |value|
+          klass = DataMapper::Inflector.constantize(value)
+          if klass.respond_to?(:salesforce_class)
+            klass.salesforce_class
+          else
+            value.split("::").last
+          end
+        end
+        @field_naming_convention = proc do |property|
+          connection.field_name_for(property.model.storage_name(name), property.name.to_s)
+        end
+      end
+
+      def schema_name
+        'salesforce'
+      end
+
+      def connection
+        @connection ||= Connection.new(options["username"], options["password"], options["path"], options["apidir"])
+      end
+
+      # FIXME: DM Adapters customarily throw exceptions when they experience errors,
+      # otherwise failed operations (e.g. Resource#save) still return true and thus
+      # confuse the caller.
+      #
+      # Someone needs to make a decision about legacy support and the consequences
+      # of changing the behaviour from broken-but-typical to
+      # correct-but-maybe-unexpected.  Maybe a config file option about whether to
+      # raise exceptions or for the user to always check Model#valid? +
+      # Model#salesforce_errors?
+      #
+      # Needs to be applied to all CRUD operations.
+      def create(resources)
+        arr = resources.map do |resource|
+          make_salesforce_obj(resource, resource.dirty_attributes)
+        end
+
+        result = connection.create(arr)
+        result.each_with_index do |record, i|
+          resource = resources[i]
+          if id_field = resource.class.key.find {|p| p.serial?}
+            normalized_value = normalize_id_value(resource.class, id_field, record.id)
+            id_field.set!(resource, normalized_value)
+          end
+        end
+
+        result.size
+
+      rescue Connection::SOAPError => e
+        handle_server_outage(e)
+      end
+
+      def update(attributes, collection)
+        query = collection.query
+        arr   = collection.map { |obj| make_salesforce_obj(query, attributes) }
+
+        connection.update(arr).size
+
+      rescue Connection::SOAPError => e
+        handle_server_outage(e)
+      end
+
+      def delete(collection)
+        query = collection.query
+        keys  = collection.map { |r| r.key }.flatten.uniq
+
+        connection.delete(keys).size
+
+      rescue Connection::SOAPError => e
+        handle_server_outage(e)
+      end
+
+      def handle_server_outage(error)
+        if error.server_unavailable?
+          raise Connection::ServerUnavailable, "The salesforce server is currently unavailable"
+        else
+          raise error
+        end
+      end
+
+      # Reading responses back from SELECTS:
+      #   In the typical case, response.size reflects the # of records returned.
+      #   In the aggregation case, response.size reflects the count.
+      #
+      # Interpretation of this field requires knowledge of whether we are expecting
+      # an aggregate result, thus the response from execute_select() is processed
+      # differently depending on invocation (read vs. aggregate).
+      def read(query)
+        properties = query.fields
+        repository = query.repository
+
+        response = execute_select(query)
+        return [] unless response.records
+
+        rows = response.records.inject([]) do |results, record|
+          results << properties.inject({}) do |result, property|
+            meth = connection.field_name_for(property.model.storage_name(repository.name), property.field)
+            result[property] = normalize_id_value(query.model, property, record.send(meth))
+            result
+          end
+        end
+
+        query.model.load(rows, query)
+      end
+
+      # http://www.salesforce.com/us/developer/docs/api90/Content/sforce_api_calls_soql.htm
+      # SOQL doesn't support anything but count(), so we catch it here and interpret
+      # the result.  Requires 'dm-aggregates' to be loaded.
+      def aggregate(query)
+        query.fields.each do |f|
+          unless f.target == :all && f.operator == :count
+            raise ArgumentError, %{Aggregate function #{f.operator} not supported in SOQL}
+          end
+        end
+
+        [ execute_select(query).size ]
+      end
+
+      private
+      def execute_select(query)
+        repository = query.repository
+        conditions = query.conditions.map {|c| conditions_statement(c, repository)}.compact.join(") AND (")
+
+        fields = query.fields.map do |f|
+          case f
+          when DataMapper::Property
+            f.field
+          when DataMapper::Query::Operator
+            %{#{f.operator}()}
+          else
+            raise ArgumentError, "Unknown query field #{f.class}: #{f.inspect}"
+          end
+        end.join(", ")
+
+        sql = "SELECT #{fields} from #{query.model.storage_name(repository.name)}"
+        sql << " WHERE (#{conditions})" unless conditions.empty?
+        sql << " ORDER BY #{order(query.order[0])}" unless query.order.nil? || query.order.empty?
+        sql << " LIMIT #{query.limit}" if query.limit
+
+        DataMapper.logger.debug sql if DataMapper.logger
+
+        connection.query(sql)
+      end
+
+      def make_salesforce_obj(from, with_attrs)
+        klass_name = from.model.storage_name(from.repository.name)
+        values     = {}
+
+        # FIXME: query.conditions is potentially a tree now
+        if from.is_a?(::DataMapper::Query)
+          key_value    = from.conditions.find { |c| c.subject.key? }.value
+          values["id"] = normalize_id_value(from.model, from.model.properties[:id], key_value)
+        end
+
+        with_attrs.each do |property, value|
+          next if property.serial? || property.key? and value.nil?
+          values[property.field] = normalize_id_value(from.model, property, value)
+        end
+
+        connection.make_object(klass_name, values)
+      end
+
+      def normalize_id_value(klass, property, value)
+        return nil unless value
+        properties = Array(klass.send(:salesforce_id_properties)).map { |p| p.to_sym } rescue []
+        return properties.include?(property.name) ? value[0..14] : value
+      end
+    end
+  end
+end

data/lib/dm-salesforce-adapter/connection.rb

@@ -0,0 +1,148 @@
+require 'dm-salesforce-adapter/connection/errors'
+
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      class Connection
+        include Errors
+
+        class HeaderHandler < SOAP::Header::SimpleHandler
+          def initialize(tag, value)
+            super(XSD::QName.new('urn:enterprise.soap.sforce.com', tag))
+            @tag = tag
+            @value = value
+          end
+          def on_simple_outbound
+            @value
+          end
+        end
+
+        def initialize(username, password, wsdl_path, api_dir, organization_id = nil)
+          @wrapper = SoapWrapper.new("SalesforceAPI", "Soap", wsdl_path, api_dir)
+          @username, @password, @organization_id = URI.unescape(username), password, organization_id
+          login
+        end
+        attr_reader :user_id, :user_details
+
+        def wsdl_path
+          @wrapper.wsdl_path
+        end
+
+        def api_dir
+          @wrapper.api_dir
+        end
+
+        def organization_id
+          @user_details && @user_details.organizationId
+        end
+
+        def make_object(klass_name, values)
+          obj = SalesforceAPI.const_get(klass_name).new
+          values.each do |property, value|
+            field = field_name_for(klass_name, property)
+            if value.nil? or value == ""
+              obj.fieldsToNull.push(field)
+            else
+              obj.send("#{field}=", value)
+            end
+          end
+          obj
+        end
+
+        def field_name_for(klass_name, column)
+          klass = SalesforceAPI.const_get(klass_name)
+          # extlib vs. activesupport
+          fields = [column, DataMapper::Inflector.camelize(column), "#{column}__c".downcase]
+          options = /^(#{fields.join("|")})$/i
+          matches = klass.instance_methods(false).grep(options)
+          if matches.any?
+            matches.first
+          else
+            raise FieldNotFound,
+                "You specified #{column} as a field, but neither #{fields.join(" or ")} exist. " \
+                "Either manually specify the field name with :field, or check to make sure you have " \
+                "provided a correct field name."
+          end
+        end
+
+        def query(string)
+          with_reconnection do
+            driver.query(:queryString => string).result
+          end
+        rescue SOAP::FaultError => e
+          raise QueryError.new(e.message, [])
+        end
+
+        def create(objects)
+          call_api(:create, CreateError, "creating", objects)
+        end
+
+        def update(objects)
+          call_api(:update, UpdateError, "updating", objects)
+        end
+
+        def delete(keys)
+          call_api(:delete, DeleteError, "deleting", keys)
+        end
+
+        private
+
+        def driver
+          @wrapper.driver
+        end
+
+        def login
+          driver
+          if @organization_id
+            driver.headerhandler << HeaderHandler.new("LoginScopeHeader", :organizationId => @organization_id)
+          end
+
+          begin
+            result = driver.login(:username => @username, :password => @password).result
+          rescue SOAP::FaultError => error
+            if error.to_s =~ /INVALID_LOGIN/
+              raise LoginFailed, error.inspect
+            else
+              raise error
+            end
+          end
+          driver.endpoint_url = result.serverUrl
+          driver.headerhandler << HeaderHandler.new("SessionHeader", "sessionId" => result.sessionId)
+          driver.headerhandler << HeaderHandler.new("CallOptions", "client" => "client")
+          @user_id = result.userId
+          @user_details = result.userInfo
+          driver
+        end
+
+        def call_api(method, exception_class, message, args)
+          with_reconnection do
+            result = driver.send(method, args)
+            if result.all? {|r| r.success}
+              result
+            else
+              # TODO: be smarter about exceptions here
+              raise exception_class.new("Got some errors while #{message} Salesforce objects", result)
+            end
+          end
+        end
+
+        def with_reconnection(&block)
+          yield
+        rescue SOAP::FaultError => error
+          retry_count ||= 0
+          if error.faultcode.to_s =~ "INVALID_SESSION_ID"
+            DataMapper.logger.debug "Got a invalid session id; reconnecting" if DataMapper.logger
+            @driver = nil
+            login
+            retry_count += 1
+            retry unless retry_count > 5
+          else
+            raise error
+          end
+
+          raise SessionTimeout, "The Salesforce session could not be established"
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce-adapter/connection/errors.rb

@@ -0,0 +1,56 @@
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      class Connection
+        module Errors
+          class Error             < StandardError; end
+          class FieldNotFound     < Error; end
+          class LoginFailed       < Error; end
+          class SessionTimeout    < Error; end
+          class UnknownStatusCode < Error; end
+          class ServerUnavailable < Error; end
+
+
+          class SOAPError      < Error
+            def initialize(message, result)
+              @result = result
+              super("#{message}: #{result_message}")
+            end
+
+            def records
+              @result.to_a
+            end
+
+            def failed_records
+              @result.reject {|r| r.success}
+            end
+
+            def successful_records
+              @result.select {|r| r.success}
+            end
+
+            def result_message
+              failed_records.map do |r|
+                message_for_record(r)
+              end.join("; ")
+            end
+
+            def message_for_record(record)
+              record.errors.map {|e| "#{e.statusCode}: #{e.message}"}.join(", ")
+            end
+
+            def server_unavailable?
+              failed_records.any? do |record|
+                record.errors.any? {|e| e.statusCode == "SERVER_UNAVAILABLE"}
+              end
+            end
+          end
+          class CreateError    < SOAPError; end
+          class QueryError     < SOAPError; end
+          class DeleteError    < SOAPError; end
+          class UpdateError    < SOAPError; end
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce-adapter/property.rb

@@ -0,0 +1,11 @@
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      module Property
+      end
+    end
+  end
+end
+
+require 'dm-salesforce-adapter/property/serial'
+require 'dm-salesforce-adapter/property/boolean'

data/lib/dm-salesforce-adapter/property/boolean.rb

@@ -0,0 +1,23 @@
+require 'dm-salesforce-adapter/property'
+
+
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      module Property
+        class Boolean < ::DataMapper::Property::Integer
+          FALSE = 0
+          TRUE  = 1
+
+          def load(value)
+            [true, 1, '1', 'true', 'TRUE', TRUE].include?(value) ? true : false
+          end
+
+          def typecast(value)
+            [true, 1, '1', 'true', 'TRUE', TRUE].include?(value) ? TRUE : FALSE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce-adapter/property/serial.rb

@@ -0,0 +1,20 @@
+require 'dm-salesforce-adapter/property'
+
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      module Property
+        class Serial < ::DataMapper::Property::String
+          accept_options :serial
+          serial true
+
+          length 15
+
+          def typecast(value)
+            value.to_str[0..14] unless value.nil? || value.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce-adapter/resource.rb

@@ -0,0 +1,12 @@
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      module Resource
+        def self.included(model)
+          model.send :include, DataMapper::Resource
+          model.send :include, DataMapper::Adapters::SalesforceAdapter::Property
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce-adapter/soap_wrapper.rb

@@ -0,0 +1,85 @@
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      class SoapWrapper
+        class ClassesFailedToGenerate < StandardError; end
+
+        attr_reader :module_name, :driver_name, :wsdl_path, :api_dir
+
+        def initialize(module_name, driver_name, wsdl_path, api_dir)
+          @module_name, @driver_name, @wsdl_path, @api_dir = module_name, driver_name, File.expand_path(wsdl_path), File.expand_path(api_dir)
+          generate_soap_classes
+          driver
+        end
+
+        def driver
+          @driver ||= Object.const_get(module_name).const_get(driver_name).new
+        end
+
+=begin
+        # Attempt at a run-time equivalent.  Works except for the API responses are
+        # in SOAP objects, not native ruby objects.  Haven't figured that one out..
+        def driver
+          return @driver if @driver
+
+          require 'wsdl/soap/wsdl2ruby'
+
+          factory            = SOAP::WSDLDriverFactory.new(wsdl_path)
+          class_name_creator = WSDL::SOAP::ClassNameCreator.new
+
+          eval(WSDL::SOAP::ClassDefCreator.new(factory.wsdl, class_name_creator, @module_name).dump, TOPLEVEL_BINDING)
+          eval(WSDL::SOAP::MappingRegistryCreator.new(factory.wsdl, class_name_creator, @module_name).dump, TOPLEVEL_BINDING)
+
+          @driver ||= factory.create_rpc_driver
+        end
+=end
+
+        def generate_soap_classes
+          unless File.file?(wsdl_path)
+            raise Errno::ENOENT, "Could not find the WSDL at #{wsdl_path}"
+          end
+
+          FileUtils.mkdir_p(wsdl_api_dir)
+
+          generate_files unless files_exist?
+
+          $:.push wsdl_api_dir
+          require "#{module_name}Driver"
+          $:.delete wsdl_api_dir
+        end
+
+        # Good candidate for shipping out into a Rakefile.
+        def generate_files
+          require 'wsdl/soap/wsdl2ruby'
+
+          wsdl2ruby          = WSDL::SOAP::WSDL2Ruby.new
+          wsdl2ruby.logger   = $LOG if $LOG
+          wsdl2ruby.location = wsdl_path
+          wsdl2ruby.basedir  = wsdl_api_dir
+
+          wsdl2ruby.opt.merge!({
+            'classdef'         => module_name,
+            'module_path'      => module_name,
+            'mapping_registry' => nil,
+            'driver'           => nil,
+            'client_skelton'   => nil,
+          })
+
+          wsdl2ruby.run
+
+          raise ClassesFailedToGenerate unless files_exist?
+        end
+
+        def files_exist?
+          ["#{module_name}.rb", "#{module_name}MappingRegistry.rb", "#{module_name}Driver.rb"].all? do |name|
+            File.exist?("#{wsdl_api_dir}/#{name}")
+          end
+        end
+
+        def wsdl_api_dir
+          "#{api_dir}/#{File.basename(wsdl_path)}"
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce-adapter/sql.rb

@@ -0,0 +1,103 @@
+module DataMapper
+  module Adapters
+    class SalesforceAdapter < DataObjectsAdapter
+      module SQL
+        def conditions_statement(conditions, repository)
+          case conditions
+          when DataMapper::Query::Conditions::NotOperation       then negate_operation(conditions.operand, repository)
+          when DataMapper::Query::Conditions::AbstractOperation  then conditions.operands.first # ignores AND/OR grouping for now.
+          when DataMapper::Query::Conditions::AbstractComparison then comparison_statement(conditions, repository)
+          else raise("Unkown condition type #{conditions.class}: #{conditions.inspect}")
+          end
+        end
+
+        def comparison_statement(comparison, repository)
+          subject = comparison.subject
+          value = comparison.value
+
+          if comparison.relationship?
+            return conditions_statement(comparison.foreign_key_mapping, repository)
+          elsif comparison.slug == :in && value.empty?
+            return []  # match everything
+          end
+
+          operator    = comparison_operator(comparison)
+          column_name = property_to_column_name(subject, repository)
+
+          "#{column_name} #{operator} #{quote_value(value,subject)}"
+        end
+
+        def comparison_operator(comparison)
+          subject = comparison.subject
+          value   = comparison.value
+
+          case comparison.slug
+          when :eql    then equality_operator(subject, value)
+          when :in     then include_operator(subject, value)
+          when :not    then inequality_operator(subject, value)
+          when :regexp then regexp_operator(value)
+          when :like   then like_operator(value)
+          when :gt     then '>'
+          when :lt     then '<'
+          when :gte    then '>='
+          when :lte    then '<='
+          end
+        end
+
+        def negate_operation(operand, repository)
+          statement = conditions_statement(operand, repository)
+          statement = "NOT(#{statement})" unless statement.nil?
+          statement
+        end
+
+        def property_to_column_name(prop, repository)
+          case prop
+          when DataMapper::Property
+            prop.field
+          when DataMapper::Query::Path
+            rels = prop.relationships
+            names = rels.map {|r| storage_name(r, repository) }.join(".")
+            "#{names}.#{prop.field}"
+          end
+        end
+
+        def storage_name(rel, repository)
+          rel.parent_model.storage_name(repository.name)
+        end
+
+        def order(direction)
+          "#{direction.target.field} #{direction.operator.to_s.upcase}"
+        end
+
+        def equality_operator(property, operand)
+          operand.nil? ? 'IS' : '='
+        end
+
+        def include_operator(property, operand)
+          case operand
+          when Array then 'IN'
+          when Range then 'BETWEEN'
+          end
+        end
+
+        def like_operator(operand)
+          "LIKE"
+        end
+
+        def quote_value(value, property)
+          if property.is_a? Property::Boolean
+            # True on salesforce needs to be TRUE/FALSE for WHERE clauses but not for inserts.
+            return value == Property::Boolean::TRUE ? 'TRUE' : 'FALSE'
+          end
+
+          case value
+          when Array then "(#{value.map {|v| quote_value(v, property)}.join(", ")})"
+          when NilClass then "NULL"
+          when String then "'#{value.gsub(/'/, "\\'").gsub(/\\/, %{\\\\})}'"
+          else "#{value}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/do_salesforce.rb

@@ -0,0 +1,5 @@
+module DataObjects
+  module Salesforce
+  end
+end
+

data/lib/do_salesforce/command.rb

@@ -0,0 +1,17 @@
+module DataObjects
+  module Salesforce
+    class Command
+      # Execute this command and return no dataset
+      def execute_non_query(*args)
+      end
+
+      # Execute this command and return a DataObjects::Reader for a dataset
+      def execute_reader(*args)
+      end
+
+      # Assign an array of types for the columns to be returned by this command
+      def set_types(column_types)
+      end
+    end
+  end
+end

data/lib/do_salesforce/connection.rb

@@ -0,0 +1,145 @@
+require 'do_salesforce/error'
+
+module DataObject
+  module Salesforce
+    class Connection
+
+      class HeaderHandler < SOAP::Header::SimpleHandler
+        def initialize(tag, value)
+          super(XSD::QName.new('urn:enterprise.soap.sforce.com', tag))
+          @tag = tag
+          @value = value
+        end
+        def on_simple_outbound
+          @value
+        end
+      end
+
+      def initialize(username, password, wsdl_path, api_dir, organization_id = nil)
+        @wrapper = SoapWrapper.new("SalesforceAPI", "Soap", wsdl_path, api_dir)
+        @username, @password, @organization_id = URI.unescape(username), password, organization_id
+        login
+      end
+      attr_reader :user_id, :user_details
+
+      def wsdl_path
+        @wrapper.wsdl_path
+      end
+
+      def api_dir
+        @wrapper.api_dir
+      end
+
+      def organization_id
+        @user_details && @user_details.organizationId
+      end
+
+      def make_object(klass_name, values)
+        obj = SalesforceAPI.const_get(klass_name).new
+        values.each do |property, value|
+          field = field_name_for(klass_name, property)
+          if value.nil? or value == ""
+            obj.fieldsToNull.push(field)
+          else
+            obj.send("#{field}=", value)
+          end
+        end
+        obj
+      end
+
+      def field_name_for(klass_name, column)
+        klass = SalesforceAPI.const_get(klass_name)
+        fields = [column, DataMapper::Inflector.camelize(column), "#{column}__c".downcase]
+        options = /^(#{fields.join("|")})$/i
+        matches = klass.instance_methods(false).grep(options)
+        if matches.any?
+          matches.first
+        else
+          raise FieldNotFound,
+              "You specified #{column} as a field, but neither #{fields.join(" or ")} exist. " \
+              "Either manually specify the field name with :field, or check to make sure you have " \
+              "provided a correct field name."
+        end
+      end
+
+      def query(string)
+        with_reconnection do
+          driver.query(:queryString => string).result
+        end
+      rescue SOAP::FaultError => e
+        raise QueryError.new(e.message, [])
+      end
+
+      def create(objects)
+        debugger
+        call_api(:create, CreateError, "creating", objects)
+      end
+
+      def update(objects)
+        call_api(:update, UpdateError, "updating", objects)
+      end
+
+      def delete(keys)
+        call_api(:delete, DeleteError, "deleting", keys)
+      end
+
+      private
+
+      def driver
+        @wrapper.driver
+      end
+
+      def login
+        driver
+        if @organization_id
+          driver.headerhandler << HeaderHandler.new("LoginScopeHeader", :organizationId => @organization_id)
+        end
+
+        begin
+          result = driver.login(:username => @username, :password => @password).result
+        rescue SOAP::FaultError => error
+          if error.to_s =~ /INVALID_LOGIN/
+            raise LoginFailed, error.inspect
+          else
+            raise error
+          end
+        end
+        driver.endpoint_url = result.serverUrl
+        driver.headerhandler << HeaderHandler.new("SessionHeader", "sessionId" => result.sessionId)
+        driver.headerhandler << HeaderHandler.new("CallOptions", "client" => "client")
+        @user_id = result.userId
+        @user_details = result.userInfo
+        driver
+      end
+
+      def call_api(method, exception_class, message, args)
+        with_reconnection do
+          result = driver.send(method, args)
+          if result.all? {|r| r.success}
+            result
+          else
+            # TODO: be smarter about exceptions here
+            raise exception_class.new("Got some errors while #{message} Salesforce objects", result)
+          end
+        end
+      end
+
+      def with_reconnection(&block)
+        yield
+      rescue SOAP::FaultError => error
+        retry_count ||= 0
+        if error.faultcode.to_s =~ "INVALID_SESSION_ID"
+          DataMapper.logger.debug "Got a invalid session id; reconnecting" if DataMapper.logger
+          @driver = nil
+          login
+          retry_count += 1
+          retry unless retry_count > 5
+        else
+          raise error
+        end
+
+        raise SessionTimeout, "The Salesforce session could not be established"
+      end
+    end
+  end
+end

data/lib/do_salesforce/error.rb

@@ -0,0 +1,53 @@
+module DataObjects
+  class Salesforce
+    class Error < StandardError
+    end
+
+    class FieldNotFound     < Error; end
+    class LoginFailed       < Error; end
+    class SessionTimeout    < Error; end
+    class UnknownStatusCode < Error; end
+    class ServerUnavailable < Error; end
+
+
+    class SOAPError      < Error
+      def initialize(message, result)
+        @result = result
+        super("#{message}: #{result_message}")
+      end
+
+      def records
+        @result.to_a
+      end
+
+      def failed_records
+        @result.reject {|r| r.success}
+      end
+
+      def successful_records
+        @result.select {|r| r.success}
+      end
+
+      def result_message
+        failed_records.map do |r|
+          message_for_record(r)
+        end.join("; ")
+      end
+
+      def message_for_record(record)
+        record.errors.map {|e| "#{e.statusCode}: #{e.message}"}.join(", ")
+      end
+
+      def server_unavailable?
+        failed_records.any? do |record|
+          record.errors.any? {|e| e.statusCode == "SERVER_UNAVAILABLE"}
+        end
+      end
+    end
+
+    class CreateError    < SOAPError; end
+    class QueryError     < SOAPError; end
+    class DeleteError    < SOAPError; end
+    class UpdateError    < SOAPError; end
+  end
+end

data/lib/do_salesforce/errors.rb

@@ -0,0 +1,52 @@
+module DataObjects
+  class Salesforce
+    class Error < StandardError; end
+
+    class FieldNotFound     < Error; end
+    class LoginFailed       < Error; end
+    class SessionTimeout    < Error; end
+    class UnknownStatusCode < Error; end
+    class ServerUnavailable < Error; end
+
+
+    class SOAPError      < Error
+      def initialize(message, result)
+        @result = result
+        super("#{message}: #{result_message}")
+      end
+
+      def records
+        @result.to_a
+      end
+
+      def failed_records
+        @result.reject {|r| r.success}
+      end
+
+      def successful_records
+        @result.select {|r| r.success}
+      end
+
+      def result_message
+        failed_records.map do |r|
+          message_for_record(r)
+        end.join("; ")
+      end
+
+      def message_for_record(record)
+        record.errors.map {|e| "#{e.statusCode}: #{e.message}"}.join(", ")
+      end
+
+      def server_unavailable?
+        failed_records.any? do |record|
+          record.errors.any? {|e| e.statusCode == "SERVER_UNAVAILABLE"}
+        end
+      end
+    end
+
+    class CreateError    < SOAPError; end
+    class QueryError     < SOAPError; end
+    class DeleteError    < SOAPError; end
+    class UpdateError    < SOAPError; end
+  end
+end

data/lib/do_salesforce/reader.rb

@@ -0,0 +1,49 @@
+module DataObjects
+  module Salesforce
+    class Reader
+
+      def initialize
+      end
+
+      # Return the array of field names
+      def fields
+        raise NotImplementedError.new
+      end
+
+      # Return the array of field values for the current row. Not legal after next! has returned false or before it's been called
+      def values
+        raise NotImplementedError.new
+      end
+
+      # Close the reader discarding any unread results.
+      def close
+        raise NotImplementedError.new
+      end
+
+      # Discard the current row (if any) and read the next one (returning true), or return nil if there is no further row.
+      def next!
+        raise NotImplementedError.new
+      end
+
+      # Return the number of fields in the result set.
+      def field_count
+        raise NotImplementedError.new
+      end
+
+      # Yield each row to the given block as a Hash
+      def each
+        begin
+          while next!
+            row = {}
+            fields.each_with_index { |field, index| row[field] = values[index] }
+            yield row
+          end
+        ensure
+          close
+        end
+        self
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification 
+name: martinemde-dm-salesforce-adapter
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 1
+  - 1
+  - 0
+  version: 1.1.0
+platform: ruby
+authors: 
+- Yehuda Katz
+- Tim Carey-Smith
+- Andy Delcambre
+- Jordan Ritter
+- Martin Emde
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-26 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 119
+        segments: 
+        - 2
+        - 1
+        - 5
+        - 2
+        version: 2.1.5.2
+  prerelease: false
+  type: :runtime
+  requirement: *id001
+  name: httpclient
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  prerelease: false
+  type: :runtime
+  requirement: *id002
+  name: dm-do-adapter
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  prerelease: false
+  type: :runtime
+  requirement: *id003
+  name: dm-core
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  prerelease: false
+  type: :runtime
+  requirement: *id004
+  name: dm-validations
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  prerelease: false
+  type: :runtime
+  requirement: *id005
+  name: dm-types
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 5
+        - 8
+        version: 1.5.8
+  prerelease: false
+  type: :runtime
+  requirement: *id006
+  name: soap4r
+description: A DataMapper 1.1.x adapter to the Salesforce API
+email: jpr5@cloudcrowd.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/dm-salesforce-adapter/adapter.rb
+- lib/dm-salesforce-adapter/connection/errors.rb
+- lib/dm-salesforce-adapter/connection.rb
+- lib/dm-salesforce-adapter/property/boolean.rb
+- lib/dm-salesforce-adapter/property/serial.rb
+- lib/dm-salesforce-adapter/property.rb
+- lib/dm-salesforce-adapter/resource.rb
+- lib/dm-salesforce-adapter/soap_wrapper.rb
+- lib/dm-salesforce-adapter/sql.rb
+- lib/dm-salesforce-adapter.rb
+- lib/do_salesforce/command.rb
+- lib/do_salesforce/connection.rb
+- lib/do_salesforce/error.rb
+- lib/do_salesforce/errors.rb
+- lib/do_salesforce/reader.rb
+- lib/do_salesforce.rb
+has_rdoc: true
+homepage: http://github.com/cloudcrowd/dm-salesforce-adapter
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: A DataMapper 1.1.x adapter to the Salesforce API
+test_files: []
+