dm-salesforce 0.9.12 → 0.10.1

data/README.markdown

@@ -1,12 +1,20 @@
 dm-salesforce
 =============
 
-A gem that provides a Salesforce Adapter for DataMapper.
+A gem that provides a Salesforce Adapter for DataMapper 0.10.x.
+There are older versions of dm-salesforce specifically for 0.9.x.
 
-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.
+The wsdl is automatically converted into Ruby classes upon the first
+invocation of the dm-salesforce adapter.  The classes in turn get
+cached locally in one of the following locations, in order of
+precedence:
+
+    :repositories:salesforce:apidir (see included database.yml-example)
+    ENV["SALESFORCE_DIR"]
+    ~/.salesforce/
+
+It just works if you have the wsdl, directions for getting going are
+outlined below.
 
 An example of using the adapter:
 
@@ -17,12 +25,20 @@ An example of using the adapter:
         :salesforce
       end
 
+      # One way to define which properties are SalesForce-style.
       def self.salesforce_id_properties
         :id
       end
 
-      property :id, String, :serial => true
-      property :name, String
+      property :id,          String, :key => true
+      property :name,        String
+      property :description, String
+      property :fax,         String
+      property :phone,       String
+      property :type,        String
+      property :website,     String
+
+      has 0..n, :contacts
     end
 
     class Contact
@@ -32,15 +48,12 @@ An example of using the adapter:
         :salesforce
       end
 
-      def self.salesforce_id_properties
-        [:id, :account_id]
-      end
-
-      property :id,    String, :serial => true
+      # Alternatively, specify the :salesforce_id option.
+      property :id,         String, :serial => true, :salesforce_id => true
       property :first_name, String
-      property :last_name, String
-      property :email, String
-      property :account_id, String
+      property :last_name,  String
+      property :email,      String
+      property :account_id, String, :salesforce_id => true
 
       belongs_to :account
     end
@@ -48,7 +61,6 @@ An example of using the adapter:
 
 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
@@ -68,12 +80,16 @@ To get a test environment going with the free development tools you'll need to f
         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
+Special Thanks to those who helped
 ==================================================
+* Yehuda Katz
 * Corey Donohoe
+* Tim Carey-Smith
 * Andy Delcambre
 * Ben Burkert
 * Larry Diehl
+* Jordan Ritter
+* Martin Emde
 
 [setup]: http://img.skitch.com/20090204-gaxdfxbi1emfita5dax48ids4m.jpg "Click on Setup"
 [getwsdl]: http://img.skitch.com/20090204-nhurnuxwf5g3ufnjk2xkfjc5n4.jpg "Expand and Save"

data/Rakefile

@@ -4,15 +4,16 @@ require 'rubygems/specification'
 require 'bundler'
 require 'date'
 require 'pp'
+require 'tmpdir'
 
 Bundler.require_env
 require File.dirname(__FILE__) + '/lib/dm-salesforce'
 
 GEM = "dm-salesforce"
-GEM_VERSION = DataMapperSalesforce::VERSION
-AUTHORS = ["Yehuda Katz", 'Tim Carey-Smith']
-EMAIL = "wycats@gmail.com"
-HOMEPAGE = "http://www.yehudakatz.com"
+GEM_VERSION = DataMapper::Salesforce::VERSION
+AUTHORS = ["Yehuda Katz", 'Tim Carey-Smith', 'Corey Donohoe']
+EMAIL = "ninja@engineyard.com"
+HOMEPAGE = "http://github.com/halorgium/dm-salesforce"
 SUMMARY = "A DataMapper adapter to the Salesforce API"
 
 @spec = Gem::Specification.new do |s|
@@ -43,7 +44,7 @@ end
 
 desc "install the gem locally"
 task :install => [:package] do
-  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION} --no-ri --no-rdoc}
+  sh %{gem install pkg/#{GEM}-#{GEM_VERSION} --no-ri --no-rdoc}
 end
 
 task :default => 'spec'
@@ -53,9 +54,9 @@ 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.spec_files = Dir["spec/**/*_spec.rb"]
   t.rcov = ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true
-  t.rcov_opts << '--exclude' << '~/.salesforce,gems,spec,config,tmp'
+  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

data/lib/dm-salesforce.rb

@@ -1,15 +1,24 @@
-$:.push File.expand_path(File.dirname(__FILE__))
-
+require "fileutils"
 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
+require 'soap/wsdlDriver'
+require 'soap/header/simplehandler'
+require "rexml/element"
 
-module DataMapperSalesforce
+module DataMapper::Salesforce
   UserDetails = Struct.new(:username, :password)
 end
+
+dir = File.expand_path(File.join(File.dirname(__FILE__), 'dm-salesforce'))
+
+require dir / :resource
+require dir / :connection
+require dir / :connection / :errors
+require dir / :soap_wrapper
+require dir / :sql
+require dir / :types
+require dir / :version
+
+require dir / :adapter
+
+DataMapper::Adapters::SalesforceAdapter = DataMapper::Salesforce::Adapter

data/lib/dm-salesforce/adapter.rb

@@ -1,5 +1,7 @@
-module DataMapperSalesforce
+module DataMapper::Salesforce
   class Adapter < DataMapper::Adapters::AbstractAdapter
+    include SQL
+
     def initialize(name, uri_or_options)
       super
       @resource_naming_convention = proc do |value|
@@ -15,185 +17,144 @@ module DataMapperSalesforce
       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
+      @connection ||= Connection.new(options["username"], options["password"], options["path"], options["apidir"])
     end
 
     def create(resources)
       arr = resources.map do |resource|
-        obj = make_salesforce_obj(resource, resource.dirty_attributes, nil)
+        make_salesforce_obj(resource, resource.dirty_attributes)
       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
+        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::CreateError => e
-      populate_errors_for(e.records, resources)
-      e.successful_records.size
+
+    rescue Connection::SOAPError => e
+      handle_server_outage(e)
     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
+    def update(attributes, collection)
+      query = collection.query
+      arr   = collection.map { |obj| make_salesforce_obj(query, attributes) }
+
       connection.update(arr).size
-    rescue Connection::UpdateError => e
-      populate_errors_for(e.records, arr, query)
-      e.successful_records.size
+
+    rescue Connection::SOAPError => e
+      handle_server_outage(e)
     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
+    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 populate_errors_for(records, resources, query = nil)
-      records.each_with_index do |record,i|
-        next if record.success
+    def handle_server_outage(error)
+      if error.server_unavailable?
+        raise Connection::ServerUnavailable, "The salesforce server is currently unavailable"
+      else
+        raise error
+      end
+    end
 
-        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
+    # 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 is
+    # processed differently depending on invocation.
+    def read(query)
+      properties = query.fields
+      repository = query.repository
+
+      response = execute_query(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
-    end
 
-    # A dummy method to allow migrations without upsetting any data
-    def destroy_model_storage(*args)
-      true
+      query.model.load(rows, query)
     end
 
-    # A dummy method to allow auto_migrate! to run
-    def upgrade_model_storage(*args)
-      true
-    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.
+    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
 
-    # A dummy method to allow migrations without upsetting any data
-    def create_model_storage(*args)
-      true
+      [ execute_query(query).size ]
     end
 
     private
-    def read(query, &block)
+    def execute_query(query)
       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 (")
+      conditions = query.conditions.map {|c| from_condition(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 #{query.fields.map {|f| f.field(repository.name)}.join(", ")} from #{query.model.storage_name(repository.name)}"
+      sql = "SELECT #{fields} 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 << " ORDER BY #{order(query.order[0])}" unless query.order.empty?
       sql << " LIMIT #{query.limit}" if query.limit
 
-      DataMapper.logger.debug sql
+      DataMapper.logger.debug sql if DataMapper.logger
 
-      result = connection.query(sql)
+      connection.query(sql)
+    end
 
-      return unless result.records
+    def make_salesforce_obj(from, with_attrs)
+      klass_name = from.model.storage_name(from.repository.name)
+      values     = {}
 
-      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
+      # 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
-    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)
+      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
 
-      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
+      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

data/lib/dm-salesforce/connection.rb

@@ -1,9 +1,4 @@
-require 'soap/wsdlDriver'
-require 'soap/header/simplehandler'
-require "rexml/element"
-require 'dm-salesforce/soap_wrapper'
-
-module DataMapperSalesforce
+module DataMapper::Salesforce
   class Connection
     class HeaderHandler < SOAP::Header::SimpleHandler
       def initialize(tag, value)
@@ -16,7 +11,7 @@ module DataMapperSalesforce
       end
     end
 
-    def initialize(username, password, wsdl_path, organization_id = nil)
+    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
@@ -27,14 +22,17 @@ module DataMapperSalesforce
       @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)
-      klass = SalesforceAPI.const_get(klass_name)
-      obj = klass.new
-      values.each do |property,value|
+      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)
@@ -81,9 +79,6 @@ module DataMapperSalesforce
     end
 
     private
-    def api_dir
-      ENV["SALESFORCE_DIR"] || "#{ENV["HOME"]}/.salesforce"
-    end
 
     def driver
       @wrapper.driver
@@ -98,7 +93,7 @@ module DataMapperSalesforce
       begin
         result = driver.login(:username => @username, :password => @password).result
       rescue SOAP::FaultError => error
-        if error.faultcode.to_obj == "sf:INVALID_LOGIN"
+        if error.faultcode.to_obj == "sf:INVALID_LOGIN" || error.faultcode.to_obj == "INVALID_LOGIN"
           raise LoginFailed, "Could not login to Salesforce; #{error.faultstring.text}"
         else
           raise
@@ -141,5 +136,3 @@ module DataMapperSalesforce
     end
   end
 end
-
-require 'dm-salesforce/connection/errors'

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

@@ -1,4 +1,4 @@
-module DataMapperSalesforce
+module DataMapper::Salesforce
   class Connection
     class Error             < StandardError; end
     class FieldNotFound     < Error; end
@@ -35,6 +35,12 @@ module DataMapperSalesforce
       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

data/lib/dm-salesforce/resource.rb

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

data/lib/dm-salesforce/soap_wrapper.rb

@@ -1,15 +1,14 @@
-require "fileutils"
-
-module DataMapperSalesforce
+module DataMapper::Salesforce
   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
-    attr_reader :module_name, :driver_name, :wsdl_path, :api_dir
 
     def driver
       @driver ||= Object.const_get(module_name).const_get(driver_name).new
@@ -24,31 +23,37 @@ module DataMapperSalesforce
         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
-          (Dir["*.rb"] - files).each do |filename|
-            FileUtils.rm(filename)
-          end
-        end
-      end
+      generate_files unless files_exist?
 
       $:.push wsdl_api_dir
       require "#{module_name}Driver"
       $:.delete wsdl_api_dir
     end
 
-    def files
-      ["#{module_name}.rb", "#{module_name}MappingRegistry.rb", "#{module_name}Driver.rb"]
+    # 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?
-      files.all? do |name|
+      ["#{module_name}.rb", "#{module_name}MappingRegistry.rb", "#{module_name}Driver.rb"].all? do |name|
         File.exist?("#{wsdl_api_dir}/#{name}")
       end
     end

data/lib/dm-salesforce/sql.rb

@@ -1,59 +1,87 @@
-module DataMapperSalesforce
+module DataMapper::Salesforce
   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 from_condition(condition, repository)
+      slug = condition.class.slug
+      condition = case condition
+                  when DataMapper::Query::Conditions::AbstractOperation then condition.operands.first
+                  when DataMapper::Query::Conditions::AbstractComparison
+                    if condition.subject.kind_of?(DataMapper::Associations::Relationship)
+                      foreign_key_conditions(condition)
+                    else
+                      condition
+                    end
+                  else raise("Unkown condition type #{condition.class}: #{condition.inspect}")
+                  end
 
-      def storage_name(rel, repository)
-        rel.parent_model.storage_name(repository.name)
+      value = condition.value
+      prop = condition.subject
+      operator = case slug
+                 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 order(direction)
-        "#{direction.property.field} #{direction.direction.to_s.upcase}"
+    def foreign_key_conditions(condition)
+      subject = case condition.subject
+        when DataMapper::Associations::ManyToOne::Relationship
+          condition.subject.child_key.first
+        else
+          condition.subject.parent_key.first
+        end
+
+      case condition.value
+      when Array, DataMapper::Collection
+        value = condition.send(:expected).flatten
+        DataMapper::Query::Conditions::InclusionComparison.new(subject, value)
+      else
+        value = condition.send(:expected)
+        DataMapper::Query::Conditions::EqualToComparison.new(subject, value)
       end
+    end
 
-      private
-      def equality_operator(value)
-        case value
-        when Array then "IN #{quote_value(value)}"
-        else "= #{quote_value(value)}"
-        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(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
+    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
+    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

data/lib/dm-salesforce/types.rb

@@ -0,0 +1,14 @@
+module DataMapper::Salesforce
+  class Type < ::DataMapper::Type
+  end
+
+  module Types
+  end
+end
+
+dir = File.expand_path(File.dirname(__FILE__) / :types)
+
+require dir / :serial
+require dir / :boolean
+require dir / :integer
+require dir / :float

data/lib/dm-salesforce/types/boolean.rb

@@ -0,0 +1,23 @@
+module DataMapper::Salesforce
+  module Types
+    class Boolean < Type
+      primitive String
+      default false
+
+      def self.dump(value, property)
+        case value
+        when nil, false then '0'
+        else value
+        end
+      end
+
+      def self.load(value, property)
+        case value
+        when TrueClass    then value
+        when '1', 'true'  then true
+        else false
+        end
+      end
+    end
+  end
+end

data/lib/dm-salesforce/types/float.rb

@@ -0,0 +1,8 @@
+module DataMapper::Salesforce
+  module Types
+    class Float < Type
+      primitive ::Float
+      default 0.0
+    end
+  end
+end

data/lib/dm-salesforce/types/integer.rb

@@ -0,0 +1,12 @@
+module DataMapper::Salesforce
+  module Types
+    class Integer < Type
+      primitive ::Integer
+      default 0
+
+      def self.load(value, property)
+        Integer(value)
+      end
+    end
+  end
+end

data/lib/dm-salesforce/types/serial.rb

@@ -0,0 +1,14 @@
+module DataMapper::Salesforce
+  module Types
+    class Serial < Type
+      primitive ::String
+      min 15
+      max 15
+      serial true
+
+      def self.dump(value, property)
+        value[0..14] unless value.blank?
+      end
+    end
+  end
+end

data/lib/dm-salesforce/version.rb

@@ -1,3 +1,3 @@
-module DataMapperSalesforce
-  VERSION = "0.9.12"
+module DataMapper::Salesforce
+  VERSION = "0.10.1"
 end

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification 
 name: dm-salesforce
 version: !ruby/object:Gem::Version 
-  version: 0.9.12
+  version: 0.10.1
 platform: ruby
 authors: 
 - Yehuda Katz
 - Tim Carey-Smith
+- Corey Donohoe
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-09-10 00:00:00 -07:00
+date: 2009-12-17 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,7 +42,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.9.8
+        version: 0.10.1
     version: 
 - !ruby/object:Gem::Dependency 
   name: dm-validations
@@ -51,40 +52,40 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.9.8
+        version: 0.10.1
     version: 
 - !ruby/object:Gem::Dependency 
-  name: soap4r
+  name: dm-types
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.5.8
+        version: 0.10.1
     version: 
 - !ruby/object:Gem::Dependency 
-  name: data_objects
+  name: do_sqlite3
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.9.9
+        version: 0.10.0
     version: 
 - !ruby/object:Gem::Dependency 
-  name: do_sqlite3
+  name: soap4r
   type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 0.9.9
+        version: 1.5.8
     version: 
 description: A DataMapper adapter to the Salesforce API
-email: wycats@gmail.com
+email: ninja@engineyard.com
 executables: []
 
 extensions: []
@@ -99,13 +100,18 @@ files:
 - lib/dm-salesforce/adapter.rb
 - lib/dm-salesforce/connection/errors.rb
 - lib/dm-salesforce/connection.rb
-- lib/dm-salesforce/extensions.rb
+- lib/dm-salesforce/resource.rb
 - lib/dm-salesforce/soap_wrapper.rb
 - lib/dm-salesforce/sql.rb
+- lib/dm-salesforce/types/boolean.rb
+- lib/dm-salesforce/types/float.rb
+- lib/dm-salesforce/types/integer.rb
+- lib/dm-salesforce/types/serial.rb
+- lib/dm-salesforce/types.rb
 - lib/dm-salesforce/version.rb
 - lib/dm-salesforce.rb
 has_rdoc: true
-homepage: http://www.yehudakatz.com
+homepage: http://github.com/halorgium/dm-salesforce
 licenses: []
 
 post_install_message: 

data/lib/dm-salesforce/extensions.rb

@@ -1,45 +0,0 @@
-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