ooor 2.0.4 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7013e218cfc09bfb4c0711c65904076f14f6e9d
-  data.tar.gz: 37e409fe1330084c5ada2b5051c92381577febe1
+  metadata.gz: 68bb22d821a0337958de6835edebec32672e31d5
+  data.tar.gz: e515ccba848078b48a39b2ab22dae262dd717bda
 SHA512:
-  metadata.gz: 09af180037d24d0008ef92c4365fa81ca9fbb503b8f07045cb1fd18e134785ddb72b8aff170c9a2c51e136b0422b6e630bef2f534f038702b0821de92254060c
-  data.tar.gz: 2330653e660fd06751bc4bfd1ab79bfe9107b37ae441a2a98bb80ee3a85839046cd14146b4d86fa7bcf9e7d5b5cb5c714b70a7cf34fd08d120a0980d929c847c
+  metadata.gz: 070ab8305192ceaa8c77c959c656c89bdd06f2250e3818a2ed088f5a6920bfda147420d583e748d5ceb2ddfec0dbe7f826ea37bf068bc92cbc2a8784028fd294
+  data.tar.gz: fdf089b8708e2e6912945976f3d85bf328af15e62bbe8e48e08553ddc0bd8887c2ca06b788ee389831424df8a70fec0a17ec5919e1feee3bfd6fe4fef73ea39a

data/lib/ooor.rb

@@ -12,7 +12,10 @@ require 'logger'
 module Ooor
   extend ActiveSupport::Autoload
   autoload :Base
+  autoload :ModelSchema
   autoload :Persistence
+  autoload :AutosaveAssociation
+  autoload :NestedAttributes
   autoload :Callbacks
   autoload :Cache, 'active_support/cache'
   autoload :Serialization
@@ -96,8 +99,10 @@ module Ooor
     end
 
 
-    def with_ooor_session(config={}, id=nil)
-      yield Ooor.session_handler.retrieve_session(config, id)
+    def with_ooor_session(config={}, id=:noweb)
+      session = Ooor.session_handler.retrieve_session(config, id)
+      Ooor.session_handler.register_session(session)
+      yield session
     end
 
     def with_ooor_default_session(config={})

data/lib/ooor/associations.rb

@@ -26,25 +26,49 @@ module Ooor
 
     # fakes associations like much like ActiveRecord according to the cached OpenERP data model
     def relationnal_result(method_name, *arguments)
-      self.class.reload_fields_definition(false, object_session)
+      self.class.reload_fields_definition(false)
       if self.class.many2one_associations.has_key?(method_name)
-        if !@associations[method_name]
-          nil
-        else
-          id = @associations[method_name].is_a?(Integer) ? @associations[method_name] : @associations[method_name][0]
-          rel = self.class.many2one_associations[method_name]['relation']
-          self.class.const_get(rel).find(id, arguments.extract_options!)
-        end
-      elsif self.class.polymorphic_m2o_associations.has_key?(method_name) && @associations[method_name]
+        load_m2o_association(method_name, *arguments)
+      elsif self.class.polymorphic_m2o_associations.has_key?(method_name)# && @associations[method_name]
+        load_polymorphic_m2o_association(method_name, *arguments)
+#        values = @associations[method_name].split(',')
+#        self.class.const_get(values[0]).find(values[1], arguments.extract_options!)
+      else # o2m or m2m
+        load_x2m_association(method_name, *arguments)
+      end
+    end
+
+    private
+
+    def load_polymorphic_m2o_association(method_name, *arguments)
+      if @associations[method_name]
         values = @associations[method_name].split(',')
         self.class.const_get(values[0]).find(values[1], arguments.extract_options!)
-      else # o2m or m2m
-        rel = self.class.all_fields[method_name]['relation']
-        load_x2m_association(rel, @associations[method_name], *arguments)
+      else
+        false
+      end
+    end
+
+    def load_m2o_association(method_name, *arguments)
+      if !@associations[method_name]
+        nil
+      else
+        if @associations[method_name].is_a?(Integer)
+          id = @associations[method_name]
+          display_name = nil
+        else
+          id = @associations[method_name][0]
+          display_name = @associations[method_name][1]
+        end
+        rel = self.class.many2one_associations[method_name]['relation']
+        self.class.const_get(rel).new({id: id, _display_name: display_name}, [], true, false, true)
+#        self.class.const_get(rel).find(id, arguments.extract_options!)
       end
     end
 
-    def load_x2m_association(model_key, ids, *arguments)
+    def load_x2m_association(method_name, *arguments)
+      model_key = self.class.all_fields[method_name]['relation']
+      ids = @associations[method_name] || []
       options = arguments.extract_options!
       related_class = self.class.const_get(model_key)
       CollectionProxy.new(related_class, {}).apply_finder_options(options.merge(ids: ids))      

data/lib/ooor/autosave_association.rb

@@ -0,0 +1,197 @@
+require 'ostruct'
+require 'active_support/concern'
+
+module Ooor
+  # = Ooor Autosave Association, adapted from ActiveRecord 4.1
+  #
+  # +AutosaveAssociation+ is a module that takes care of automatically saving
+  # associated records when their parent is saved. In addition to saving, it
+  # also destroys any associated records that were marked for destruction.
+  # (See +mark_for_destruction+ and <tt>marked_for_destruction?</tt>).
+  #
+  # Saving of the parent, its associations, and the destruction of marked
+  # associations, all happen inside a transaction. This should never leave the
+  # database in an inconsistent state.
+  #
+  # If validations for any of the associations fail, their error messages will
+  # be applied to the parent (TODO)
+  module AutosaveAssociation
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      private
+
+        # same as ActiveRecord
+        def define_non_cyclic_method(name, &block)
+          define_method(name) do |*args|
+            result = true; @_already_called ||= {}
+            # Loop prevention for validation of associations
+            unless @_already_called[name]
+              begin
+                @_already_called[name]=true
+                result = instance_eval(&block)
+              ensure
+                @_already_called[name]=false
+              end
+            end
+
+            result
+          end
+        end
+
+        # Adds validation and save callbacks for the association as specified by
+        # the +reflection+.
+        #
+        # For performance reasons, we don't check whether to validate at runtime.
+        # However the validation and callback methods are lazy and those methods
+        # get created when they are invoked for the very first time. However,
+        # this can change, for instance, when using nested attributes, which is
+        # called _after_ the association has been defined. Since we don't want
+        # the callbacks to get defined multiple times, there are guards that
+        # check if the save or validation methods have already been defined
+        # before actually defining them.
+        def add_autosave_association_callbacks(reflection) # TODO add support for m2o
+          save_method = :"autosave_associated_records_for_#{reflection.name}"
+          validation_method = :"validate_associated_records_for_#{reflection.name}"
+          collection = true #reflection.collection?
+          unless method_defined?(save_method)
+            if collection
+              before_save :before_save_collection_association
+              define_non_cyclic_method(save_method) { save_collection_association(reflection) }
+              before_save save_method
+              # NOTE Ooor is different from ActiveRecord here: we run the nested callbacks before saving
+              # the whole hash of values including the nested records
+              # Doesn't use after_save as that would save associations added in after_create/after_update twice
+#              after_create save_method
+#              after_update save_method
+            else
+              raise raise ArgumentError, "Not implemented in Ooor; seems OpenERP won't support such nested attribute in the same transaction anyhow"
+            end
+          end
+
+          if reflection.validate? && !method_defined?(validation_method)
+            method = (collection ? :validate_collection_association : :validate_single_association)
+            define_non_cyclic_method(validation_method) { send(method, reflection) }
+            validate validation_method
+          end
+        end
+    end
+
+    # Reloads the attributes of the object as usual and clears <tt>marked_for_destruction</tt> flag.
+    def reload(options = nil)
+      @marked_for_destruction = false
+      @destroyed_by_association = nil
+      super
+    end
+
+    # Marks this record to be destroyed as part of the parents save transaction.
+    # This does _not_ actually destroy the record instantly, rather child record will be destroyed
+    # when <tt>parent.save</tt> is called.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    def mark_for_destruction
+      @marked_for_destruction = true
+    end
+
+    # Returns whether or not this record will be destroyed as part of the parents save transaction.
+    #
+    # Only useful if the <tt>:autosave</tt> option on the parent is enabled for this associated model.
+    def marked_for_destruction?
+      @marked_for_destruction
+    end
+
+    # Records the association that is being destroyed and destroying this
+    # record in the process.
+    def destroyed_by_association=(reflection)
+      @destroyed_by_association = reflection
+    end
+
+    # Returns the association for the parent being destroyed.
+    #
+    # Used to avoid updating the counter cache unnecessarily.
+    def destroyed_by_association
+      @destroyed_by_association
+    end
+
+    # Returns whether or not this record has been changed in any way (including whether
+    # any of its nested autosave associations are likewise changed)
+    def changed_for_autosave?
+      new_record? || changed? || marked_for_destruction? # TODO || nested_records_changed_for_autosave?
+    end
+
+    private
+
+      # Returns the record for an association collection that should be validated
+      # or saved. If +autosave+ is +false+ only new records will be returned,
+      # unless the parent is/was a new record itself.
+      def associated_records_to_validate_or_save(association, new_record, autosave)
+        if new_record
+          association && association.target
+        elsif autosave
+          association.target.find_all { |record| record.changed_for_autosave? }
+        else
+          association.target.find_all { |record| record.new_record? }
+        end
+      end
+
+      # go through nested autosave associations that are loaded in memory (without loading
+      # any new ones), and return true if is changed for autosave
+#      def nested_records_changed_for_autosave?
+#        self.class.reflect_on_all_autosave_associations.any? do |reflection|
+#          association = association_instance_get(reflection.name)
+#          association && Array.wrap(association.target).any? { |a| a.changed_for_autosave? }
+#        end
+#      end
+
+      # Is used as a before_save callback to check while saving a collection
+      # association whether or not the parent was a new record before saving.
+      def before_save_collection_association
+        @new_record_before_save = new_record?
+        true
+      end
+
+      # Saves any new associated records, or all loaded autosave associations if
+      # <tt>:autosave</tt> is enabled on the association.
+      #
+      # In addition, it destroys all children that were marked for destruction
+      # with mark_for_destruction.
+      #
+      # This all happens inside a transaction, _if_ the Transactions module is included into
+      # ActiveRecord::Base after the AutosaveAssociation module, which it does by default.
+      def save_collection_association(reflection)
+#        if association = association_instance_get(reflection.name)
+        if target = @loaded_associations[reflection.name] #TODO use a real Association wrapper
+          association = OpenStruct.new(target: target)
+          autosave = reflection.options[:autosave]
+
+          if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+             # NOTE saving the object with its nested associations will properly destroy records in OpenERP
+             # no need to do it now like in ActiveRecord
+            records.each do |record|
+              next if record.destroyed?
+
+              saved = true
+
+              if autosave != false && (@new_record_before_save || record.new_record?)
+                if autosave
+#                  saved = association.insert_record(record, false)
+                  record.run_callbacks(:save) { false }
+                  record.run_callbacks(:create) { false }
+#                else
+#                  association.insert_record(record) unless reflection.nested?
+                end
+              elsif autosave
+                record.run_callbacks(:save) {false}
+                record.run_callbacks(:update) {false}
+#                saved = record.save(:validate => false)
+              end
+
+            end
+          end
+          # reconstruct the scope now that we know the owner's id
+#          association.reset_scope if association.respond_to?(:reset_scope)
+        end
+      end
+
+  end
+end

data/lib/ooor/base.rb

@@ -12,36 +12,19 @@ require 'ooor/errors'
 
 module Ooor
 
-  # meta data shared across sessions, a cache of the data in ir_model in OpenERP.
-  # reused accross workers in a multi-process web app (via memcache for instance).
-  class ModelTemplate
-
-    TEMPLATE_PROPERTIES = [:name, :openerp_id, :info, :access_ids, :description,
-      :openerp_model, :field_ids, :state, :fields,
-      :many2one_associations, :one2many_associations, :many2many_associations,
-      :polymorphic_m2o_associations, :associations_keys,
-      :associations, :columns]
-
-      attr_accessor *TEMPLATE_PROPERTIES, :columns_hash
-  end
-
   # the base class for proxies to OpenERP objects
   class Base < Ooor::MiniActiveResource
     include Naming, TypeCasting, Serialization, ReflectionOoor, Reflection
-    include Associations, Report, FinderMethods, FieldMethods
+    include Associations, Report, FinderMethods, FieldMethods, AutosaveAssociation, NestedAttributes
 
     # ********************** class methods ************************************
     class << self
 
-      attr_accessor  :name, :connection, :t, :scope_prefix #template
-      delegate *ModelTemplate::TEMPLATE_PROPERTIES, to: :t
+      attr_accessor :name, :session, :t, :scope_prefix
+      delegate *ModelSchema::TEMPLATE_PROPERTIES, to: :t
 
       # ******************** remote communication *****************************
 
-      def create(attributes = {}, context={}, default_get_list=false, reload=true)
-        self.new(attributes, default_get_list, context).tap { |resource| resource.save(context, reload) }
-      end
-
       #OpenERP search method
       def search(domain=[], offset=0, limit=false, order=false, context={}, count=false)
         rpc_execute(:search, to_openerp_domain(domain), offset, limit, order, context, count)
@@ -60,8 +43,12 @@ module Ooor
       end
 
       def object_service(service, obj, method, *args)
-        reload_fields_definition(false, connection.connection_session)
-        cast_answer_to_ruby!(connection.object.object_service(service, obj, method, *cast_request_to_openerp(args)))
+        reload_fields_definition(false)
+        cast_answer_to_ruby!(session.object.object_service(service, obj, method, *cast_request_to_openerp(args)))
+      end
+
+      def context
+        session.session_context
       end
 
       def method_missing(method_symbol, *args)
@@ -71,8 +58,6 @@ module Ooor
 
       # ******************** AREL Minimal implementation ***********************
 
-      def relation(context={}); @relation ||= Relation.new(self, context); end #TODO template
-      def scoped(context={}); relation(context); end
       def where(opts, *rest); relation.where(opts, *rest); end
       def all(*args); relation.all(*args); end
       def limit(value); relation.limit(value); end
@@ -83,18 +68,22 @@ module Ooor
       
       def logger; Ooor.logger; end
 
+      private
+
+      def relation; @relation ||= Relation.new(self); end
+
     end
 
     self.name = "Base"
 
     # ********************** instance methods **********************************
 
-    attr_accessor :associations, :loaded_associations, :ir_model_data_id, :object_session
+    attr_accessor :associations, :loaded_associations, :ir_model_data_id
 
     include Persistence, Callbacks, ActiveModel::Dirty
 
     def rpc_execute(method, *args)
-      args += [self.class.connection.connection_session.merge(object_session)] unless args[-1].is_a? Hash
+      args += [self.class.context] unless args[-1].is_a? Hash
       self.class.object_service(:execute, self.class.openerp_model, method, *args)
     end
 
@@ -111,8 +100,8 @@ module Ooor
 
     #wrapper for OpenERP exec_workflow Business Process Management engine
     def wkf_action(action, context={}, reload=true)
-      self.class.object_service(:exec_workflow, self.class.openerp_model, action, self.id, object_session)
-      reload_fields(context) if reload
+      self.class.object_service(:exec_workflow, self.class.openerp_model, action, self.id, context)
+      reload_fields if reload
     end
 
     #Add get_report_data to obtain [report["result"],report["format]] of a concrete openERP Object
@@ -124,6 +113,10 @@ module Ooor
 
     private
 
+    def context
+      self.class.context
+    end
+
     # Ruby 1.9.compat, See also http://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary/
     def to_ary; nil; end # :nodoc:
 

data/lib/ooor/errors.rb

@@ -25,7 +25,7 @@ module Ooor
         return ValueError.new(method, faultCode, faultString, *args)
       elsif faultCode =~ /ValidateError/
         return ValidationError.new(method, faultCode, faultString, *args)
-      elsif faultCode =~ /AccessDenied/
+      elsif faultCode =~ /AccessDenied/ || faultCode =~ /Access Denied/
         return UnAuthorizedError.new(method, faultCode, faultString, *args)
       elsif faultCode =~ /AuthenticationError: Credentials not provided/
         return InvalidSessionError.new(method, faultCode, faultString, *args)

data/lib/ooor/field_methods.rb

@@ -6,7 +6,7 @@ module Ooor
 
     module ClassMethods
 
-      def reload_fields_definition(force=false, context=connection.web_session)
+      def reload_fields_definition(force=false)
         if force || !fields
           @t.fields = {}
           @columns_hash = {}
@@ -14,7 +14,7 @@ module Ooor
           fields_get.each { |k, field| reload_field_definition(k, field) }
           @t.associations_keys = many2one_associations.keys + one2many_associations.keys + many2many_associations.keys + polymorphic_m2o_associations.keys
           logger.debug "#{fields.size} fields loaded in model #{self.name}"
-          Ooor.model_registry.set_template(connection.config, @t)
+          Ooor.model_registry.set_template(session.config, @t)
         end
         generate_accessors if fields != {} && (force || !@accessor_defined) #TODOmove in define_accessors method
       end
@@ -30,44 +30,28 @@ module Ooor
         end
       end
       
-      # this is used by fields_for in ActionView FormHelper
-      def define_nested_attributes_method(meth)
-        unless self.respond_to?(meth)
-          self.instance_eval do
-            define_method "#{meth}_attributes=" do |*args|
-              send("#{meth}_will_change!")
-              @associations[meth] = args[0]
-              @loaded_associations[meth] = args[0]
-            end
-            define_method "#{meth}_attributes" do |*args|
-              @loaded_associations[meth]
-            end
-          end
-        end
-      end
-
       private
 
       def generate_accessors #TODO we should cache this is a module cached like the template, or eventually generate source code or both
         fields.keys.each { |meth| define_field_method meth }
         associations_keys.each { |meth| define_association_method meth }
-        one2many_associations.keys.each { |meth| define_nested_attributes_method meth }
+        one2many_associations.keys.each { |meth| accepts_nested_attributes_for meth } #TODO do it for m2o too
         many2one_associations.keys.each do |meth|
           define_association_method meth
           define_m2o_association_method meth
         end
         (one2many_associations.keys + many2many_associations.keys).each do |meth|
           define_association_method meth
-          alias_method "#{meth}_ids", meth
           alias_method "#{meth}_ids=", "#{meth}="
-          alias_method "#{meth.to_s.singularize}_ids", meth
           alias_method "#{meth.to_s.singularize}_ids=", "#{meth}="
+          define_x2m_ids_association_method meth
+          alias_method "#{meth.to_s.singularize}_ids", "#{meth}_ids"
         end
         @accessor_defined = true
       end
 
       def define_field_method(meth)
-        define_attribute_methods meth
+        define_attribute_method meth
         define_method meth do |*args|
           get_attribute(meth, *args)
         end
@@ -78,7 +62,7 @@ module Ooor
       end
 
       def define_association_method(meth)
-        define_attribute_methods meth
+        define_attribute_method meth
         define_method meth do |*args|
           get_association(meth, *args)
         end
@@ -88,6 +72,12 @@ module Ooor
         end
       end
 
+      def define_x2m_ids_association_method(meth)
+        define_method "#{meth}_ids" do |*args|
+          @associations[meth]
+        end
+      end
+
       def define_m2o_association_method(meth)
         define_method "#{meth}_id" do |*args|
           if @associations[meth].is_a? Array
@@ -116,12 +106,31 @@ module Ooor
 
     end
 
+    attr_accessor :_display_name
+    alias _name _display_name
+
+    def _destroy=(dummy)
+      @marked_for_destruction = true unless dummy.blank? || ["false", "0", 0].index(dummy)
+    end
+
+    def _destroy
+      @marked_for_destruction
+    end
+
+    def lazy_load(meth, *args)
+      @lazy = false
+      load(rpc_execute('read', [id], (self.class.fast_fields + [meth]).uniq, *args || context)[0]).tap do
+        @lazy = false
+      end
+    end
+
     def get_attribute(meth, *args)
+      lazy_load(meth, *args) if @lazy
       if @attributes.has_key?(meth)
         @attributes[meth]
       else #lazy loading
         if @attributes["id"]
-          @attributes[meth] = rpc_execute('read', [@attributes["id"]], [meth], *args || object_session)[0][meth]
+          @attributes[meth] = rpc_execute('read', [@attributes["id"]], [meth], *args || context)[0][meth]
         else
           nil
         end
@@ -137,16 +146,17 @@ module Ooor
 
     def get_association(meth, *args)
       return @associations[meth] || :undef if @skip
+      lazy_load(meth, *args) if @lazy
       if @loaded_associations.has_key?(meth)
         @loaded_associations[meth]
       elsif @associations.has_key?(meth)
         @loaded_associations[meth] = relationnal_result(meth, *args)
       else
         if @attributes["id"]
-          @associations[meth] = rpc_execute('read', [@attributes["id"]], [meth], *args || object_session)[0][meth]
+          @associations[meth] = rpc_execute('read', [@attributes["id"]], [meth], *args || context)[0][meth]
           @loaded_associations[meth] = relationnal_result(meth, *args)
         elsif self.class.one2many_associations.has_key?(meth) || self.class.many2many_associations.has_key?(meth)
-          load_x2m_association(self.class.all_fields[meth]['relation'], [], *args)
+          load_x2m_association(meth, [], *args)
         else
           nil
         end
@@ -185,7 +195,7 @@ module Ooor
 #    end
 
     def method_missing(method_symbol, *arguments)
-      self.class.reload_fields_definition(false, object_session)
+      self.class.reload_fields_definition(false)
       if id
         rpc_execute(method_symbol, [id], *arguments) #we assume that's an action
       else