dm-salesforce-adapter 1.0.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::Salesforce::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::Salesforce::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,65 @@
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'pp'
+require 'tmpdir'
+
+require 'bundler/setup'
+
+Bundler.require
+
+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 = Dir["spec/**/*_spec.rb"]
+  t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
+  t.rcov_opts << '--exclude' << "~/.salesforce,gems,vendor,/var/folders,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 = SalesforceAdapter::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 SalesforceAdapter
+  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-adapter.rb

@@ -0,0 +1,29 @@
+require 'data_objects'
+require 'dm-core'
+require 'dm-types'
+require 'dm-validations'
+
+require 'soap/wsdlDriver'
+require 'soap/header/simplehandler'
+require 'rexml/element'
+
+class SalesforceAdapter < ::DataMapper::Adapters::AbstractAdapter
+  Inflector = ::DataMapper.const_defined?(:Inflector) ? ::DataMapper::Inflector : ::Extlib::Inflection
+end
+
+require 'dm-salesforce-adapter/resource'
+require 'dm-salesforce-adapter/connection'
+require 'dm-salesforce-adapter/connection/errors'
+require 'dm-salesforce-adapter/soap_wrapper'
+require 'dm-salesforce-adapter/sql'
+require 'dm-salesforce-adapter/version'
+require 'dm-salesforce-adapter/adapter'
+require 'dm-salesforce-adapter/property'
+
+# For convenience (WRT the examples)
+module DataMapper::Salesforce
+    Resource = SalesforceAdapter::Resource
+end
+
+::DataMapper::Adapters::SalesforceAdapter = SalesforceAdapter
+::DataMapper::Adapters.const_added(:SalesforceAdapter)

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

@@ -0,0 +1,172 @@
+
+class SalesforceAdapter
+  include SQL
+
+  def initialize(name, uri_or_options)
+    super
+    @resource_naming_convention = proc do |value|
+      klass = 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 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.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
+
+

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

@@ -0,0 +1,144 @@
+require 'dm-salesforce-adapter/connection/errors'
+
+class SalesforceAdapter
+  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, (column.camel_case rescue column.camelcase), "#{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.faultcode.to_s =~ /INVALID_LOGIN/
+          raise LoginFailed, error.faultstring.to_s
+        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

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

@@ -0,0 +1,50 @@
+class SalesforceAdapter::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

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

@@ -0,0 +1,7 @@
+class SalesforceAdapter
+  module Property
+  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,17 @@
+module SalesforceAdapter::Property
+  class Boolean < ::DataMapper::Property::Integer
+    FALSE = 0
+    TRUE  = 1
+
+    def self.dump(value, property)
+      case value
+      when nil, false then FALSE
+      else TRUE
+      end
+    end
+
+    def self.load(value, property)
+      [true, 1, '1', 'true', 'TRUE', TRUE].include?(value)
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module SalesforceAdapter::Property
+  class Serial < ::DataMapper::Property::String
+    accept_options :serial
+    serial true
+
+    length 15
+
+    def self.dump(value, property)
+      value[0..14] unless value.blank?
+    end
+  end
+end

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

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

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

@@ -0,0 +1,82 @@
+class SalesforceAdapter
+  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
+

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

@@ -0,0 +1,99 @@
+class SalesforceAdapter
+  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.type == 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

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

@@ -0,0 +1,3 @@
+class SalesforceAdapter
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification 
+name: dm-salesforce-adapter
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Yehuda Katz
+- Tim Carey-Smith
+- Andy Delcambre
+- Jordan Ritter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-23 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httpclient
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 119
+        segments: 
+        - 2
+        - 1
+        - 5
+        - 2
+        version: 2.1.5.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 37
+        segments: 
+        - 0
+        - 9
+        - 15
+        version: 0.9.15
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: dm-validations
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: dm-types
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: soap4r
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 5
+        - 8
+        version: 1.5.8
+  type: :runtime
+  version_requirements: *id006
+description: A DataMapper 1.0x 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/version.rb
+- lib/dm-salesforce-adapter.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.3.7
+signing_key: 
+specification_version: 3
+summary: A DataMapper 1.0x adapter to the Salesforce API
+test_files: []
+