active_force 0.7.0 → 0.15.0

data/lib/active_force/sobject.rb

@@ -1,6 +1,4 @@
 require 'active_model'
-require 'active_attr'
-require 'active_attr/dirty'
 require 'active_force/active_query'
 require 'active_force/association'
 require 'active_force/mapping'
@@ -13,18 +11,26 @@ module ActiveForce
   class RecordInvalid < StandardError;end
 
   class SObject
-    include ActiveAttr::Model
-    include ActiveAttr::Dirty
-    extend ActiveForce::Association
+    include ActiveModel::API
+    include ActiveModel::AttributeMethods
+    include ActiveModel::Attributes
+    include ActiveModel::Model
+    include ActiveModel::Dirty
     extend ActiveModel::Callbacks
+    include ActiveModel::Serializers::JSON
+    extend ActiveForce::Association
+
 
-    define_model_callbacks :save, :create, :update
+    define_model_callbacks :build, :create, :update, :save, :destroy
 
     class_attribute :mappings, :table_name
 
+    attr_accessor :id, :title
+
     class << self
       extend Forwardable
-      def_delegators :query, :where, :first, :last, :all, :find, :find_by, :count, :includes, :limit, :order, :select
+      def_delegators :query, :not, :or, :where, :first, :last, :all, :find, :find!, :find_by, :find_by!, :sum, :count,
+                     :includes, :limit, :order, :select, :none, :pluck
       def_delegators :mapping, :table, :table_name, :custom_table?, :mappings
 
       private
@@ -49,13 +55,24 @@ module ActiveForce
       ActiveForce::ActiveQuery.new self
     end
 
-    def self.build mash
+    def self.describe
+      sfdc_client.describe(table_name)
+    end
+
+    attr_accessor :build_attributes
+    def self.build mash, association_mapping={}
       return unless mash
       sobject = new
-      mash.each do |column, sf_value|
-        sobject.write_value column, sf_value
+      sobject.build_attributes = mash[:build_attributes] || mash
+      sobject.run_callbacks(:build) do
+        mash.each do |column, value|
+          if association_mapping.has_key?(column.downcase)
+            column = association_mapping[column.downcase]
+          end
+          sobject.write_value column, value
+        end
       end
-      sobject.changed_attributes.clear
+      sobject.clear_changes_information
       sobject
     end
 
@@ -65,7 +82,7 @@ module ActiveForce
       run_callbacks :save do
         run_callbacks :update do
           sfdc_client.update! table_name, attributes_for_sfdb
-          changed_attributes.clear
+          clear_changes_information
         end
       end
       true
@@ -75,7 +92,7 @@ module ActiveForce
 
     def update_attributes attributes = {}
       update_attributes! attributes
-    rescue Faraday::Error::ClientError, RecordInvalid => error
+    rescue Faraday::ClientError, RecordInvalid => error
       handle_save_error error
     end
 
@@ -86,7 +103,7 @@ module ActiveForce
       run_callbacks :save do
         run_callbacks :create do
           self.id = sfdc_client.create! table_name, attributes_for_sfdb
-          changed_attributes.clear
+          clear_changes_information
         end
       end
       self
@@ -94,13 +111,15 @@ module ActiveForce
 
     def create
       create!
-    rescue Faraday::Error::ClientError, RecordInvalid => error
+    rescue Faraday::ClientError, RecordInvalid => error
       handle_save_error error
       self
     end
 
     def destroy
-      sfdc_client.destroy! self.class.table_name, id
+      run_callbacks(:destroy) do
+        sfdc_client.destroy! self.class.table_name, id
+      end
     end
 
     def self.create args
@@ -123,7 +142,7 @@ module ActiveForce
 
     def save
       save!
-    rescue Faraday::Error::ClientError, RecordInvalid => error
+    rescue Faraday::ClientError, RecordInvalid => error
       handle_save_error error
     end
 
@@ -136,27 +155,45 @@ module ActiveForce
     end
 
     def self.field field_name, args = {}
+      options = args.except(:as, :from, :sfdc_name)
       mapping.field field_name, args
-      attribute field_name
+      cast_type = args.fetch(:as, :string)
+      attribute field_name, cast_type, **options
+      define_attribute_methods field_name
+    end
+
+    def modified_attributes
+      attributes.select{ |attr, key| changed.include? attr.to_s }
     end
 
     def reload
       association_cache.clear
       reloaded = self.class.find(id)
       self.attributes = reloaded.attributes
-      changed_attributes.clear
+      clear_changes_information
       self
     end
 
-    def write_value column, value
-      if association = self.class.find_association(column)
+    def write_value key, value
+      if association = self.class.find_association(key.to_sym)
         field = association.relation_name
         value = Association::RelationModelBuilder.build(association, value)
+      elsif key.to_sym.in?(mappings.keys)
+        # key is a field name
+        field = key
       else
-        field = mappings.invert[column]
-        value = self.class.mapping.translate_value value, field unless value.nil?
+        # Assume key is an SFDC column
+        field = mappings.key(key)
       end
-      send "#{field}=", value if field
+      send "#{field}=", value if field && respond_to?(field)
+    end
+
+    def [](name)
+      send(name.to_sym)
+    end
+
+    def []=(name,value)
+      send("#{name.to_sym}=", value)
     end
 
    private
@@ -181,14 +218,23 @@ module ActiveForce
     def logger_output action, exception, params = {}
       logger = Logger.new(STDOUT)
       logger.info("[SFDC] [#{self.class.model_name}] [#{self.class.table_name}] Error while #{ action }, params: #{params}, error: #{exception.inspect}")
-      errors[:base] << exception.message
+      errors.add(:base, exception.message)
       false
     end
 
     def attributes_for_sfdb
-      attrs = self.class.mapping.translate_to_sf(attributes_and_changes)
-      attrs.merge!({'Id' => id }) if persisted?
-      attrs
+      attrs_to_change = persisted? ? attributes_for_update : attributes_for_create
+      self.class.mapping.translate_to_sf(@attributes.values_for_database.slice(*attrs_to_change))
+    end
+
+    def attributes_for_create
+      @attributes.each_value.select { |value| value.is_a?(ActiveModel::Attribute::UserProvidedDefault) }
+                            .map(&:name)
+                            .concat(changed)
+    end
+
+    def attributes_for_update
+      ['id'].concat(changed)
     end
 
     def self.picklist field
@@ -199,7 +245,7 @@ module ActiveForce
     end
 
     def self.sfdc_client
-      @client ||= Restforce.new
+      ActiveForce.sfdc_client
     end
 
     def sfdc_client

data/lib/active_force/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveForce
-  VERSION = "0.7.0"
+  VERSION = '0.15.0'
 end

data/lib/active_force.rb

@@ -1,6 +1,15 @@
+require 'active_model/type/salesforce/multipicklist'
+require 'active_model/type/salesforce/percent'
 require 'active_force/version'
 require 'active_force/sobject'
 require 'active_force/query'
 
 module ActiveForce
+
+  class << self
+    attr_accessor :sfdc_client
+  end
+
+  self.sfdc_client = Restforce.new
+
 end

data/lib/active_model/type/salesforce/multipicklist.rb

@@ -0,0 +1,29 @@
+require 'active_model'
+
+module ActiveModel
+  module Type
+    module Salesforce
+      class Multipicklist < ActiveModel::Type::Value
+        include ActiveModel::Type::Helpers::Mutable
+
+        def type
+          :multipicklist
+        end
+
+        def deserialize(value)
+          value.to_s.split(';')
+        end
+
+        def serialize(value)
+          return if value.blank?
+
+          return value if value.is_a?(::String)
+
+          value.to_a.reject(&:empty?).join(';')
+        end
+      end
+    end
+  end
+end
+
+ActiveModel::Type.register(:multipicklist, ActiveModel::Type::Salesforce::Multipicklist)

data/lib/active_model/type/salesforce/percent.rb

@@ -0,0 +1,22 @@
+require 'active_model'
+
+module ActiveModel
+  module Type
+    module Salesforce
+      class Percent < ActiveModel::Type::Value
+
+        def type
+          :percent
+        end
+
+        private
+
+        def cast_value(value)
+          value.to_f
+        end
+      end
+    end
+  end
+end
+
+ActiveModel::Type.register(:percent, ActiveModel::Type::Salesforce::Percent)

data/lib/generators/active_force/model/model_generator.rb

@@ -1,35 +1,48 @@
 module ActiveForce
   class ModelGenerator < Rails::Generators::NamedBase
-    desc 'This generator loads the table fields from SFDC and generates the fields for the SObject with a more ruby names'
+    desc 'This generator loads the table fields from SFDC and generates the fields for the SObject with a more Ruby name'
 
     source_root File.expand_path('../templates', __FILE__)
+    argument :namespace, type: :string, optional: true, default: ''
+
+    SALESFORCE_TO_ACTIVEMODEL_TYPE_MAP = {
+      'boolean' => :boolean,
+      'double' => :float,
+      'percentage' => :float,
+      'currency' => :float,
+      'date' => :date,
+      'datetime' => :datetime,
+      'int' => :integer,
+    }
 
     def create_model_file
       @table_name = file_name.capitalize
-      @class_name = @table_name.gsub '__c', ''
-      template "model.rb.erb", "app/models/#{@class_name.downcase}.rb" if table_exists?
+      @class_name = prepare_namespace + @table_name.gsub('__c', '')
+      template "model.rb.erb", "app/models/#{@class_name.underscore}.rb" if table_exists?
     end
 
     protected
 
-    Attribute = Struct.new :field, :column
+    def prepare_namespace
+      @namespace.present? ? @namespace + '::' : @namespace
+    end
+
+    Attribute = Struct.new :field, :column, :type
 
-    def attributes 
-      @attributes ||= sfdc_columns.map do |column|
-        Attribute.new column_to_field(column), column
+    def attributes
+      @attributes ||= sfdc_columns.sort_by { |col| col[:name].downcase }.map do |column|
+        Attribute.new column_to_field(column.name), column.name, saleforce_to_active_model_type(column.type)
       end
       @attributes - [:id]
     end
 
     def sfdc_columns
-      @columns ||= ActiveForce::SObject.sfdc_client.describe(@table_name).fields.map do |field|
-        field.name
-      end
+      @columns ||= ActiveForce::SObject.sfdc_client.describe(@table_name).fields
     end
 
     def table_exists?
       !! sfdc_columns
-      rescue Faraday::Error::ResourceNotFound
+      rescue Faraday::ResourceNotFound
         puts "The specified table name is not found. Be sure to append __c if it's custom"
     end
 
@@ -38,7 +51,7 @@ module ActiveForce
     end
 
     def attribute_line attribute
-      "field :#{ attribute.field },#{ space_justify attribute.field }  from: '#{ attribute.column }'"
+      "field :#{ attribute.field },#{ space_justify attribute.field }  from: '#{ attribute.column }'#{ add_type(attribute.type) }"
     end
 
     def space_justify field_name
@@ -47,16 +60,14 @@ module ActiveForce
       " " * justify_count
     end
 
-
-    class String
-      def underscore
-        self.gsub(/::/, '/').
-        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-        gsub(/([a-z\d])([A-Z])/,'\1_\2').
-        tr("-", "_").
-        downcase
-      end
+    def add_type(type)
+      # String is the default so no need to add it
+      return '' if type == :string
+      ", as: :#{ type }"
     end
 
+    def saleforce_to_active_model_type type
+      SALESFORCE_TO_ACTIVEMODEL_TYPE_MAP.fetch(type, :string)
+    end
   end
 end

data/lib/generators/active_force/model/templates/model.rb.erb

@@ -1,4 +1,6 @@
-class <%= @class_name %> < ActiveForce::SObject
+class <%= @class_name.classify %> < ActiveForce::SObject
+  self.table_name = '<%= @table_name %>'
+
 <% attributes.each do |attribute| -%>
   <%= attribute_line attribute %>
 <% end -%>

data/spec/active_force/active_query_spec.rb

@@ -8,9 +8,16 @@ describe ActiveForce::ActiveQuery do
       mappings: mappings
     })
   end
-  let(:mappings){ { field: "Field__c", other_field: "Other_Field" } }
+  let(:mappings){ { id: "Id", field: "Field__c", other_field: "Other_Field" } }
   let(:client){ double("client") }
-  let(:active_query){ ActiveForce::ActiveQuery.new(sobject) }
+  let(:active_query){ described_class.new(sobject) }
+  let(:api_result) do
+    [
+      {"Id" => "0000000000AAAAABBB"},
+      {"Id" => "0000000000CCCCCDDD"}
+    ]
+  end
+
 
   before do
     allow(active_query).to receive(:sfdc_client).and_return client
@@ -19,7 +26,7 @@ describe ActiveForce::ActiveQuery do
 
   describe "to_a" do
     before do
-      expect(client).to receive(:query)
+      expect(client).to receive(:query).and_return(api_result)
     end
 
     it "should return an array of objects" do
@@ -27,9 +34,9 @@ describe ActiveForce::ActiveQuery do
       expect(result).to be_a Array
     end
 
-    it "should allow to chain query methods" do
-      result = active_query.where("Text_Label = 'foo'").where("Checkbox_Label = true").to_a
-      expect(result).to be_a Array
+    it "should decorate the array of objects" do
+      expect(sobject).to receive(:decorate)
+      active_query.where("Text_Label = 'foo'").to_a
     end
   end
 
@@ -56,6 +63,24 @@ describe ActiveForce::ActiveQuery do
       expect(active_query.to_s).to end_with("(Field__c = 'hello')")
     end
 
+    it "formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if it's a DateTime" do
+      value = DateTime.now
+      active_query.where(field: value)
+      expect(active_query.to_s).to end_with("(Field__c = #{value.iso8601})")
+    end
+
+    it "formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if it's a Time" do
+      value = Time.now
+      active_query.where(field: value)
+      expect(active_query.to_s).to end_with("(Field__c = #{value.iso8601})")
+    end
+
+    it "formats as YYYY-MM-DD and does not enclose in quotes if it's a Date" do
+      value = Date.today
+      active_query.where(field: value)
+      expect(active_query.to_s).to end_with("(Field__c = #{value.iso8601})")
+    end
+
     it "puts NULL when a field is set as nil" do
       active_query.where field: nil
       expect(active_query.to_s).to end_with("(Field__c = NULL)")
@@ -84,6 +109,24 @@ describe ActiveForce::ActiveQuery do
         expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
       end
 
+      it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a DateTime' do
+        value = DateTime.now
+        active_query.where('Field__c > ?', value)
+        expect(active_query.to_s).to end_with("(Field__c > #{value.iso8601})")
+      end
+
+      it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a Time' do
+        value = Time.now
+        active_query.where('Field__c > ?', value)
+        expect(active_query.to_s).to end_with("(Field__c > #{value.iso8601})")
+      end
+
+      it 'formats as YYYY-MM-DD and does not enclose in quotes if value is a Date' do
+        value = Date.today
+        active_query.where('Field__c > ?', value)
+        expect(active_query.to_s).to end_with("(Field__c > #{value.iso8601})")
+      end
+
       it 'complains when there given an incorrect number of bind parameters' do
         expect{
           active_query.where('Field__c = ? AND Other_Field__c = ? AND Name = ?', 123, 321)
@@ -101,6 +144,24 @@ describe ActiveForce::ActiveQuery do
           expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = NULL)")
         end
 
+        it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a DateTime' do
+          value = DateTime.now
+          active_query.where('Field__c < :field', field: value)
+          expect(active_query.to_s).to end_with("(Field__c < #{value.iso8601})")
+        end
+
+        it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a Time' do
+          value = Time.now
+          active_query.where('Field__c < :field', field: value)
+          expect(active_query.to_s).to end_with("(Field__c < #{value.iso8601})")
+        end
+
+        it 'formats as YYYY-MM-DD and does not enclose in quotes if value is a Date' do
+          value = Date.today
+          active_query.where('Field__c < :field', field: value)
+          expect(active_query.to_s).to end_with("(Field__c < #{value.iso8601})")
+        end
+
         it 'accepts multiple bind parameters' do
           active_query.where('Field__c = :field AND Other_Field__c = :other_field AND Name = :name', field: 123, other_field: 321, name: 'Bob')
           expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
@@ -120,6 +181,41 @@ describe ActiveForce::ActiveQuery do
     end
   end
 
+  describe '#where' do
+    before do
+      allow(client).to receive(:query).with("SELECT Id FROM table_name WHERE (Text_Label = 'foo')").and_return(api_result1)
+      allow(client).to receive(:query).with("SELECT Id FROM table_name WHERE (Text_Label = 'foo') AND (Checkbox_Label = true)").and_return(api_result2)
+    end
+    let(:api_result1) do
+      [
+        {"Id" => "0000000000AAAAABBB"},
+        {"Id" => "0000000000CCCCCDDD"},
+        {"Id" => "0000000000EEEEEFFF"}
+      ]
+    end
+    let(:api_result2) do
+      [
+        {"Id" => "0000000000EEEEEFFF"}
+      ]
+    end
+    it 'allows method chaining' do
+      result = active_query.where("Text_Label = 'foo'").where("Checkbox_Label = true")
+      expect(result).to be_a described_class
+    end
+
+    context 'when calling `where` on an ActiveQuery object that already has records' do
+      it 'returns a new ActiveQuery object' do
+        first_active_query = active_query.where("Text_Label = 'foo'")
+        first_active_query.inspect # so the query is executed
+        second_active_query = first_active_query.where("Checkbox_Label = true")
+        second_active_query.inspect
+        expect(second_active_query).to be_a described_class
+        expect(second_active_query).not_to eq first_active_query
+      end
+    end
+
+  end
+
   describe "#find_by" do
     it "should query the client, with the SFDC field names and correctly enclosed values" do
       expect(client).to receive :query
@@ -128,6 +224,50 @@ describe ActiveForce::ActiveQuery do
     end
   end
 
+  describe '#find_by!' do
+    it 'raises if record not found' do
+      allow(client).to receive(:query).and_return(build_restforce_collection)
+      expect { active_query.find_by!(field: 123) }
+        .to raise_error(ActiveForce::RecordNotFound, "Couldn't find #{sobject.table_name} with {:field=>123}")
+    end
+  end
+
+  describe '#find!' do
+    let(:id) { 'test_id' }
+
+    before do
+      allow(client).to receive(:query).and_return(build_restforce_collection([{ 'Id' => id }]))
+    end
+
+    it 'queries for single record by given id' do
+      active_query.find!(id)
+      expect(client).to have_received(:query).with("SELECT Id FROM #{sobject.table_name} WHERE (Id = '#{id}') LIMIT 1")
+    end
+
+    context 'when record is found' do
+      let(:record) { build_restforce_sobject(id: id) }
+
+      before do
+        allow(active_query).to receive(:build).and_return(record)
+      end
+
+      it 'returns the record' do
+        expect(active_query.find!(id)).to eq(record)
+      end
+    end
+
+    context 'when no record is found' do
+      before do
+        allow(client).to receive(:query).and_return(build_restforce_collection)
+      end
+
+      it 'raises RecordNotFound' do
+        expect { active_query.find!(id) }
+          .to raise_error(ActiveForce::RecordNotFound, "Couldn't find #{sobject.table_name} with id #{id}")
+      end
+    end
+  end
+
   describe "responding as an enumerable" do
     before do
       expect(active_query).to receive(:to_a).and_return([])
@@ -147,7 +287,7 @@ describe ActiveForce::ActiveQuery do
     let(:quote_input){ "' OR Id!=NULL OR Id='" }
     let(:backslash_input){ "\\" }
     let(:number_input){ 123 }
-    let(:expected_query){ "SELECT Id FROM table_name WHERE (Backslash_Field__c = '\\\\' AND NumberField = 123 AND QuoteField = ''' OR Id!=NULL OR Id=''')" }
+    let(:expected_query){ "SELECT Id FROM table_name WHERE (Backslash_Field__c = '\\\\' AND NumberField = 123 AND QuoteField = '\\' OR Id!=NULL OR Id=\\'')" }
 
     it 'escapes quotes and backslashes in bind parameters' do
       active_query.where('Backslash_Field__c = :backslash_field AND NumberField = :number_field AND QuoteField = :quote_field', number_field: number_input, backslash_field: backslash_input, quote_field: quote_input)
@@ -161,7 +301,59 @@ describe ActiveForce::ActiveQuery do
 
     it 'escapes quotes and backslashes in hash conditions' do
       active_query.where(backslash_field: backslash_input, number_field: number_input, quote_field: quote_input)
-      expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Backslash_Field__c = '\\\\') AND (NumberField = 123) AND (QuoteField = ''' OR Id!=NULL OR Id=''')")
+      expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Backslash_Field__c = '\\\\') AND (NumberField = 123) AND (QuoteField = '\\' OR Id!=NULL OR Id=\\'')")
+    end
+  end
+
+  describe '#none' do
+    it 'returns a query with a where clause that is impossible to satisfy' do
+      expect(active_query.none.to_s).to eq "SELECT Id FROM table_name WHERE (Id = '111111111111111111') AND (Id = '000000000000000000')"
+    end
+
+    it 'does not query the API' do
+      expect(client).to_not receive :query
+      active_query.none.to_a
+    end
+  end
+
+  describe '#loaded?' do
+    subject { active_query.loaded? }
+
+    before do
+      active_query.instance_variable_set(:@records, records)
+    end
+
+    context 'when there are records loaded in memory' do
+      let(:records) { nil }
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when there are records loaded in memory' do
+      let(:records) { [build_restforce_sobject(id: 1)] }
+
+      it { is_expected.to be_truthy }
+    end
+  end
+
+  describe "#order" do
+    context 'when it is symbol' do 
+      it "should add an order condition with actual SF field name" do
+        expect(active_query.order(:field).to_s).to eq "SELECT Id FROM table_name ORDER BY Field__c"
+      end
+    end
+
+    context 'when it is string - raw soql' do
+      it "should add an order condition same as the string provided" do
+        expect(active_query.order('Field__c').to_s).to eq "SELECT Id FROM table_name ORDER BY Field__c"
+      end
+    end
+
+   context 'when it is multiple columns' do
+    it "should add an order condition with actual SF field name and the provided order type" do
+      expect(active_query.order(:other_field, field: :desc).to_s).to eq "SELECT Id FROM table_name ORDER BY Other_Field, Field__c DESC"
     end
+   end
+    
   end
 end