sugarcrm_emp 0.10.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,29 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+Gemfile.lock
+
+## PROJECT::SPECIFIC
+
+.bundle
+
+lib/sugarcrm/monkey_patches/*.rb
+
+# ignore test config file so each contributor can have his own
+test/config.yaml

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+
+gem "activesupport", ">= 2.3.10", :require => "active_support"
+gem "i18n"
+gem "json"
+gem "httpclient"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+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
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,275 @@
+= SugarCRM
+
+* http://github.com/chicks/sugarcrm
+
+REST Bindings for SugarCRM!  
+
+== SUMMARY: 
+
+A less clunky way to interact with SugarCRM via REST. 
+
+== FEATURES/PROBLEMS:
+
+* Works with all v2 API calls
+* Supports Rails 2 and 3
+* ActiveRecord style finders and objects
+* Supports creation, saving, and deletion of SugarCRM specific objects
+* Flexible extension framework
+* Validations, typecasting, and serialization of boolean, date, and integer fields
+* Query, update and delete records from collections
+* Access API methods directly on the SugarCRM.connection object
+
+== SYNOPSIS:
+
+  require 'sugarcrm'
+  
+  # Establish a connection
+  SugarCRM.connect("http://localhost/sugarcrm", 'user', 'password')
+
+  # 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
+
+  # Show a list of available modules
+  SugarCRM.modules
+
+  # Retrieve a User by user_name
+  users = SugarCRM::User.find_by_user_name("admin")
+  
+  # Return a User instance's SugarCRM URL (also works for any other module instance)
+  users.url
+  
+  # Update a User's title
+  u = SugarCRM::User.find_by_first_name_and_last_name("Will", "Westin")
+  u.title = "Sales Manager Central"
+  u.save
+  
+  # Check if an object is valid (i.e. if it has the required fields to save)
+  u.valid?
+    
+  # Access the errors collection
+  u.errors
+  
+  # Show the fields required to save
+  u.required_attributes
+  
+  # Delete an Account
+  a = SugarCRM::Account.find_by_name("JAB Funds Ltd.")
+  a.delete
+
+  # Retrieve all Email Addresses assigned to a particular User.
+  SugarCRM::User.find_by_user_name('sarah').email_addresses
+  
+  # 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
+    end
+  end
+  
+  # Add a Meeting to a Contact
+  c = SugarCRM::Contact.first
+  c.meetings << SugarCRM::Meeting.new({
+    :name => "Product Introduction", 
+    :date_start => DateTime.now,
+    :duration_hours => 1
+  })
+  c.save!
+  
+  # Add a Contact to an Account
+  a = SugarCRM::Account.find_by_name("JAB Funds Ltd.")
+  c = SugarCRM::Contact.new
+  c.last_name = 'Doe'
+  a.contacts << c
+  a.save # or a.contacts.save
+  
+  # Check if an Account has a specific Contact associated with it
+  c = SugarCRM::Contact.find_by_last_name("Doe")
+  a = SugarCRM::Account.find_by_name("JAB Funds Ltd.")
+  a.contacts.include?(c)
+  
+  # Remove a Contact from an Account
+  c = SugarCRM::Contact.find_by_last_name("Doe")
+  a = SugarCRM::Account.find_by_name("JAB Funds Ltd.")
+  a.contacts.delete(c)
+  a.save # or a.contacts.save
+  
+  # Retrieve the number of accounts in CRM with 'Inc' in their name
+  SugarCRM::Account.count(:conditions => {:name => "LIKE '%Inc'"})
+  
+  # Look up the Case with the smallest case number
+  SugarCRM::Case.first({
+    :order_by => 'case_number'
+  })
+  
+  # Retrieve the first 10 Accounts with a zip code between 10000 and 10500
+  SugarCRM::Account.all({
+    :conditions => { :billing_address_postalcode => ["> '10000'", "<= '10500'" ] },
+    :limit => '10',
+    :order_by => 'billing_address_postalcode'
+  })
+  
+  # Retrieve all Accounts with a zip code
+  SugarCRM::Account.all({
+    :conditions => { :billing_address_postalcode => "<> NULL" }
+  })
+  
+  # Retrieve all Accounts with 'Fund' in their name
+  SugarCRM::Account.all({
+    :conditions => { :name => "LIKE '%Fund%'" } # note that SQL operators must be uppercase
+  })
+
+  # Use block to iterate over results: print all account names
+  SugarCRM::Account.all{|a| puts a.name } # note: this method will be much quicker than SugarCRM::Account.all.each{|a| puts a.name }
+                                          # because records are passed to the block as they get fetched from SugarCRM (whereas `each`
+                                          # will fetch all records, and only then pass them to the block). This will make a major difference
+                                          # in resource use and execution time if you're dealing with many records.
+
+  # Create a document instance and upload a file
+  file = File.read(File.join(File.dirname(__FILE__),"test_excel.xls"))
+  doc = SugarCRM::Document.new
+  doc.active_date = Date.today
+  doc.document_name = "test_excel.xls"
+  doc.filename = "test_excel.xls"
+  doc.revision = 0
+  doc.uploadfile = SugarCRM.connection.b64_encode(file)
+  doc.save!
+  
+  # Look up the fields for a given module
+  SugarCRM::Module.find("Accounts").fields
+  
+  # Look up the relationships for a given module
+  SugarCRM::Module.find("Accounts").link_fields
+  
+  # Use the HTTP Connection and SugarCRM API to load the Admin user
+  SugarCRM.connection.get_entry("Users", 1)
+
+  # Retrieve all Accounts by user name (direct API method)
+  SugarCRM.connection.get_entry_list(
+    "Users",
+    "users.user_name = \'sarah\'",
+    {
+      :link_fields => [
+        {
+          "name"  => "accounts",
+          "value" => ["id", "name"]
+        }
+      ]          
+    } 
+  )
+
+== USING THE GEM WITH RAILS 3
+
+Note: this gem works with Active Support >= 2.3.10, but is optimized for Rails 3.
+
+1. Add the sugarcrm gem to your Gemfile (sugarcrm gem version >= 0.9.12)
+2. Run `bundle install`
+4. Run `rails g sugarcrm:config`
+5. Edit the configuration file in `config/sugarcrm.yml` to match your environment
+
+Example apps:
+* https://github.com/davidsulc/sugar_on_rails_basic
+* https://github.com/davidsulc/dev_zone_basic_rails_app
+
+== 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 add your credentials to one (or more) of
+
+* `/etc/sugarcrm.yaml`
+* `~/.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.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'` (Note: Windows users might need to `require 'rubygems'` before `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.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
+
+If you want to extend 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.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 >= 2.3.10
+* i18n
+* json
+
+== INSTALL:
+
+* sudo gem install sugarcrm
+
+Note: Windows users might need to `require 'rubygems'` before `require 'sugarcrm'`.
+
+== TEST:
+
+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
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Carl Hicks. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "sugarcrm"
+  gem.summary = %Q{A less clunky way to interact with SugarCRM via REST.} 
+  gem.email = "carl.hicks@gmail.com"
+  gem.homepage = "http://github.com/chicks/sugarcrm"
+  gem.authors = ["Carl Hicks", "David Sulc"]
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sugarcrm #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.9.18

data/WATCHLIST.rdoc

@@ -0,0 +1,7 @@
+Each time a new version of SugarCRM comes out, the following should be checked to see whether it is still an issue. Conditional code based on SugarCRM version can be added if SugarCRM patches buggy functionality.
+
+The get_entries_count function does not work properly (always returns 0) if a condition on a custom (i.e. made with studio and ending in _c) is passed
+When functionality is fixed in SugarCRM: add conditional code so InvalidAttribute exception is raised on ly when dealing with broken versions
+
+get_entry_list function 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
+When functionality is fixed in SugarCRM: update comment in find_by_sql to reflect the fix (code can stay as is)

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/rails/generators/sugarcrm/config/config_generator.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Sugarcrm
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      desc 'Creates a SugarCRM gem configuration file at config/sugarcrm.yml, and an initializer at config/initializers/sugarcrm.rb'
+
+      def self.source_root
+        @_sugarcrm_source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def create_config_file
+        template 'sugarcrm.yml', File.join('config', 'sugarcrm.yml')
+      end
+
+      def create_initializer_file
+        template 'initializer.rb', File.join('config', 'initializers', 'sugarcrm.rb')
+      end
+    end
+  end
+end
+

data/lib/rails/generators/sugarcrm/config/templates/initializer.rb

@@ -0,0 +1,4 @@
+# Load the values in config/sugarcrm.yml into a hash
+config_values = SugarCRM::Session.parse_config_file(File.join(Rails.root, 'config', 'sugarcrm.yml'))
+# Connect to appropriate SugarCRM instance (depending on Rails environment)
+SugarCRM::Session.from_hash(config_values[Rails.env.to_sym])

data/lib/rails/generators/sugarcrm/config/templates/sugarcrm.yml

@@ -0,0 +1,19 @@
+development:
+  base_url: http://127.0.0.1/sugarcrm # where your SugarCRM instance is located
+  username: admin
+  password: letmein
+  # connection pool settings
+  # if you don't know what purpose this serves, you can safely ignore these settings
+  # works similarly to Rails' database connection pooling (documented here: http://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/ConnectionPool.html)
+#   pool: 3 # the maximum number of simulatenous connections the gem should open with the SugarCRM server (default is 5)
+#   wait_timeout: 7 # maximum time to wait for an available connection to SugarCRM server, in seconds (default is 5)
+
+test:
+  base_url: http://127.0.0.1/sugarcrm
+  username: admin
+  password: letmein
+
+production:
+  base_url: http://127.0.0.1/sugarcrm
+  username: admin
+  password: letmein

data/lib/sugarcrm/associations/association.rb

@@ -0,0 +1,170 @@
+module SugarCRM
+  
+  # Associations are middlemen between the object that holds the association, known as the @owner, 
+  # and the actual associated object, known as the @target.  Methods are added to the @owner that 
+  # allow access to the association collection, and are held in @proxy_methods.  The cardinality 
+  # of the association is available in @cardinality, and the actual relationship details are held
+  # in @relationship.
+  class Association    
+    attr :owner, true
+    attr :target, true
+    attr :link_field, true
+    attr :relationship, true
+    attr :attributes, true 
+    attr :proxy_methods, true
+    attr :cardinality, true
+    
+    # Creates a new instance of an Association
+    def initialize(owner,link_field,opts={})
+      @options = { :define_methods? => true }.merge! opts
+      @owner = owner
+      check_valid_owner
+      @link_field = link_field
+      @attributes = owner.link_fields[link_field]
+      @relationship = relationship_for(@attributes["relationship"])
+      @proxy_methods = define_methods if @options[:define_methods?]
+      @target = resolve_target
+      @cardinality = resolve_cardinality
+      self
+    end
+
+    # Returns true if the association includes an attribute that matches
+    # the provided string
+    def include?(attribute)
+      return true if attribute.class == @target
+      return true if attribute == link_field
+      return true if methods.include? attribute
+      false
+    end
+    
+    def ==(comparison_object)
+      comparison_object.instance_of?(self.class) &&
+      @target.class == comparison_object.class &&
+      @link_field == comparison_object.link_field
+    end
+    alias :eql? :==
+        
+    def hash
+      "#{@target.class}##{@link_field}".hash
+    end
+    
+    def inspect
+      self
+    end
+    
+    def to_s
+      "#<#{@owner.class.session.namespace_const}::Association @proxy_methods=[#{@proxy_methods.join(", ")}], " +
+      "@link_field=\"#{@link_field}\", @target=#{@target}, @owner=#{@owner.class}, " +
+      "@cardinality=:#{@cardinality}>"
+    end
+    
+    def pretty_print(pp)
+      pp.text self.inspect, 0
+    end
+    
+    protected
+
+    def check_valid_owner
+      valid = @owner.class.ancestors.include? SugarCRM::Base
+      raise InvalidModule, "#{@owner} is not registered, or is not a descendant of SugarCRM::Base" unless valid
+    end
+    
+    # Attempts to determine the class of the target in the association
+    def resolve_target
+      # Use the link_field name first
+      klass = @link_field.singularize.camelize
+      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"], @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 namespace.const_get(klass) if namespace.const_defined? klass
+      end
+
+      if @proxy_methods.is_a? Array
+        if @proxy_methods.last.include? "_1"
+          return namespace.const_get(@proxy_methods.last[0..-3].camelize) if @proxy_methods.last != "securitygroups_1"
+          return namespace.const_get("SecurityGroup")
+        end
+
+        if @proxy_methods.include? "acl_roles"
+          return namespace.const_get("ACLRole")
+        end
+      end
+      false
+    end
+
+    # Defines methods for accessing the association target on the owner class.
+    # If the link_field name includes the owner class name, it is stripped before
+    # creating the method.  If this occurs, we also create an alias to the stripped
+    # method using the full link_field name.
+    def define_methods
+      methods = []
+      pretty_name = @relationship[:target][:name]
+      methods << define_method(@link_field)
+      methods << define_alias(pretty_name, @link_field) if pretty_name != @link_field
+      methods
+    end
+    
+    # Generates the association proxy method for related module
+    def define_method(link_field)
+      raise ArgumentException, "argument cannot be nil" if link_field.nil?
+      if (@owner.respond_to? link_field.to_sym) && @owner.debug
+        warn "Warning: Overriding method: #{@owner.class}##{link_field}"
+      end
+      @owner.class.module_eval %Q?
+        def #{link_field}
+          query_association :#{link_field}
+        end
+      ?
+      link_field
+    end
+    
+    # Defines a method alias.  Checks to see if a method is already defined.
+    def define_alias(alias_name, method_name)
+      @owner.class.module_eval %Q?
+        alias :#{alias_name} :#{method_name}
+      ?
+      alias_name
+    end
+    
+    # This method breaks the relationship into parts and returns them
+    def relationship_for(relationship)
+      # We need to run both regexes, because the plurality of the @owner module name is 
+      # important
+      plural_regex   = /((.*)_)?(#{Regexp.quote(@owner.class._module.name.downcase)})(_(.*))?/
+      singular_regex = /((.*)_)?(#{Regexp.quote(@owner.class._module.name.downcase.singularize)})(_(.*))?/
+      # Break the loop if we match
+      [plural_regex, singular_regex].each {|r| break if relationship.match(r)}
+      # Assign sane values to things if we didnt match
+      o   = $3
+      o   = @owner.class._module.name.downcase if o.nil? || o.empty?
+      t   = [$2, $5].compact.join('_')
+      t   = @link_field if t.nil? || t.empty?
+      # Look up the cardinality
+      o_c, t_c = cardinality_for(o,t)
+      {:owner   => {:name => o, :cardinality => o_c},
+       :target  => {:name => t, :cardinality => t_c}}
+    end
+    
+    # Determines if the provided string is plural or singular
+    # Plurality == Cardinality
+    def cardinality_for(*args)
+      args.inject([]) {|results,arg|
+        result = :many 
+        result = :one if arg.singularize == arg
+        results << result        
+      }
+    end
+    
+    def resolve_cardinality
+      "#{@relationship[:owner][:cardinality]}_to_#{@relationship[:target][:cardinality]}".to_sym
+    end
+  end
+end
+

data/lib/sugarcrm/associations/association_cache.rb

@@ -0,0 +1,36 @@
+module SugarCRM; module AssociationCache
+
+  attr :association_cache, false
+    
+  # Returns true if an association is cached
+  def association_cached?(association)
+    @association_cache.symbolize_keys.include? association.to_sym
+  end
+
+  # 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?
+    @association_cache.values.each do |collection|
+      return true if collection.changed?
+    end
+    false
+  end
+
+  protected
+  
+  # Resets the association cache
+  def clear_association_cache
+    @association_cache = {}.with_indifferent_access
+  end
+end; end