ooor 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [Raphaël Valyi]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,268 @@
+OOOR - OpenObject On Rails
+====
+
+<table>
+    <tr>
+        <td><a href="http://github.com/rvalyi/ooor" title="OOOR - OpenObject On Rails"><img src="http://sites.google.com/site/assetserversite/_/rsrc/1257126460164/home/ooor_s.jpg" width="159px" height="124px" /></a></td>
+        <td><b>BY</b></td>
+        <td><a href="http://www.akretion.com" title="Akretion - open source to spin the world"><img src="http://sites.google.com/site/assetserversite/_/rsrc/1257126470309/home/akretion_s.png" width="228px" height="124px" /></a></td>
+        <td>
+OOOR stands for OpenObject On Rails. OpenObject is the RAD framework behind OpenERP,
+the ERP that doesn't hurt, just like Rails is "web development that doesn't hurt".
+So OOOR exposes seamlessly your OpenOpbject application, to your custom Rails application.
+Needless to say, OOOR doubly doesn't hurt.
+Furthermore, OOOR only depends on the "activeresource" gem. So it can even be used
+in any (J)Ruby application without Rails.
+        </td>
+    </tr>
+</table>
+
+
+Why?
+------------
+
+OpenERP makes it really straightforward to create/customize business applications with:
+
+* standard ERP business modules (more than 300 modules)
+* complex relationnal data model, with automated migration and backoffice interfaces
+* ACID transactions on PostgreSQL
+* role based
+* modular
+* integrated BPM (Business Process Management)
+* integrated reporting system, with integrated translations
+* both native GTK/QT clients and standard web access
+
+In a word OpenERP really shines when it's about quickly creating the backoffice of those enterprise applications.
+OpenERP is a bit higher level than Rails (for instance it's component oriented while Rails is REST oriented) so if you adhere to the OpenERP conventions, 
+then you are done faster than coding a Rails app (seriously).
+Adhering means: you stick to OpenObject views, widgets, look and feel, components composition, ORM (kind of ActiveRecord), the Postgres database...
+
+But sometimes you can't afford that. Typicall examples are B2C end users applications like e-commerce shops.
+So what happens if you don't adhere to the OpenERP framework?
+Well that's where OOOR comes into action. It allows you to build a Rails application much like you want, where you totally control the end user presentation and interaction.
+But OOOR makes it straightforward to use a standard OpenERP models as your persistent models.
+
+An other reason why you might want to use OOOR is because you would like to code essentially a Rails or say web application
+(because you know it better, because the framework is cleaner or because you will reuse something, possibly Java libraries though JRuby)
+but you still want to benefit from OpenERP features.
+
+Yet an other typicall use case would be to test your OpenERP application/module using Rails best of bread BDD Ruby frameworks such as RSpec or Cucumber.
+
+Finally you might also want to use OOOR simply to expose your OpenERP through REST to other consumer applications. Since OOOR just does that too out of the box.
+
+
+
+How?
+------------
+
+OpenERP is a Python based open source ERP. Every action in OpenERP is actually invokable as a webservice (SOA orientation, close to being RESTful).
+OOOR just takes advantage of brings this power your favorite web development tool - Rails - with OpenERP domain objects and business methods.
+
+OOOR aims at being a very simple piece of code (< 500 lines of code; e.g no bug, easy to evolve) adhering to Rails standards.
+So instead of re-inventing the wheel, OOOR basically just sits on the top of Rails ActiveResource::Base, the standard way of remoting you ActiveRecord Rails models with REST.
+
+Remember, ActiveResource is actually simpler than ActiveRecord. It's aimed at remoting ANY object model, not necessarily ActiveRecord models.
+So ActiveResource is only a subset of ActiveRecord, sharing the common denominator API (integration is expected to become even more powerful in Rails 3).
+
+OOOR implements ActiveResource public API almost fully. It means that you can remotely work on any OpenERP model using the standard ActiveResource API.
+
+But, OOOR goes actually a bit further: it does implements model associations (one2many, many2many, many2one, single table inheritance).
+Indeed, when loading the OpenERP models, we load the relational meta-model using OpenERP standard datamodel introspection services.
+Then we cache that relational model and use it in OpenObjectResource.method_missing to load associations as requested.
+
+OOOR also extends ActiveResource a bit with special request parameters (like :domain or :context) that will just map smoothly to the OpenERP native API, see API.
+
+
+Installation
+------------
+
+You can use OOOR in a standalone (J)Ruby application, or in a Rails application.
+For both example we assume that you already started some OpenERP server on localhost, with XML/RPC on port 8069 (default),
+with a database called 'mybase', with username 'admin' and password 'admin'.
+
+In all case, you first need to install the ooor gem:
+
+    $ gem install ooor
+(the ooor gem is hosted [on gemcutter.org here](http://gemcutter.org/gems/ooor), make sure you have it in your gem source lists, a way is to do >gem tumble)
+
+
+### Standalone (J)Ruby application:
+
+Let's test OOOR in an irb console (irb command):
+    $ require 'rubygems'
+    $ require 'ooor'
+    $ include Ooor
+    $ Ooor.reload!({:url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'})
+This should load all your OpenERP models into Ruby proxy Activeresource objects. Of course there are option to load only some models.
+Let's try to retrieve the user with id 1:
+    $ ResUsers.find(1)
+    
+    
+### (J)Ruby on Rails application:
+
+we assume you created a working Rails application, in your config/environment.rb
+Inside the Rails::Initializer.run do |config| statement, paste the following gem dependency:
+
+    $ config.gem "ooor"
+
+Now, you should also create a ooor.yml config file in your config directory
+You can copy/paste [the default ooor.yml from the OOOR gem](http://github.com/rvalyi/ooor/blob/master/ooor.yml)
+and then adapt it to your OpenERP server environment.
+If you set the 'bootstrap' parameter to true, OpenERP models will be loaded at the Rails startup.
+That the easiest option to get started while you might not want that in production.
+
+Then just start your Rails application, your OpenERP models will be loaded as you'll see in the Rails log.
+You can then use all the OOOR API upon all loaded OpenERP models in your regular Rails code (see API usage section).
+
+Enabling REST HTTP routes to your OpenERP models:
+in your config/route.rb, you can alternatively enable routes to all your OpenERP models by addding:
+    $ OpenObjectsController.load_all_controllers(map)
+
+Or only enable the route to some specific model instead (here partners):
+    $ map.resources :res_partner
+
+
+
+API usage
+------------
+
+Note: Ruby proxies objects are named after OpenERP models in but removing the '.' and using CamelCase.
+we remind you that OpenERP tables are also named after OpenERP models but replacing the '.' by '_'.
+
+Basic finders:
+
+    $ ProductProduct.find(1)
+    $ ProductProduct.find([1,2])
+    $ ProductProduct.find([1])
+    $ ProductProduct.find(:all)
+    $ ProductProduct.find(:last)
+
+
+OpenERP domain support:
+
+    $ ResPartner.find(:all, :domain=>[['supplier', '=', 1],['active','=',1]])
+
+
+OpenERP context support:
+
+    $ ProductProduct.find(1, :context => {:my_key => 'value'}
+
+
+Request params or ActiveResource equivalence of OpenERP domain (but degraded as only the = operator is supported, else use domain):
+
+    $ Partners.find(:all, :params => {:supplier => true})
+
+
+Relations (many2one, one2many, many2many) support:
+
+    $ SaleOrder.find(1).order_line
+    $ p = ProductProduct.find(1)
+    $ p.product_tmpl_id #many2one relation
+    $ p.tax_ids = [6, 0, [1,2]] #create many2many associations,
+    $ p.save #assigns taxes with id 1 and 2 as sale taxes,
+see [the official OpenERP documentation](http://doc.openerp.com/developer/5_18_upgrading_server/19_1_upgrading_server.html?highlight=many2many)
+
+
+Inherited relations support:
+
+    $ ProductProduct.find(1).categ_id #where categ_id is inherited from the ProductTemplate
+
+
+Load only specific fields support (faster than loading all fields):
+
+    $ ProductProduct.find(1, :fields=>["state", "id"])
+    $ ProductProduct.find(:all, :fields=>["state", "id"])
+    $ ProductProduct.find([1,2], :fields=>["state", "id"])
+    $ ProductProduct.find(:all, :fields=>["state", "id"])
+    even in relations:
+    $ SaleOrder.find(1).order_line(:fields => ["state"])
+
+
+Create:
+
+    $ pc = ProductCategory.new(:name => 'Categ From Rails!')
+    $ #<ProductCategory:0xb702c42c @prefix_options={}, @attributes={"name"=>"Categ From Rails!"}>
+    $ pc.create
+    $ => 14
+
+
+Update:
+
+    $ pc.name = "A new name"
+    $ pc.save
+
+
+Delete:
+
+    $ pc.destroy
+
+
+Call workflow: see code; TODO document
+
+
+Call aribtrary method: see code; TODO document
+
+
+
+FAQ
+------------
+
+### How do I know which object or OpenERP webservice I should Invoke from OOOR?
+
+An easy way to discover what is the sebservice to do something in OpenERP, is to use your GTK client and start it with the -l debug_rpc (or alternatively -l debug_rpc_answer) option.
+For non *nix users, you can alternatively start your server with the --log-level=debug_rpc option (you can also set this option in your hidden OpenERP server config file in your user directory).
+Then create indents in the log before doing some action and watch your logs carefully. OOOR will allow you to do the same easily from Ruby/Rails.
+
+### How can I load/reload my OpenERP models into my Ruby application?
+
+You can load/reload your models at any time (even in console), using the Ooor.reload! method, for instance:
+    $ Ooor.reload!({:url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'})
+or using a config YAML file instead:
+    $ Ooor.reload!("config/ooor.yml")
+
+### Do I need to load all the OpenERP models in my Ruby application?
+
+You can load only some OpenERP models (not all), which is faster and better in term of memory/security:
+    $ Ooor.reload!({:models => [res.partner, product.template, product.product], :url => 'http://localhost:8069/xmlrpc', :database => 'mybase', :username => 'admin', :password => 'admin'})
+
+
+### Isn't OOOR slow?
+
+You might think that proxying a Python based server through a Rails app using XML/RPC would be dog slow. Well, not too much actually.
+I did some load testing using a Centrino Duo laptop (dual core at 1.6 GHz), and I was able to approach 10 requests/sec, to display some OpenERP resource as XML through HTTP.
+That should be enough for what it's meant too. Heavily loaded application might cache things at the Rails level if that's too slow, but I don't think so.
+
+Also notice that using JRuby I could serve some 20% faster.
+
+### JRuby compatibility
+
+Yes Ooor is fully JRuby compatible. It's even somewhat 20% faster using Java6 + last JRuby.
+This might be espcially interresting if you plan to mix Java libraries with OpenERP in the same web appication.
+
+### Can I extend the OOOR models?
+
+Yes you can perfectly do that. Basically an OpenERP model get a basic ActiveResource model. For instance: product.product is mapped to the ProductProduct ActiveResource model.
+But using the Ruby open classes features, you can asbolutely re-open the ProductProduct class and add features of your own.
+In you app/model directory, create a product_product.rb file with inside, the redéfinition of ProductProduct, for instance:
+
+    $ class ProductProduct < OpenObjectResource
+    $   def foo
+    $     "bar"
+    $   end
+    $ end
+
+Now a ProductProduct resource got a method foo, returning "bar".
+
+### Can I extend the OOOR controllers?
+
+Yes, you can do that, see the "how to extends models" section as it's very similar. Instead, in the app/controllers directory, you'll re-open defined controllers,
+for the product.product controllers, it means creating a product_product_controller.rb file with:
+
+    $ class ProductProduct < OpenObjectsController
+    $   def foo
+    $     render :text => "bar"
+    $   end
+    $ end
+
+Now, if you register that new method in your route.rb file GET /product_product/1/foo will render "bar" on your browser screen.
+You could instead just customize the existing CRUD methods so you don't need to regiter any other route in route.rb.

data/lib/app/controllers/open_objects_controller.rb

@@ -0,0 +1,139 @@
+require 'action_controller'
+
+class OpenObjectsController < ActionController::Base
+
+  #TODO get lang from URL in before filter
+  #TODO use timezone from HTTP header and put is in context
+
+  # ******************** class methods ********************
+  class << self
+
+    cattr_accessor :logger
+
+    def model_class
+        if defined?(@model_class)
+          @model_class
+        elsif superclass != Object && superclass.model_class
+          superclass.model_class.dup.freeze
+        end
+    end
+
+    def model_class=(_model_class)
+      @model_class = _model_class
+    end
+
+    def ids_from_param(param)
+      if param.split(',').size > 0
+        return eval param
+      else
+        return param
+      end
+    end
+
+    def define_openerp_controller(model_key, binding)
+      model_class_name = OpenObjectResource.class_name_from_model_key(model_key)
+      controller_class_name = model_class_name + "Controller"
+      logger.info "registering #{controller_class_name} as a Rails ActiveResource Controller wrapper for OpenObject #{model_key} model"
+      eval "
+      class #{controller_class_name} < OpenObjectsController
+        self.model_class = #{model_class_name}
+      end
+      ", binding
+    end
+
+    def load_all_controllers(map)
+      OpenObjectResource.all_loaded_models.each do |model|
+        map.resources model.gsub('.', '_').to_sym
+      end
+    end
+
+  end
+
+
+  # ******************** instance methods ********************
+
+  # GET /models
+  # GET /models.xml
+  def index
+    @models = self.class.model_class.find(:all)
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.xml  { render :xml => @models }
+    end
+  end
+
+  # GET /models/1
+  # GET /models/1.xml
+  def show
+    @models = self.class.model_class.find(self.class.ids_from_param(params[:id]))
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.xml  { render :xml => @models }
+      format.json  { render :json => @models }
+    end
+  end
+
+  # GET /models/new
+  # GET /models/new.xml
+  def new
+    @models = self.class.model_class.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.xml  { render :xml => @models }
+    end
+  end
+
+  # GET /models/1/edit
+  def edit
+    @models = self.class.model_class.find(params[:id])
+  end
+
+  # POST /models
+  # POST /models.xml
+  def create
+    @models = self.class.model_class.new(params[:partners])
+
+    respond_to do |format|
+      if @models.save
+        flash[:notice] = 'Model was successfully created.'
+        format.html { redirect_to(@models) }
+        format.xml  { render :xml => @models, :status => :created, :location => @models }
+      else
+        format.html { render :action => "new" }
+        format.xml  { render :xml => @models.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /models/1
+  # PUT /models/1.xml
+  def update
+    @models = self.class.model_class.find(params[:id])
+
+    respond_to do |format|
+      if @models.update_attributes(params[:partners])
+        flash[:notice] = 'Partners was successfully updated.'
+        format.html { redirect_to(@models) }
+        format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.xml  { render :xml => @models.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /models/1
+  # DELETE /models/1.xml
+  def destroy
+    @models = self.class.model_class.find(params[:id])
+    @models.destroy
+
+    respond_to do |format|
+      format.html { redirect_to(url_for(:action => index)) }
+      format.xml  { head :ok }
+    end
+  end
+end

data/lib/app/models/open_object_resource.rb

@@ -0,0 +1,263 @@
+require 'xmlrpc/client'
+require 'activeresource'
+
+#TODO support name_search via search + param
+#see name_search(self, cr, user, name='', args=None, operator='ilike', context=None, limit=None):
+#TODO support offset, limit and order
+#see def search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False):
+
+class OpenObjectResource < ActiveResource::Base
+
+  # ******************** class methods ********************
+  class << self
+
+    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
+                  :field_defined, :many2one_relations, :one2many_relations, :many2many_relations,
+                  :openerp_database, :all_loaded_models
+
+    def class_name_from_model_key(model_key)
+      model_key.split('.').collect {|name_part| name_part[0..0].upcase + name_part[1..-1]}.join
+    end
+
+    def reload_fields_definition(force = false)
+      if self != IrModel and self != IrModelFields and (force or not @field_defined)#TODO have a way to force reloading @field_ids too eventually
+        unless @field_ids
+           model_def = IrModel.find(:all, :domain => [['model', '=', @openerp_model]])
+           @field_ids = model_def.field_id
+           @access_ids = model_def.access_ids
+        end
+        fields = IrModelFields.find(@field_ids)
+        @fields = {}
+        @many2one_relations = {}
+        @one2many_relations = {}
+        @many2many_relations = {}
+        fields.each do |field|
+          case field.attributes['ttype']
+          when 'many2one'
+            @many2one_relations[field.attributes['name']] = field
+          when 'one2many'
+            @one2many_relations[field.attributes['name']] = field
+          when 'many2many'
+            @many2many_relations[field.attributes['name']] = field
+          else
+            @fields[field.attributes['name']] = field
+          end
+        end
+        logger.info "#{fields.size} fields"
+      end
+      @field_defined = true
+    end
+
+    def define_openerp_model(arg, url, database, user_id, pass, binding)
+      param = (arg.is_a? OpenObjectResource) ? arg.attributes.merge(arg.relations) : {'model' => arg}
+      model_key = param['model']
+      @all_loaded_models ||= []
+      all_loaded_models.push(model_key)
+      model_class_name = class_name_from_model_key(model_key)
+      logger.info "registering #{model_class_name} as a Rails ActiveResource Model wrapper for OpenObject #{model_key} model"
+      definition = "
+      class #{model_class_name} < OpenObjectResource
+        self.site = '#{url}'
+        self.user = #{user_id}
+        self.password = '#{pass}'
+        self.openerp_database = '#{database}'
+        self.openerp_model = '#{model_key}'
+        self.openerp_id = #{param['id'] || false}
+        self.info = '#{param['info']}'
+        self.name = '#{param['name']}'
+        self.state = '#{param['state']}'
+        self.field_ids = #{(param['field_id'] and '[' + param['field_id'].join(',') + ']') || false}
+        self.access_ids = #{(param['access_ids'] and '[' + param['access_ids'].join(',') + ']') || false}
+        self.many2one_relations = {}
+        self.one2many_relations = {}
+        self.many2many_relations = {}
+      end"
+      eval definition, binding
+    end
+
+
+    # ******************** remote communication ********************
+
+    def client
+      @client ||= XMLRPC::Client.new2(@site.to_s.gsub(/\/$/,'')) #always remove trailing / to make OpenERP happy
+    end
+
+    #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
+    def rpc_execute(method, *args)
+      rpc_execute_with_object(@openerp_model, method, *args)
+    end
+
+    def rpc_execute_with_object(object, method, *args)
+      rpc_execute_with_all(@openerp_database, @user, @password, object, method, *args)
+    end
+
+    #corresponding method for OpenERP osv.execute(self, db, uid, obj, method, *args, **kw) method
+    def rpc_execute_with_all(db, uid, pass, obj, method, *args)
+      try_with_pretty_error_log { client.call("execute", db, uid, pass, obj, method, *args) }
+    end
+
+     #corresponding method for OpenERP osv.exec_workflow(self, db, uid, obj, method, *args)
+    def rpc_exec_workflow(method, *args)
+      rpc_exec_workflow_with_object(@openerp_model, method, *args)
+    end
+
+    def rpc_exec_workflow_with_object(object, method, *args)
+      rpc_exec_workflow_with_all(@openerp_database, @user, @password, object, method, *args)
+    end
+
+    def rpc_exec_workflow_with_all(method, *args)
+      try_with_pretty_error_log { client.call("exec_workflow", db, uid, pass, obj, method,  *args) }
+    end
+
+    #grab the eventual error log from OpenERP response as OpenERP doesn't enforce carefuly
+    #the XML/RPC spec, see https://bugs.launchpad.net/openerp/+bug/257581
+    def try_with_pretty_error_log
+        yield
+      rescue RuntimeError => e
+        logger.error "OpenERP server error!
+        ***********
+        #{eval("#{ e }".gsub("wrong fault-structure: ", ""))["faultString"]}
+        ***********"""
+        raise
+    end
+
+    def load_relation(model_key, ids, *arguments)
+      options = arguments.extract_options!
+      relation_model_class = eval class_name_from_model_key(model_key)
+      relation_model_class.send :find, ids, :fields => options[:fields] || [], :context => options[:context] || {}
+    end
+
+
+    # ******************** finders low level implementation ********************
+
+    private
+
+    def find_every(options)
+      domain = options[:domain]
+      context = options[:context] || {}
+      unless domain
+        prefix_options, query_options = split_options(options[:params])
+        domain = []
+        query_options.each_pair do |k, v|
+          domain.push [k.to_s, '=', v]
+        end
+      end
+      ids = rpc_execute('search', domain, context)
+      find_single(ids, options)
+    end
+
+    #TODO, make sense?
+    def find_one
+      raise "Not implemented yet, go one!"
+    end
+
+    # Find a single resource from the default URL
+    def find_single(scope, options)
+      fields = (options[:fields] and [options[:fields]]) || []
+      context = options[:context] || {}
+      prefix_options, query_options = split_options(options[:params])
+      is_collection = true
+      if !scope.is_a? Array
+        scope = [scope]
+        is_collection = false
+      end
+      records = rpc_execute('read', scope, *(fields + [context]))
+      active_resources = []
+      records.each do |record|
+        r = {}
+        record.each_pair do |k,v|
+          r[k.to_sym] = v
+        end
+        active_resources << instantiate_record(r, prefix_options)
+      end
+      unless is_collection
+        return active_resources[0]
+      end
+      return active_resources
+    end
+
+  end
+
+
+  # ******************** instance methods ********************
+
+  def pre_cast_attributes
+    @attributes.each {|k, v| @attributes[k] = ((v.is_a? BigDecimal) ? Float(v) : v)}
+  end
+
+  def load(attributes)
+    self.class.reload_fields_definition unless self.class.field_defined
+    raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
+    @prefix_options, attributes = split_options(attributes)
+    attributes.each do |key, value|
+      case value
+        when Array
+           relations[key.to_s] = value #the relation because we want the method to load the association through method missing
+        when Hash
+          resource = find_or_create_resource_for(key)
+          @attributes[key.to_s] = resource@attributes[key.to_s].new(value)
+        else
+          @attributes[key.to_s] = value.dup rescue value
+      end
+    end
+
+    self
+  end
+
+  #compatible with the Rails way but also supports OpenERP context
+  def create(context={})
+    self.pre_cast_attributes
+    self.id = self.class.rpc_execute('create', @attributes, context)
+  end
+
+  #compatible with the Rails way but also supports OpenERP context
+  def update(context={})
+    self.pre_cast_attributes
+    self.class.rpc_execute('write', self.id, @attributes.reject{|k, v| k == 'id'}, context)
+  end
+
+  #compatible with the Rails way but also supports OpenERP context
+  def destroy(context={})
+    self.class.rpc_execute('unlink', self.id, context)
+  end
+
+
+  # ******************** fake associations like much like ActiveRecord according to the cached OpenERP data model ********************
+
+  def relations
+      @relations ||= {} and @relations
+  end
+
+  def relationnal_result(method_id, *arguments)
+    self.class.reload_fields_definition unless self.class.field_defined
+    if self.class.many2one_relations[method_id.to_s]
+      self.class.load_relation(self.class.many2one_relations[method_id.to_s].relation, @relations[method_id.to_s][0], *arguments)
+    elsif self.class.one2many_relations[method_id.to_s]
+      self.class.load_relation(self.class.one2many_relations[method_id.to_s].relation, @relations[method_id.to_s], *arguments)
+    elsif self.class.many2many_relations[method_id.to_s]
+      self.class.load_relation(self.class.many2many_relations[method_id.to_s].relation, @relations[method_id.to_s], *arguments)
+    else
+      false
+    end
+  end
+
+  def method_missing(method_id, *arguments)
+    result = relationnal_result(method_id, *arguments)
+    if result
+      return result
+    elsif @relations and @relations[method_id.to_s] and !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|
+        model = self.class.load_relation(field.relation, @relations[method_id.to_s][0], *arguments)
+        result = model.relationnal_result(method_id, *arguments)
+        if result
+          return result
+        end
+      end
+      super
+    end
+    super
+  end
+
+end

data/lib/ooor.rb

@@ -0,0 +1,96 @@
+require 'logger'
+
+module Ooor
+
+  @ooor_logger = ((defined?(RAILS_ENV) and RAILS_ENV != "development") ? Rails.logger : Logger.new(STDOUT))
+
+  #load the custom configuration
+  def self.load_config(config_file=nil, env=nil)
+    config_file ||= defined?(RAILS_ROOT) && "#{RAILS_ROOT}/config/ooor.yml" || 'ooor.yml'
+    env ||= defined?(RAILS_ENV) && RAILS_ENV || 'development'
+    @ooor_config = YAML.load_file(config_file)[env]
+  rescue SystemCallError
+    @ooor_logger.error """failed to load OOOR yaml configuration file.
+       make sure your app has a #{config_file} file correctly set up
+       if not, just copy/paste the default ooor.yml file from the OOOR Gem
+       to #{RAILS_ROOT}/config/ooor.yml and customize it properly\n\n"""
+    raise
+  end
+
+  def self.loaded?
+    OpenObjectResource.all_loaded_models.is_a? Array and OpenObjectResource.all_loaded_models.size > 0
+  end
+
+  def self.reload!(config=false, env=false, keep_config=false)
+    @ooor_config = config.is_a?(Hash) && config or keep_config && @ooor_config or self.load_config(config, env)
+    @ooor_config.symbolize_keys!
+
+    begin
+      url = @ooor_config[:url]
+      database = @ooor_config[:database]
+      user = @ooor_config[:username]
+      pass = @ooor_config[:password]
+    rescue Exception => error
+      @ooor_logger.error """ooor.yml failed: #{error.inspect}
+       #{error.backtrace}
+       You probably didn't configure the ooor.yml file properly because we can't load it"""
+      raise
+    end
+
+    require 'xmlrpc/client'
+    begin
+      login_url = url.gsub(/\/$/,'') + "/common"
+      client = XMLRPC::Client.new2(login_url)
+      user_id = client.call("login", database, user, pass)
+
+
+      #*************** load the models
+
+      models_url = url.gsub(/\/$/,'') + "/object"
+      OpenObjectResource.logger = @ooor_logger
+      @ooor_binding = lambda {}
+      OpenObjectResource.define_openerp_model("ir.model", models_url, database, user_id, pass, @ooor_binding)
+      OpenObjectResource.define_openerp_model("ir.model.fields", models_url, database, user_id, pass, @ooor_binding)
+
+
+      if @ooor_config[:models] #we load only a customized subset of the OpenERP models
+        models = IrModel.find(:all, :domain => [['model', 'in', @ooor_config[:models]]])
+      else #we load all the models
+        models = IrModel.find(:all)
+      end
+
+      models.each {|openerp_model| OpenObjectResource.define_openerp_model(openerp_model, models_url, database, user_id, pass, @ooor_binding) }
+
+
+      # *************** load the models REST controllers
+      if defined?(ActionController)
+        OpenObjectsController.logger = @ooor_logger
+        models.each {|openerp_model| OpenObjectsController.define_openerp_controller(openerp_model.model, @ooor_binding) }
+      end
+
+
+    rescue SystemCallError => error
+      @ooor_logger.error """login to OpenERP server failed:
+       #{error.inspect}
+       #{error.backtrace}
+       Are your sure the server is started? Are your login parameters correct? Can this server ping the OpenERP server?
+       login XML/RPC url was #{login_url}
+       database: #{database}; user name: #{user}; password: #{pass}
+       OOOR plugin not loaded! Continuing..."""
+    end
+
+  end
+
+end
+
+
+require 'app/models/open_object_resource'
+require 'app/controllers/open_objects_controller'
+
+
+if defined?(Rails)
+  include Ooor
+  if Ooor.load_config['bootstrap']
+    Ooor.reload!(false, false, true)
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: ooor
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+  - Raphael Valyi - www.Akretion.com
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-31 00:00:00 -02:00
+default_executable: 
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: activeresource
+    type: :runtime
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+      version: 
+description: OOOR exposes business object proxies to your Ruby (Rails or not) application, that map seamlessly to your remote OpenObject/OpenERP server using webservices. It extends the standard ActiveResource API.
+email: rvalyi@akretion.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - README.md
+  - MIT-LICENSE
+  - lib/ooor.rb
+  - lib/app/models/open_object_resource.rb
+  - lib/app/controllers/open_objects_controller.rb
+has_rdoc: true
+homepage: http://code.google.com/p/ooor/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: OpenObject on Rails
+test_files: []
+