ooor 2.0.3 → 2.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7013e218cfc09bfb4c0711c65904076f14f6e9d
+  data.tar.gz: 37e409fe1330084c5ada2b5051c92381577febe1
+SHA512:
+  metadata.gz: 09af180037d24d0008ef92c4365fa81ca9fbb503b8f07045cb1fd18e134785ddb72b8aff170c9a2c51e136b0422b6e630bef2f534f038702b0821de92254060c
+  data.tar.gz: 2330653e660fd06751bc4bfd1ab79bfe9107b37ae441a2a98bb80ee3a85839046cd14146b4d86fa7bcf9e7d5b5cb5c714b70a7cf34fd08d120a0980d929c847c

data/README.md

@@ -1,4 +1,5 @@
 [![Build Status](https://secure.travis-ci.org/akretion/ooor.png?branch=master)](http://travis-ci.org/akretion/ooor) [![Code Climate](https://codeclimate.com/github/akretion/ooor.png)](https://codeclimate.com/github/akretion/ooor)
+[![Coverage Status](https://coveralls.io/repos/akretion/ooor/badge.png?branch=master)](https://coveralls.io/r/akretion/ooor?branch=master) [![Gem Version](https://badge.fury.io/rb/ooor.png)](http://badge.fury.io/rb/ooor) [![Dependency Status](https://www.versioneye.com/ruby/ooor/badge.png)](https://www.versioneye.com/ruby/ooor)
 
 [![OOOR by Akretion](https://s3.amazonaws.com/akretion/assets/ooor_by_akretion.png)](http://akretion.com)
 

data/bin/ooor

@@ -41,6 +41,7 @@ unless ARGV.empty?
     system "stty -echo"
     password = $stdin.gets.chomp!
     system "stty echo"
+    password = 'admin' if password.blank?
   end
   
 else

data/lib/ooor.rb

@@ -12,6 +12,8 @@ require 'logger'
 module Ooor
   extend ActiveSupport::Autoload
   autoload :Base
+  autoload :Persistence
+  autoload :Callbacks
   autoload :Cache, 'active_support/cache'
   autoload :Serialization
   autoload :Relation

data/lib/ooor/associations.rb

@@ -1,63 +1,53 @@
 module Ooor
   module Associations
 
-    def many2one_id_method(rel, *arguments)
-      if @associations[rel]
-        @associations[rel][0]
-      else
-        obj = method_missing(rel.to_sym, *arguments)
-        obj.is_a?(Base) ? obj.id : obj
+    # similar to ActiveRecord CollectionProxy but without lazy loading work yet
+    class CollectionProxy < Relation
+
+      def to_ary
+        to_a.dup
+      end
+#      alias_method :to_a, :to_ary
+
+      def class
+        Array
       end
-    end
 
-    def x_to_many_ids_method(rel, *arguments)
-      if @associations[rel]
-        @associations[rel]
-      else
-        method_missing(rel.to_sym, *arguments)
+      def is_a?(*args)
+        @records.is_a?(*args)
       end
+
+      def kind_of?(*args)
+        @records.kind_of?(*args)
+      end
+
     end
 
+
     # 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)
       if self.class.many2one_associations.has_key?(method_name)
-        if @associations[method_name]
-          rel = self.class.many2one_associations[method_name]['relation']
-          id = @associations[method_name].is_a?(Integer) ? @associations[method_name] : @associations[method_name][0]
-          load_association(rel, id, nil, *arguments)
+        if !@associations[method_name]
+          nil
         else
-          false
+          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.one2many_associations.has_key?(method_name)
-        rel = self.class.one2many_associations[method_name]['relation']
-        load_association(rel, @associations[method_name], [], *arguments)
-      elsif self.class.many2many_associations.has_key?(method_name)
-        rel = self.class.many2many_associations[method_name]['relation']
-        load_association(rel, @associations[method_name], [], *arguments)
-      elsif self.class.polymorphic_m2o_associations.has_key?(method_name)
+      elsif self.class.polymorphic_m2o_associations.has_key?(method_name) && @associations[method_name]
         values = @associations[method_name].split(',')
-        load_association(values[0], values[1].to_i, nil, *arguments)
-      else
-        false
+        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)
       end
     end
 
-    def load_association(model_key, ids, substitute=nil, *arguments)
+    def load_x2m_association(model_key, ids, *arguments)
       options = arguments.extract_options!
       related_class = self.class.const_get(model_key)
-      fields = options[:fields] || options[:only] || nil
-      context = options[:context] || object_session
-      (related_class.send(:find, ids, fields: fields, context: context) || substitute).tap do |r|
-        #TODO the following is a hack to minimally mimic the CollectionProxy of Rails 3.1+; this should probably be re-implemented
-        def r.association=(association)
-          @association = association
-        end
-        r.association = related_class
-        def r.build(attrs={})
-          @association.new(attrs)
-        end
-      end
+      CollectionProxy.new(related_class, {}).apply_finder_options(options.merge(ids: ids))      
     end
 
   end

data/lib/ooor/base.rb

@@ -1,27 +1,34 @@
 #    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2013 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-2014 Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #    Licensed under the MIT license, see MIT-LICENSE file
 
-require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/module/delegation.rb'
+require 'active_model/attribute_methods'
+require 'active_model/dirty'
 require 'ooor/reflection'
 require 'ooor/reflection_ooor'
+require 'ooor/errors'
 
 module Ooor
-  class ModelTemplate #meta data shared across sessions
-    TEMPLATE_PROPERTIES = [:openerp_id, :info, :access_ids, :description,
+
+  # 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, :columns_hash]
-    attr_accessor *TEMPLATE_PROPERTIES
-  end
+      :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
-    #PREDEFINED_INHERITS = {'product.product' => 'product_tmpl_id'}
-    include Naming, TypeCasting, Serialization, ReflectionOoor, Reflection, Associations, Report, FinderMethods, FieldMethods
-
+    include Naming, TypeCasting, Serialization, ReflectionOoor, Reflection
+    include Associations, Report, FinderMethods, FieldMethods
 
     # ********************** class methods ************************************
     class << self
@@ -71,6 +78,8 @@ module Ooor
       def limit(value); relation.limit(value); end
       def order(value); relation.order(value); end
       def offset(value); relation.offset(value); end
+      def first(*args); relation.first(*args); end
+      def last(*args); relation.last(*args); end
       
       def logger; Ooor.logger; end
 
@@ -82,90 +91,13 @@ module Ooor
 
     attr_accessor :associations, :loaded_associations, :ir_model_data_id, :object_session
 
+    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
       self.class.object_service(:execute, self.class.openerp_model, method, *args)
     end
 
-    def load(attributes, remove_root=false, persisted=false)#an attribute might actually be a association too, will be determined here
-      self.class.reload_fields_definition(false, object_session)
-      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
-      @prefix_options, attributes = split_options(attributes)
-      @associations ||= {}
-      @attributes ||= {}
-      @loaded_associations = {}
-      attributes.each do |key, value|
-        skey = key.to_s
-        if self.class.associations_keys.index(skey) || value.is_a?(Array) #FIXME may miss m2o with inherits!
-          if value.is_a?(Ooor::Base) || value.is_a?(Array) && value.all? {|i| i.is_a?(Ooor::Base)}
-            @loaded_associations[skey] = value #we want the method to load the association through method missing
-          else
-            @associations[skey] = value
-          end
-        else
-          @attributes[skey] = value || nil #don't bloat with false values
-        end
-      end
-      self
-    end
-
-    #takes care of reading OpenERP default field values.
-    def initialize(attributes = {}, default_get_list=false, context={}, persisted=false)
-      @attributes = {}
-      @prefix_options = {}
-      @ir_model_data_id = attributes.delete(:ir_model_data_id)
-      @object_session = {}
-      @object_session = HashWithIndifferentAccess.new(context)
-      @persisted = persisted
-      self.class.reload_fields_definition(false, @object_session)
-      if default_get_list == []
-        load(attributes)
-      else
-        load_with_defaults(attributes, default_get_list)
-      end
-    end
-
-    def save(context={}, reload=true)
-      new? ? create(context, reload) : update(context, reload)
-    rescue ValidationError => e
-      e.extract_validation_error!(errors)
-      return false
-    end
-
-    #compatible with the Rails way but also supports OpenERP context
-    def create(context={}, reload=true)
-      self.id = rpc_execute('create', to_openerp_hash, context)
-      if @ir_model_data_id
-        IrModelData.create(model: self.class.openerp_model,
-          'module' => @ir_model_data_id[0],
-          'name' => @ir_model_data_id[1],
-          'res_id' => self.id)
-      end
-      reload_from_record!(self.class.find(self.id, context: context)) if reload
-      @persisted = true
-    end
-
-    def update_attributes(attributes, context={}, reload=true)
-      load(attributes, false) && save(context, reload)
-    end
-
-    #compatible with the Rails way but also supports OpenERP context
-    def update(context={}, reload=true) #TODO use http://apidock.com/rails/ActiveRecord/Dirty to minimize data to save back
-      rpc_execute('write', [self.id], to_openerp_hash, context)
-      reload_fields(context) if reload
-      @persisted = true
-    end
-
-    #compatible with the Rails way but also supports OpenERP context
-    def destroy(context={})
-      rpc_execute('unlink', [self.id], context)
-    end
-
-    #OpenERP copy method, load persisted copied Object
-    def copy(defaults={}, context={})
-      self.class.find(rpc_execute('copy', self.id, defaults, context), context: context)
-    end
-
     #Generic OpenERP rpc method call
     def call(method, *args) rpc_execute(method, *args) end
 
@@ -192,31 +124,8 @@ module Ooor
 
     private
 
-    def load_with_defaults(attributes, default_get_list)
-      defaults = rpc_execute("default_get", default_get_list || self.class.fields.keys + self.class.associations_keys, object_session.dup)
-      attributes = HashWithIndifferentAccess.new(defaults.merge(attributes.reject {|k, v| v.blank? }))
-      load(attributes)
-    end
-      
-    def load_on_change_result(result, field_name, field_value)
-      if result["warning"]
-        self.class.logger.info result["warning"]["title"]
-        self.class.logger.info result["warning"]["message"]
-      end
-      attrs = @attributes.merge(field_name => field_value)
-      attrs.merge!(result["value"])
-      load(attrs)
-    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:
 
-    def reload_from_record!(record) load(record.attributes.merge(record.associations)) end
-
-    def reload_fields(context)
-      records = self.class.find(self.id, context: context, fields: @attributes.keys + @associations.keys)
-      reload_from_record!(records)
-    end
-
   end
 end

data/lib/ooor/callbacks.rb

@@ -0,0 +1,18 @@
+module Ooor
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :before_validation, :after_validation, :before_save, :around_save, :after_save,
+      :before_create, :around_create, :after_create, :before_update, :around_update,
+      :after_update, :before_destroy, :around_destroy, :after_destroy
+    ]
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+  end
+end

data/lib/ooor/field_methods.rb

@@ -13,22 +13,17 @@ module Ooor
           fields_get = rpc_execute("fields_get", false, context)
           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
-          (fields.keys + associations_keys).each do |meth| #generates method handlers for auto-completion tools
-            define_field_method(meth)
-          end
-          one2many_associations.keys.each do |meth|
-            define_nested_attributes_method(meth)
-          end
           logger.debug "#{fields.size} fields loaded in model #{self.name}"
           Ooor.model_registry.set_template(connection.config, @t)
         end
+        generate_accessors if fields != {} && (force || !@accessor_defined) #TODOmove in define_accessors method
       end
 
       def all_fields
         fields.merge(polymorphic_m2o_associations).merge(many2many_associations).merge(one2many_associations).merge(many2one_associations)
       end
 
-      def fast_fields(options)
+      def fast_fields(options={})
         fields = all_fields
         fields.keys.select do |k|
           fields[k]["type"] != "binary" && (options[:include_functions] || !fields[k]["function"])
@@ -40,10 +35,12 @@ module Ooor
         unless self.respond_to?(meth)
           self.instance_eval do
             define_method "#{meth}_attributes=" do |*args|
-              self.send :method_missing, *[meth, *args]
+              send("#{meth}_will_change!")
+              @associations[meth] = args[0]
+              @loaded_associations[meth] = args[0]
             end
             define_method "#{meth}_attributes" do |*args|
-              self.send :method_missing, *[meth, *args]
+              @loaded_associations[meth]
             end
           end
         end
@@ -51,102 +48,153 @@ module Ooor
 
       private
 
-        def define_field_method(meth)
-          unless self.respond_to?(meth)
-            self.instance_eval do
-              define_method meth do |*args|
-                self.send :method_missing, *[meth, *args]
-              end
-            end
-          end
+      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 }
+        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}="
+        end
+        @accessor_defined = true
+      end
 
-        def reload_field_definition(k, field)
-          case field['type']
-          when 'many2one'
-            many2one_associations[k] = field
-          when 'one2many'
-            one2many_associations[k] = field
-          when 'many2many'
-            many2many_associations[k] = field
-          when 'reference'
-            polymorphic_m2o_associations[k] = field
-          else
-            fields[k] = field if field['name'] != 'id'
-          end
+      def define_field_method(meth)
+        define_attribute_methods meth
+        define_method meth do |*args|
+          get_attribute(meth, *args)
         end
-    end
 
-    def method_missing(method_symbol, *arguments)
-      method_name = method_symbol.to_s
-      method_key = method_name.sub('=', '')
-      self.class.reload_fields_definition(false, object_session)
-      if attributes.has_key?(method_key)
-        if method_name.end_with?('=')
-          attributes[method_key] = arguments[0]
-        else
-          attributes[method_key]
+        define_method "#{meth}=" do |*args|
+          set_attribute(meth, *args)
         end
-      elsif @loaded_associations.has_key?(method_name)
-        @loaded_associations[method_name]
-      elsif @associations.has_key?(method_name)
-        result = relationnal_result(method_name, *arguments)
-        @loaded_associations[method_name] = result and return result if result
-      elsif method_name.end_with?('=')
-        return method_missing_value_assign(method_key, arguments)
-      elsif self.class.fields.has_key?(method_name) || self.class.associations_keys.index(method_name) #unloaded field/association
-        return lazzy_load_field(method_name, *arguments)
-      # check if that is not a Rails style association with an _id[s][=] suffix:
-      elsif method_name.match(/_id$/) && self.class.associations_keys.index(rel=method_name.gsub(/_id$/, ""))
-        return many2one_id_method(rel, *arguments)
-      elsif method_name.match(/_ids$/) && self.class.associations_keys.index(rel=method_name.gsub(/_ids$/, ""))
-        return x_to_many_ids_method(rel, *arguments)
-      elsif id
-        rpc_execute(method_key, [id], *arguments) #we assume that's an action
-      else
-        super
       end
 
-    rescue UnknownAttributeOrAssociationError => e
-      e.klass = self.class
-      raise e
-    end
+      def define_association_method(meth)
+        define_attribute_methods meth
+        define_method meth do |*args|
+          get_association(meth, *args)
+        end
 
-    private
+        define_method "#{meth}=" do |*args|
+          set_association(meth, *args)
+        end
+      end
 
-      def method_missing_value_assign(method_key, arguments)
-        if is_association_assignment(method_key)
-          @associations[method_key] = arguments[0]
-          @loaded_associations[method_key] = arguments[0]
-        elsif is_attribute_assignment(method_key)
-          @attributes[method_key] = arguments[0]
+      def define_m2o_association_method(meth)
+        define_method "#{meth}_id" do |*args|
+          if @associations[meth].is_a? Array
+            @associations[meth][0]
+          else
+            r = get_association(meth, *args)
+            r.is_a?(Ooor::Base) ? r.id : r
+          end
         end
       end
 
-      def is_association_assignment(method_key)
-        (self.class.associations_keys + self.class.many2one_associations.collect do |k, field|
-          klass = self.class.const_get(field['relation'])
-          klass.reload_fields_definition(false, object_session)
-          klass.t.associations_keys
-        end.flatten).index(method_key)
+      def reload_field_definition(k, field)
+        case field['type']
+        when 'many2one'
+          many2one_associations[k] = field
+        when 'one2many'
+          one2many_associations[k] = field
+        when 'many2many'
+          many2many_associations[k] = field
+        when 'reference'
+          polymorphic_m2o_associations[k] = field
+        else
+          fields[k] = field if field['name'] != 'id'
+        end
       end
 
-      def is_attribute_assignment(method_key)
-        (self.class.fields.keys + self.class.many2one_associations.collect do |k, field|
-          klass = self.class.const_get(field['relation'])
-          klass.reload_fields_definition(false, object_session)
-          klass.t.fields.keys
-        end.flatten).index(method_key)
+    end
+
+    def get_attribute(meth, *args)
+      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]
+        else
+          nil
+        end
       end
+    end
+
+    def set_attribute(meth, *args)
+      value = sanitize_attribute(meth, args[0])
+      @attributes[meth] ||= nil
+      send("#{meth}_will_change!") unless @attributes[meth] == value
+      @attributes[meth] = value
+    end
 
-      def lazzy_load_field(field_name, *arguments)
-        if attributes["id"]
-          load(rpc_execute('read', [id], [field_name], *arguments || object_session)[0] || {})
-          method_missing(field_name, *arguments)
+    def get_association(meth, *args)
+      return @associations[meth] || :undef if @skip
+      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]
+          @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)
         else
           nil
         end
       end
+    end
+
+    def set_association(meth, *args)
+      value = sanitize_association(meth, args[0])
+      if self.class.many2one_associations.has_key?(meth) # TODO detect false positives changes for other associations too
+        if @associations[meth].is_a?(Array) && @associations[meth][0] == value \
+           || @associations[meth] == value #\
+          return value
+        end
+      end
+      @skip = true
+      send("#{meth}_will_change!")
+      @skip = false
+      if value.is_a?(Ooor::Base) || value.is_a?(Array) && !value.empty? && value.all? {|i| i.is_a?(Ooor::Base)}
+        @loaded_associations[meth] = value
+      else
+        @loaded_associations.delete(meth)
+      end
+      @associations[meth] = value
+    end
+
+#    # Raise NoMethodError if the named attribute does not exist in order to preserve behavior expected by #clone.
+#    def attribute(name)
+#      key = name.to_s
+#      if self.class.fields.has_key?(key) #TODO check not symbols
+#        get_attribute(key)
+#      elsif self.class.associations_keys.index(key)
+#        get_association(key)
+#      else
+#        raise NoMethodError
+#      end
+#    end
+
+    def method_missing(method_symbol, *arguments)
+      self.class.reload_fields_definition(false, object_session)
+      if id
+        rpc_execute(method_symbol, [id], *arguments) #we assume that's an action
+      else
+        super
+      end
+    rescue UnknownAttributeOrAssociationError => e
+      e.klass = self.class
+      raise e
+    end
 
   end
 end