sugarcrm 0.9.10 → 0.9.11

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Carl Hicks
+Copyright (c) 2011 Carl Hicks
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -28,6 +28,9 @@ A less clunky way to interact with SugarCRM via REST.
   # Enable debugging on the current connection
   SugarCRM.connection.debug = true
 
+  # Reload the environment (will make the gem classes reflect changes made on SugarCRM server, such as adding fields)
+  SugarCRM.reload!
+
   # Get the logged in user
   SugarCRM.current_user
 
@@ -61,7 +64,7 @@ A less clunky way to interact with SugarCRM via REST.
   # Retrieve all Email Addresses on an Account
   SugarCRM::Account.find_by_name("JAB Funds Ltd.").contacts.each do |contact|
     contact.email_addresses.each do |email|
-      puts "#{email.email_address}" unless email.opt_out == true
+      puts "#{email.email_address}" unless email.opt_out
     end
   end
   
@@ -145,7 +148,7 @@ If you want to use a configuration file instead of always specifying the url, us
 * `~/.sugarcrm.yaml` (i.e. your home directory on Linux and Mac OSX)
 * a `sugarcrm.yaml` file at the root of you Windows home directory (execute `ENV['USERPROFILE']` in Ruby to see which directory should contain the file)
 * `config/sugarcrm.yaml` (will need to be copied each time you upgrade or reinstall the gem)
-* a YAML file and call `SugarCRM::Environment.load_config` followed by the absolute path to your configuration file
+* a YAML file and call `SugarCRM.load_config` followed by the absolute path to your configuration file
 
 If there are several configuration files, they are loaded sequentially in the order above and will overwrite previous values (if present). This allows you to (e.g.) have a config file in `/etc/sugarcrm.yaml` with system-wide configuration information (such as the url where SugarCRM is located) and/or defaults. Each developer/user can then have his personal configuration file in `~/.sugarcrm.yaml` with his own username and password. A developer could also specify a different location for the SugarCRM instance (e.g. a local testing instance) in his configuration file, which will take precedence over the value in `/etc/sugarcrm.yaml`.
 
@@ -165,10 +168,12 @@ An example, accompanied by instructions, can be found in the `config/sugarcrm.ya
 2.  Require the gem with `require 'sugarcrm'`
 
 3.  * if your login credentials are stored in the `config/sugarcrm.yaml` file, you have been automagically logged in already ;
-    * if your login credentials are stored in a different config file, just call `SugarCRM::Environment.load_config` followed by the absolute path to your config file. This will log you in automatically ;
+    * if your login credentials are stored in a different config file, just call `SugarCRM.load_config` followed by the absolute path to your config file. This will log you in automatically ;
     * if you don't have a configuration file, you can still call the basic `SugarCRM.connect` and give it the proper arguments (see documentation above)
 
 4. You now have full access to the gem's functionality, e.g. `puts SugarCRM::Account.first.name`
+
+5. If you make changes on the SugarCRM server (e.g. adding a field to a module), you can call `SugarCRM.reload!` to rebuild the gem's modules and gain access to the new fields
   
 == EXTENDING THE GEM
 
@@ -176,11 +181,38 @@ If you want to extend the gem's capabilities (e.g. to add methods specific to yo
 
 * drop your `*.rb` files in `lib/sugarcrm/extensions/` (see the README in that folder)
 
-* drop your `*.rb` files in any other folder and call `SugarCRM::Environment.extensions_folder = ` followed by the absolute path to the folder containing your extensions
+* drop your `*.rb` files in any other folder and call `SugarCRM.extensions_folder = ` followed by the absolute path to the folder containing your extensions
+
+== WORKING WITH SIMULTANEOUS SESSIONS
+
+This gem allows you to work with several SugarCRM session simultaneously: on each `SugarCRM.connect` call, a namespace is returned. Make sure you do NOT store this namespace in a reserved name (such as SugarCRM). This namespace can then be used just like you would use the `SugarCRM` module. For example:
+
+    ServerOne = SugarCRM.connect(URL1,...)
+    ServerOne::User.first
+    ServerTwo = SugarCRM.connect(URL2,...)
+    ServerTwo::User.first
+
+If you have only one active session, calls to SugarCRM are delegated to the active session's namespace, like so
+
+    ServerOne = SugarCRM.connect(...)
+    ServerOne::User.first # this call does
+    SugarCRM::User.first # the exact same thing as this one
+
+To replace your session to connect with different credentials, use
+
+    ServerOne.reconnect(...)
+
+Then your session will be reused (SugarCRM modules will be reloaded).
+
+To disconnect an active session:
+
+    ServerOne.disconnect!
 
 == REQUIREMENTS:
 
-* >= activesupport 3.0.0 gem
+* activesupport >= 3.0.0
+* i18n
+* json
 
 == INSTALL:
 
@@ -188,7 +220,7 @@ If you want to extend the gem's capabilities (e.g. to add methods specific to yo
 
 == TEST:
 
-Set the values in `test/helper.rb` to point to a SugarCRM instance with demo data
+Put your credentials in a file called `test/config.yaml` (which you will have to create). These must point to a SugarCRM test instance with demo data. See an example file in `test/config_test.yaml` (leave that file as is).
 
 == Note on Patches/Pull Requests
  

data/Rakefile

@@ -17,6 +17,7 @@ Jeweler::Tasks.new do |gem|
   gem.email = "carl.hicks@gmail.com"
   gem.homepage = "http://github.com/chicks/sugarcrm"
   gem.authors = ["Carl Hicks", "David Sulc"]
+  gem.executables = ['sugarcrm']
 end
 Jeweler::RubygemsDotOrgTasks.new
 

data/VERSION

@@ -1 +1 @@
-0.9.10
+0.9.11

data/bin/sugarcrm

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'irb'
+
+begin
+  require 'sugarcrm'
+rescue LoadError
+  sugarcrm_path = File.join(File.dirname(__FILE__), '..', 'lib')
+  $:.unshift(sugarcrm_path)
+  require 'sugarcrm'
+end
+puts <<-EOF
+Welcome to the SugarCRM Console!
+EOF
+
+IRB.start
+IRB.conf[:PROMPT][:SUGARCRM] = {
+  :PROMPT_C => "SugarCRM :%03n > ", 
+  :AUTO_INDENT=>true, 
+  :RETURN=>" => %s \n", 
+  :PROMPT_I=>"SugarCRM :%03n > ", 
+  :PROMPT_N=>"SugarCRM :%03n?> ", 
+  :PROMPT_S=>"SugarCRM :%03n%l> "
+}
+IRB.conf[:PROMPT_MODE] = :SUGARCRM
+

data/lib/sugarcrm.rb

@@ -8,13 +8,13 @@ require 'rubygems'
 require 'active_support/core_ext'
 require 'json'
 
-require 'sugarcrm/environment'
+require 'sugarcrm/session'
 require 'sugarcrm/module_methods'
 require 'sugarcrm/connection'
 require 'sugarcrm/exceptions'
+require 'sugarcrm/finders'
 require 'sugarcrm/attributes'
 require 'sugarcrm/associations'
-require 'sugarcrm/dynamic_finder_match'
 require 'sugarcrm/module'
 require 'sugarcrm/base'
 

data/lib/sugarcrm/associations/association.rb

@@ -53,9 +53,13 @@ module SugarCRM
     end
     
     def to_s
-      "#<SugarCRM::Association @proxy_methods=[#{@proxy_methods.join(", ")}], " +
+      "#<#{@owner.class.session.namespace_const}::Association @proxy_methods=[#{@proxy_methods.join(", ")}], " +
       "@link_field=\"#{@link_field}\", @target=#{@target}, @owner=#{@owner.class}, " +
-      "@cardinality=#{@cardinality}>"
+      "@cardinality=:#{@cardinality}>"
+    end
+    
+    def pretty_print(pp)
+      pp.text self.inspect, 0
     end
     
     protected
@@ -69,16 +73,17 @@ module SugarCRM
     def resolve_target
       # Use the link_field name first
       klass = @link_field.singularize.camelize
-      return "SugarCRM::#{klass}".constantize if SugarCRM.const_defined? klass
+      namespace = @owner.class.session.namespace_const
+      return namespace.const_get(klass) if namespace.const_defined? klass
       # Use the link_field attribute "module"
       if @attributes["module"].length > 0
-        module_name = SugarCRM::Module.find(@attributes["module"])
-        return "SugarCRM::#{module_name.klass}".constantize if SugarCRM.const_defined? module_name.klass
+        module_name = SugarCRM::Module.find(@attributes["module"], @owner.class.session)
+        return namespace.const_get(module_name.klass) if namespace.const_defined? module_name.klass
       end
       # Use the "relationship" target
       if @attributes["relationship"].length > 0
         klass = @relationship[:target][:name].singularize.camelize
-        return "SugarCRM::#{klass}".constantize if SugarCRM.const_defined? klass
+        return namespace.const_get(klass) if namespace.const_defined? klass
       end
       false
     end
@@ -146,11 +151,9 @@ module SugarCRM
       }
     end
     
-    # TODO: Add Tests for This
     def resolve_cardinality
       "#{@relationship[:owner][:cardinality]}_to_#{@relationship[:target][:cardinality]}".to_sym
     end
-    
   end
 end
 

data/lib/sugarcrm/associations/association_collection.rb

@@ -106,7 +106,7 @@ module SugarCRM
     
     # Loads related records for the given association
     def load_associated_records
-      array = SugarCRM.connection.get_relationships(@owner.class._module.name, @owner.id, @association.to_s)
+      array = @owner.class.session.connection.get_relationships(@owner.class._module.name, @owner.id, @association.to_s)
       @loaded = true
       # we use original to track the state of the collection at start
       @collection = Array.wrap(array).dup

data/lib/sugarcrm/associations/association_methods.rb

@@ -29,7 +29,7 @@ module SugarCRM; module AssociationMethods
     targets = Array.wrap(target)
     targets.each do |t|
       association = @associations.find!(t)
-      response = SugarCRM.connection.set_relationship(
+      response = self.class.session.connection.set_relationship(
         self.class._module.name, self.id, 
         association.link_field, [t.id], opts
       )

data/lib/sugarcrm/attributes/attribute_methods.rb

@@ -32,7 +32,12 @@ module SugarCRM; module AttributeMethods
         # Default to = if we can't resolve the condition.
         operator ||= '=' 
         # Extract value from query
-        value = $3 
+        value = $3
+        if [TrueClass, FalseClass].include? attribute_condition.class
+          # fix value for checkboxes: users can pass true/false as condition, should be converted to '1' or '0' respectively
+          value = (attribute_condition.class == TrueClass ? '1' : '0')
+        end
+        
         # TODO: Write a test for sending invalid attribute names.  
         # strip single quotes
         value = value.strip[/'?([^']*)'?/,1] 
@@ -129,7 +134,7 @@ module SugarCRM; module AttributeMethods
     # Complain if we aren't valid
     raise InvalidRecord, errors.to_a.join(", ") if !valid?
     # Send the save request
-    response = SugarCRM.connection.set_entry(self.class._module.name, serialize_modified_attributes)
+    response = self.class.session.connection.set_entry(self.class._module.name, serialize_modified_attributes)
     # Complain if we don't get a parseable response back
     raise RecordsaveFailed, "Failed to save record: #{self}.  Response was not a Hash" unless response.is_a? Hash
     # Complain if we don't get a valid id back

data/lib/sugarcrm/attributes/attribute_typecast.rb

@@ -6,8 +6,8 @@ module SugarCRM; module AttributeTypeCast
   def attr_type_for(attribute)
     fields = self.class._module.fields
     field  = fields[attribute]
-    raise UninitializedModule, "SugarCRM::Module #{self.class._module.name} was not initialized properly (fields.length == 0)" if fields.length == 0
-    raise InvalidAttribute, "#{self.class}_module.fields does not contain an entry for #{attribute} (of type: #{attribute.class})\nValid fields: #{self.class._module.fields.keys.sort.join(", ")}" if field.nil?
+    raise UninitializedModule, "#{self.class.session.namespace_const}Module #{self.class._module.name} was not initialized properly (fields.length == 0)" if fields.length == 0
+    raise InvalidAttribute, "#{self.class}._module.fields does not contain an entry for #{attribute} (of type: #{attribute.class})\nValid fields: #{self.class._module.fields.keys.sort.join(", ")}" if field.nil?
     raise InvalidAttributeType, "#{self.class}._module.fields[#{attribute}] does not have a key for \'type\'" if field["type"].nil?
     field["type"].to_sym
   end

data/lib/sugarcrm/base.rb

@@ -3,9 +3,6 @@ module SugarCRM; class Base
   # Unset all of the instance methods we don't need.
   instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$|^define_method$|^class$|^nil.$|^methods$|^instance_of.$|^respond_to)/ }
 
-  # This holds our connection
-  cattr_accessor :connection, :instance_writer => false
-
   # Tracks if we have extended our class with attribute methods yet.
   class_attribute :attribute_methods_generated
   self.attribute_methods_generated = false
@@ -16,6 +13,10 @@ module SugarCRM; class Base
   class_attribute :_module
   self._module = nil
   
+  # the session to which we're linked
+  class_attribute :session
+  self.session = nil
+  
   # Contains a list of attributes
   attr :attributes, true
   attr :modified_attributes, true
@@ -24,28 +25,32 @@ module SugarCRM; class Base
   attr :errors, true
 
   class << self # Class methods
-    def establish_connection(url, user, pass, opts={})
-      options = { 
-        :debug  => false,
-        :register_modules => true
-      }.merge(opts)
-      @debug  = options[:debug]
-      @@connection = SugarCRM::Connection.new(url, user, pass, options)
-    end
-    
     def find(*args)
       options = args.extract_options!
+      options = {:order_by => 'date_entered'}.merge(options)
       validate_find_options(options)
 
       case args.first
         when :first
           find_initial(options)
+        when :last
+          begin
+            options[:order_by] = reverse_order_clause(options[:order_by])
+          rescue Exception => e
+            raise
+          end
+          find_initial(options)
         when :all
           Array.wrap(find_every(options)).compact
         else
           find_from_ids(args, options)
       end
     end
+  
+    # return the connection to the correct SugarCRM server (there can be several)
+    def connection
+      self.parent.session.connection
+    end
 
     # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
     # same arguments to this method as you can to <tt>find(:first)</tt>.
@@ -53,13 +58,19 @@ module SugarCRM; class Base
       find(:first, *args)
     end
 
+    # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:last)</tt>.
+    def last(*args)
+      find(:last, *args)
+    end
+
     # This is an alias for find(:all).  You can pass in all the same arguments to this method as you can
     # to find(:all)
     def all(*args)
       find(:all, *args)
     end
     
-    # Creates an object (or multiple objects) and saves it to SugarCRM, if validations pass.
+    # Creates an object (or multiple objects) and saves it to SugarCRM if validations pass.
     # The resulting object is returned whether the object was saved successfully to the database or not.
     #
     # The +attributes+ parameter can be either be a Hash or an Array of Hashes.  These Hashes describe the
@@ -92,226 +103,6 @@ module SugarCRM; class Base
       end
     end
 
-    private 
-    
-    def find_initial(options)
-      options.update(:limit => 1)
-      result = find_by_sql(options)
-      return result.first if result.instance_of? Array # find_by_sql will return an Array if result are found
-      result
-    end
-  
-    def find_from_ids(ids, options)
-      expects_array = ids.first.kind_of?(Array)
-      return ids.first if expects_array && ids.first.empty?
-
-      ids = ids.flatten.compact.uniq
-
-      case ids.size
-        when 0
-          raise RecordNotFound, "Couldn't find #{self._module.name} without an ID"
-        when 1
-          result = find_one(ids.first, options)
-          expects_array ? [ result ] : result
-        else
-          find_some(ids, options)
-      end
-    end
-  
-    def find_one(id, options)
-      if result = SugarCRM.connection.get_entry(self._module.name, id, {:fields => self._module.fields.keys})
-        result
-      else
-        raise RecordNotFound, "Couldn't find #{name} with ID=#{id}#{conditions}"
-      end
-    end
-    
-    def find_some(ids, options)
-      result = SugarCRM.connection.get_entries(self._module.name, ids, {:fields => self._module.fields.keys})
-
-      # Determine expected size from limit and offset, not just ids.size.
-      expected_size =
-        if options[:limit] && ids.size > options[:limit]
-          options[:limit]
-        else
-          ids.size
-        end
-
-      # 11 ids with limit 3, offset 9 should give 2 results.
-      if options[:offset] && (ids.size - options[:offset] < expected_size)
-        expected_size = ids.size - options[:offset]
-      end
-
-      if result.size == expected_size
-        result
-      else
-        raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions} (found #{result.size} results, but was looking for #{expected_size})"
-      end
-    end
-    
-    def find_every(options)
-      find_by_sql(options)
-    end
-        
-    def find_by_sql(options)
-      # SugarCRM REST API has a bug where, when :limit and :offset options are passed simultaneously, :limit is considered to be the smallest of the two, and :offset is the larger
-      # in addition to allowing querying of large datasets while avoiding timeouts,
-      # this implementation fixes the :limit - :offset bug so that it behaves correctly
-      local_options = {}
-      options.keys.each{|k|
-        local_options[k] = options[k]
-      }
-      local_options.delete(:offset) if local_options[:offset] == 0
-      
-      # store the number of records wanted by user, as we'll overwrite :limit option to obtain several slices of records (to avoid timeout issues)
-      nb_to_fetch = local_options[:limit]
-      nb_to_fetch = nb_to_fetch.to_i if nb_to_fetch
-      offset_value = local_options[:offset] || 10 # arbitrary value, must be bigger than :limit used (see comment above)
-      offset_value = offset_value.to_i
-      offset_value.freeze
-      initial_limit = nb_to_fetch.nil?  ? offset_value : [offset_value, nb_to_fetch].min # how many records should be fetched on first pass
-      # ensure results are ordered so :limit and :offset option behave in a deterministic fashion
-      local_options = { :order_by => :id }.merge(local_options)
-      local_options.update(:limit => initial_limit) # override original argument
-      
-      # get first slice of results
-      # note: to work around a SugarCRM REST API bug, the :limit option must always be smaller than the :offset option
-      # this is the reason this first query is separate (not in the loop): the initial query has a larger limit, so that we can then use the loop
-      # with :limit always smaller than :offset
-      results = SugarCRM.connection.get_entry_list(self._module.name, query_from_options(local_options), local_options)
-      return nil unless results
-      results = Array.wrap(results)
-      
-      limit_value = [5, offset_value].min # arbitrary value, must be smaller than :offset used (see comment above)
-      limit_value.freeze
-      local_options = { :order_by => :id }.merge(local_options)
-      local_options.update(:limit => limit_value)
-      
-      # a portion of the results has already been queried
-      # update or set the :offset value to reflect this
-      local_options[:offset] ||= results.size
-      local_options[:offset] += offset_value
-      
-      # continue fetching results until we either
-      # a) have as many results as the user wants (specified via the original :limit option)
-      # b) there are no more results matching the criteria
-      while result_slice = SugarCRM.connection.get_entry_list(self._module.name, query_from_options(local_options), local_options)
-        results.concat(Array.wrap(result_slice))
-        # make sure we don't return more results than the user requested (via original :limit option)
-        if nb_to_fetch && results.size >= nb_to_fetch
-          return results.slice(0, nb_to_fetch)
-        end
-        local_options[:offset] += local_options[:limit] # update :offset as we get more records
-      end
-      results
-    end
-
-    def query_from_options(options)
-      # If we dont have conditions, just return an empty query
-      return "" unless options[:conditions]
-      conditions = []
-      options[:conditions].each do |condition|
-        # Merge the result into the conditions array
-        conditions |= flatten_conditions_for(condition)
-      end
-      conditions.join(" AND ")
-    end
-    
-    # Enables dynamic finders like <tt>find_by_user_name(user_name)</tt> and <tt>find_by_user_name_and_password(user_name, password)</tt>
-    # that are turned into <tt>find(:first, :conditions => ["user_name = ?", user_name])</tt> and
-    # <tt>find(:first, :conditions => ["user_name = ? AND password = ?", user_name, password])</tt> respectively. Also works for
-    # <tt>find(:all)</tt> by using <tt>find_all_by_amount(50)</tt> that is turned into <tt>find(:all, :conditions => ["amount = ?", 50])</tt>.
-    #
-    # It's even possible to use all the additional parameters to +find+. For example, the full interface for +find_all_by_amount+
-    # is actually <tt>find_all_by_amount(amount, options)</tt>.
-    #
-    # Also enables dynamic scopes like scoped_by_user_name(user_name) and scoped_by_user_name_and_password(user_name, password) that
-    # are turned into scoped(:conditions => ["user_name = ?", user_name]) and scoped(:conditions => ["user_name = ? AND password = ?", user_name, password])
-    # respectively.
-    #
-    # Each dynamic finder, scope or initializer/creator is also defined in the class after it is first invoked, so that future
-    # attempts to use it do not run through method_missing.
-    def method_missing(method_id, *arguments, &block)
-      if match = DynamicFinderMatch.match(method_id)
-        attribute_names = match.attribute_names
-        super unless all_attributes_exists?(attribute_names)
-        if match.finder?
-          finder = match.finder
-          bang = match.bang?
-          self.class_eval <<-EOS, __FILE__, __LINE__ + 1
-            def self.#{method_id}(*args)
-              options = args.extract_options!
-              attributes = construct_attributes_from_arguments(
-                [:#{attribute_names.join(',:')}],
-                args
-              )
-              finder_options = { :conditions => attributes }
-              validate_find_options(options)
-
-              #{'result = ' if bang}if options[:conditions]
-                with_scope(:find => finder_options) do
-                  find(:#{finder}, options)
-                end
-              else
-                find(:#{finder}, options.merge(finder_options))
-              end
-              #{'result || raise(RecordNotFound, "Couldn\'t find #{name} with #{attributes.to_a.collect {|pair| "#{pair.first} = #{pair.second}"}.join(\', \')}")' if bang}
-            end
-          EOS
-          send(method_id, *arguments)
-        elsif match.instantiator?
-          instantiator = match.instantiator
-          self.class_eval <<-EOS, __FILE__, __LINE__ + 1
-            def self.#{method_id}(*args)
-              attributes = [:#{attribute_names.join(',:')}]
-              protected_attributes_for_create, unprotected_attributes_for_create = {}, {}
-              args.each_with_index do |arg, i|
-                if arg.is_a?(Hash)
-                  protected_attributes_for_create = args[i].with_indifferent_access
-                else
-                  unprotected_attributes_for_create[attributes[i]] = args[i]
-                end
-              end
-
-              find_attributes = (protected_attributes_for_create.merge(unprotected_attributes_for_create)).slice(*attributes)
-
-              options = { :conditions => find_attributes }
-
-              record = find(:first, options)
-
-              if record.nil?
-                record = self.new(unprotected_attributes_for_create)
-                #{'record.save' if instantiator == :create}
-                record
-              else
-                record
-              end
-            end
-          EOS
-          send(method_id, *arguments, &block)
-        end
-      else
-        super
-      end
-    end
-    
-    def all_attributes_exists?(attribute_names)
-      attribute_names.all? { |name| attributes_from_module.include?(name) }
-    end
-    
-    def construct_attributes_from_arguments(attribute_names, arguments)
-      attributes = {}
-      attribute_names.each_with_index { |name, idx| attributes[name] = arguments[idx] }
-      attributes
-    end
-    
-    VALID_FIND_OPTIONS = [ :conditions, :include, :joins, :limit, :offset,
-                           :order_by, :select, :readonly, :group, :having, :from, :lock ]
-
-    def validate_find_options(options) #:nodoc:
-      options.assert_valid_keys(VALID_FIND_OPTIONS)
-    end
-    
   end
 
   # Creates an instance of a Module Class, i.e. Account, User, Contact, etc.
@@ -363,7 +154,12 @@ module SugarCRM; class Base
     params          = {}
     params[:id]     = serialize_id
     params[:deleted]= {:name => "deleted", :value => "1"}
-    (SugarCRM.connection.set_entry(self.class._module.name, params).class == Hash)       
+    (self.class.connection.set_entry(self.class._module.name, params).class == Hash)       
+  end
+  
+  # Reloads the record from SugarCRM
+  def reload!
+    self.attributes = self.class.find(self.id).attributes
   end
   
   # Returns true if +comparison_object+ is the same exact object, or +comparison_object+ 
@@ -393,13 +189,17 @@ module SugarCRM; class Base
     end
     self.save
   end
-  
+    
   # Delegates to id in order to allow two records of the same type and id to work with something like:
   #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
   def hash
     id.hash
   end
-  
+
+  def pretty_print(pp)
+    pp.text self.inspect, 0
+  end
+
   def attribute_methods_generated?
     self.class.attribute_methods_generated
   end  
@@ -409,6 +209,7 @@ module SugarCRM; class Base
   end
   
   Base.class_eval do
+    extend  FinderMethods::ClassMethods
     include AttributeMethods
     extend  AttributeMethods::ClassMethods
     include AttributeValidations