sugarcrm 0.9.8 → 0.9.9

data/Gemfile

@@ -2,6 +2,7 @@ source "http://rubygems.org"
 
 gem "activesupport", ">= 3.0.0", :require => "active_support"
 gem "i18n"
+gem "json"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
@@ -9,5 +10,4 @@ group :development do
   gem "shoulda", ">= 0"
   gem "bundler", "~> 1.0.0"
   gem "jeweler", "~> 1.5.2"
-  gem "rcov", ">= 0"
 end

data/README.rdoc

@@ -143,6 +143,46 @@ Instead of SugarCRM.connection.get_entry("Users", "1") you could use SugarCRM::U
     } 
   )
 
+== USING A CONFIGURATION FILE
+
+If you want to use a configuration file instead of always specifying the url, username, and password to connect to SugarCRM, you can either
+
+* add your credentials to `/etc/sugarcrm.yaml`
+* add your credentials to `~/.sugarcrm.yaml`
+* add your credentials to `config/sugarcrm.yaml` (will need to be copied each time you upgrade or reinstall the gem)
+* add your credentials to a YAML file and call `SugarCRM::Environment.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`.
+
+Your configuration should be in YAML format:
+
+    config:
+      base_url: http://127.0.0.1/sugarcrm
+      username: admin
+      password: letmein
+
+An example, accompanied by instructions, can be found in the `config/sugarcrm.yaml` file. In addition, a working example used for testing can be found in `test/config_test.yaml`
+
+== USING THE GEM IN A CONSOLE
+
+1.  Type `irb` in your command prompt
+
+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 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`
+  
+== EXPANDING THE GEM
+
+If you want to expand the gem's capabilities (e.g. to add methods specific to your environment), you can either
+
+* 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
+
 == REQUIREMENTS:
 
 * >= activesupport 3.0.0 gem
@@ -151,6 +191,10 @@ Instead of SugarCRM.connection.get_entry("Users", "1") you could use SugarCRM::U
 
 * sudo gem install sugarcrm
 
+== TEST:
+
+Set the values in `test/helper.rb` to point to a SugarCRM instance with demo data
+
 == Note on Patches/Pull Requests
  
 * Fork the project.

data/Rakefile

@@ -28,12 +28,12 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rcov/rcovtask'
-Rcov::RcovTask.new do |test|
-  test.libs << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
-end
+#require 'rcov/rcovtask'
+#Rcov::RcovTask.new do |test|
+#  test.libs << 'test'
+#  test.pattern = 'test/**/test_*.rb'
+#  test.verbose = true
+#end
 
 task :default => :test
 

data/VERSION

@@ -1 +1 @@
-0.9.8
+0.9.9

data/lib/sugarcrm.rb

@@ -1,10 +1,13 @@
 require 'net/https'
 require 'pp'
 require 'set'
+require 'cgi'
 require 'uri'
 require 'rubygems'
 require 'active_support/core_ext'
+require 'json'
 
+require 'sugarcrm/environment'
 require 'sugarcrm/module_methods'
 require 'sugarcrm/connection'
 require 'sugarcrm/exceptions'

data/lib/sugarcrm/associations/association.rb

@@ -1,12 +1,13 @@
 module SugarCRM
   # Represents an association and it's metadata
   class Association    
-    attr :owner
-    attr :target
-    attr :link_field
-    attr :attributes
-    attr :methods
+    attr :owner, true
+    attr :target, true
+    attr :link_field, true
+    attr :attributes, true 
+    attr :methods, true 
     
+    # TODO: Describe this.
     def initialize(owner,link_field,opts={})
       @options = { :define_methods? => true }.merge! opts
       @owner = owner
@@ -35,11 +36,11 @@ module SugarCRM
     end
     
     # Attempts to determine the class of the target in the association
+    # TODO: Write tests for this.
     def resolve_target
       # Use the link_field name first
       klass = @link_field.singularize.camelize
       return "SugarCRM::#{klass}".constantize if SugarCRM.const_defined? klass
-
       # Use the link_field attribute "module"
       if @attributes["module"].length > 0
         module_name = SugarCRM::Module.find(@attributes["module"])
@@ -54,14 +55,12 @@ module SugarCRM
     end
     
     # Generates the association proxy method for related module
-    def define_method(link_field, pretty_name=nil)
-      pretty_name ||= link_field
+    def define_method(link_field)
       @owner.class.module_eval %Q?
-        def #{pretty_name}
+        def #{link_field}
           query_association :#{link_field}
         end
       ?
-      pretty_name
     end
     
     # Defines methods for accessing the association target on the owner class.
@@ -71,10 +70,10 @@ module SugarCRM
     def define_methods
       methods = []
       pretty_name = humanized_link_name(@link_field)
-      methods << define_method(pretty_name)
+      methods << define_method(@link_field)
       if pretty_name != @link_field
         @owner.class.module_eval %Q?
-          alias :#{@link_field} #{pretty_name}
+          alias :#{pretty_name} #{@link_field}
         ?
         methods << @link_field
       end
@@ -85,18 +84,9 @@ module SugarCRM
     # e.g. if a custom relationship is defined in Studio between Tasks and Documents,
     # the link_field will be `tasks_documents` but a human would call the relationship `documents`
     def humanized_link_name(link_field)
-      # Split the relationship name into parts
-      # "contact_accounts" => ["contact","accounts"]
-      m = link_field.split(/_/)
-      # Determine the parts we don't want
-      # SugarCRM::Contact => ["contacts", "contact"]
-      o = @owner.class._module.table_name
-      # Use array subtraction to remove parts representing the owner side of the relationship
-      # ["contact", "accounts"] - ["contacts", "contact"] => ["accounts"]
-      t = m - [o, o.singularize]
-      # Reassemble whatever's left
-      # "accounts"
-      t.join('_')
+      # the module name is used to function properly with modules containing '_' (e.g. a custom module abc_sale : custom modules need a prefix (abc here) so they will always have a '_' in their table name)
+      return link_field unless link_field.to_s =~ /((.*)_)?#{Regexp.quote(@owner.class._module.name.downcase)}(_(.*))?/
+      [$2, $4].compact.join('_')
     end
     
   end

data/lib/sugarcrm/associations/association_cache.rb

@@ -7,7 +7,17 @@ module SugarCRM; module AssociationCache
     @association_cache.symbolize_keys.include? association.to_sym
   end
 
-  protected
+  # Updates an association cache entry if it's been initialized
+  def update_association_cache_for(association, target, action=:add)
+    return unless association_cached? association
+    case action
+    when :add
+      return if @association_cache[association].collection.include? target
+      @association_cache[association].push(target) # don't use `<<` because overriden method in AssociationCollection gets called instead
+    when :delete      
+      @association_cache[association].delete target
+    end
+  end
 
   # Returns true if an association collection has changed
   def associations_changed?
@@ -17,11 +27,7 @@ module SugarCRM; module AssociationCache
     false
   end
 
-  # Updates an association cache entry if it's been initialized
-  def update_association_cache_for(association, target)
-    # only add to the cache if the relationship has been queried
-    @association_cache[association] << target if association_cached? association
-  end
+  protected
   
   # Resets the association cache
   def clear_association_cache

data/lib/sugarcrm/associations/association_collection.rb

@@ -2,6 +2,8 @@ module SugarCRM
   # A class for handling association collections.  Basically just an extension of Array
   # doesn't actually load the records from Sugar until you invoke one of the public methods
   class AssociationCollection
+  
+    attr_reader :collection
     
     # creates a new instance of an AssociationCollection
     # Owner is the parent object, and association is the target
@@ -66,7 +68,8 @@ module SugarCRM
       record.save! if record.new?
       result = true
       result = false if include?(record)
-      @collection << record
+      @owner.update_association_cache_for(@association, record, :add)
+      record.update_association_cache_for(record.associations.find!(@owner).link_field, @owner, :add)
       result && self
     end
     alias :add :<<

data/lib/sugarcrm/associations/association_methods.rb

@@ -24,7 +24,7 @@ module SugarCRM; module AssociationMethods
   # In contrast to using account.contacts << contact, this method doesn't load the relationships
   # before setting the new relationship.
   # This method is useful when certain modules have many links to other modules: not loading the
-  # relationships allows one ot avoid a Timeout::Error
+  # relationships allows one to avoid a Timeout::Error
   def associate!(target,opts={})
     targets = Array.wrap(target)
     targets.each do |t|
@@ -37,10 +37,25 @@ module SugarCRM; module AssociationMethods
         raise AssociationFailed, 
         "Couldn't associate #{self.class._module.name}: #{self.id} -> #{t}: #{t.id}!" 
       end
-      update_association_cache_for(association.link_field, t)
+      # We need to update the association cache for any changes we make.
+      if opts[:delete]
+        update_association_cache_for(association.link_field, t, :delete)
+        t.update_association_cache_for(association.link_field, self, :delete)
+      else
+        update_association_cache_for(association.link_field, t, :add)
+        t.update_association_cache_for(t.associations.find!(self).link_field, self, :add)
+      end
     end
     true
   end
+  alias :relate! :associate!
+    
+  # Removes a relationship between the current object and the target object
+  # TODO: Write a test for this.
+  def disassociate!(target)
+    associate!(target,{:delete => 1})
+  end
+  alias :unrelate! :disassociate!
     
   protected
 

data/lib/sugarcrm/base.rb

@@ -27,7 +27,7 @@ module SugarCRM; class Base
     def establish_connection(url, user, pass, opts={})
       options = { 
         :debug  => false,
-        :register_modules => true,
+        :register_modules => true
       }.merge(opts)
       @debug  = options[:debug]
       @@connection = SugarCRM::Connection.new(url, user, pass, options)
@@ -96,7 +96,9 @@ module SugarCRM; class Base
     
     def find_initial(options)
       options.update(:limit => 1)
-      find_every(options)
+      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)
@@ -152,8 +154,56 @@ module SugarCRM; class Base
     end
         
     def find_by_sql(options)
-      query = query_from_options(options)
-      SugarCRM.connection.get_entry_list(self._module.name, query, options) || nil # return nil instead of false if no results are found
+      # 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)

data/lib/sugarcrm/config/sugarcrm.yaml

@@ -0,0 +1,10 @@
+# below is an example configuration file
+#
+# to create you own configuration file, simply copy and adapt the text below, removing the '#' in front of the key-value pairs
+#
+# you'll find an example of a configuration file (used for tests) in test/config_test.yaml
+#
+# config:
+#   base_url: http://127.0.0.1/sugarcrm # where your SugarCRM instance is located
+#   username: admin
+#   password: letmein

data/lib/sugarcrm/connection/api/get_document_revision.rb

@@ -10,6 +10,5 @@ module SugarCRM; class Connection
     EOF
     json.gsub!(/^\s{6}/,'')
     SugarCRM::Response.handle(send!(:get_document_revision, json))
-    #send!(:get_document_revision, json)
   end
 end; end

data/lib/sugarcrm/connection/api/get_entries.rb

@@ -14,7 +14,7 @@ module SugarCRM; class Connection
         \"module_name\": \"#{module_name}\"\,
         \"ids\": #{ids.to_json}\,
         \"select_fields\": #{resolve_fields(module_name, options[:fields])}\,
-        \"link_name_to_fields_array\": #{options[:link_fields].to_json}\,
+        \"link_name_to_fields_array\": #{options[:link_fields].to_json}
       }
     EOF
     json.gsub!(/^\s{6}/,'')

data/lib/sugarcrm/connection/api/get_entry.rb

@@ -13,7 +13,7 @@ module SugarCRM; class Connection
         \"module_name\": \"#{module_name}\"\,
         \"id\": \"#{id}\"\,
         \"select_fields\": #{resolve_fields(module_name, options[:fields])}\,
-        \"link_name_to_fields_array\": #{options[:link_fields]}\,
+        \"link_name_to_fields_array\": #{options[:link_fields]}
       }
     EOF
         

data/lib/sugarcrm/connection/api/login.rb

@@ -1,15 +1,15 @@
 module SugarCRM; class Connection
   # Logs the user into the Sugar application.
   def login
-    connect! unless connected?
+    connect! unless connected?    
     json = <<-EOF
       {
-        \"user_auth\": {
-          \"user_name\": \"#{@user}\"\,
-          \"password\": \"#{OpenSSL::Digest::MD5.new(@pass)}\"\,
-          \"version\": \"2\"\,
+        "user_auth": {
+          "user_name": "#{@user}",
+           "password": "#{OpenSSL::Digest::MD5.new(@pass)}",
+            "version": 2
         },
-        \"application\": \"\"
+        "application": "sugarcrm_rubygem"
       }
     EOF
     json.gsub!(/^\s{6}/,'')

data/lib/sugarcrm/connection/connection.rb

@@ -18,7 +18,8 @@ module SugarCRM; class Connection
   def initialize(url, user, pass, options={})
     @options  = {
       :debug => false,
-      :register_modules => true      
+      :register_modules => true,
+      :load_environment => true
     }.merge(options)
     @url      = URI.parse(url)
     @user     = user
@@ -27,6 +28,8 @@ module SugarCRM; class Connection
     @response = ""
     resolve_url
     login!
+    # make sure the environment singleton gets loaded
+    SugarCRM::Environment.instance if @options[:load_environment]
     self
   end
   
@@ -123,12 +126,12 @@ module SugarCRM; class Connection
     return @response.body if RESPONSE_IS_NOT_JSON.include? @request.method
     begin
       # Push it through the old meat grinder.
-      response_json = ActiveSupport::JSON.decode(@response.body)
+      response_json = JSON.parse(@response.body)
     rescue StandardError => e
       raise UnhandledResponse, @response.body
     end
     # Empty result.  Is this wise?
-    return false if response_json["result_count"] == 0
+    return nil if response_json["result_count"] == 0
     # Filter debugging on REALLY BIG responses
     if @options[:debug] && !(DONT_SHOW_DEBUG_FOR.include? @request.method)
       puts "#{@request.method}: JSON Response:"

data/lib/sugarcrm/connection/request.rb

@@ -8,14 +8,14 @@ module SugarCRM; class Request
   def initialize(url, method, json, debug=false)
     @url      = url
     @method   = method
-    @json     = json
+    @json     = CGI.escape(json)
     @request  = 'method=' << @method.to_s
     @request << '&input_type=JSON'
     @request << '&response_type=JSON'
     @request << '&rest_data=' << @json
     if debug
       puts "#{method}: Request:"
-      puts @request 
+      puts json 
       puts "\n"
     end
     self
@@ -26,6 +26,6 @@ module SugarCRM; class Request
   end
   
   def to_s
-    URI.escape(@request)
+    @request
   end
 end; end

data/lib/sugarcrm/connection/response.rb

@@ -17,9 +17,8 @@ module SugarCRM; class Response
         if SugarCRM.connection.debug?
           puts "Failed to process JSON:"
           pp json
-          raise e
         end
-        return json
+        raise e
       end
     end
   end
@@ -36,7 +35,7 @@ module SugarCRM; class Response
   # populated from the response
   def to_obj
     # If this is not a "entry_list" response, just return
-    return @response unless @response["entry_list"]
+    return @response unless @response && @response["entry_list"]
     
     objects = []
     @response["entry_list"].each do |object|

data/lib/sugarcrm/environment.rb

@@ -0,0 +1,48 @@
+require 'singleton'
+
+module SugarCRM; class Environment
+  include Singleton
+  
+  attr_reader :config
+  
+  def initialize
+    @config = {}
+    
+    # see README for reasoning behind the priorization
+    ['/etc/sugarcrm.yaml', File.expand_path('~/.sugarcrm.yaml'), File.join(File.dirname(__FILE__), 'config', 'sugarcrm.yaml')].each{|path|
+      load_config path if File.exists? path
+    }
+    extensions_folder = File.join(File.dirname(__FILE__), 'extensions')
+    SugarCRM::Base.establish_connection(@config[:base_url], @config[:username], @config[:password], {:load_environment => false}) if SugarCRM.connection.nil? && connection_info_loaded?
+  end
+  
+  def connection_info_loaded?
+    @config[:base_url] && @config[:username] && @config[:password]
+  end
+  
+  def load_config(path)
+    validate_path path
+    config = YAML.load_file(path)
+    if config && config["config"]
+      config["config"].each{|k,v|
+        @config[k.to_sym] = v
+      }
+    end
+  end
+  
+  # load all the monkey patch extension files in the provided folder
+  def extensions_folder=(folder, dirstring=nil)
+    validate_path folder
+    path = File.expand_path(folder, dirstring)
+    Dir[File.join(path, '**', '*.rb').to_s].each { |f| load(f) }
+  end
+  
+  def self.method_missing(method_id, *args, &block)
+    self.instance.send(method_id, *args, &block)
+  end
+  
+  private
+  def validate_path(path)
+    raise "Invalid path: #{path}" unless File.exists? path
+  end
+end; end

data/lib/sugarcrm/extensions/README.txt

@@ -0,0 +1,23 @@
+# Include your extension files here, as simple *.rb files. Here is an example of an extension:
+
+SugarCRM::Contact.class_eval do
+  def self.ten_oldest
+    self.find(:order_by => 'date_entered', :limit => 10)
+  end
+  
+  def vip?
+    self.opportunities.size > 100
+  end
+end
+
+# This will enable you to call
+
+SugarCRM::Contact.ten_oldest
+
+# to get the 10 oldest contacts entered in CRM .
+# 
+# You will also be able to call
+
+SugarCRM::Contact.first.vip?
+
+# to see whether a contact is VIP or not.

data/lib/sugarcrm/module.rb

@@ -15,7 +15,11 @@ module SugarCRM
     def initialize(name)
       @name   = name
       @klass  = name.classify
-      @table_name = name.tableize
+      unless custom_module?
+        @table_name = name.tableize
+      else
+        @table_name = @name
+      end
       @custom_table_name = resolve_custom_table_name      
       @fields = {}
       @link_fields = {}
@@ -36,8 +40,11 @@ module SugarCRM
     # For custom modules (created in the Studio), table name don't need to be tableized since
     # the name passed to the constructor is already tableized    
     def resolve_custom_table_name
-      @custom_table_name = @table_name + "_cstm"
-      @custom_table_name = @name + "_cstm" if custom_module?
+      if custom_module?
+        @custom_table_name = @name + "_cstm"
+      else
+        @custom_table_name = @table_name + "_cstm"
+      end
     end
     
     # Returns the fields associated with the module

data/lib/sugarcrm/module_methods.rb

@@ -7,7 +7,7 @@ module SugarCRM
   def self.connection=(connection)
     @@connection = connection
   end
-  def self.connect(url, user, pass, options={})
+  def self.connect(url=SugarCRM::Environment.config[:base_url], user=SugarCRM::Environment.config[:username], pass=SugarCRM::Environment.config[:password], options={})
     SugarCRM::Base.establish_connection(url, user, pass, options)
   end
   class << self
@@ -26,4 +26,21 @@ module SugarCRM
     SugarCRM::User.find_by_user_name(connection.user)
   end
   
+  # If a user tries to access a SugarCRM class before they're logged in,
+  # try to log in using credentials from config file.
+  # This will trigger module loading,
+  # and we can then attempt to return the requested class automagically
+  def self.const_missing(sym)
+    # if we're logged in, modules should be loaded and available
+    if SugarCRM.connection && SugarCRM.connection.logged_in?
+      super
+    else
+      # here, we initialize the environment (which happens on any method call, if singleton hasn't already been initialized)
+      # initializing the environment will log user in if credentials present in config file
+      # if it isn't possible to log in and access modules, pass the exception on
+      super unless SugarCRM::Environment.connection_info_loaded?
+      # try and return the requested module
+      SugarCRM.const_get(sym)
+    end
+  end
 end

data/test/config_test.yaml

@@ -0,0 +1,15 @@
+# below is an example configuration file
+#
+# to create you own configuration file, simply copy and adapt the text below, removing the '#' in front of the key-value pairs
+#
+# you'll find an example of a configuration file (used for tests) in test/config_test.yaml
+#
+# config:
+#   base_url: http://127.0.0.1/sugarcrm # where your SugarCRM instance is located
+#   username: admin
+#   password: letmein
+
+config:
+  base_url: http://127.0.0.1/sugarcrm # where your SugarCRM instance is located
+  username: admin
+  password: letmein

data/test/extensions_test/patch.rb

@@ -0,0 +1,9 @@
+SugarCRM::Contact.class_eval do
+  def self.is_extended?
+    true
+  end
+  
+  def is_extended?
+    true
+  end
+end

data/test/test_association.rb

@@ -1 +1,18 @@
-#TODO: Figure out how to test this.
+#TODO: Figure out how to test this.
+
+
+# That code works, but what didn't work:
+# document.tasks.size
+# document.associate!(task)
+# document.tasks.size
+# This seems to be fixed in HEAD in my repo. I haven't pushed the changes to your repo, because I don't really see why commit https://github.com/davidsulc/sugarcrm/commit/228375348c9113324370afa0aca4120eb117d3e1 fixes the issue...
+# Also, I fixed this case
+# document.tasks.size
+# document.associate!(task)
+# document.tasks.size # => 1 (correct)
+# document.associate!(task)
+# document.tasks.size # => 2 (incorrect: should remain 1)
+# One thing we should look into is
+# document.associate!(task)
+# document.tasks.size # => 1
+# task.documents.size # => 0 (should be 1)

data/test/test_environment.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+class TestEnvironment < Test::Unit::TestCase
+  context "A SugarCRM::Environment singleton" do
+    
+    should "delegate missing methods to singleton instance" do
+      assert_equal SugarCRM::Environment.instance.config, SugarCRM::Environment.config
+    end
+
+    should "load monkey patch extensions" do
+      SugarCRM::Environment.extensions_folder = File.join(File.dirname(__FILE__), 'extensions_test')
+      assert SugarCRM::Contact.is_extended?
+      assert SugarCRM::Contact.is_extended?
+    end
+    
+    should "load config file" do
+      SugarCRM::Environment.load_config File.join(File.dirname(__FILE__), 'config_test.yaml')
+      
+      config_contents = { 
+        :config => {
+                      :base_url => 'http://127.0.0.1/sugarcrm',
+                      :username => 'admin',
+                      :password => 'letmein'
+                   }
+      }
+      
+      config_contents[:config].each{|k,v|
+        assert_equal v, SugarCRM::Environment.config[k]
+      }
+    end
+    
+    should "log in to Sugar automatically if credentials are present in config file" do
+      SugarCRM::Environment.load_config File.join(File.dirname(__FILE__), 'config_test.yaml')
+      assert SugarCRM.connection.logged_in?
+    end
+  end
+  
+end

data/test/test_sugarcrm.rb

@@ -52,28 +52,26 @@ class TestSugarCRM < Test::Unit::TestCase
     end
 
     should "not save a record that is missing required attributes" do
-      SugarCRM.connection.debug = false
       u = SugarCRM::User.new
       u.last_name = "Test"
       assert !u.save
-      SugarCRM.connection.debug = false
       assert_raise SugarCRM::InvalidRecord do
         u.save!
       end
     end
 
     should "always return an Array when :all" do
-      users = SugarCRM::User.all
+      users = SugarCRM::User.all(:limit => 10)
       assert_instance_of Array, users
       users = SugarCRM::User.find(:all, :conditions => {:user_name => '= admin'})
       assert_instance_of Array, users
+      assert users.length == 1
       users = SugarCRM::User.find(:all, :conditions => {:user_name => '= invalid_user_123'})
       assert_instance_of Array, users
       assert users.length == 0
     end
 
     should "create, modify, and delete a record" do
-      #SugarCRM.connection.debug = true
       u = SugarCRM::User.new
       u.email1 = "abc@abc.com"
       u.first_name = "Test"
@@ -85,10 +83,10 @@ class TestSugarCRM < Test::Unit::TestCase
       assert u.save!
       assert !u.new?
       m = SugarCRM::User.find_by_first_name_and_last_name("Test", "User")
+      assert m.user_name != "admin"
       m.title = "Test User"
       assert m.save!
       assert m.delete
-      #SugarCRM.connection.debug = false
     end
     
     should "support finding first instance (sorted by attribute)" do
@@ -126,7 +124,48 @@ class TestSugarCRM < Test::Unit::TestCase
     
     should "return an array of records when sent #find([id1, id2, id3])" do
       users = SugarCRM::User.find(["seed_sarah_id", 1])
-      assert_equal "Administrator", users.last.title
+      assert_equal "admin", users.last.user_name
+    end
+    
+    # test Base#find_by_sql edge case
+    should "return an array of records with small limit and an offset of 0" do
+      accounts = SugarCRM::Account.all(:limit => 3, :offset => 0)
+      assert_equal 3, accounts.size
+    end
+    
+    # test Base#find_by_sql standard case
+    should "return an array of records with high limit" do
+      accounts = SugarCRM::Account.all(:limit => 12)
+      assert_equal 12, accounts.size
+    end
+    
+    should "return an array of records when using :order_by, :limit, and :offset options" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 3, :offset => 10)
+      accounts_api = SugarCRM.connection.get_entry_list('Accounts', '1=1', :order_by => 'name', :limit => 3, :offset => 10)
+      assert_equal accounts_api, accounts
+    end
+    
+    should "return an array of records working around a SugarCRM bug when :limit > :offset" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 10, :offset => 2)
+      assert_equal 10, accounts.size
+    end
+    
+    should "return an array of 1 record with :limit => 1, :offset => 1" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 1, :offset => 1)
+      assert_equal 1, accounts.size
+    end
+    
+    should "ignore :offset => 0" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 3)
+      accounts_offset = SugarCRM::Account.all(:order_by => 'name', :limit => 3, :offset => 0)
+      assert_equal accounts, accounts_offset
+    end
+    
+    should "compute offsets correctly" do
+      accounts = SugarCRM::Account.all(:order_by => 'name', :limit => 10, :offset => 3)
+      accounts_first_slice = SugarCRM::Account.all(:order_by => 'name', :limit => 5, :offset => 3)
+      accounts_second_slice = SugarCRM::Account.all(:order_by => 'name', :limit => 5, :offset => 8)
+      assert_equal accounts, accounts_first_slice.concat(accounts_second_slice)
     end
     
     should "return an instance of User when sent User#find_by_username" do
@@ -143,12 +182,64 @@ class TestSugarCRM < Test::Unit::TestCase
       assert a.delete
     end
     
-#    should "support saving of records with special characters in them" do
-#      a = SugarCRM::Account.new
-#      a.name = "COHEN, WEISS & SIMON LLP"
-#      assert a.save!
-#    end
-    
+    should "update association cache on associate! only if association changes" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      a.associate!(c)
+      assert_equal nb_contacts + 1, a.contacts.size
+      a.associate!(c)
+      assert_equal nb_contacts + 1, a.contacts.size # should not change: already associated
+      
+      c.delete
+    end
+    
+    should "update association cache on << only if association changes" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      a.contacts  << c
+      assert_equal nb_contacts + 1, a.contacts.size
+      a.contacts  << c
+      assert_equal nb_contacts + 1, a.contacts.size # should not change: already associated
+      
+      c.delete
+    end
+    
+    should "update association cache for both sides of the relationship when calling associate!" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      nb_accounts = c.accounts.size
+      a.associate!(c)
+      assert_equal nb_contacts + 1, a.contacts.size
+      assert_equal nb_accounts + 1, c.accounts.size
+      
+      c.delete
+    end
+    
+    should "update association cache for both sides of the relationship when calling <<" do
+      a = SugarCRM::Account.first
+      c = SugarCRM::Contact.create(:last_name => 'Doe')
+      
+      nb_contacts = a.contacts.size
+      nb_accounts = c.accounts.size
+      a.contacts  << c
+      assert_equal nb_contacts + 1, a.contacts.size
+      assert_equal nb_accounts + 1, c.accounts.size
+      
+      c.delete
+    end
+    
+    should "support saving of records with special characters in them" do
+      a = SugarCRM::Account.new
+      a.name = "COHEN, WEISS & SIMON LLP"
+      assert a.save!
+      assert a.delete
+    end
   end
   
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sugarcrm
 version: !ruby/object:Gem::Version 
+  hash: 41
   prerelease: false
   segments: 
   - 0
   - 9
-  - 8
-  version: 0.9.8
+  - 9
+  version: 0.9.9
 platform: ruby
 authors: 
 - Carl Hicks
@@ -14,93 +15,99 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-18 00:00:00 -08:00
+date: 2011-01-30 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
+  type: :runtime
+  prerelease: false
   name: activesupport
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 3
         - 0
         - 0
         version: 3.0.0
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
   type: :runtime
   prerelease: false
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
   name: i18n
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
   type: :runtime
   prerelease: false
-  version_requirements: *id002
+  name: json
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id003
 - !ruby/object:Gem::Dependency 
+  type: :development
+  prerelease: false
   name: shoulda
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
   type: :development
   prerelease: false
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
   name: bundler
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 23
         segments: 
         - 1
         - 0
         - 0
         version: 1.0.0
+  requirement: *id005
+- !ruby/object:Gem::Dependency 
   type: :development
   prerelease: false
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
   name: jeweler
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  version_requirements: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 1
         - 5
         - 2
         version: 1.5.2
-  type: :development
-  prerelease: false
-  version_requirements: *id005
-- !ruby/object:Gem::Dependency 
-  name: rcov
-  requirement: &id006 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  prerelease: false
-  version_requirements: *id006
+  requirement: *id006
 description: A less clunky way to interact with SugarCRM via REST.  Instead of SugarCRM.connection.get_entry("Users", "1") you could use SugarCRM::User.find(1).  There is support for collections a la SugarCRM::User.find(1).email_addresses, or SugarCRM::Contact.first.meetings << new_meeting.  ActiveRecord style finders are in place, with limited support for conditions and joins.
 email: carl.hicks@gmail.com
 executables: []
@@ -130,6 +137,7 @@ files:
 - lib/sugarcrm/attributes/attribute_typecast.rb
 - lib/sugarcrm/attributes/attribute_validations.rb
 - lib/sugarcrm/base.rb
+- lib/sugarcrm/config/sugarcrm.yaml
 - lib/sugarcrm/connection.rb
 - lib/sugarcrm/connection/api/get_available_modules.rb
 - lib/sugarcrm/connection/api/get_document_revision.rb
@@ -160,9 +168,12 @@ files:
 - lib/sugarcrm/connection/request.rb
 - lib/sugarcrm/connection/response.rb
 - lib/sugarcrm/dynamic_finder_match.rb
+- lib/sugarcrm/environment.rb
 - lib/sugarcrm/exceptions.rb
+- lib/sugarcrm/extensions/README.txt
 - lib/sugarcrm/module.rb
 - lib/sugarcrm/module_methods.rb
+- test/config_test.yaml
 - test/connection/test_get_available_modules.rb
 - test/connection/test_get_entries.rb
 - test/connection/test_get_entry.rb
@@ -175,11 +186,13 @@ files:
 - test/connection/test_login.rb
 - test/connection/test_logout.rb
 - test/connection/test_set_relationship.rb
+- test/extensions_test/patch.rb
 - test/helper.rb
 - test/test_association.rb
 - test/test_association_collection.rb
 - test/test_associations.rb
 - test/test_connection.rb
+- test/test_environment.rb
 - test/test_module.rb
 - test/test_response.rb
 - test/test_sugarcrm.rb
@@ -197,7 +210,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -1258950620288984122
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -206,6 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -229,11 +243,13 @@ test_files:
 - test/connection/test_login.rb
 - test/connection/test_logout.rb
 - test/connection/test_set_relationship.rb
+- test/extensions_test/patch.rb
 - test/helper.rb
 - test/test_association.rb
 - test/test_association_collection.rb
 - test/test_associations.rb
 - test/test_connection.rb
+- test/test_environment.rb
 - test/test_module.rb
 - test/test_response.rb
 - test/test_sugarcrm.rb