kangaroo 0.0.1.pre

data/lib/kangaroo/model/remote_execute.rb

@@ -0,0 +1,29 @@
+module Kangaroo
+  module Model
+    module RemoteExecute
+      def call name, *args
+        return_value = remote.send name, ids_for_execute, *args
+        
+        # TODO: handle warnings etc
+        if Hash === return_value && return_value[:value]
+          handle_updated_values return_value[:value] 
+          self
+        else
+          return_value
+        end
+      end
+      
+      protected
+      def handle_updated_values values
+        values.each do |key, value|
+          write_attribute key, value
+        end
+      end
+      
+      private
+      def ids_for_execute
+        new_record? ? [] : [id]
+      end
+    end
+  end
+end

data/lib/kangaroo/railtie.rb

@@ -0,0 +1,13 @@
+module Kangaroo
+  class Railtie < Rails::Railtie
+    initializer 'kangaroo.initialize' do
+      begin
+        config_file = File.join(Rails.root, %w(config kangaroo.yml))
+        configuration = Kangaroo::Util::Configuration.new config_file, Rails.logger
+        configuration.load_models
+      rescue Errno::ECONNREFUSED => e
+        Rails.logger.error "Could not connect to OpenERP XML-RPC Service."
+      end
+    end
+  end
+end

data/lib/kangaroo/ruby_adapter/base.rb

@@ -0,0 +1,28 @@
+require 'kangaroo/ruby_adapter/class_definition'
+require 'kangaroo/ruby_adapter/fields'
+
+module Kangaroo
+  module RubyAdapter
+    class Base
+      include ClassDefinition
+      include Fields
+      
+      attr_accessor :oo_model, :root_namespace
+
+      def initialize model
+        @oo_model = model
+        @root_namespace = model.class.namespace
+      end
+
+      # Adapt the OpenERP model to ruby
+      #
+      # return [Class] A Kangaroo::Model::Base subclass representing the OpenERP model
+      def to_ruby
+        define_class
+        add_fields
+
+        @ruby_model
+      end
+    end
+  end
+end

data/lib/kangaroo/ruby_adapter/class_definition.rb

@@ -0,0 +1,46 @@
+require 'kangaroo/model/base'
+
+module Kangaroo
+  module RubyAdapter
+    module ClassDefinition
+      def define_class
+        initialize_namespace
+        define_model_class
+      end
+
+      protected
+      def model_subclass
+        Class.new(Kangaroo::Model::Base)
+      end
+
+      def define_model_class
+        @ruby_model = set_const_in @namespace, constant_names.last, model_subclass
+
+        if !@ruby_model.is_a?(Class)
+          raise ChildDefinedBeforeParentError
+        end
+        @ruby_model.database = @oo_model.class.database
+
+        @ruby_model
+      end
+
+      def initialize_namespace
+        @namespace = @root_namespace
+
+        constant_names[1..-2].each do |mod|
+          @namespace = set_const_in @namespace, mod, Module.new
+        end
+      end
+
+      def constant_names
+        @constant_names ||= @oo_model.model_class_name.split("::")
+      end
+
+      # Set constant only if not already defined
+      def set_const_in mod, name, const
+        mod.const_set name, const unless mod.const_defined?(name)
+        mod.const_get name
+      end
+    end
+  end
+end

data/lib/kangaroo/ruby_adapter/fields.rb

@@ -0,0 +1,18 @@
+module Kangaroo
+  module RubyAdapter
+    module Fields
+      def add_fields
+        @ruby_model.define_multiple_accessors *field_names
+      end
+      
+      protected
+      def field_names
+        fields.map &:name
+      end
+      
+      def fields
+        @fields ||= @ruby_model.fields
+      end
+    end
+  end
+end

data/lib/kangaroo/util/client.rb

@@ -0,0 +1,59 @@
+require 'rapuncel'
+require 'kangaroo/util/database'
+require 'kangaroo/util/proxy'
+
+module Kangaroo
+  module Util
+    class Client < Rapuncel::Client
+      SERVICES = %w(db common object wizard report).freeze
+
+      # Initialize a Kangaroo XMLRPC Client
+      #
+      # @param [Hash] configuration configuration Hash
+      # @option configuration [String] 'host' Hostname or IP address
+      # @option configuration [String, Number] 'port' Port
+      def initialize configuration
+        super configuration.merge(:raise_on => :both)
+      end
+
+      # @private
+      def clone
+        super.tap do |c|
+          c.connection = connection.clone
+        end
+      end
+
+      SERVICES.each do |name|
+        class_eval <<-RUBY
+          def #{name}_service
+            @#{name}_service ||= clone.tap do |c|
+              c.connection.path = '/xmlrpc/#{name}'
+            end
+          end
+        RUBY
+      end
+
+      # Access the {Kangaroo::Util::Proxy::Superadmin Superadmin Proxy}
+      #
+      # @param [String] super_password Superadmin password
+      # @return [Kangaroo::Util::Proxy::Superadmin] Superadmin proxy
+      def superadmin super_password
+        Proxy::Superadmin.new db_service, super_password
+      end
+
+      # Access the {Kangaroo::Util::Proxy::Common Common Proxy}
+      #
+      # @return [Kangaroo::Util::Proxy::Common] Common proxy
+      def common
+        @common_proxy ||= Proxy::Common.new common_service
+      end
+
+      # Access the {Kangaroo::Util::Proxy::Db Db Proxy}
+      #
+      # @return [Kangaroo::Util::Proxy::Db] Db proxy
+      def db
+        @db_proxy ||= Proxy::Db.new db_service
+      end
+    end
+  end
+end

data/lib/kangaroo/util/configuration.rb

@@ -0,0 +1,82 @@
+require 'logger'
+require 'active_support/core_ext/hash'
+require 'kangaroo/util/client'
+require 'kangaroo/util/loader'
+
+module Kangaroo
+  module Util
+    class Configuration
+      attr_accessor :logger, :database, :models, :client
+
+      # Initialize the Kangaroo configuration
+      #
+      # @param [Hash, String] config_file_or_hash Configuration filename or Hash
+      # @param [Logger] logger logger instance
+      def initialize config_file_or_hash, logger = Logger.new(STDOUT)
+        @logger = logger
+        case config_file_or_hash
+        when String
+          configure_by_file config_file_or_hash
+        when Hash
+          configure_by_hash config_file_or_hash
+        end
+      end
+
+      # Load configured models with {Kangaroo::Util::Loader Loader}
+      #
+      def load_models
+        if models.blank?
+          logger.info "No models to load."
+          return
+        end
+
+        login
+        Loader.new(@database, models).load!
+        logger.info "Loaded OpenERP models matching #{models.inspect}."
+      rescue Exception => e
+        logger.error "Loading of OpenERP models failed.\n#{e.inspect}"
+      end
+
+      # Configure Kangaroo by YAML file
+      #
+      # @param [String] filename Filename to load YAML configuration from
+      def configure_by_file filename
+        configure_by_hash YAML.load_file(filename)
+      end
+
+      # Configure Kangaroo by Hash
+      #
+      # @param [Hash] config configuration Hash
+      # @option config [String] 'host' Hostname or IP address
+      # @option config [String, Number] 'port' Port
+      # @option config [Hash] 'database' Configuration for database
+      def configure_by_hash config
+        @client = Client.new config.slice('host', 'port')
+        configure_database config['database']
+      end
+
+      # Configure an OpenERP database
+      #
+      # @param [Hash] db_config database configuration hash
+      # @option db_config [String] 'name' Name of database
+      # @option db_config [String] 'user' Username to use for authentication
+      # @option db_config [String] 'password' Password for authentication
+      # @option db_config [Enumerable] 'models' List of models(-patterns) to load
+      def configure_database db_config
+        @database = Database.new @client, *db_config.values_at('name', 'user', 'password')
+        @models =  db_config['models']
+        logger.info %Q(Configured OpenERP database "#{db_config['name']}" at "#{client.connection.host}")
+      end
+
+      # Login to the configured database
+      #
+      def login
+        if @database.login
+          logger.info %Q(Authenticated user "#{@database.user}" for OpenERP database "#{@database.db_name}")
+        else
+          logger.warn %Q(Login to OpenERP database "#{@database.db_name}" with user "#{@database.user}" failed!)
+        end
+      end
+    end
+  end
+end

data/lib/kangaroo/util/database.rb

@@ -0,0 +1,92 @@
+module Kangaroo
+  module Util
+    class Database
+      attr_accessor :db_name, :user, :password, :user_id, :client
+
+      # Initialize a new OpenERP database configuration
+      #
+      # @param client A {Kangaroo::Util::Client Client} instance
+      # @param name Database name to configure
+      # @param user Username
+      # @param password Password
+      def initialize client, name, user, password
+        @client, @db_name, @user, @password = client, name, user, password
+      end
+
+      # Access to the {Kangaroo::Util::Proxy::Superadmin Superadmin Proxy}
+      #
+      # @param super_password superadmin password
+      # @return superadmin service proxy
+      def superadmin super_password
+        client.superadmin super_password
+      end
+
+      # Access to the {Kangaroo::Util::Proxy::Db Database Proxy}
+      #
+      # @return database service proxy
+      def db
+        client.db
+      end
+
+      # Access to the {Kangaroo::Util::Proxy::Common Common Proxy}
+      #
+      # @return common service proxy
+      def common
+        client.common
+      end
+
+      # Access to the {Kangaroo::Util::Proxy::Workflow Workflow Proxy}
+      #
+      # @return workflow service proxy
+      def workflow
+        @workflow_proxy ||= Proxy::Workflow.new client.object_service, db_name, user_id, password
+      end
+
+      # Access to the {Kangaroo::Util::Proxy::Object Object Proxy}
+      #
+      # @return object service proxy
+      def object model_name
+        Proxy::Object.new client.object_service, db_name, user_id, password, model_name
+      end
+
+      # Access to the {Kangaroo::Util::Proxy::Wizard Wizard Proxy}
+      #
+      # @return wizard service proxy
+      def wizard
+        @wizard_proxy ||= Proxy::Wizard.new client.wizard_service, db_name, user_id, password
+      end
+
+      # Access to the {Kangaroo::Util::Proxy::Report Report Proxy}
+      #
+      # @return report service proxy
+      def report
+        @report_proxy ||= Proxy::Report.new client.report_service, db_name, user_id, password
+      end
+
+      # Test of the current user is logged in
+      #
+      # @return true/false
+      def logged_in?
+        !!user_id
+      end
+
+      # Login the current user
+      #
+      # @return true/false
+      def login!
+        @user_id = common.login db_name, user, password
+
+        logged_in?
+      end
+
+      # Login the current user, unless logged in.
+      #
+      # @return true/false
+      def login
+        logged_in? || login!
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/kangaroo/util/loader.rb

@@ -0,0 +1,98 @@
+require 'active_support/core_ext/enumerable'
+require 'kangaroo/ruby_adapter/base'
+
+module Kangaroo
+  module Util
+    class Loader
+      autoload :Model, 'kangaroo/util/loader/model'
+      autoload :Namespace, 'kangaroo/util/loader/namespace'
+      attr_accessor :model_names, :models, :database, :namespace
+
+      # Initialize a Loader instance
+      #
+      # @param [Array] model_names List of model names / patterns to load
+      def initialize model_names, database, namespace = "Oo"
+        @namespace = namespace[0,2] == "::" ? namespace : "::#{namespace}"
+        @database = database
+        @model_names = model_names
+        sanitize_model_names
+      end
+
+      # Loads matching models and uses {Kangaroo::RubyAdapter::Base RubyAdapter} to
+      # create the neccessary Ruby classes.
+      #
+      # @return [Array] list of ruby models
+      def load!
+        load_oo_models
+        sort_oo_models
+        adapt_oo_models
+      end
+
+      protected
+      def root_module
+        namespace.constantize
+        
+      rescue NameError
+        eval <<-RUBY
+          module #{namespace}
+            extend Kangaroo::Util::Loader::Namespace
+          end
+        RUBY
+      end
+      
+      def ir_module
+        root_module.const_defined?("Ir") ?
+        root_module.const_get("Ir") :
+        root_module.const_set("Ir", Module.new)
+      end
+      
+      def reflection_model
+        ir_module.const_defined?("Model") ?
+        ir_module.const_get("Model") :
+        ir_module.const_set("Model", create_reflection_model)
+      end
+      
+      def create_reflection_model
+        Class.new(Kangaroo::Model::Base).tap do |model|
+          model.send :include, Model
+          model.database = database
+        end
+      end
+      
+      def load_oo_models
+        @models = model_names.sum([]) do |model_name|
+          reflection_model.where("model ilike #{model_name}").all
+        end.uniq
+      end
+
+      def sort_oo_models
+        @models = @models.sort_by &:length_of_model_name
+      end
+
+      def adapt_oo_models
+        @models.map do |model|
+          RubyAdapter::Base.new(model).to_ruby
+        end
+      end
+
+      def sanitize_model_names
+        @model_names = case @model_names
+        when nil, []
+          raise 'No models specified.'
+        when :all
+          ['%']
+        when Array
+          @model_names.map do |model_name|
+            replace_wildcard model_name
+          end
+        else
+          raise "Expected list of models or :all, got #{@model_names.inspect}"
+        end
+      end
+
+      def replace_wildcard string
+        string.gsub '*', '%'
+      end
+    end
+  end
+end