ooor 1.2.2 → 1.2.3

data/lib/app/models/open_object_resource.rb

@@ -13,13 +13,21 @@ class OpenObjectResource < ActiveResource::Base
 
     cattr_accessor :logger
     attr_accessor :openerp_id, :info, :access_ids, :name, :openerp_model, :field_ids, :state, #model class attributes assotiated to the OpenERP ir.model
-                  :fields, :fields_defined, :many2one_relations, :one2many_relations, :many2many_relations,
+                  :fields, :fields_defined, :many2one_relations, :one2many_relations, :many2many_relations, :relations_keys,
                   :openerp_database, :user_id, :scope_prefix, :ooor
 
     def class_name_from_model_key(model_key=self.openerp_model)
       self.scope_prefix + model_key.split('.').collect {|name_part| name_part.capitalize}.join
     end
 
+    #similar to Object#const_get but for OpenERP model key
+    def const_get(model_key)
+      klass_name = class_name_from_model_key(model_key)
+      klass = Object.const_defined?(klass_name) ? Object.const_get(klass_name) : @ooor.define_openerp_model(model_key, nil, nil, nil, nil, self.scope_prefix)
+      klass.reload_fields_definition unless klass.fields_defined
+      klass
+    end
+
     def reload_fields_definition(force = false)
       if not (self.to_s.match('IrModel') || self.to_s.match('IrModelFields')) and (force or not @fields_defined)#TODO have a way to force reloading @field_ids too eventually
         fields = Object.const_get(self.scope_prefix + 'IrModelFields').find(@field_ids)
@@ -36,6 +44,7 @@ class OpenObjectResource < ActiveResource::Base
             @fields[field.attributes['name']] = field
           end
         end
+        @relations_keys = @many2one_relations.merge(@one2many_relations).merge(@many2many_relations).keys
         logger.info "#{fields.size} fields loaded in model #{self.class}"
       end
       @fields_defined = true
@@ -113,15 +122,7 @@ class OpenObjectResource < ActiveResource::Base
         raise
     end
 
-    def method_missing(method_symbol, *arguments) return self.rpc_execute(method_symbol.to_s, *arguments) end
-
-    def load_relation(model_key, ids, scope_prefix, *arguments)
-      options = arguments.extract_options!
-      class_name = class_name_from_model_key(model_key)
-      @ooor.define_openerp_model(model_key, nil, nil, nil, nil, scope_prefix) unless Object.const_defined?(class_name)
-      relation_model_class = Object.const_get(class_name)
-      relation_model_class.send :find, ids, :fields => options[:fields] || [], :context => options[:context] || {}
-    end
+    def method_missing(method_symbol, *arguments) self.rpc_execute(method_symbol.to_s, *arguments) end
 
 
     # ******************** finders low level implementation ********************
@@ -226,15 +227,13 @@ class OpenObjectResource < ActiveResource::Base
     end
 
     @relations.each do |k, v| #see OpenERP awkward relations API
+      next if v.is_a?(Array) && v.size == 1 && v[0].is_a?(Array) #already casted, possibly before server error!
       new_rel = self.cast_relation(k, v, self.class.one2many_relations, self.class.many2many_relations)
       if new_rel #matches a known o2m or m2m
         @relations[k] = new_rel
       else
         self.class.many2one_relations.each do |k2, field| #try to cast the relation to na inherited o2m or m2m:
-          class_name = self.class.class_name_from_model_key(field.relation)
-          self.class.ooor.define_openerp_model(field.relation, nil, nil, nil, nil, self.class.scope_prefix) unless Object.const_defined?(class_name)
-          linked_class = Object.const_get(class_name)
-          linked_class.reload_fields_definition unless linked_class.fields_defined
+          linked_class = self.class.const_get(field.relation)
           new_rel = self.cast_relation(k, v, linked_class.one2many_relations, linked_class.many2many_relations)
           @relations[k] = new_rel and break if new_rel
         end
@@ -244,7 +243,7 @@ class OpenObjectResource < ActiveResource::Base
 
   def reload_from_record!(record) load(record.attributes, record.relations) end
 
-  def load(attributes, relations={})
+  def load(attributes, relations={})#an attribute might actually be a relation too, will be determined here
     self.class.reload_fields_definition() unless self.class.fields_defined
     raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
     @prefix_options, attributes = split_options(attributes)
@@ -253,8 +252,7 @@ class OpenObjectResource < ActiveResource::Base
     @loaded_relations = {}
     attributes.each do |key, value|
       skey = key.to_s
-      if self.class.many2one_relations.has_key?(skey) || self.class.one2many_relations.has_key?(skey) ||
-         self.class.many2many_relations.has_key?(skey) || value.is_a?(Array)
+      if self.class.relations_keys.index(skey) || value.is_a?(Array)
         relations[skey] = value #the relation because we want the method to load the association through method missing
       else
         case value
@@ -270,6 +268,12 @@ class OpenObjectResource < ActiveResource::Base
     self
   end
 
+  def load_relation(model_key, ids, *arguments)
+    options = arguments.extract_options!
+    related_class = self.class.const_get(model_key)
+    related_class.send :find, ids, :fields => options[:fields] || [], :context => options[:context] || {}
+  end
+
   def display_available_fields
     self.class.logger.debug ""
     self.class.logger.debug "*** DIRECTLY AVAILABLE FIELDS ON OBJECT #{self} ARE: ***\n"
@@ -323,7 +327,7 @@ class OpenObjectResource < ActiveResource::Base
       self.class.logger.info result["warning"]["title"]
       self.class.logger.info result["warning"]["message"]
     end
-    load({field_name => field_value}.merge(result["value"]))
+    load(@attributes.merge({field_name => field_value}).merge(result["value"]), @relations)
   end
 
   #wrapper for OpenERP exec_workflow Business Process Management engine
@@ -337,17 +341,19 @@ class OpenObjectResource < ActiveResource::Base
     OpenObjectWizard.new(wizard_name, result[0], result[1], [self], self.class.ooor.global_context)
   end
 
+  def type() method_missing(:type) end #skips deprecated Object#type method
+
 
   # ******************** fake associations like much like ActiveRecord according to the cached OpenERP data model ********************
 
   def relationnal_result(method_name, *arguments)
     self.class.reload_fields_definition unless self.class.fields_defined
     if self.class.many2one_relations.has_key?(method_name)
-      self.class.load_relation(self.class.many2one_relations[method_name].relation, @relations[method_name][0], self.class.scope_prefix, *arguments)
+      load_relation(self.class.many2one_relations[method_name].relation, @relations[method_name][0], *arguments)
     elsif self.class.one2many_relations.has_key?(method_name)
-      self.class.load_relation(self.class.one2many_relations[method_name].relation, @relations[method_name], self.class.scope_prefix, *arguments)
+      load_relation(self.class.one2many_relations[method_name].relation, @relations[method_name], *arguments)
     elsif self.class.many2many_relations.has_key?(method_name)
-      self.class.load_relation(self.class.many2many_relations[method_name].relation, @relations[method_name], self.class.scope_prefix, *arguments)
+      load_relation(self.class.many2many_relations[method_name].relation, @relations[method_name], *arguments)
     else
       false
     end
@@ -355,28 +361,31 @@ class OpenObjectResource < ActiveResource::Base
 
   def method_missing(method_symbol, *arguments)
     method_name = method_symbol.to_s
-    return super if attributes.has_key?(method_name) or attributes.has_key?(method_name.first(-1))
-    if method_name.end_with?('=') && @relations[method_name.sub('=', '')]
-      @relations[method_name.sub('=', '')] = *arguments
-      return
-    end
+    is_assign = method_name.end_with?('=')
+    method_key = method_name.sub('=', '')
+    return super if attributes.has_key?(method_key)
+    
+    @relations[method_key] = arguments[0] and return if is_assign && self.class.relations_keys.index(method_key)
+    @attributes[method_key] = arguments[0] and return if is_assign && self.class.fields.keys.index(method_key)
+
     return @loaded_relations[method_name] if @loaded_relations.has_key?(method_name)
     return false if @relations.has_key?(method_name) and !@relations[method_name]
 
     result = relationnal_result(method_name, *arguments)
-    if result
-      @loaded_relations[method_name] = result
-      return result
-    elsif !self.class.many2one_relations.empty? #maybe the relation is inherited or could be inferred from a related field
-      self.class.many2one_relations.each do |k, field|
-        if @relations[k]
-          @loaded_relations[k] ||= self.class.load_relation(field.relation, @relations[k][0], self.class.scope_prefix, *arguments)
-          model = @loaded_relations[k]
-          model.loaded_relations[method_name] ||= model.relationnal_result(method_name, *arguments)
-          return model.loaded_relations[method_name] if model.loaded_relations[method_name]
-        end
+    @loaded_relations[method_name] = result and return result if result
+
+    #maybe the relation is inherited or could be inferred from a related field
+    self.class.many2one_relations.each do |k, field| #TODO could be recursive eventually
+      if @relations[k]
+        @loaded_relations[k] ||= load_relation(field.relation, @relations[k][0], *arguments)
+        model = @loaded_relations[k]
+        model.loaded_relations[method_key] ||= model.relationnal_result(method_key, *arguments)
+        return model.loaded_relations[method_key] if model.loaded_relations[method_key]
+      elsif is_assign
+        klazz = self.class.const_get(field.relation)
+        @relations[method_key] = arguments[0] and return if klazz.relations_keys.index(method_key)
+        @attributes[method_key] = arguments[0] and return if klazz.fields.keys.index(method_key)
       end
-      super
     end
 
   rescue

data/lib/app/models/uml.rb

@@ -172,9 +172,9 @@ module UML
 
   def self.get_target(is_reverse, local, enabled_targets, field, model)
     if (is_reverse && !local) || (!enabled_targets) || enabled_targets.index(field.relation)
-      target_name = model.class_name_from_model_key(field.relation)
-      return Object.const_defined?(target_name) ? Object.const_get(target_name) : model.ooor.define_openerp_model(field.relation, nil, nil, nil, nil, model.scope_prefix)
+      model.const_get(field.relation)
+    else
+      false
     end
-    return false
   end
 end

data/lib/ooor.rb

@@ -77,6 +77,7 @@ class Ooor
     klass.many2one_relations = {}
     klass.one2many_relations = {}
     klass.many2many_relations = {}
+    klass.relations_keys = []
     klass.fields = {}
     klass.scope_prefix = scope_prefix
     model_class_name = klass.class_name_from_model_key

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ooor
 version: !ruby/object:Gem::Version 
-  version: 1.2.2
+  version: 1.2.3
 platform: ruby
 authors: 
   - Raphael Valyi - www.akretion.com