ooor 1.9.2 → 2.0.0

data/README.md

@@ -1,96 +1,48 @@
-OOOR - OpenObject On Ruby:
-====
-
-<table>
-    <tr>
-        <td width="159px"><a href="http://github.com/rvalyi/ooor" title="OOOR - OpenObject On Ruby"><img src="http://akretion.s3.amazonaws.com/assets/ooor_m.jpg" width="159px" height="124px" /></a></td>
-        <td><b>BY</b></td>
-        <td width="320px"><a href="http://www.akretion.com" title="Akretion - open source to spin the world"><img src="http://akretion.s3.amazonaws.com/assets/logo.png" width="320px" height="154px" /></a></td>
-        <td width="285px">
-OOOR stands for OpenObject On Ruby. 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 OpenObject application, to your custom Ruby or 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 Ruby application without Rails. It's also fully JRuby compatible and hence make the bridge between the Python OpenERP and the Java ecosystem.
-        </td>
-    </tr>
-</table>
-
-
-Why?
-------------
-
-OpenERP makes it really straightforward to create custom business applications with:
+[![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)
 
-* standard ERP business modules (more than 500 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
+[![OOOR by Akretion](https://s3.amazonaws.com/akretion/assets/ooor_by_akretion.png)](http://akretion.com)
 
-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.
+Why use Ooor?
+-------------
 
-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. Notice that despite its name OOOR doens't hold a dependency upon Rails anymore.
+* Ooor is an **administration Swiss Army knife** in interactive IRB sessions. It lets you connect remotely to any running OpenERP instance without stopping it, without compromising its security. It has tab auto-completion and object introspection features.
+* Ooor is a **data migration tool** (inside Kettle with the TerminatOOOR JRuby plugin). Your favorite ETL with OpenERP API super-powers!
+* Ooor is the basis for unleashed **web development**, using any **Rack** framework such as **Sinatra** or **Rails**.
 
-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.
-We use RSpec to test OOOR againt OpenERP [here](http://github.com/rvalyi/ooor/blob/master/spec/ooor_spec.rb) and thanks to the initiative of CampToCamp, the OpenERP community tests OpenERP business features extensively
-using Cucumber in [OEPScenario](http://launchpad.net/oerpscenario).
+OpenERP is all the rage for ERP back-offices, but sometimes you want **freedom and scalablity** for your web front ends and this is exactly what Ooor offers you. It enables you to just **reuse OpenERP Model layer** (yay! no data duplication!) and let you build the other layers much the way you want, possibly standing on the shoulders of giants like Rails. Ooor even has an optionnal Rack filter that enables you to proxy some OpenERP applications of your choice (say the shopping cart for instance) and share the HTTP session with it. Ooor is also published under the **MIT licence** so it frees you from the OpenERP AGPL license contamination for your web developements.
 
-An other usage of OOOR, is it ability to bridge the OpenERP Python world and and the Java world thanks to its JRuby compatibility. This is especially useful in to do extensive "Data Integration" with OpenERP and benefit from the
-most powerful Java based ETL's. The main project here is [TerminatOOOR](http://github.com/rvalyi/terminatooor), a Pentaho ETL Kettle 4 plugin allowing to push/pull data into/from OpenERP with an incomparable flexibility and yet benefit
-all standard ETL features, including the AgileBI OLAP business intelligence plugin.
 
-Finally you might also want to use OOOR simply to expose your OpenERP through REST to other consumer applications using [the OOOREST project](http://github.com/rvalyi/ooorest).
+Related projects - a full web stack!
+------------------------------------
 
+* [Ooorest](http://github.com/akretion/ooorest), Ooor is the **Model** layer of **MVC**. Ooorest is the **Controller** layer, enforcing a clean Railish **REST API** and offering handy **helper** to use OpenERP in your Rails application.
+* [Aktooor](http://github.com/akretion/aktooor), Aktoor is the missing **View** layer of **MVC**. It's based on [SimpleForm](https://github.com/plataformatec/simple_form), that is a clean minimalist framework that extend Rails form framework over [Twitter Bootstrap](http://getbootstrap.com)
+* [Erpify](http://github.com/akretion/erpify), Erpify is OpenERP inside the Liquid non evaling language, that is the templating language of Shopify or LocomotiveCMS for instance.
+* [Locomotive-erpify](http://github.com/akretion/locomtive-erpify), Erpify for LocomotiveCMS, both the engine and the Wagon local editor
+* [Solarize](http://github.com/akretion/solarize), pulling data from OpenERP relational database may not scale to your need. No problem with Solarize: you can index your OpenERP data with the [Solerp](http://github.com/akretion/solerp) OpenERP module, then search it using SolR API and even load it from SolR without even hitting OpenERP!
+* [TerminatOOOR](http://github.com/rvalyi/terminatooor), a Pentaho ETL Kettle plugin allowing to push/pull data into/from OpenERP with an incomparable flexibility and yet benefit all standard ETL features, including the AgileBI OLAP business intelligence plugin.
 
 
 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 it.
-
-OOOR aims at being a very simple piece of code (< 500 lines of code; e.g no bug, [heavility tested](http://github.com/rvalyi/ooor/blob/master/spec/ooor_spec.rb), 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](http://api.rubyonrails.org/classes/ActiveResource/Base.html), the standard way of remoting you ActiveRecord Rails models with REST.
+OpenERP is a Python based open source ERP. But every action in OpenERP is actually exposed as a webservice (SOA orientation, close to being RESTful).
+Ooor doesn't connect to the OpenERP database, instead it uses the OpenERP data access **JSON API** so it fully enforces OpenERP security model and business logic.
 
-Remember, ActiveResource is actually simpler than [ActiveRecord](http://api.rubyonrails.org/classes/ActiveRecord/Base.html). 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 is less than 2000 lines of code. It has a test coverage of around 80%. It doesn't embed any business rule, it's just a client to OpenERP. The code of Ooor is modeled after Rails [ActiveModel](http://api.rubyonrails.org/classes/ActiveModel/Model.html), [ActiveResource](https://github.com/rails/activeresource) and [ActiveRecord](http://api.rubyonrails.org/classes/ActiveRecord/Base.html) layers.
 
-OOOR implements ActiveResource public API almost fully. It means that you can remotely work on any OpenERP model using [the standard ActiveResource API](http://api.rubyonrails.org/classes/ActiveResource/Base.html).
+More specifically, an OpenERP Ooor proxy implements the ActiveModel API. Instead of depending on ActiveResource which is actually a bit different (not multi-tenant, little access right management), we copied a tiny subset of it in the mini_active_resource.rb file and OpenERP proxies include this module. Finally Ooor emulates the ActiveRecord API wherever possible delegating its requests to OpenERP using OpenERP domain [S expressions](http://en.wikipedia.org/wiki/S-expression) instead of SQL. The ActiveRecord API emulation is actually pretty good: think **Ooor looks more like ActiveRecord than Mongoid**; it has associations, surface ARel API, Reflection API, can be paginated via Kaminary, can be integrated with SimpleForm or Cocoon seamlessly...
 
-But, OOOR goes actually a bit further: it does implements model associations (one2many, many2many, many2one, single table inheritance, polymorphic associations...).
-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.
+Ooor features **several session modes**: in the default IRB console usage it uses a global login scheme and generate constants for your OpenERP proxies, such as ProductProduct for the product.product OpenERP object much like Rails ActiveRecord. In web mode instead, you can have several sessions and do session['product.product'] to get a proxy to the Product object matching your current session credentials, chosen database and OpenERP url (yes Ooor is not only multi-database like OpenEP, it's in fact **multi-OpenERP**!)
 
 
 Installation
 ------------
 
-You can use OOOR in a standalone (J)Ruby application, or in a Rails application, it only depends on the activeresource gem.
-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 Ruby, then the rubygems package manager and finally the ooor gem with:
-
     $ 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)
 
+(Warning Ooor has been ureleased for several months, don't hesitate to run the git version instead)
 
 Trying it simply
 ------------
@@ -130,7 +82,7 @@ Please read details [https://github.com/rvalyi/ooor/wiki/(J)Ruby-on-Rails-applic
 API usage
 ------------
 
-Note: Ruby proxies objects are named after OpenERP models in but removing the '.' and using CamelCase.
+Note: Ruby proxy 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:

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/ooor

@@ -4,6 +4,7 @@ puts "*** OOOR - OpenObject on Ruby! Published under the MIT license by Akretion
 
 require 'irb'
 require 'rubygems'
+require 'logger'
 require 'ooor'
 require 'irb/completion'
   

data/lib/ooor.rb

@@ -1,155 +1,113 @@
 #    OOOR: OpenObject On Ruby
-#    Copyright (C) 2009-2012 Akretion LTDA (<http://www.akretion.com>).
+#    Copyright (C) 2009-2013 Akretion LTDA (<http://www.akretion.com>).
 #    Author: Raphaël Valyi
 #    Licensed under the MIT license, see MIT-LICENSE file
 
+require 'active_support/dependencies/autoload'
+require 'active_support/concern'
+require 'active_support/cache'
 require 'logger'
-require 'app/models/open_object_resource'
-require 'app/models/services'
-require 'app/models/base64'
-require 'app/ui/client_base'
+
 
 module Ooor
-  def self.new(*args)
-    Ooor.send :new, *args
-  end
+  extend ActiveSupport::Autoload
+  autoload :Base
+  autoload :Cache, 'active_support/cache'
+  autoload :Serialization
+  autoload :Relation
+  autoload :TypeCasting
+  autoload :Naming
+  autoload :Associations
+  autoload :FieldMethods
+  autoload :Report
+  autoload :Locale
+  autoload :Transport
+  autoload :Block
+  autoload :MiniActiveResource
+  autoload :SessionHandler
+  autoload :ModelRegistry
+  autoload :UnknownAttributeOrAssociationError, 'ooor/errors'
+  autoload :OpenERPServerError, 'ooor/errors'
+  autoload :HashWithIndifferentAccess, 'active_support/core_ext/hash/indifferent_access'
 
-  def self.xtend(model_name, &block)
-    @extensions ||= {}
-    @extensions[model_name] ||= []
-    @extensions[model_name] << block
-    @extensions
+  autoload_under 'relation' do
+    autoload :FinderMethods
   end
 
-  def self.extensions
-    @extensions
-  end
-  
-  class Ooor
-    include DbService
-    include CommonService
-    include ReportService
-    include ClientBase
-
-    cattr_accessor :default_ooor, :default_config
-    attr_accessor :logger, :config, :loaded_models, :base_url, :global_context, :ir_model_class
-
-    #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'
-      @config = YAML.load_file(config_file)[env || 'development']
-    rescue SystemCallError
-      puts """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"""
-      {}
-    end
+  module OoorBehavior
+    extend ActiveSupport::Concern
+    module ClassMethods
+      
+      attr_accessor :default_config, :default_session, :cache_store
+      
+      IRREGULAR_CONTEXT_POSITIONS = {
+        import_data: 5,
+        fields_view_get: 2,
+        search: 4,
+        name_search:  3,
+        read_group: 5,
+        fields_get: 1,
+        read: 2,
+        perm_read: 1,
+        check_recursion: 1
+      }
 
-    def get_rpc_client(url)
-      @rpc_clients ||= {}
-      unless @rpc_clients[url]
-        if defined?(Java) && @config[:rpc_client] != 'ruby'
-          begin
-            require 'jooor'
-            @rpc_clients[url] = get_java_rpc_client(url)
-          rescue LoadError
-            puts "WARNING falling back on Ruby xmlrpc/client client (much slower). Install the 'jooor' gem if you want Java speed for the RPC!"
-            @rpc_clients[url] = get_ruby_rpc_client(url)
-          end
-        else
-          @rpc_clients[url] = get_ruby_rpc_client(url)
+      def new(config={})
+        Ooor.default_config = config.merge(generate_constants: true)
+        session = session_handler.retrieve_session(config)
+        if config[:database] && config[:password]
+          session.global_login(config)
         end
+        Ooor.default_session = session
       end
-      @rpc_clients[url]
-    end
 
-    def get_ruby_rpc_client(url)
-      require 'app/models/client_xmlrpc'
-      XMLClient.new2(self, url, nil, @config[:rpc_timeout] || 900)
-    end
+      def cache(store=nil)
+        @cache_store ||= ActiveSupport::Cache.lookup_store(store)
+      end
 
-    def initialize(config, env=false)
-      @config = config.is_a?(String) ? Ooor.load_config(config, env) : config
-      @config.symbolize_keys!
-      @logger = ((defined?(Rails) && $0 != 'irb' && Rails.logger || @config[:force_rails_logger]) ? Rails.logger : Logger.new($stdout))
-      @logger.level = @config[:log_level] if @config[:log_level]
-      OpenObjectResource.logger = @logger
-      @base_url = @config[:url] = "#{@config[:url].gsub(/\/$/,'').chomp('/xmlrpc')}/xmlrpc"
-      @loaded_models = []
-      scope = Module.new and Object.const_set(@config[:scope_prefix], scope) if @config[:scope_prefix]
-      global_login(@config[:username] || 'admin', @config[:password] || 'admin', @config[:database], @config[:models]) if @config[:database]
-    end
+      def xtend(model_name, &block)
+        @extensions ||= {}
+        @extensions[model_name] ||= []
+        @extensions[model_name] << block
+        @extensions
+      end
 
-    def const_get(model_key)
-      @ir_model_class.const_get(model_key)
-    end
+      def extensions
+        @extensions ||= {}
+      end
+
+      def session_handler() @session_handler ||= SessionHandler.new; end
+      def model_registry() @model_registry ||= ModelRegistry.new; end
+      
+      def logger
+        @logger ||= Logger.new($stdout)
+      end
+      
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def irregular_context_position(method)
+        IRREGULAR_CONTEXT_POSITIONS.merge(default_config[:irregular_context_positions] || {})[method.to_sym]
+      end
 
-    def global_login(user, password, database=@config[:database], model_names=false)
-      @config[:username] = user
-      @config[:password] = password
-      @config[:database] = database
-      @config[:user_id] = login(database, user, password)
-      load_models(model_names, true)
     end
 
-    def load_models(model_names=false, reload=@config[:reload])
-      @global_context = @config[:global_context] || {}
-      ([File.dirname(__FILE__) + '/app/helpers/*'] + (@config[:helper_paths] || [])).each {|dir|  Dir[dir].each { |file| require file }}
-      @ir_model_class = define_openerp_model({'model' => 'ir.model'}, @config[:scope_prefix])
-      model_ids = model_names && @ir_model_class.search([['model', 'in', model_names]]) || @ir_model_class.search() - [1]
-      models = @ir_model_class.read(model_ids, ['model', 'name'])#['name', 'model', 'id', 'info', 'state', 'field_id', 'access_ids'])
-      @global_context.merge!({}).merge!(@config[:global_context] || {}) #TODO ensure it's required
-      models.each {|openerp_model| define_openerp_model(openerp_model, @config[:scope_prefix], nil, nil, nil, nil, reload)}
+
+    def with_ooor_session(config={}, id=nil)
+      yield Ooor.session_handler.retrieve_session(config, id)
     end
 
-    def define_openerp_model(param, scope_prefix=nil, url=nil, database=nil, user_id=nil, pass=nil, reload=false)
-      model_class_name = OpenObjectResource.class_name_from_model_key(param['model'])
-      scope = scope_prefix ? Object.const_get(scope_prefix) : Object
-      if reload || !scope.const_defined?(model_class_name)
-        klass = Class.new(OpenObjectResource)
-        klass.ooor = self
-        klass.site = url || @base_url
-        klass.user = user_id
-        klass.password = pass
-        klass.database = database
-        klass.openerp_model = param['model']
-        klass.openerp_id = url || param['id']
-        klass.info = (param['info'] || '').gsub("'",' ')
-        klass.name = model_class_name
-        klass.description = param['name']
-        klass.state = param['state']
-        #klass.field_ids = param['field_id']
-        #klass.access_ids = param['access_ids']
-        klass.many2one_associations = {}
-        klass.one2many_associations = {}
-        klass.many2many_associations = {}
-        klass.polymorphic_m2o_associations = {}
-        klass.associations_keys = []
-        klass.fields = {}
-        klass.scope_prefix = scope_prefix
-        @logger.debug "registering #{model_class_name} as an ActiveResource proxy for OpenObject #{param['model']} model"
-        scope.const_set(model_class_name, klass)
-        (::Ooor.extensions[param['model']] || []).each {|block| klass.class_eval(&block)}
-        @loaded_models.push(klass)
-        return klass
+    def with_ooor_default_session(config={})
+      if config
+        Ooor.new(config)
       else
-        return scope.const_get(model_class_name)
+        Ooor.default_session
       end
     end
   end
-  
-  if defined?(Rails) #Optional autoload in Rails:
-    if Rails.version[0] == "3"[0] #Rails 3 bootstrap
-      class Railtie < Rails::Railtie
-        initializer "ooor.middleware" do |app|
-          Ooor.default_config = Ooor.load_config(false, Rails.env)
-          Ooor.default_ooor = Ooor.new(Ooor.default_config) if Ooor.default_config['bootstrap']
-        end
-      end
-    else #Rails 2.3.x bootstrap
-      Ooor.default_config = Ooor.load_config(false, RAILS_ENV)
-         Ooor.default_ooor = Ooor.new(Ooor.default_config) if Ooor.default_config['bootstrap']
-     end
-  end
+
+  include OoorBehavior
 end
+
+require 'ooor/railtie' if defined?(Rails)

data/lib/ooor/associations.rb

@@ -0,0 +1,64 @@
+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
+      end
+    end
+
+    def x_to_many_ids_method(rel, *arguments)
+      if @associations[rel]
+        @associations[rel]
+      else
+        method_missing(rel.to_sym, *arguments)
+      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)
+        else
+          false
+        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)
+        values = @associations[method_name].split(',')
+        load_association(values[0], values[1].to_i, nil, *arguments)
+      else
+        false
+      end
+    end
+
+    def load_association(model_key, ids, substitute=nil, *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
+    end
+
+  end
+end