kangaroo 0.0.1.pre

data/lib/kangaroo/model/finder.rb

@@ -0,0 +1,92 @@
+require 'active_support/core_ext/module'
+
+module Kangaroo
+  module Model
+    module Finder
+      RELATION_DELEGATES = %w(where limit offset order select context reverse)
+      delegate *(RELATION_DELEGATES + [:to => :relation])
+
+      # Retrieve all records
+      #
+      # @return [Array] records
+      def all
+        relation.all
+      end
+
+      # ActiveRecord-ish find method
+      #
+      # @overload find(id)
+      #   Find a record by id
+      #   @param [Number] id
+      # @overload find(keyword)
+      #   Find all, first or last record
+      #   @param [String, Symbol] keyword :all, :first or :last
+      def find id_or_keyword
+        case id_or_keyword
+        when :all, 'all'
+          all
+        when :first, 'first'
+          first
+        when :last, 'last'
+          last
+        else
+          super
+        end
+      end
+
+      def exists? ids
+        where(:id => ids).exists?
+      end
+
+      # Retrieve first record
+      #
+      # @return record
+      def first
+        relation.first
+      end
+
+      # Retrieve last record
+      #
+      # @return record
+      def last
+        relation.last
+      end
+
+      # Count number of records
+      #
+      # @return [Number]
+      def count
+        count_by
+      end
+
+      # @private
+      # Search, read and instantiate records at once
+      #
+      # @param [Array, Hash, String] conditions
+      # @param [Hash] search_options
+      # @param [Hash] read_options
+      # @return [Array]
+      def search_and_read conditions, search_options = {}, read_options = {}
+        ids = search conditions, search_options.merge(:count => false)
+        return [] if ids.blank?
+
+        read ids, read_options
+      end
+
+      # @private
+      # Count objects matching the conditions
+      #
+      # @param [Array, Hash, String] conditions
+      # @param [Hash] search options
+      # @return [Number]
+      def count_by conditions = [], search_options = {}
+        search conditions, search_options.merge(:count => true)
+      end
+
+      # @private
+      def relation
+        Relation.new self
+      end
+    end
+  end
+end

data/lib/kangaroo/model/inspector.rb

@@ -0,0 +1,55 @@
+module Kangaroo
+  module Model
+    module Inspector
+      # @private
+      def self.included klass
+        klass.extend ClassMethods
+      end
+
+      # @private
+      def inspect
+        inspect_wrap do |str|
+          str << [inspect_id, *inspect_attributes].join(', ')
+        end
+      end
+
+      private
+      def inspect_id
+        "id: #{id.inspect}"
+      end
+
+      def inspect_attributes
+        attributes.to_a.map do |key_val|
+          name, value = key_val
+          [name, value.inspect].join ": "
+        end
+      end
+
+      def inspect_wrap
+        "".tap do |str|
+          str << "<#{self.class.name} "
+          yield str
+          str << ">"
+        end
+      end
+
+      # @private
+      module ClassMethods
+        def inspect
+          inspect_wrap do |str|
+            str << ['id', *attribute_names].join(', ')
+          end
+        end
+
+        private
+        def inspect_wrap
+          "".tap do |str|
+            str << "<#{name} "
+            yield str
+            str << ">"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kangaroo/model/open_object_orm.rb

@@ -0,0 +1,117 @@
+require 'kangaroo/model/condition_normalizer'
+require 'kangaroo/model/field'
+
+module Kangaroo
+  module Model
+    module OpenObjectOrm
+      include ConditionNormalizer
+
+      # Search for records in the OpenERP database
+      #
+      # @param [Hash, Array, String] conditions
+      # @param [Hash] options
+      # @option options [Number] limit
+      # @option options [Number] offset
+      # @option options [String] order
+      # @option options [Hash] context
+      # @option options [boolean] count
+      # @return list of ids
+      def search conditions, options = {}
+        options = {
+          :limit  => false,
+          :offset => 0
+        }.merge(options)
+
+        remote.search normalize_conditions(conditions),
+                      options[:offset],
+                      options[:limit],
+                      options[:order],
+                      options[:context],
+                      options[:count]
+      end
+
+      # Read records and instantiate them
+      #
+      # @param [Array] ids
+      # @param [Hash] options
+      # @option options [Array] fields
+      # @option options [Hash] context
+      # @return [Array] list of Kangaroo::Model::Base instances
+      def read ids, options = {}
+        fields = options[:fields]
+        fields = attribute_names if options[:fields].blank?
+        context = options[:context]
+
+        [].tap do |result|
+          remote.read(ids, fields, context).each do |attributes|
+            position = ids.index(attributes[:id].to_i)
+            result[position] = instantiate attributes, context
+          end
+        end
+      end
+
+      # Retrieve field informations
+      #
+      # @param [Hash] options
+      # @option options [Array] fields
+      # @option options [Hash] context
+      # @return [Hash]
+      def fields_get options = {}
+        options = {
+          :fields => attribute_names,
+          :context => {}
+        }.merge(options)
+
+        remote.fields_get(options[:fields], options[:context]).map do |key, val|
+          Field.new key, val
+        end
+      end
+
+      # Create a OpenObject record.
+      #
+      # @param [Hash] attributes
+      # @param [Hash] options
+      # @option options [Hash] context
+      # @return [Number] id
+      def create_record attributes, options = {}
+        remote.create attributes, options[:context]
+      end
+
+
+      # Fetch default attribute values from OpenERP database
+      #
+      # @param [Hash] options
+      # @option options [Array] fields
+      # @option options [Hash] context
+      # @return [Hash] default values
+      def default_get options = {}
+        options = {
+          :fields => attribute_names
+        }.merge(options)
+
+        remote.default_get options[:fields], options[:context]
+      end
+
+      # Write values to records
+      #
+      # @param [Array] ids
+      # @param [Hash] attributes
+      # @param [Hash] options
+      # @option options [Hash] context
+      # @return [boolean] true/false
+      def write_record ids, attributes, options = {}
+        remote.write ids, attributes, options[:context]
+      end
+
+      # Remove records
+      #
+      # @param [Array] ids
+      # @param [Hash] options
+      # @option options [Hash] context
+      # @return [boolean] true/false
+      def unlink ids, options = {}
+        remote.unlink ids, options[:context]
+      end
+    end
+  end
+end

data/lib/kangaroo/model/persistence.rb

@@ -0,0 +1,180 @@
+require 'kangaroo/exception'
+require 'active_support/core_ext/hash'
+
+module Kangaroo
+  module Model
+    module Persistence
+      # @private
+      def self.included klass
+        klass.extend ClassMethods
+        klass.define_model_callbacks :destroy, :save, :update, :create, :find
+        klass.after_destroy :mark_destroyed
+        klass.after_create :mark_persisted
+        klass.after_save :reload
+
+        klass.send :attr_accessor, :context
+
+        klass.before_initialize do
+          @destroyed  = false
+          @readonly   = false
+          @new_record = !@id
+        end
+      end
+
+      # Check if this record hasnt been persisted yet
+      #
+      # @return [boolean] true/false
+      def new_record?
+        @new_record
+      end
+
+      # Check if this record has been persisted yet
+      #
+      # @return [boolean] true/false
+      def persisted?
+        !@new_record
+      end
+
+      # Check if this record has been destroyed
+      #
+      # @return [boolean] true/false
+      def destroyed?
+        @destroyed
+      end
+
+      # Destroy this record
+      #
+      # @return self
+      def destroy
+        return true if destroyed? || new_record?
+        _run_destroy_callbacks do
+          remote.unlink [id], :context => context
+        end
+
+        self
+      end
+
+      # Save this record
+      #
+      # @param [Hash] options unused
+      # @return [boolean] true/false
+      def save options = {}
+        _run_save_callbacks do
+          create_or_update
+        end
+      end
+
+      # Save this record or raise an error
+      #
+      # @param [Hash] options unused
+      # @return [boolean] true
+      def save! options = {}
+        save options ||
+        raise(RecordSavingFailed)
+      end
+
+      # Reload this record, or just a subset of fields
+      #
+      # @param [Array] fields to reload
+      # @return self
+      def reload fields = self.class.attribute_names
+        @attributes = remote.read([id], fields, context).first.except(:id).stringify_keys
+        fields.each do |field|
+          @changed_attributes.delete field.to_s
+        end
+
+        self
+      end
+
+      module ClassMethods
+        # Initialize a record and immediately save it
+        #
+        # @param [Hash] attributes
+        # @return saved record
+        def create attributes = {}
+          new(attributes).tap do |new_record|
+            new_record.save
+          end
+        end
+
+        # Retrieve a record by id
+        #
+        # @param [Number] id
+        # @return record
+        # @raise RecordNotFound
+        def find id
+          Array === id ?
+          find_every(ids) :
+          find_single(id)
+        end
+
+        protected
+        def find_single id
+          read([id]).first ||
+          raise(RecordNotFound)
+        end
+
+        def find_every ids
+          read ids
+        end
+
+        def instantiate attributes, context = {}
+          allocate.tap do |instance|
+            instance.instance_exec(attributes.stringify_keys, context) do |attributes, context|
+              @attributes = attributes.except 'id'
+              @id = attributes['id']
+              @context = context
+              raise InstantiatedRecordNeedsIDError if @id.nil?
+
+              @new_record = false
+              @destroyed  = false
+              @readonly   = false
+
+              _run_initialize_callbacks
+              _run_find_callbacks
+            end
+          end
+        end
+      end
+
+      protected
+      def attributes_for_update
+        @attributes
+      end
+
+      def attributes_for_create
+        @attributes
+      end
+
+      def create_or_update
+        new_record? ? create : update
+      end
+
+      private
+      def create
+        _run_create_callbacks do
+          if id = self.class.create_record(attributes_for_create, :context => context)
+            @id = id
+          else
+            false
+          end
+        end
+      end
+
+      def update
+        _run_update_callbacks do
+          self.class.write_record [id], attributes_for_update, :context => context
+        end
+      end
+
+      def mark_persisted
+        @new_record = false
+      end
+
+      def mark_destroyed
+        @destroyed = true
+        freeze
+      end
+    end
+  end
+end

data/lib/kangaroo/model/relation.rb

@@ -0,0 +1,212 @@
+module Kangaroo
+  module Model
+    class Relation
+      # @private
+      ARRAY_DELEGATES = %w( all? any? as_json at b64encode blank? choice class clone collect collect! combination compact compact! concat
+                            cycle decode64 delete delete_at delete_if detect drop drop_while dup duplicable? each each_cons each_index
+                            each_slice each_with_index each_with_object empty? encode64 encode_json entries enum_cons enum_for enum_slice
+                            enum_with_index eql? equal? exclude? extract_options! fetch fifth fill find_all find_index flatten
+                            flatten! forty_two fourth freeze frozen? grep group_by html_safe? in_groups in_groups_of include? index
+                            index_by indexes indices inject insert inspect instance_eval instance_exec instance_of? is_a? join kind_of?
+                            last many? map map! max max_by member? min min_by minmax minmax_by nitems none? one? pack paginate
+                            partition permutation pop presence present? pretty_inspect pretty_print pretty_print_cycle pretty_print_inspect
+                            pretty_print_instance_variables product push rassoc reduce reject reject! replace respond_to? returning reverse
+                            reverse! reverse_each rindex sample second shelljoin shift shuffle shuffle! slice slice! sort sort!
+                            sort_by split sum take take_while tap third to to_ary to_default_s to_enum to_formatted_s to_json to_matcher
+                            to_param to_query to_s to_sentence to_set to_xml to_xml_rpc to_yaml to_yaml_properties to_yaml_style transpose
+                            type uniq uniq! uniq_by uniq_by! unshift values_at yaml_initialize zip |).freeze
+
+      # @private
+      attr_accessor :target, :where_clauses, :offset_clause, :limit_clause, :select_clause, :order_clause, :context_clause
+
+      alias_method :_clone, :clone
+      alias_method :_tap, :tap
+
+      delegate *(ARRAY_DELEGATES + [:to => :to_a])
+
+      # @private
+      def initialize target
+        @target     = target
+        @where_clauses = []
+        @select_clause = []
+        @order_clause  = []
+        @context_clause = {}
+      end
+
+      # Submit the query
+      def to_a
+        @target.search_and_read @where_clauses, search_parameters, read_parameters
+      end
+      alias_method :all, :to_a
+
+      # Return only the first record
+      def first
+        limit(1).to_a.first
+      end
+
+      # Return only the last record
+      def last
+        reverse.first
+      end
+
+      # Check if a record with fulfilling this conditions exist
+      def exists?
+        @target.search(@where_clauses, search_parameters.merge(:limit => 1)).present?
+      end
+
+      # Find record(s) by id(s)
+      def find ids
+        records = where(:id => ids)
+
+        Array === ids ?
+        records.all :
+        records.first
+      end
+
+      # Count how many records fulfill this conditions
+      def count
+        @target.count_by @where_clauses, search_parameters
+      end
+      alias_method :size, :count
+      alias_method :length, :count
+
+      # Reverse all order clauses
+      def reverse
+        if @order_clause.blank?
+          order('id', true)
+        else
+          _clone._tap do |c|
+            c.order_clause = c.order_clause.map do |order|
+              reverse_order order
+            end
+          end
+        end
+      end
+
+      # Clone this relation and add the condition to the where clause
+      #
+      # @param [Hash, Array, String] condition
+      # @return [Relation] cloned relation
+      def where condition
+        _clone._tap do |c|
+          c.where_clauses += [condition]
+        end
+      end
+
+      # Clone this relation and (re)set the limit clause
+      #
+      # @param [Number] limit maximum records to retriebe
+      # @return [Relation] cloned relation
+      def limit limit
+        _clone._tap do |c|
+          c.limit_clause = limit
+        end
+      end
+
+      # Clone this relation and (re)set the offset clause
+      #
+      # @param [Number] offset number of records to skip
+      # @return [Relation] cloned relation
+      def offset offset
+        _clone._tap do |c|
+          c.offset_clause = offset
+        end
+      end
+
+      # Clone this relation and add select expressions to select clause
+      #
+      # @param [Array, String, Symbol] selects fields to retrieve
+      # @return [Relation] cloned relation
+      def select *selects
+        selects = selects.flatten.map &:to_s
+        _clone._tap do |c|
+          c.select_clause += selects
+        end
+      end
+
+      # Clone this relation and add a context
+      #
+      # @param [Hash] context
+      # @return [Relation] cloned relation
+      def context context = {}
+        _clone._tap do |c|
+          c.context_clause = c.context_clause.merge(context)
+        end
+      end
+
+      # Clone this relation and add an order instruction
+      #
+      # @param [String, Symbol] column field to order by
+      # @param [boolean] desc true to order descending
+      def order column, desc = false
+        column = column.to_s + " desc" if desc
+        _clone._tap do |c|
+          c.order_clause += [column.to_s]
+        end
+      end
+
+      # Shortcut to set limit and offset and execute queries immediately.
+      # If {#limit} or {#offset} are already set, [] is equal to #to_a[]
+      #
+      # @overload [](n)
+      #   @param [Number] n
+      #   @return [Kangaroo::Model::Base] n-th record
+      # @overload [](n, m)
+      #   @param [Number] n
+      #   @param [Number] m
+      #   @return [Array<Kangaroo::Model::Base>] m records, offset n
+      # @overload [](n..m)
+      #   @param [Range] range n..m
+      #   @return [Array<Kangaroo::Model::Base>] records m to n
+      def [] start_or_range, stop = nil
+        if @limit_clause || @offset_clause
+          return to_a[start_or_range, stop] if stop
+          return to_a[start_or_range]
+        end
+
+        c = _clone
+
+        c.offset_clause = if start_or_range.is_a?(Range)
+          range_end = start_or_range.end
+          range_end += 1 unless start_or_range.exclude_end?
+
+          c.limit_clause = range_end - start_or_range.begin
+          start_or_range.begin
+        elsif stop
+          c.limit_clause = stop
+          start_or_range
+        else
+          c.limit_clause = 1
+          start_or_range
+        end
+
+        (stop.nil? && Integer===start_or_range) ? c.to_a.first : c.to_a
+      end
+
+      protected
+      def search_parameters
+        {
+          :offset => @offset_clause,
+          :limit => @limit_clause,
+          :order => @order_clause.join(", "),
+          :context => @context_clause
+        }
+      end
+
+      def read_parameters
+        {
+          :fields => @select_clause,
+          :context => @context_clause
+        }
+      end
+
+      def reverse_order order
+        if match = order.match(/(.*)\sdesc/i)
+          match[1]
+        else
+          order + " desc"
+        end
+      end
+    end
+  end
+end