active_force 0.7.1 → 0.15.0

data/lib/active_force/active_query.rb

@@ -1,24 +1,42 @@
+require 'active_support/all'
 require 'active_force/query'
 require 'forwardable'
 
 module ActiveForce
   class PreparedStatementInvalid < ArgumentError; end
+
+  class RecordNotFound < StandardError
+    attr_reader :table_name, :conditions
+
+    def initialize(message = nil, table_name = nil, conditions = nil)
+      @table_name = table_name
+      @conditions = conditions
+
+      super(message)
+    end
+  end
+
   class ActiveQuery < Query
     extend Forwardable
 
-    attr_reader :sobject
+    attr_reader :sobject, :association_mapping
 
     def_delegators :sobject, :sfdc_client, :build, :table_name, :mappings
-    def_delegators :to_a, :each, :map, :inspect
+    def_delegators :to_a, :each, :map, :inspect, :pluck, :each_with_object
 
     def initialize sobject
       @sobject = sobject
+      @association_mapping = {}
       super table_name
       fields sobject.fields
     end
 
     def to_a
-      @records ||= result.to_a.map { |mash| build mash }
+      @decorated_records ||= sobject.try(:decorate, records) || records
+    end
+
+    private def records
+      @records ||= result.to_a.map { |mash| build mash, association_mapping }
     end
 
     alias_method :all, :to_a
@@ -28,13 +46,34 @@ module ActiveForce
       sfdc_client.query(to_s).first.expr0
     end
 
+    def sum field
+      super(mappings[field])
+      sfdc_client.query(to_s).first.expr0
+    end
+
+    def pluck(*fields)
+      fields = mappings.keys if fields.blank?
+
+      sfdc_client.query(select(*fields).to_s).map do |record|
+        values = fields.map { |field| cast_value(field, record) }
+        values.length == 1 ? values.first : values
+      end
+    end
+
     def limit limit
       super
       limit == 1 ? to_a.first : self
     end
 
+    def not args=nil, *rest
+      return self if args.nil?
+      super build_condition args, rest
+      self
+    end
+
     def where args=nil, *rest
       return self if args.nil?
+      return clone_self_and_clear_cache.where(args, *rest) if @decorated_records.present?
       super build_condition args, rest
       self
     end
@@ -44,18 +83,48 @@ module ActiveForce
       super *fields
     end
 
+    def find!(id)
+      result = find(id)
+      raise RecordNotFound.new("Couldn't find #{table_name} with id #{id}", table_name, id: id) if result.nil?
+
+      result
+    end
+
     def find_by conditions
       where(conditions).limit 1
     end
 
+    def find_by!(conditions)
+      result = find_by(conditions)
+      raise RecordNotFound.new("Couldn't find #{table_name} with #{conditions}", table_name, conditions) if result.nil?
+
+      result
+    end
+
     def includes(*relations)
       relations.each do |relation|
         association = sobject.associations[relation]
         fields Association::EagerLoadProjectionBuilder.build association
+        # downcase the key and downcase when we do the comparison so we don't do any more crazy string manipulation
+        association_mapping[association.sfdc_association_field.downcase] = association.relation_name
       end
       self
     end
 
+    def none
+      @records = []
+      where(id: '1'*18).where(id: '0'*18)
+    end
+
+    def loaded?
+      !@records.nil?
+    end
+
+    def order *args
+      return self if args.nil?
+      super build_order_by args
+    end
+
     private
 
     def build_condition(args, other=[])
@@ -130,21 +199,53 @@ module ActiveForce
     def enclose_value value
       case value
       when String
-        "'#{quote_string(value)}'"
+        quote_string(value)
       when NilClass
         'NULL'
+      when Time
+        value.iso8601
       else
         value.to_s
       end
     end
 
     def quote_string(s)
-      # From activerecord/lib/active_record/connection_adapters/abstract/quoting.rb, version 4.1.5, line 82
-      s.gsub(/\\/, '\&\&').gsub(/'/, "''")
+      "'#{s.gsub(/(['\\])/, '\\\\\\1')}'"
     end
 
     def result
       sfdc_client.query(self.to_s)
     end
+
+    def cast_value(field, object)
+      attribute_type = sobject.attribute_types[field.to_s]
+      value = object[mappings[field]]
+      attribute_type&.cast(value) || value
+    end
+
+    def clone_self_and_clear_cache
+      new_query = self.clone
+      new_query.instance_variable_set(:@decorated_records, nil)
+      new_query.instance_variable_set(:@records, nil)
+      new_query
+    end
+
+    def build_order_by(args)
+      args.map do |arg|
+        case arg
+        when Symbol
+          mappings[arg].to_s
+        when Hash
+          arg.map { |key, value| "#{mappings[key]} #{order_type(value)}" }
+        else
+          arg
+        end
+      end.join(', ')
+    end
+
+    def order_type(type)
+      type == :desc ? 'DESC' : 'ASC'
+    end
+
   end
 end

data/lib/active_force/association/association.rb

@@ -11,10 +11,11 @@ module ActiveForce
         @relation_name = relation_name
         @options       = options
         define_relation_method
+        define_assignment_method
       end
 
       def relation_model
-        options[:model] || relation_name.to_s.singularize.camelcase.constantize
+        (options[:model] || relation_name.to_s.singularize.camelcase).to_s.constantize
       end
 
       def foreign_key
@@ -22,7 +23,7 @@ module ActiveForce
       end
 
       def relationship_name
-        options[:relationship_name] || relation_model.table_name
+        options[:relationship_name] || relation_model.to_s.constantize.table_name
       end
 
       ###
@@ -38,13 +39,56 @@ module ActiveForce
         relationship_name.gsub /__c\z/, '__r'
       end
 
+      def load_target(owner)
+        if loadable?(owner)
+          target(owner)
+        else
+          target_when_unloadable
+        end
+      end
+
       private
 
+      attr_reader :parent
+
+      def loadable?(owner)
+        owner&.persisted?
+      end
+
+      def target(_owner)
+        raise NoMethodError, 'target must be implemented'
+      end
+
+      def target_when_unloadable
+        nil
+      end
+
+      def define_relation_method
+        association = self
+        method_name = relation_name
+        parent.send(:define_method, method_name) do
+          association_cache.fetch(method_name) { association_cache[method_name] = association.load_target(self) }
+        end
+      end
+
+      def define_assignment_method
+        raise NoMethodError, 'define_assignment_method must be implemented'
+      end
+
       def infer_foreign_key_from_model(model)
         name = model.custom_table? ? model.name : model.table_name
         name.foreign_key.to_sym
       end
-    end
 
+      def apply_scope(query, owner)
+        return query unless (scope = options[:scoped_as])
+
+        if scope.arity.positive?
+          query.instance_exec(owner, &scope)
+        else
+          query.instance_exec(&scope)
+        end
+      end
+    end
   end
 end

data/lib/active_force/association/belongs_to_association.rb

@@ -1,24 +1,38 @@
 module ActiveForce
   module Association
     class BelongsToAssociation < Association
+      def relationship_name
+        options[:relationship_name] || default_relationship_name
+      end
+
       private
 
+      def loadable?(owner)
+        foreign_key_value(owner).present?
+      end
+
+      def target(owner)
+        relation_model.find(foreign_key_value(owner))
+      end
+
+      def default_relationship_name
+        parent.mappings[foreign_key].gsub(/__c\z/, '__r')
+      end
+
       def default_foreign_key
         infer_foreign_key_from_model relation_model
       end
 
-      def define_relation_method
-        association = self
-        _method = @relation_name
-        @parent.send :define_method, _method do
-          association_cache.fetch(_method) do
-            association_cache[_method] = association.relation_model.find(send association.foreign_key)
-          end
-        end
+      def foreign_key_value(owner)
+        owner&.public_send(foreign_key)
+      end
 
-        @parent.send :define_method, "#{_method}=" do |other|
-          send "#{ association.foreign_key }=", other.nil? ? nil : other.id
-          association_cache[_method] = other
+      def define_assignment_method
+        association = self
+        method_name = relation_name
+        parent.send :define_method, "#{method_name}=" do |other|
+          send "#{association.foreign_key}=", other&.id
+          association_cache[method_name] = other
         end
       end
     end

data/lib/active_force/association/eager_load_projection_builder.rb

@@ -40,15 +40,21 @@ module ActiveForce
       # relationship name. Per SFDC convention, the name needs
       # to be pluralized
       def projections
-        match = association.sfdc_association_field.match /__r\z/
-        # pluralize the table name, and append '__r' if it was there to begin with
-        relationship_name = association.sfdc_association_field.sub(match.to_s, '').pluralize + match.to_s
+        relationship_name = association.sfdc_association_field
         query = Query.new relationship_name
         query.fields association.relation_model.fields
         ["(#{query.to_s})"]
       end
     end
 
+    class HasOneAssociationProjectionBuilder < AbstractProjectionBuilder
+      def projections
+        query = Query.new association.sfdc_association_field
+        query.fields association.relation_model.fields
+        ["(#{query.to_s})"]
+      end
+    end
+
     class BelongsToAssociationProjectionBuilder < AbstractProjectionBuilder
       def projections
         association.relation_model.fields.map do |field|

data/lib/active_force/association/has_many_association.rb

@@ -1,31 +1,31 @@
 module ActiveForce
   module Association
     class HasManyAssociation < Association
+      def sfdc_association_field
+        name = relationship_name.gsub(/__c\z/, '__r')
+        match = name.match(/__r\z/)
+        # pluralize the table name, and append '__r' if it was there to begin with
+        name.sub(match.to_s, '').pluralize + match.to_s
+      end
+
       private
 
       def default_foreign_key
-        infer_foreign_key_from_model @parent
+        infer_foreign_key_from_model parent
       end
 
-      def define_relation_method
-        association = self
-        _method = @relation_name
-        @parent.send :define_method, _method do
-          association_cache.fetch _method do
-            query = association.relation_model.query
-            if scope = association.options[:scoped_as]
-              if scope.arity > 0
-                query.instance_exec self, &scope
-              else
-                query.instance_exec &scope
-              end
-            end
-            association_cache[_method] = query.where association.foreign_key => self.id
-          end
-        end
+      def target(owner)
+        apply_scope(relation_model.query, owner).where(foreign_key => owner.id)
+      end
+
+      def target_when_unloadable
+        relation_model.none
+      end
 
-        @parent.send :define_method, "#{_method}=" do |associated|
-          association_cache[_method] = associated
+      def define_assignment_method
+        method_name = relation_name
+        parent.send :define_method, "#{method_name}=" do |associated|
+          association_cache[method_name] = associated
         end
       end
     end

data/lib/active_force/association/has_one_association.rb

@@ -0,0 +1,30 @@
+module ActiveForce
+  module Association
+    class HasOneAssociation < Association
+      private
+
+      def target(owner)
+        apply_scope(relation_model.query, owner).find_by(foreign_key => owner.id)
+      end
+
+      def default_foreign_key
+        infer_foreign_key_from_model parent
+      end
+
+      def define_assignment_method
+        foreign_key = self.foreign_key
+        method_name = relation_name
+        parent.send :define_method, "#{method_name}=" do |new_target|
+          new_target = new_target.first if new_target.is_a?(Array)
+          if new_target.present?
+            new_target.public_send("#{foreign_key}=", id)
+          else
+            current_target = public_send(method_name)
+            current_target&.public_send("#{foreign_key}=", nil)
+          end
+          association_cache[method_name] = new_target
+        end
+      end
+    end
+  end
+end

data/lib/active_force/association/relation_model_builder.rb

@@ -54,7 +54,7 @@ module ActiveForce
 
     class BuildFromNilClass < AbstractBuildFrom
       def call
-        association.is_a?(BelongsToAssociation) ? nil : []
+        association.is_a?(HasManyAssociation) ? [] : nil
       end
     end
 

data/lib/active_force/association.rb

@@ -2,6 +2,7 @@ require 'active_force/association/association'
 require 'active_force/association/eager_load_projection_builder'
 require 'active_force/association/relation_model_builder'
 require 'active_force/association/has_many_association'
+require 'active_force/association/has_one_association'
 require 'active_force/association/belongs_to_association'
 
 module ActiveForce
@@ -10,17 +11,18 @@ module ActiveForce
       @associations ||= {}
     end
 
-    # i.e name = 'Quota__r'
     def find_association name
-      associations.values.detect do |association|
-        association.represents_sfdc_table? name
-      end
+      associations[name.to_sym]
     end
 
     def has_many relation_name, options = {}
       associations[relation_name] = HasManyAssociation.new(self, relation_name, options)
     end
 
+    def has_one relation_name, options = {}
+      associations[relation_name] = HasOneAssociation.new(self, relation_name, options)
+    end
+
     def belongs_to relation_name, options = {}
       associations[relation_name] = BelongsToAssociation.new(self, relation_name, options)
     end

data/lib/active_force/{attribute.rb → field.rb}

@@ -1,5 +1,5 @@
 module ActiveForce
-  class Attribute
+  class Field
 
     attr_accessor :local_name, :sfdc_name, :as
 
@@ -11,8 +11,8 @@ module ActiveForce
 
     def value_for_hash value
       case as
-      when :multi_picklist
-        value.reject(&:empty?).join(';')
+      when :datetime
+        value&.to_fs(:iso8601)
       else
         value
       end

data/lib/active_force/mapping.rb

@@ -1,4 +1,4 @@
-require 'active_force/attribute'
+require 'active_force/field'
 require 'active_force/table'
 require 'forwardable'
 
@@ -6,12 +6,6 @@ module ActiveForce
   class Mapping
     extend Forwardable
 
-    STRINGLIKE_TYPES = [
-      nil, :string, :base64, :byte, :ID, :reference, :currency, :textarea,
-      :phone, :url, :email, :combobox, :picklist, :multipicklist, :anyType,
-      :location
-    ]
-
     def_delegators :table, :custom_table?, :table_name
 
     def initialize model
@@ -19,7 +13,7 @@ module ActiveForce
     end
 
     def mappings
-      Hash[fields.map { |field, attr| [field, attr.sfdc_name] }]
+      @mappings ||= Hash[fields.map { |field, attr| [field, attr.sfdc_name] }]
     end
 
     def sfdc_names
@@ -27,7 +21,7 @@ module ActiveForce
     end
 
     def field name, options
-      fields.merge!({ name => ActiveForce::Attribute.new(name, options) })
+      fields.merge!({ name => ActiveForce::Field.new(name, options) })
     end
 
     def table
@@ -36,15 +30,15 @@ module ActiveForce
 
     def translate_to_sf attributes
       attrs = attributes.map do |attribute, value|
-        attr = fields[attribute.to_sym]
-        [attr.sfdc_name, attr.value_for_hash(value)]
+        field = fields[attribute.to_sym]
+        [field.sfdc_name, field.value_for_hash(value)]
       end
       Hash[attrs]
     end
 
     def translate_value value, field_name
       return value unless !!field_name
-      typecast_value value.to_s, fields[field_name].as
+      value
     end
 
 
@@ -54,25 +48,5 @@ module ActiveForce
       @fields ||= {}
     end
 
-    # Handles Salesforce FieldTypes as described here:
-    # http://www.salesforce.com/us/developer/docs/api/Content/sforce_api_calls_describesobjects_describesobjectresult.htm#i1427700
-    def typecast_value value, type
-      case type
-      when *STRINGLIKE_TYPES
-        value
-      when :boolean
-        !['false','0','f'].include? value.downcase
-      when :int
-        value.to_i
-      when :double, :percent
-        value.to_f
-      when :date
-        Date.parse value
-      when :datetime
-        DateTime.parse value
-      else
-        value
-      end
-    end
   end
 end

data/lib/active_force/query.rb

@@ -35,7 +35,17 @@ module ActiveForce
       self
     end
 
-    def where condition
+    def not condition
+      @conditions << "NOT ((#{ condition.join(') AND (') }))"
+      self
+    end
+
+    def or query
+      @conditions = ["(#{ and_conditions }) OR (#{ query.and_conditions })"]
+      self
+    end
+
+    def where condition = nil
       @conditions << condition if condition
       self
     end
@@ -86,13 +96,22 @@ module ActiveForce
       self
     end
 
+    def sum field
+      @query_fields = ["sum(#{field})"]
+      self
+    end
+
     protected
+      def and_conditions
+        "(#{@conditions.join(') AND (')})" unless @conditions.empty?
+      end
+
       def build_select
         @query_fields.compact.uniq.join(', ')
       end
 
       def build_where
-        "WHERE (#{ @conditions.join(') AND (') })" unless @conditions.empty?
+        "WHERE #{and_conditions}" unless @conditions.empty?
       end
 
       def build_limit