ooor 2.0.4 → 2.0.5

data/lib/ooor/reflection.rb

@@ -1,18 +1,20 @@
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/object/inclusion'
 
-# NOTE this is a scoped copy of ActiveRecord reflection.rb
-# the few necessary hacks are explicited with a FIXME or a NOTE
-# an addition Ooor specific reflection module completes this one explicitely
 module Ooor
   # = Active Record Reflection
+  # NOTE this is a shrinked copy of ActiveRecord reflection.rb
+  # the few necessary hacks are explicited with a FIXME or a NOTE
+  # an addition Ooor specific reflection module completes this one explicitely
   module Reflection # :nodoc:
     extend ActiveSupport::Concern
 
-    included do
-      class_attribute :reflections
-      self.reflections = {}
-    end
+# NOTE we do the following differently in Ooor because we really don't want to share
+# reflactions between the various sessions!!     
+#    included do
+#      class_attribute :reflections
+#      self.reflections = {}
+#    end
 
     # Reflection enables to interrogate Active Record classes and objects
     # about their associations and aggregations. This information can,

data/lib/ooor/reflection_ooor.rb

@@ -6,11 +6,19 @@ module Ooor
   module ReflectionOoor # :nodoc:
     extend ActiveSupport::Concern
 
-      def column_for_attribute(name)
-        self.class.columns_hash[name.to_s]
-      end
+    def column_for_attribute(name)
+      self.class.columns_hash[name.to_s]
+    end
 
     module ClassMethods
+      def reflections
+        @reflections ||= {}
+      end
+
+      def reflections=(reflections)
+        @reflections = reflections
+      end
+
       def columns_hash(view_fields=nil)
         if view_fields || !@t.columns_hash
           view_fields ||= {}
@@ -30,32 +38,23 @@ module Ooor
       def create_reflection(name)
         reload_fields_definition()
         options = {}
+        relation = all_fields[name]['relation']
+        options[:class_name] = relation
         if many2one_associations.keys.include?(name)
           macro = :belongs_to
-          relation = many2one_associations[name]['relation'] #TODO prefix?
-          const_get(relation)
-          options[:class_name] = relation #TODO or pass it camelized already?
         elsif many2many_associations.keys.include?(name)
           macro = :has_and_belongs_to_many
         elsif one2many_associations.keys.include?(name)
           macro = :has_many
         end
         reflection = Reflection::AssociationReflection.new(macro, name, options, nil)#active_record) #TODO active_record?
-#        case macro
-#          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
-#            klass = options[:through] ? ThroughReflection : AssociationReflection
-#            reflection = klass.new(macro, name, options, active_record)
-#          when :composed_of
-#            reflection = AggregateReflection.new(macro, name, options, active_record)
-#        end
-
         self.reflections = self.reflections.merge(name => reflection)
         reflection
       end
 
       def reflect_on_association(association)
         reflections[association] ||= create_reflection(association.to_s).tap do |reflection|
-          reflection.connection = connection
+          reflection.session = session
         end
       end
     end
@@ -69,7 +68,7 @@ module Ooor
   module Reflection # :nodoc:
 
     class MacroReflection
-      attr_accessor :connection
+      attr_accessor :session
     end
 
     # Holds all the meta-data about an association as it was specified in the
@@ -89,7 +88,8 @@ module Ooor
       # instead. This allows plugins to hook into association object creation.
       def klass
 #        @klass ||= active_record.send(:compute_type, class_name)
-        @klass ||= connection.class_name_from_model_key(class_name).constantize
+#        @klass ||= session.class_name_from_model_key(class_name).constantize
+        @klass = session.const_get(class_name)
       end
 
       def initialize(macro, name, options, active_record)

data/lib/ooor/relation.rb

@@ -4,7 +4,6 @@
 #    Licensed under the MIT license, see MIT-LICENSE file
 
 #TODO chainability of where via scopes
-#TODO include relations for single read
 
 module Ooor
   # = Similar to Active Record Relation

data/lib/ooor/relation/finder_methods.rb

@@ -41,7 +41,7 @@ module Ooor
         #actually finds many resources specified with scope = ids_array
         def find_single(scope, options)
           context = options[:context] || {}
-          reload_fields_definition(false, context)
+          reload_fields_definition(false)
           fields = options[:fields] || options[:only] || fast_fields(options)
           fields += options[:include] if options[:include]
           
@@ -51,7 +51,7 @@ module Ooor
             is_collection, records = read_domain(context, fields, options)
           end
           active_resources = []
-          records.each { |record| active_resources << new(record, [], context, true)}
+          records.each { |record| active_resources << new(record, [], true)}
           if is_collection
             active_resources
           else
@@ -68,12 +68,12 @@ module Ooor
           end
           scope.map! { |item| item_to_id(item, context) }.reject! {|item| !item}
           records = rpc_execute('read', scope, fields, context.dup)
-          records.sort_by! {|r| scope.index(r["id"])} if @connection.config[:force_xml_rpc]
+          records.sort_by! {|r| scope.index(r["id"])} if @session.config[:force_xml_rpc]
           return is_collection, records
         end
         
         def read_domain(context, fields, options)
-          if @connection.config[:force_xml_rpc]
+          if @session.config[:force_xml_rpc]
             domain = to_openerp_domain(options[:domain] || options[:conditions] || [])
             ids = rpc_execute('search', domain, options[:offset] || 0, options[:limit] || false,  options[:order] || false, context.dup)
             records = rpc_execute('read', ids, fields, context.dup)

data/lib/ooor/report.rb

@@ -7,19 +7,19 @@ module Ooor
     module ClassMethods
       #Added methods to obtain report data for a model
       def report(report_name, ids, report_type='pdf', context={}) #TODO move to ReportService
-        context = connection.object.inject_session_context(:report, false, context)[0]
-        uid = @connection.config[:user_id]
-        pass = @connection.config[:password]
-        db = @connection.config[:database]
+        context = session.object.inject_session_context(:report, false, context)[0]
+        uid = @session.config[:user_id]
+        pass = @session.config[:password]
+        db = @session.config[:database]
         params = {model: openerp_model, id: ids[0], report_type: report_type}
-        connection.report.report(db, uid, pass, report_name, ids, params, context)
+        session.report.report(db, uid, pass, report_name, ids, params, context)
       end
 
       def report_get(report_id)
-        uid = @connection.config[:user_id]
-        pass = @connection.config[:password]
-        db = @connection.config[:database]
-        connection.report.report_get(db, uid, pass, report_id)
+        uid = @session.config[:user_id]
+        pass = @session.config[:password]
+        db = @session.config[:database]
+        session.report.report_get(db, uid, pass, report_id)
       end
 
       def get_report_data(report_name, ids, report_type='pdf', context={})

data/lib/ooor/services.rb

@@ -66,7 +66,7 @@ module Ooor
 
     def create(password=@session.config[:db_password], db_name='ooor_test', demo=true, lang='en_US', user_password=@session.config[:password] || 'admin')
       @session.logger.info "creating database #{db_name} this may take a while..."
-      process_id = @session.get_client(:xml, @session.base_url + "/db").call("create", password, db_name, demo, lang, user_password)
+      process_id = @session.get_client(:xml, @session.base_url + "/db").call("create_database", password, db_name, demo, lang, user_password)
       sleep(2)
       while get_progress(password, process_id)[0] != 1
         @session.logger.info "..."

data/lib/ooor/session.rb

@@ -1,38 +1,60 @@
 require 'ooor/services'
+require 'active_support/configurable'
+require 'active_support/core_ext/hash/slice'
 
 module Ooor
-  class Session < SimpleDelegator
+  class Session
+    include ActiveSupport::Configurable
     include Transport
 
-    attr_accessor :web_session, :connection, :id
+    attr_accessor :web_session, :id, :models
 
     def common(); @common_service ||= CommonService.new(self); end
     def db(); @db_service ||= DbService.new(self); end
     def object(); @object_service ||= ObjectService.new(self); end
     def report(); @report_service ||= ReportService.new(self); end
 
-    def initialize(connection, web_session, id)
-      super(connection)
-      @connection = connection
+    def initialize(config, web_session, id)
+      set_config(_config(config))
+      Object.const_set(config[:scope_prefix], Module.new) if config[:scope_prefix]
+      @models = {}
+      @local_context = {}
       @web_session = web_session || {}
       @id = id || web_session[:session_id]
     end
 
+    def set_config(configuration)
+      configuration.each do |k, v|
+        config.send "#{k}=", v
+      end
+    end
+
+    # a part of the config that will be mixed in the context of each session
+    def connection_session
+      HashWithIndifferentAccess.new(config[:connection_session] || {})
+    end
+
     def [](key)
-      @session[key]
+      self[key]
     end
 
     def []=(key, value)
-      @session[key] = value
+      self[key] = value
     end
 
     def global_login(options)
-      config.merge!(options)
+      config.merge!(options.symbolize_keys)
       load_models(config[:models], options[:reload])
     end
 
+    def with_context(context)
+      @local_context = context
+      yield
+      @local_context = {}
+    end
+
     def session_context(context={})
-      connection_session.merge(web_session.slice('lang', 'tz')).merge(context) # not just lang and tz?
+      connection_session.merge(web_session.slice('lang', 'tz')).merge(@local_context).merge(context) # not just lang and tz?
     end
 
     def const_get(model_key, lang=nil);
@@ -56,27 +78,40 @@ module Ooor
 
     def load_models(model_names=config[:models], reload=config[:reload])
       helper_paths.each do |dir|
-        Dir[dir].each { |file| require file }
+        ::Dir[dir].each { |file| require file }
       end
-      domain = model_names ? [['model', 'in', model_names]] : []
-      search_domain = domain - [1]
-      model_ids = object.object_service(:execute, "ir.model", :search, search_domain, 0, false, false, {}, false)
-      models_records = object.object_service(:execute, "ir.model", :read, model_ids, ['model', 'name']) #TODO use search_read
-      models_records.each do |opts|
-        options = HashWithIndifferentAccess.new(opts.merge(scope_prefix: config[:scope_prefix], reload: reload, generate_constants: config[:generate_constants]))
+      search_domain = model_names ? [['model', 'in', model_names]] : []
+      models_records = read_model_data(search_domain)
+      models_records.reject {|opts| opts['model'] == '_unknown' }.each do |opts|
+        options = HashWithIndifferentAccess.new(opts.merge(scope_prefix: config[:scope_prefix],
+                                                           reload: reload,
+                                                           generate_constants: config[:generate_constants]))
         define_openerp_model(options)
       end
     end
 
+    def read_model_data(search_domain)
+      if config[:force_xml_rpc]
+        model_ids = object.object_service(:execute, "ir.model", :search, search_domain, 0, false, false, {}, false)
+        models_records = object.object_service(:execute, "ir.model", :read, model_ids, ['model', 'name'])
+      else
+        response = object.object_service(:search_read, "ir.model", 'search_read', 
+                fields: ['model', 'name'],
+                offset: 0,
+                limit: false,
+                domain: search_domain,
+                sort: false,
+                context: {})
+        models_records = response["records"]
+      end
+    end
+
     def set_model_template!(klass, options)
       template = Ooor.model_registry.get_template(config, options[:model])
       if template
         klass.t = template
-        klass.one2many_associations.keys.each do |meth|
-          klass.define_nested_attributes_method(meth)
-        end
       else
-        template = Ooor::ModelTemplate.new
+        template = Ooor::ModelSchema.new
         template.openerp_model = options[:model]
         template.openerp_id = options[:id]
         template.description = options[:name]
@@ -100,7 +135,7 @@ module Ooor
         set_model_template!(klass, options)
         klass.name = model_class_name
         klass.scope_prefix = scope_prefix
-        klass.connection = self
+        klass.session = self
         if options[:generate_constants] && (options[:reload] || !scope.const_defined?(model_class_name))
           scope.const_set(model_class_name, klass)
         end
@@ -112,9 +147,24 @@ module Ooor
       models[options[:model]]
     end
 
-    def models; @models ||= {}; end
+#    def models; @models ||= {}; end
     
     def logger; Ooor.logger; end
 
+    def helper_paths
+      [File.dirname(__FILE__) + '/helpers/*', *config[:helper_paths]]
+    end
+
+    def class_name_from_model_key(model_key)
+      model_key.split('.').collect {|name_part| name_part.capitalize}.join
+    end
+
+    private
+
+    def _config(config)
+      c = config.is_a?(String) ? Ooor.load_config(config, env) : config #TODO env, see old Connection
+      HashWithIndifferentAccess.new(c)
+    end
+
   end
 end

data/lib/ooor/session_handler.rb

@@ -1,49 +1,45 @@
 require 'active_support/core_ext/hash/indifferent_access'
 require 'ooor/session'
-require 'ooor/connection'
 
 module Ooor
   autoload :SecureRandom, 'securerandom'
+  # The SessionHandler allows to retrieve a session with its loaded proxies to OpenERP
   class SessionHandler
-    def connection_spec(config)
-      HashWithIndifferentAccess.new(config.slice(:url, :username, :password, :database, :scope_prefix, :helper_paths)) #TODO should really password be part of it?
+
+    def noweb_session_spec(config)
+      "#{config[:url]}-#{config[:database]}-#{config[:username]}"
     end
 
     def retrieve_session(config, id=nil, web_session={})
       id ||= SecureRandom.hex(16)
-      if config[:reload] || !s = sessions[id]
-        create_new_session(config, web_session, id)
+      if id == :noweb
+        spec = noweb_session_spec(config)
       else
-        s.tap {|s| s.web_session.merge!(web_session)} #TODO merge config also?
+        spec = id
       end
-    end
-
-    def create_new_session(config, web_session, id=nil)
-      c_spec = connection_spec(config)
-      if connections[c_spec]
-        Ooor::Session.new(connections[c_spec], web_session, id)
+      if config[:reload] || !s = sessions[spec]
+        config = Ooor.default_config.merge(config) if Ooor.default_config.is_a? Hash
+        Ooor::Session.new(config, web_session, id)
+      elsif noweb_session_spec(s.config) != noweb_session_spec(config)
+        config = Ooor.default_config.merge(config) if Ooor.default_config.is_a? Hash
+        Ooor::Session.new(config, web_session, id)
       else
-        Ooor::Session.new(create_new_connection(config, c_spec), web_session, id).tap do |s|
-          connections[c_spec] = s.connection
-        end
+        s.tap {|s| s.web_session.merge!(web_session)} #TODO merge config also?
       end
     end
 
     def register_session(session)
       if session.config[:session_sharing]
         spec = session.web_session[:session_id]
+      elsif session.id != :noweb
+        spec = session.id
       else
-        spec= session.id
+        spec = noweb_session_spec(session.config)
       end
       set_web_session(spec, session.web_session)
       sessions[spec] = session
     end
 
-    def create_new_connection(config, spec)
-      config = Ooor.default_config.merge(config) if Ooor.default_config.is_a? Hash
-      Connection.new(config)
-    end
-
     def reset!
       @sessions = {}
       @connections = {}

data/lib/ooor/type_casting.rb

@@ -107,7 +107,9 @@ module Ooor
         true
       elsif type == 'boolean'&& value == 0 || value == "0"
         false
-      elsif value == false and type != 'boolean'
+      elsif value == false && type != 'boolean'
+        nil
+      elsif (type == 'char' || type == 'text') && value == "" && @attributes[skey] == nil
         nil
       else
         value
@@ -120,13 +122,13 @@ module Ooor
       elsif value.is_a?(Array) && !self.class.many2one_associations.keys.index(skey)
         value.reject {|i| i == ''}.map {|i| i.is_a?(String) ? i.to_i : i}
       elsif value.is_a?(String)
-        sanitize_associatio_as_string(skey, value)
+        sanitize_association_as_string(skey, value)
       else
         value
       end
     end
 
-    def sanitize_associatio_as_string(skey, value)
+    def sanitize_association_as_string(skey, value)
       if self.class.polymorphic_m2o_associations.has_key?(skey)
         value
       elsif self.class.many2one_associations.has_key?(skey)
@@ -145,56 +147,51 @@ module Ooor
     end
 
     def to_openerp_hash
-      attributes, associations = get_changed_values
-      associations = cast_associations_to_openerp(associations)
-      attributes.merge(associations)
+      attribute_keys, association_keys = get_changed_values
+      associations = {}
+      association_keys.each { |k| associations[k] = self.cast_association(k) }
+      @attributes.slice(*attribute_keys).merge(associations)
     end
     
     def get_changed_values
-      attributes = {}
-      associations = {}
-
-      changed.each do |k|
-        if self.class.associations_keys.index(k)
-          associations[k] = @associations[k]#changes[k][1]
-        elsif self.class.fields.has_key?(k)
-          attributes[k]= @attributes[k]
-        elsif !BLACKLIST.index(k)
-          attributes[k] = changes[k][1]
-        end
-      end
-      return attributes, associations
-    end
-
-    def cast_associations_to_openerp(associations=@associations)
-      associations.each do |k, v|
-        associations[k] = self.cast_association(k, v)
-      end
+      attribute_keys = changed.select {|k| self.class.fields.has_key?(k)} - BLACKLIST
+      association_keys = changed.select {|k| self.class.associations_keys.index(k)}
+      return attribute_keys, association_keys
     end
 
     # talk OpenERP cryptic associations API
-    def cast_association(k, v)
+    def cast_association(k)
       if self.class.one2many_associations[k]
-        cast_o2m_assocation(v)
+        if @loaded_associations[k]
+          v = @loaded_associations[k].select {|i| i.changed?}
+          v = @associations[k] if v.empty?
+        else
+          v = @associations[k]
+        end
+        cast_o2m_association(v)
       elsif self.class.many2many_associations[k]
+        v = @associations[k]
         [[6, false, (v || []).map {|i| i.is_a?(Base) ? i.id : i}]]
       elsif self.class.many2one_associations[k]
+        v = @associations[k] # TODO support for nested
         cast_m2o_association(v)
       end
     end
 
-    def cast_o2m_assocation(v)
-      if v.is_a?(Hash)
-        cast_o2m_nested_attributes(v)
-      else
-        v.collect do |value|
-          if value.is_a?(Base)
+    def cast_o2m_association(v)
+      v.collect do |value|
+        if value.is_a?(Base)
+          if value.new_record?
             [0, 0, value.to_openerp_hash]
-          elsif value.is_a?(Hash)
-            [0, 0, value]
-          else
-            [1, value, {}]
+          elsif value.marked_for_destruction?
+            [2, value.id]
+          elsif value.id
+            [1, value.id , value.to_openerp_hash]
           end
+        elsif value.is_a?(Hash)
+          [0, 0, value]
+        else #use case?
+          [1, value, {}]
         end
       end
     end