dm-salesforce 0.10.1 → 0.10.2

data/lib/dm-salesforce/adapter.rb

@@ -110,7 +110,7 @@ module DataMapper::Salesforce
     private
     def execute_query(query)
       repository = query.repository
-      conditions = query.conditions.map {|c| from_condition(c, repository)}.compact.join(") AND (")
+      conditions = query.conditions.map {|c| conditions_statement(c, repository)}.compact.join(") AND (")
 
       fields = query.fields.map do |f|
         case f

data/lib/dm-salesforce/sql.rb

@@ -1,56 +1,61 @@
 module DataMapper::Salesforce
   module SQL
-    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 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
 
-      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
+    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} #{operator}"
+        prop.field
       when DataMapper::Query::Path
         rels = prop.relationships
         names = rels.map {|r| storage_name(r, repository) }.join(".")
-        "#{names}.#{prop.field} #{operator}"
-      end
-    end
-
-    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)
+        "#{names}.#{prop.field}"
       end
     end
 
@@ -62,23 +67,29 @@ module DataMapper::Salesforce
       "#{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
+    def equality_operator(property, operand)
+      operand.nil? ? 'IS' : '='
     end
 
-    def inequality_operator(value)
-      case value
-      when Array then "NOT IN #{quote_value(value)}"
-      else "!= #{quote_value(value)}"
+    def include_operator(property, operand)
+      case operand
+      when Array then 'IN'
+      when Range then 'BETWEEN'
       end
     end
 
-    def quote_value(value)
+    def like_operator(operand)
+      "LIKE"
+    end
+
+    def quote_value(value, property)
+      if property.type == DataMapper::Salesforce::Types::Boolean
+        # True on salesforce needs to be TRUE/FALSE for WHERE clauses but not for inserts.
+        return value == DataMapper::Salesforce::Types::Boolean::TRUE ? 'TRUE' : 'FALSE'
+      end
+
       case value
-      when Array then "(#{value.map {|v| quote_value(v)}.join(", ")})"
+      when Array then "(#{value.map {|v| quote_value(v, property)}.join(", ")})"
       when NilClass then "NULL"
       when String then "'#{value.gsub(/'/, "\\'").gsub(/\\/, %{\\\\})}'"
       else "#{value}"

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

@@ -1,22 +1,20 @@
 module DataMapper::Salesforce
   module Types
     class Boolean < Type
-      primitive String
+      primitive Integer
+      FALSE = 0
+      TRUE  = 1
       default false
 
       def self.dump(value, property)
         case value
-        when nil, false then '0'
-        else value
+        when nil, false then FALSE
+        else TRUE
         end
       end
 
       def self.load(value, property)
-        case value
-        when TrueClass    then value
-        when '1', 'true'  then true
-        else false
-        end
+        [true, 1, '1', 'true', 'TRUE', TRUE].include?(value)
       end
     end
   end

data/lib/dm-salesforce/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-salesforce
 version: !ruby/object:Gem::Version 
-  version: 0.10.1
+  version: 0.10.2
 platform: ruby
 authors: 
 - Yehuda Katz