ooor 2.0.4 → 2.0.5

data/lib/ooor/mini_active_resource.rb

@@ -3,26 +3,19 @@ require 'active_support/core_ext/class/attribute_accessors'
 require 'active_model'
 
 module Ooor
+  # Ooor::MiniActiveResource is a shrinked version of ActiveResource::Base with the bare minimum we need for Ooor.
+  # as a reminder ActiveResource::Base is the main class for mapping RESTful resources as models in a Rails application.
+  # Ooor is a bit like ActiveResource but eventually it can use more OpenERP metadata and a richer API
+  # to become closer to ActiveRecord or Mongoid than Activeresource. Also OpenERP isn't really good at REST
+  # so the part of ActiveResource dedicated to REST is of little help here.
+  # An other fundamental difference is Ooor is multi OpenERP instances and multi-sessions.
+  # for each session, proxies to OpenERP may be different.
   class MiniActiveResource
 
     class << self
       def element_name
         @element_name ||= model_name.element
       end
-
-      private
-        # split an option hash into two hashes, one containing the prefix options,
-        # and the other containing the leftovers.
-        def split_options(options = {})
-          prefix_options, query_options = {}, {}
-
-          (options || {}).each do |key, value|
-            next if key.blank? || !key.respond_to?(:to_sym)
-            query_options[key.to_sym] = value
-          end
-
-          [ prefix_options, query_options ]
-        end
     end
 
     attr_accessor :attributes, :id
@@ -35,6 +28,7 @@ module Ooor
       super({ :root => self.class.element_name }.merge(options))
     end
 
+    # Returns +true+ if this object hasn't yet been saved, otherwise, returns +false+.
     def new?
       !@persisted
     end
@@ -50,11 +44,16 @@ module Ooor
 
     # Sets the <tt>\id</tt> attribute of the resource.
     def id=(id)
-      attributes["id"] = id
+      attributes["id"] = id.to_i # NOTE added to_i for Ooor (HTML forms can pass it as a string)
     end
 
-    def reload
-      self.class.find(id)
+    # Reloads the record from the database.
+    #
+    # This method finds record by its primary key (which could be assigned manually) and
+    # modifies the receiver in-place
+    # NOTE in Ooor, like ActiveRecord and unlike ActiveResource, reload can take an options parameter
+    def reload(options = nil)
+      self.class.find(id, options)
     end
 
     # Returns the Errors object that holds all information about attribute error messages.
@@ -62,11 +61,6 @@ module Ooor
       @errors ||= ActiveModel::Errors.new(self)
     end
 
-    private
-
-      def split_options(options = {})
-        self.class.__send__(:split_options, options)
-      end
 
     include ActiveModel::Conversion
     include ActiveModel::Serializers::JSON

data/lib/ooor/model_registry.rb

@@ -1,8 +1,13 @@
 module Ooor
+  # Enables to cache expensive model metadata and reuse these metadata
+  # according to connection parameters. Indeed, these metadata are
+  # expensive before they require a fields_get request to OpenERP
+  # so in a web application with several worker processes, it's a good
+  # idea to cache them and share them using a data store like Memcache
   class ModelRegistry
     
     def cache_key(config, model_name)
-      h = config.slice(:url, :database, :username, :scope_prefix) #sure we want username?
+      h = {url: config[:url], database: config[:database], username: config[:username], scope_prefix: config[:scope_prefix]}
       (h.map{|k, v| v} + [model_name]).join('-')
     end
 

data/lib/ooor/model_schema.rb

@@ -0,0 +1,25 @@
+#    OOOR: OpenObject On Ruby
+#    Copyright (C) 2009-2014 Akretion LTDA (<http://www.akretion.com>).
+#    Author: Raphaël Valyi
+#    Licensed under the MIT license, see MIT-LICENSE file
+
+module Ooor
+
+  # Meta data shared across sessions, a cache of the data in ir_model in OpenERP.
+  # in Activerecord, ModelSchema is a module and its properties are carried by the
+  # ActiveRecord object. But in Ooor we don't want do do that because the Ooor::Base
+  # object is different for each session, so instead we delegate the schema
+  # properties to some ModelSchema instance that is shared between sessions, 
+  # reused accross workers in a multi-process web app (via memcache for instance).
+  class ModelSchema
+
+    TEMPLATE_PROPERTIES = [: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, :name, :columns_hash
+  end
+
+end

data/lib/ooor/naming.rb

@@ -4,16 +4,30 @@ module Ooor
   module Naming
     extend ActiveSupport::Concern
 
+    class Name < ActiveModel::Name
+      def initialize(klass, namespace = nil, name = nil)
+        super
+        @singular = klass.openerp_model
+        @plural = klass.openerp_model # OpenERP doesn't enforce plural / singular conventions sadly...
+        @element = klass.openerp_model
+        @human = klass.description || klass.openerp_model
+        @param_key = klass.openerp_model.gsub('.', '_') 
+        @i18n_key = klass.openerp_model
+        @route_key = klass.openerp_model.gsub('.', '-')
+        @singular_route_key = klass.openerp_model.gsub('.', '-')
+      end
+    end
+
     module ClassMethods
       def model_name
         @_model_name ||= begin
-          namespace = self.parents.detect do |n|
-            n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
-          end
-          ActiveModel::Name.new(self, namespace, self.description || self.openerp_model).tap do |r|
-            def r.param_key
-              @klass.openerp_model.gsub('.', '_')
+          if self.respond_to?(:openerp_model) && self.t
+            namespace = self.parents.detect do |n|
+              n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
             end
+            Ooor::Naming::Name.new(self, namespace)
+          else
+            super
           end
         end
       end
@@ -25,11 +39,11 @@ module Ooor
       #similar to Object#const_get but for OpenERP model key
       def const_get(model_key)
         scope = self.scope_prefix ? Object.const_get(self.scope_prefix) : Object
-        klass_name = connection.class_name_from_model_key(model_key)
-        if scope.const_defined?(klass_name) && Ooor.session_handler.connection_spec(scope.const_get(klass_name).connection.config) == Ooor.session_handler.connection_spec(connection.config)
+        klass_name = session.class_name_from_model_key(model_key)
+        if scope.const_defined?(klass_name) && Ooor.session_handler.noweb_session_spec(scope.const_get(klass_name).session.config) == Ooor.session_handler.noweb_session_spec(session.config)
           scope.const_get(klass_name)
         else
-          connection.define_openerp_model(model: model_key, scope_prefix: self.scope_prefix)
+          session.define_openerp_model(model: model_key, scope_prefix: self.scope_prefix)
         end
       end
 
@@ -39,7 +53,7 @@ module Ooor
       end
 
       def param_field
-        connection.config[:param_keys] && connection.config[:param_keys][openerp_model] || :id
+        session.config[:param_keys] && session.config[:param_keys][openerp_model] || :id
       end
 
       def find_by_permalink(param, options={})
@@ -51,9 +65,9 @@ module Ooor
 
       def alias(context={})
         # NOTE in v8, see if we can use ModelConvert here https://github.com/akretion/openerp-addons/blob/trunk-website-al/website/models/ir_http.py#L126
-        if connection.config[:aliases]
-          lang = context['lang'] || connection.config['lang'] || 'en_US'
-          if alias_data = connection.config[:aliases][lang]
+        if session.config[:aliases]
+          lang = context['lang'] || session.config['lang'] || 'en_US'
+          if alias_data = session.config[:aliases][lang]
             alias_data.select{|key, value| value == openerp_model }.keys[0] || openerp_model
           else
             openerp_model

data/lib/ooor/nested_attributes.rb

@@ -0,0 +1,57 @@
+require 'ostruct'
+require 'active_support/concern'
+
+module Ooor
+  module NestedAttributes #:nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Defines an attributes writer for the specified association(s).
+      # Note that in Ooor this is active by default for all one2many and many2one associations
+      def accepts_nested_attributes_for(*attr_names)
+        attr_names.each do |association_name|
+          if rel = all_fields[association_name]
+            reflection = OpenStruct.new(rel.merge({options: {autosave: true}, name: association_name})) #TODO use a reflection class
+            generate_association_writer(association_name, :collection) #TODO add support for m2o
+            add_autosave_association_callbacks(reflection)
+          else
+            raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
+          end
+        end
+      end
+
+      private
+
+      # Generates a writer method for this association. Serves as a point for
+      # accessing the objects in the association. For example, this method
+      # could generate the following:
+      #
+      #   def pirate_attributes=(attributes)
+      #     assign_nested_attributes_for_one_to_one_association(:pirate, attributes)
+      #   end
+      #
+      # This redirects the attempts to write objects in an association through
+      # the helper methods defined below. Makes it seem like the nested
+      # associations are just regular associations.
+      def generate_association_writer(association_name, type)
+        unless self.respond_to?(association_name)
+          self.instance_eval do
+            define_method "#{association_name}_attributes=" do |*args|
+              send("#{association_name}_will_change!")
+#              @associations[association_name] = args[0] # TODO what do we do here?
+              association_obj = self.class.reflect_on_association(association_name).klass
+              associations = []
+              (args[0] || {}).each do |k, v|
+                persisted = !v['id'].blank? || v[:id]
+                associations << association_obj.new(v, [], persisted, true) #TODO eventually use k to set sequence
+              end
+              @loaded_associations[association_name] = associations
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ooor/persistence.rb

@@ -9,65 +9,272 @@ require 'active_model/dirty'
 require 'ooor/errors'
 
 module Ooor
+  # = Ooor RecordInvalid
+  #
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
+  # +record+ method to retrieve the record which did not validate.
+  #
+  #   begin
+  #     complex_operation_that_calls_save!_internally
+  #   rescue ActiveRecord::RecordInvalid => invalid
+  #     puts invalid.record.errors
+  #   end
+  class RecordInvalid < OpenERPServerError
+    attr_reader :record # :nodoc:
+    def initialize(record) # :nodoc:
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      super(I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", :errors => errors, :default => :"errors.messages.record_invalid"))
+    end
+  end
 
-  # the base class for proxies to OpenERP objects
+  # = Ooor Persistence
+  # Note that at the moment it also includes the Validations stuff as it is quite superficial in Ooor
+  # Most of the time, when we talk about validation here we talk about extra Rails validations
+  # as OpenERP validations will happen anyhow when persisting records to OpenERP.
+  # some of the methods found in ActiveRecord Persistence which are identical in ActiveResource
+  # may be found in the Ooor::MiniActiveResource module instead
   module Persistence
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    module ClassMethods
+
+      # Creates an object (or multiple objects) and saves it to the database, if validations pass.
+      # The resulting object is returned whether the object was saved successfully to the database or not.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be created.
+      # 
+      # the +default_get_list+ parameter differs from the ActiveRecord API
+      # it is used to tell OpenERP the list of fields for which we want the default values
+      # false will request all default values while [] will not ask for any default value (faster)
+      # +reload+ can be set to false to indicate you don't want to reload the record after it is saved
+      # which will save a roundtrip to OpenERP and perform faster.
+      def create(attributes = {}, default_get_list = false, reload = true, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, &block) }
+        else
+          object = new(attributes, default_get_list, &block)
+          object.save(reload)
+          object
+        end
+      end
+
+      # Creates an object just like Base.create but calls <tt>save!</tt> instead of +save+
+      # so an exception is raised if the record is invalid.
+      def create!(attributes = {}, default_get_list = false, reload = true, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create!(attr, &block) }
+        else
+          object = new(attributes, default_get_list)
+          yield(object) if block_given?
+          object.save!(reload)
+          object
+        end
+      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)
+    end
+
+    # Returns true if this object has been destroyed, otherwise returns false.
+    def destroyed?
+      @destroyed
+    end
+
+    # Flushes the current object and loads the +attributes+ Hash
+    # containing the attributes and the associations into the current object
+    def load(attributes)
+      self.class.reload_fields_definition(false)
       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|
-        self.send "#{key}=".to_sym, value if self.respond_to?("#{key}=".to_sym)
+        self.send "#{key}=", value if self.respond_to?("#{key}=")
       end
       self
     end
 
     #takes care of reading OpenERP default field values.
-    def initialize(attributes = {}, default_get_list=false, context={}, persisted=false)
+    def initialize(attributes = {}, default_get_list = false, persisted = false, has_changed = false, lazy = false)
+      self.class.reload_fields_definition(false)
       @attributes = {}
-      @prefix_options = {}
       @ir_model_data_id = attributes.delete(:ir_model_data_id)
-      @object_session = {}
-      @object_session = HashWithIndifferentAccess.new(context)
+      @marked_for_destruction = false
       @persisted = persisted
-      self.class.reload_fields_definition(false, @object_session)
+      @lazy = lazy
       if default_get_list == []
         load(attributes)
       else
         load_with_defaults(attributes, default_get_list)
       end.tap do
-        if id
+        if id && !has_changed
           @previously_changed = ActiveSupport::HashWithIndifferentAccess.new # see ActiveModel::Dirty reset_changes
           @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new
         end
       end
     end
 
-    # Saves (+create+) or \updates (+write+) a resource. Delegates to +create+ if the object is \new,
-    # +update+ if it exists.
-    def save(context={}, reload=true)
-      create_or_update(context, reload)
+    # Saves the model.
+    #
+    # If the model is new a record gets created in OpenERP, otherwise
+    # the existing record gets updated.
+    #
+    # By default, save always run validations. If any of them fail the action
+    # is cancelled and +save+ returns +false+. However, if you supply
+    # validate: false, validations are bypassed altogether.
+    # In Ooor however, real validations always happen on the OpenERP side
+    # so the only validations you can bypass or not are extra pre-validations
+    # in Ruby if you have any.
+    #
+    # There's a series of callbacks associated with +save+. If any of the
+    # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
+    # +save+ returns +false+. See ActiveRecord::Callbacks for further
+    # details.
+    #
+    # Attributes marked as readonly are silently ignored if the record is
+    # being updated. (TODO)
+    def save(options = {})
+      perform_validations(options) ? save_without_raising(options) : false
+    end
+
+    # Attempts to save the record just like save but will raise a +RecordInvalid+
+    # exception instead of returning +false+ if the record is not valid.
+    def save!(options = {})
+      perform_validations(options) ? save_without_raising(options) : raise(RecordInvalid.new(self))
+    end
+
+    # Deletes the record in OpenERP and freezes this instance to
+    # reflect that no changes should be made (since they can't be
+    # persisted). Returns the frozen instance.
+    #
+    # no callbacks are executed.
+    #
+    # To enforce the object's +before_destroy+ and +after_destroy+
+    # callbacks or any <tt>:dependent</tt> association
+    # options, use <tt>#destroy</tt>.
+    def delete
+      rpc_execute('unlink', [id], context) if persisted?
+      @destroyed = true
+      freeze
+    end
+
+    # Deletes the record in OpenERP and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    #
+    # There's a series of callbacks associated with <tt>destroy</tt>. If
+    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+    # and <tt>destroy</tt> returns +false+. See
+    # ActiveRecord::Callbacks for further details.
+    def destroy
+      run_callbacks :destroy do
+        rpc_execute('unlink', [id], context)
+        @destroyed = true
+        freeze 
+      end
+    end
+
+    # Deletes the record in the database and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    #
+    # There's a series of callbacks associated with <tt>destroy!</tt>. If
+    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+    # and <tt>destroy!</tt> raises ActiveRecord::RecordNotDestroyed. See
+    # ActiveRecord::Callbacks for further details.
+    def destroy! #TODO
+      destroy || raise(ActiveRecord::RecordNotDestroyed)
+    end
+
+    #TODO implement becomes / becomes! eventually
+
+    # Updates a single attribute and saves the record.
+    # This is especially useful for boolean flags on existing records. Also note that
+    #
+    # * Validation is skipped.
+    # * Callbacks are invoked.
+    # * updated_at/updated_on column is updated if that column is available.
+    # * Updates all the attributes that are dirty in this object.
+    #
+    # This method raises an +ActiveRecord::ActiveRecordError+  if the
+    # attribute is marked as readonly.
+    #
+    # See also +update_column+.
+    def update_attribute(name, value)
+      send("#{name}=", value)
+      save(validate: false)
+    end
+
+    # Updates the attributes of the model from the passed-in hash and saves the
+    # record, all wrapped in a transaction. If the object is invalid, the saving
+    # will fail and false will be returned.
+    def update(attributes, reload=true)
+      load(attributes) && save(reload)
+    end
+
+    alias update_attributes update
+
+    # Updates its receiver just like +update+ but calls <tt>save!</tt> instead
+    # of +save+, so an exception is raised if the record is invalid.
+    def update!(attributes, reload=true)
+      load(attributes) && save!(reload)
+    end
+
+    alias update_attributes! update!
+
+    #OpenERP copy method, load persisted copied Object
+    def copy(defaults={}, context={})
+      self.class.find(rpc_execute('copy', id, defaults, context), context: context)
     end
 
-    def create_or_update(context={}, reload=true)
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, +false+ otherwise.
+    #
+    # Aliased as validate.
+    #
+    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      errors.empty? && output
+    end
+
+    alias_method :validate, :valid?
+
+  protected
+
+    # Real validations happens on OpenERP side, only pre-validations can happen here eventually
+    def perform_validations(options={}) # :nodoc:
+      if options.is_a?(Hash)
+        options[:validate] == false || valid?(options[:context])
+      else
+        valid?
+      end
+    end
+
+  private
+
+    def create_or_update(options={})
       run_callbacks :save do
-        new? ? create_record(context, reload) : update_record(context, reload)
+        new? ? create_record(options) : update_record(options)
       end
     rescue ValidationError => e
       e.extract_validation_error!(errors)
       return false
     end
 
-    # Create (i.e., \save to OpenERP service) the \new resource.
-    def create(context={}, reload=true)
-      create_or_update(context, reload)
+    def update_record(options)
+      run_callbacks :update do
+        rpc_execute('write', [self.id], to_openerp_hash, context)
+        reload_fields if should_reload?(options)
+        @persisted = true
+      end
     end
 
-    def create_record(context={}, reload=true)
+    def create_record(options={})
       run_callbacks :create do
         self.id = rpc_execute('create', to_openerp_hash, context)
         if @ir_model_data_id
@@ -77,45 +284,36 @@ module Ooor
             'res_id' => self.id)
         end
         @persisted = true
-        reload_fields(context) if reload
+        reload_fields if should_reload?(options)
       end
     end
 
-    def update_attributes(attributes, context={}, reload=true)
-      load(attributes, false) && save(context, reload)
-    end
-
-    # Update the resource on the remote service.
-    def update(context={}, reload=true, keys=nil)
-      create_or_update(context, reload, keys)
+    def save_without_raising(options = {})
+      create_or_update(options)
+    rescue Ooor::RecordInvalid
+      false
     end
 
-    def update_record(context={}, reload=true)
-      run_callbacks :update do
-        rpc_execute('write', [self.id], to_openerp_hash, context)
-        reload_fields(context) if reload
-        @persisted = true
+    def should_validate?(options)
+      if options.is_a?(Hash)
+        options[:validate] != false
+      else
+        true
       end
     end
 
-    #Deletes the record in OpenERP and freezes this instance to reflect that no changes should be made (since they can’t be persisted).
-    def destroy(context={})
-      run_callbacks :destroy do
-        rpc_execute('unlink', [self.id], context)
-        @destroyed = true
-        freeze 
+    def should_reload?(options)
+      if options == false
+        false
+      elsif options.is_a?(Hash) && options[:reload] == false
+        false
+      else
+        true
       end
     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
-
-    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)
+      defaults = rpc_execute("default_get", default_get_list || self.class.fields.keys + self.class.associations_keys, context)
       attributes = HashWithIndifferentAccess.new(defaults.merge(attributes.reject {|k, v| v.blank? }))
       load(attributes)
     end
@@ -130,7 +328,7 @@ module Ooor
       load(attrs)
     end
 
-    def reload_fields(context)
+    def reload_fields
       record = self.class.find(self.id, context: context)
       load(record.attributes.merge(record.associations))
       @changed_attributes = ActiveSupport::HashWithIndifferentAccess.new # see ActiveModel::Dirty