dm-salesforce 0.9.10

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,80 @@
+dm-salesforce
+=============
+
+A gem that provides a Salesforce Adapter for DataMapper.
+
+The wsdl is converted into Ruby classes and stored in ~/.salesforce. This automatically
+happens the first time you use the salesforce adapter, so you don't need to worry about
+generating Ruby code. It just works if you have the wsdl, directions for getting going 
+are outlined below.
+
+An example of using the adapter:
+
+    class Account
+      include DataMapper::Resource
+
+      def self.default_repository_name
+        :salesforce
+      end
+
+      def self.salesforce_id_properties
+        :id
+      end
+
+      property :id, String, :serial => true
+      property :name, String
+    end
+
+    class Contact
+      include DataMapper::Resource
+
+      def self.default_repository_name
+        :salesforce
+      end
+
+      def self.salesforce_id_properties
+        [:id, :account_id]
+      end
+
+      property :id,    String, :serial => true
+      property :first_name, String
+      property :last_name, String
+      property :email, String
+      property :account_id, String
+
+      belongs_to :account
+    end
+
+
+To get a test environment going with the free development tools you'll need to follow these steps.
+
+
+* Get a developer account from http://force.salesforce.com
+* Hit up https://login.salesforce.com, and login with the password they provided in your signup email
+* Remember the password they force you to reset
+* Grab the following from Salesforce's web UI
+    *  Your Enterprise API WSDL [Click Setup][setup] and [Expand and Save As][getwsdl]
+    *  Your API Token [Reset if needed][gettoken]
+* Copy the WSDL file you downloaded to config/wsdl.xml
+*   Copy and modify config/database.rb-example to use your info.  In this case my password is 'skateboards' and my API key is 'f938915c9cdc36ff5498881b':
+
+        DataMapper.setup(:salesforce, {:adapter  => 'salesforce',
+                                       :username => 'salesforceuser@mydomain.com',
+                                       :password => 'skateboardsf938915c9cdc36ff5498881b',
+                                       :path     => File.expand_path(File.dirname(__FILE__)+'/wsdl.xml'),
+                                       :host     => ''})
+
+        VALID_USER = DataMapperSalesforce::UserDetails.new('salesforceuser@mydomain.com', 'skateboardsf938915c9cdc36ff5498881b')
+        VALID_SELF_SERVICE_USER = DataMapperSalesforce::UserDetails.new("quentin@example.com", "foo")
+* Run 'bin/irb' and you should have access to the Account and Contact models
+
+Special Thanks to Engine Yard Employees who helped
+==================================================
+* Corey Donohoe
+* Andy Delcambre
+* Ben Burkert
+* Larry Diehl
+
+[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,101 @@
+require File.dirname(__FILE__) + '/vendor/gems/environments/default'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+
+require File.dirname(__FILE__) + '/lib/dm-salesforce'
+require 'bundler'
+
+GEM = "dm-salesforce"
+GEM_VERSION = DataMapperSalesforce::VERSION
+AUTHORS = ["Yehuda Katz", 'Tim Carey-Smith']
+EMAIL = "wycats@gmail.com"
+HOMEPAGE = "http://www.yehudakatz.com"
+SUMMARY = "A DataMapper adapter to the Salesforce API"
+
+@spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README.markdown", "LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.authors = AUTHORS
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+
+  manifest = Bundler::ManifestFile.load(File.dirname(__FILE__) + '/Gemfile')
+  manifest.dependencies.each do |d|
+    next unless d.in?(:release)
+    s.add_dependency(d.name, d.version)
+  end
+
+  s.require_path = 'lib'
+  s.files = %w(LICENSE README.markdown Rakefile) + Dir.glob("lib/**/*")
+end
+
+Rake::GemPackageTask.new(@spec) do |pkg|
+  pkg.gem_spec = @spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION} --no-ri --no-rdoc}
+end
+
+task :default => 'spec'
+require 'spec'
+require 'spec/rake/spectask'
+desc "Run specs"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts << %w(-fs --color) << %w(-O spec/spec.opts)
+  t.spec_opts << '--loadby' << 'random'
+  t.spec_files = %w(adapter connection models).collect { |dir| Dir["spec/#{dir}/**/*_spec.rb"] }.flatten
+  t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+  t.rcov_opts << '--exclude' << '~/.salesforce,gems,spec,config,tmp'
+  t.rcov_opts << '--text-summary'
+  t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+end
+
+desc "Release the version"
+task :release => :repackage do
+  version = DataMapperSalesforce::VERSION
+  puts "Releasing #{version}"
+
+  `git show-ref tags/v#{version}`
+  unless $?.success?
+    abort "There is no tag for v#{version}"
+  end
+
+  `git show-ref heads/releasing`
+  if $?.success?
+    abort "Remove the releasing branch, we need it!"
+  end
+
+  puts "Checking out to the releasing branch as the tag"
+  system("git", "checkout", "-b", "releasing", "tags/v#{version}")
+
+  puts "Reseting back to master"
+  system("git", "checkout", "master")
+  system("git", "branch", "-d", "releasing")
+
+  current = @spec.version.to_s + ".0"
+  next_version = Gem::Version.new(current).bump
+
+  puts "Changing the version to #{next_version}."
+
+  version_file = File.dirname(__FILE__)+"/lib/#{GEM}/version.rb"
+  File.open(version_file, "w") do |f|
+    f.puts <<-EOT
+module DataMapperSalesforce
+  VERSION = "#{next_version}"
+end
+    EOT
+  end
+
+  puts "Committing the version change"
+  system("git", "commit", version_file, "-m", "Next version: #{next_version}")
+
+  puts "Push the commit up! if you don't, you'll be hunted down"
+end

data/lib/dm-salesforce.rb

@@ -0,0 +1,15 @@
+$:.push File.expand_path(File.dirname(__FILE__))
+
+require 'dm-core'
+require 'dm-validations'
+require 'dm-salesforce/sql'
+require 'dm-salesforce/extensions'
+require 'dm-salesforce/adapter'
+require 'dm-salesforce/connection'
+require 'dm-salesforce/version'
+
+DataMapper::Adapters::SalesforceAdapter = DataMapperSalesforce::Adapter
+
+module DataMapperSalesforce
+  UserDetails = Struct.new(:username, :password)
+end

data/lib/dm-salesforce/adapter.rb

@@ -0,0 +1,199 @@
+module DataMapperSalesforce
+  class Adapter < DataMapper::Adapters::AbstractAdapter
+    def initialize(name, uri_or_options)
+      super
+      @resource_naming_convention = proc do |value|
+        klass = Extlib::Inflection.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 normalize_uri(uri_or_options)
+      if uri_or_options.kind_of?(Addressable::URI)
+        return uri_or_options
+      end
+
+      if uri_or_options.kind_of?(String)
+        uri_or_options = Addressable::URI.parse(uri_or_options)
+      end
+
+      adapter  = uri_or_options.delete(:adapter).to_s
+      user     = uri_or_options.delete(:username)
+      password = uri_or_options.delete(:password)
+      host     = uri_or_options.delete(:host) || "."
+      path     = uri_or_options.delete(:path)
+      query    = uri_or_options.to_a.map { |pair| pair * '=' } * '&'
+      query    = nil if query == ''
+
+      return Addressable::URI.new({:adapter => adapter, :user => user, :password => password, :host => host, :path => path, :query => query})
+    end
+
+    def connection
+      @connection ||= Connection.new(@uri.user, @uri.password, @uri.host + @uri.path)
+    end
+
+    def read_many(query)
+      ::DataMapper::Collection.new(query) do |set|
+        read(query) do |result|
+          set.load(result)
+        end
+      end
+    end
+
+    def read_one(query)
+      read(query) do |result|
+        return query.model.load(result, query)
+      end
+    end
+
+    def create(resources)
+      arr = resources.map do |resource|
+        obj = make_salesforce_obj(resource, resource.dirty_attributes, nil)
+      end
+
+      result = connection.create(arr)
+      result.each_with_index do |record, i|
+        resource = resources[i]
+        id_field = resource.class.key(resource.repository.name).find {|p| p.serial?}
+        if id_field
+          normalized_value = normalize_id_value(resource.class, id_field, record.id)
+          id_field.set!(resource, normalized_value)
+        end
+      end
+      result.size
+    rescue Connection::CreateError => e
+      populate_errors_for(e.records, resources)
+      e.successful_records.size
+    end
+
+    def update(attributes, query)
+      arr = if key_condition = query.conditions.find {|op,prop,val| prop.key?}
+        [ make_salesforce_obj(query, attributes, key_condition.last) ]
+      else
+        read_many(query).map do |obj|
+          obj = make_salesforce_obj(query, attributes, x.key)
+        end
+      end
+      connection.update(arr).size
+    rescue Connection::UpdateError => e
+      populate_errors_for(e.records, arr, query)
+      e.successful_records.size
+    end
+
+    def delete(query)
+      keys = if key_condition = query.conditions.find {|op,prop,val| prop.key?}
+        [key_condition.last]
+      else
+        query.read_many.map {|r| r.key}
+      end
+
+      connection.delete(keys).size
+    end
+
+    def populate_errors_for(records, resources, query = nil)
+      records.each_with_index do |record,i|
+        next if record.success
+
+        if resources[i].is_a?(DataMapper::Resource)
+          resource = resources[i]
+        elsif resources[i].is_a?(SalesforceAPI::SObject)
+          resource = query.repository.identity_map(query.model)[[resources[i].id]]
+        else
+          resource = query.repository.identity_map(query.model)[[resources[i]]]
+        end
+        
+        resource.class.send(:include, SalesforceExtensions)
+        record.errors.each do |error|
+          case error.statusCode
+          when "DUPLICATE_VALUE"
+            if error.message =~ /duplicate value found: (.*) duplicates/
+              resource.add_salesforce_error_for($1, error.message)
+            end
+          when "REQUIRED_FIELD_MISSING", "INVALID_EMAIL_ADDRESS"
+            error.fields.each do |field|
+              resource.add_salesforce_error_for(field, error.message)
+            end
+          when "SERVER_UNAVAILABLE"
+            raise Connection::ServerUnavailable, "The salesforce server is currently unavailable"
+          else
+            raise Connection::UnknownStatusCode, "Got an unknown statusCode: #{error.statusCode.inspect}"
+          end
+        end
+      end
+    end
+
+    # A dummy method to allow migrations without upsetting any data
+    def destroy_model_storage(*args)
+      true
+    end
+
+    # A dummy method to allow auto_migrate! to run
+    def upgrade_model_storage(*args)
+      true
+    end
+
+    # A dummy method to allow migrations without upsetting any data
+    def create_model_storage(*args)
+      true
+    end
+
+    private
+    def read(query, &block)
+      repository = query.repository
+      properties = query.fields
+      properties_with_indexes = Hash[*properties.zip((0...properties.size).to_a).flatten]
+      conditions = query.conditions.map {|c| SQL.from_condition(c, repository)}.compact.join(") AND (")
+
+      sql = "SELECT #{query.fields.map {|f| f.field(repository.name)}.join(", ")} from #{query.model.storage_name(repository.name)}"
+      sql << " WHERE (#{conditions})" unless conditions.empty?
+      sql << " ORDER BY #{SQL.order(query.order[0])}" unless query.order.empty?
+      sql << " LIMIT #{query.limit}" if query.limit
+
+      DataMapper.logger.debug sql
+
+      result = connection.query(sql)
+
+      return unless result.records
+
+      result.records.each do |record|
+        accum = []
+        properties_with_indexes.each do |(property, idx)|
+          meth = connection.field_name_for(property.model.storage_name(repository.name), property.field(repository.name))
+          accum[idx] = normalize_id_value(query.model, property, record.send(meth))
+        end
+        yield accum
+      end
+    end
+
+    def make_salesforce_obj(query, attrs, key)
+      klass_name = query.model.storage_name(query.repository.name)
+      values = {}
+      if key
+        key_value = query.conditions.find {|op,prop,val| prop.key?}.last
+        values["id"] = normalize_id_value(query.model, query.model.properties[:id], key_value)
+      end
+
+      attrs.each do |property,value|
+        normalized_value = normalize_id_value(query.model, property, value)
+        values[property.field(query.repository.name)] = normalized_value
+      end
+      connection.make_object(klass_name, values)
+    end
+
+    def normalize_id_value(klass, property, value)
+      return value unless value
+      if klass.respond_to?(:salesforce_id_properties)
+        properties = Array(klass.salesforce_id_properties).map {|p| p.to_sym}
+        return value[0..14] if properties.include?(property.name)
+      end
+      value
+    end
+  end
+end

data/lib/dm-salesforce/connection.rb

@@ -0,0 +1,145 @@
+require 'soap/wsdlDriver'
+require 'soap/header/simplehandler'
+require "rexml/element"
+require 'dm-salesforce/soap_wrapper'
+
+module DataMapperSalesforce
+  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, 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 organization_id
+      @user_details && @user_details.organizationId
+    end
+
+    def make_object(klass_name, values)
+      klass = SalesforceAPI.const_get(klass_name)
+      obj = klass.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, column.camel_case, "#{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 api_dir
+      ENV["SALESFORCE_DIR"] || "#{ENV["HOME"]}/.salesforce"
+    end
+
+    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.faultcode.to_obj == "sf:INVALID_LOGIN"
+          raise LoginFailed, "Could not login to Salesforce; #{error.faultstring.text}"
+        else
+          raise
+        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
+          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.text == "sf:INVALID_SESSION_ID"
+        $stderr.puts "Got a invalid session id; reconnecting"
+        @driver = nil
+        login
+        retry_count += 1
+        retry unless retry_count > 5
+      else
+        raise
+      end
+
+      raise SessionTimeout, "The Salesforce session could not be established"
+    end
+  end
+end
+
+require 'dm-salesforce/connection/errors'

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

@@ -0,0 +1,44 @@
+module DataMapperSalesforce
+  class Connection
+    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
+    end
+    class CreateError    < SOAPError; end
+    class QueryError     < SOAPError; end
+    class DeleteError    < SOAPError; end
+    class UpdateError    < SOAPError; end
+  end
+end

data/lib/dm-salesforce/extensions.rb

@@ -0,0 +1,45 @@
+module DataMapperSalesforce
+  module SalesforceExtensions
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def properties_with_salesforce_validation
+        @properties_with_salesforce_validation ||= []
+      end
+
+      def add_salesforce_validation_for(property)
+        unless properties_with_salesforce_validation.include?(property)
+          validates_with_block property.name do
+            if message = salesforce_errors[property]
+              [false, message]
+            else
+              true
+            end
+          end
+        end
+        properties_with_salesforce_validation << property
+      end
+    end
+
+    def add_salesforce_error_for(field, message)
+      if property = property_for_salesforce_field(field)
+        self.class.add_salesforce_validation_for(property)
+        salesforce_errors[property] = message
+      else
+        raise "Field not found"
+      end
+    end
+
+    def property_for_salesforce_field(name)
+      self.class.properties.find do |p|
+        p.field.downcase == name.downcase
+      end
+    end
+
+    def salesforce_errors
+      @salesforce_errors ||= {}
+    end
+  end
+end

data/lib/dm-salesforce/soap_wrapper.rb

@@ -0,0 +1,53 @@
+require "fileutils"
+
+module DataMapperSalesforce
+  class SoapWrapper
+    class ClassesFailedToGenerate < StandardError; end
+
+    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
+    attr_reader :module_name, :driver_name, :wsdl_path, :api_dir
+
+    def driver
+      @driver ||= Object.const_get(module_name).const_get(driver_name).new
+    end
+
+    def generate_soap_classes
+      unless File.file?(wsdl_path)
+        raise Errno::ENOENT, "Could not find the WSDL at #{wsdl_path}"
+      end
+
+      unless File.directory?(wsdl_api_dir)
+        FileUtils.mkdir_p wsdl_api_dir
+      end
+
+      unless files_exist?
+        soap4r = Gem.loaded_specs['soap4r']
+        wsdl2ruby = File.expand_path(File.join(soap4r.full_gem_path, soap4r.bindir, "wsdl2ruby.rb"))
+        Dir.chdir(wsdl_api_dir) do
+          old_args = ARGV.dup
+          ARGV.replace %W(--wsdl #{wsdl_path} --module_path #{module_name} --classdef #{module_name} --type client)
+          load wsdl2ruby
+          ARGV.replace old_args
+          FileUtils.rm Dir["*Client.rb"]
+        end
+      end
+
+      $:.push wsdl_api_dir
+      require "#{module_name}Driver"
+    end
+
+    def files_exist?
+      %w( .rb Driver.rb MappingRegistry.rb ).all? do |suffix|
+        File.exist?("#{wsdl_api_dir}/#{module_name}#{suffix}")
+      end
+    end
+
+    def wsdl_api_dir
+      "#{api_dir}/#{File.basename(wsdl_path)}"
+    end
+  end
+end

data/lib/dm-salesforce/sql.rb

@@ -0,0 +1,60 @@
+module DataMapperSalesforce
+  module SQL
+    class << self
+      def from_condition(condition, repository)
+        op, prop, value = condition
+        operator = case op
+          when String then operator
+          when :eql, :in then equality_operator(value)
+          when :not      then inequality_operator(value)
+          when :like     then "LIKE #{quote_value(value)}"
+          when :gt       then "> #{quote_value(value)}"
+          when :gte      then ">= #{quote_value(value)}"
+          when :lt       then "< #{quote_value(value)}"
+          when :lte      then "<= #{quote_value(value)}"
+          else raise "CAN HAS CRASH?"
+        end
+        case prop
+        when DataMapper::Property
+          "#{prop.field} #{operator}"
+        when DataMapper::Query::Path
+          rels = prop.relationships
+          names = rels.map {|r| storage_name(r, repository) }.join(".")
+          "#{names}.#{prop.field} #{operator}"
+        end
+      end
+
+      def storage_name(rel, repository)
+        rel.parent_model.storage_name(repository.name)
+      end
+
+      def order(direction)
+        "#{direction.property.field} #{direction.direction.to_s.upcase}"
+      end
+
+      private
+      def equality_operator(value)
+        case value
+        when Array then "IN #{quote_value(value)}"
+        else "= #{quote_value(value)}"
+        end
+      end
+
+      def inequality_operator(value)
+        case value
+        when Array then "NOT IN #{quote_value(value)}"
+        else "!= #{quote_value(value)}"
+        end
+      end
+
+      def quote_value(value)
+        case value
+        when Array then "(#{value.map {|v| quote_value(v)}.join(", ")})"
+        when NilClass then "NULL"
+        when String then "'#{value.gsub(/'/, "\\'").gsub(/\\/, %{\\\\})}'"
+        else "#{value}"
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce/version.rb

@@ -0,0 +1,3 @@
+module DataMapperSalesforce
+  VERSION = "0.9.10"
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: dm-salesforce
+version: !ruby/object:Gem::Version 
+  version: 0.9.10
+platform: ruby
+authors: 
+- Yehuda Katz
+- Tim Carey-Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-06 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httpclient
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.1.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.8
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-validations
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.8
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: soap4r
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.5.8
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: data_objects
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: do_sqlite3
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.9
+    version: 
+description: A DataMapper adapter to the Salesforce API
+email: wycats@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/dm-salesforce/adapter.rb
+- lib/dm-salesforce/connection/errors.rb
+- lib/dm-salesforce/connection.rb
+- lib/dm-salesforce/extensions.rb
+- lib/dm-salesforce/soap_wrapper.rb
+- lib/dm-salesforce/sql.rb
+- lib/dm-salesforce/version.rb
+- lib/dm-salesforce.rb
+has_rdoc: true
+homepage: http://www.yehudakatz.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+source: 
+specification_version: 3
+summary: A DataMapper adapter to the Salesforce API
+test_files: []
+