aqua 0.1.6 → 0.2.0

data/lib/aqua/object/pack.rb

@@ -11,11 +11,11 @@ module Aqua
         extend ClassMethods
         include InstanceMethods
       
-        unless instance_methods.include?( 'id=' ) || new.instance_variables.include?( '@id' )
+        unless instance_methods.include?( 'id=' ) # || new.instance_variables.include?( '@id' )
           attr_accessor :id
         end
       
-        hide_attributes :_store, :__pack, :id, :_rev 
+        hide_attributes :_store, :__pack, :id, :_rev, :_translator 
       end  
     end
   
@@ -65,8 +65,8 @@ module Aqua
         end 
       end # InstanceMethods     
     end   
-  
-    module ClassMethods 
+    
+    module ClassMethods  
     end # ClassMethods
   
     module InstanceMethods
@@ -91,12 +91,25 @@ module Aqua
         self.__pack = Storage.new
         self.__pack.id = @id if @id
         self.__pack[:_rev] = _rev if _rev 
-        self.__pack[:keys] = []
-        self.__pack[:stubs] = [] 
-        self.__pack.merge!( _pack_object( self ) )
-        _pack_singletons
+        self.__pack.merge!( _translator.pack_object( self ) ) 
+        _pack_attachments
         __pack
       end
+      
+      def _pack_attachments 
+        _translator.attachments.each do |file|
+          self.__pack.attachments.add( file.filename, file )
+        end  
+      end   
+      
+      # Translator object responsible for packing the object and keeping track of externally
+      # stored records and also attachments
+      # @return [Translator]
+      # 
+      # @api private
+      def _translator
+        @_translator ||= Translator.new( self )
+      end  
     
       # Details from configuration options for the objects class about embedability. 
       # @return [true, false, Hash] If true then it should be embedded in the object at hand. 
@@ -105,74 +118,21 @@ module Aqua
       #   with a few cached methods as defined in the array.
       # 
       # @api private
-      def _embed_me 
-        self.class._aqua_opts[:embed]
+      def _stubbed_methods 
+        meths = !_embedded? && self.class._aqua_opts[:embed] && self.class._aqua_opts[:embed][:stub]
+        meths ? [meths].flatten : []
       end 
-    
-      # Packs an object into data and meta data. Works recursively sending out to array, hash, etc.  
-      # object packers, which send their values back to _pack_object
-      #
-      # @param Object to pack
-      # @return [Mash] Indifferent hash that is the data/metadata deconstruction of an object.
-      #
-      # @api private
-      def _pack_object( obj ) 
-        klass = obj.class
-        if klass == String
-          obj
-        elsif obj.respond_to?(:to_aqua) # Types requiring initialization
-          obj.to_aqua( self )
-        elsif obj.aquatic? && obj != self
-          if obj._embed_me == true
-            obj._pack
-          else
-            _build_stub( obj ) 
-          end   
-        else # other object without initializations
-          _pack_vanilla( obj )
-        end     
-      end
-     
-      # Packs the ivars for a given object.  
-      #
-      # @param Object to pack
-      # @return [Mash] Indifferent hash that is the data/metadata deconstruction of an object.
-      #
-      # @api private
-      def _pack_ivars( obj )
-        return_hash = {}
-        vars = obj.respond_to?(:_storable_attributes) ? obj._storable_attributes : obj.instance_variables
-        vars.each do |ivar_name|
-          ivar = obj.instance_variable_get( ivar_name )
-          return_hash[ivar_name] = _pack_object( ivar ) unless ivar.nil?       
-        end
-        return_hash
-      end
-    
-      # Handles the case of an hash-like object with keys that are objects  
-      #
-      # @param Object to pack
-      # @return [Integer] Index of the object in the keys array, used by the hash packer to name the key
-      #
+      
+      # Details from configuration options for the objects class about embedability. 
+      # @return [true, false] If true then it should be embedded in the base object. 
+      #   If false, then it should be saved externally. 
+      # 
       # @api private
-      def _build_object_key( obj )
-        index = self.__pack[:keys].length
-        self.__pack[:keys] << _pack_object( obj )
-        index # return key
+      def _embedded? 
+        self.class._aqua_opts[:embed] == true
       end 
       
-      # Adds an attachment to the __pack document. Before save the attachments are encoded into the doc  
-      #
-      # @param [String] filename used as the key/index
-      # @param [File, Tempfile] file to be attached
-      #
-      # @api semi-public
-      def _pack_file( filename, file )
-        __pack.attachments.add( filename, file )
-      end     
-           
-    
-      attr_accessor :_warnings 
+      attr_accessor :_warnings, :_rev 
        
       # Private/protected methods are all prefaced by an underscore to prevent
       # clogging the object instance space. Some of the public ones above are too!
@@ -187,7 +147,7 @@ module Aqua
         # do without this accessor, but it would mean that an extra get request would have to be
         # made with each PUT request so that the latest _rev could be obtained. 
         #
-        attr_accessor :_store, :__pack, :_rev
+        attr_accessor :_store, :__pack
       
       private
       
@@ -206,61 +166,13 @@ module Aqua
           if result
             self.id =   __pack.id
             self._rev = __pack.rev
-            _clear_accessors
+            _clear_aqua_accessors
             self
           else
             result
           end    
         end    
        
-        # Object packing methods ------------
-      
-        # Packs the an object requiring no initialization.  
-        #
-        # @param Object to pack
-        # @return [Mash] Indifferent hash that is the data/metadata deconstruction of an object.
-        #
-        # @api private 
-        def _pack_vanilla( obj ) 
-          {
-            'class' => obj.class.to_s,
-            'ivars' => _pack_ivars( obj )
-          }
-        end
-      
-        # Packs the stub for an externally saved object.  
-        #
-        # @param Object to pack
-        # @return [Mash] Indifferent hash that is the data/metadata deconstruction of an object.
-        #
-        # @api private    
-        def _build_stub( obj )
-          index = self.__pack[:stubs].length 
-          stub = { :class => obj.class.to_s, :id => obj } 
-          # deal with cached methods
-          if obj._embed_me && obj._embed_me.keys && stub_methods = obj._embed_me[:stub]
-            stub[:methods] = {}
-            if stub_methods.class == Symbol || stub_methods.class == String
-              stub_method = stub_methods.to_sym 
-              stub[:methods][stub_method] = obj.send( stub_method )
-            else # is an array of values
-              stub_methods.each do |meth|
-                stub_method = meth.to_sym
-                stub[:methods][stub_method] = obj.send( stub_method )
-              end  
-            end    
-          end
-          # add the stub  
-          self.__pack[:stubs] << stub
-          # return a hash  
-          {'class' => 'Aqua::Stub', 'init' => "/STUB_#{index}"}
-        end 
-      
-        def _pack_singletons
-          # TODO: figure out 1.8 and 1.9 compatibility issues. 
-          # Also learn the library usage, without any docs :(
-        end    
-      
         # Saves all self and nested object requiring independent saves
         # 
         # @return [Object, false] Returns false on failure and self on success.
@@ -276,31 +188,43 @@ module Aqua
         #
         # @api private
         def _commit_externals 
-          __pack[:stubs].each_with_index do |obj_hash, index|
-            obj = obj_hash[:id]
+          _translator.externals.each do |obj, path|
             if obj.commit
-              obj_hash[:id] = obj.id
+              _update_external_id( path, obj.id )
             else
-              if obj.id
-                self._warnings << "Unable to save latest version of #{obj.inspect}, stubbed at index #{index}"
-                obj_hash[:id] = obj.id if obj.id 
-              else  
-                self._warnings << "Unable to save #{obj.inspect}, stubbed at index #{index}" 
-              end  
+              self._warnings << ( obj.id ? 
+                 "Unable to save latest version of #{obj.inspect}, stubbed at #{path}" :
+                 "Unable to save #{obj.inspect}, stubbed at #{path}" 
+              )
             end    
           end  
         end 
+        
+        # When external objects are saved to the base object, ids need to be updated after save
+        # This is the method used to locate the original id and updated it
+        # 
+        # @param [String] path to external
+        # @param [String] id to save
+        # 
+        # @api private
+        def _update_external_id( path, new_id )
+          __pack.instance_eval "self#{path}['init']['id'] = '#{new_id}'"
+        end    
+
       
         # clears the __pack and _store accessors to save on memory after each pack and unpack
         # 
         # @api private
-        def _clear_accessors
+        def _clear_aqua_accessors
           self.__pack = nil
           self._store = nil
+          @_translator = nil
         end
               
       public  
     end # InstanceMethods     
   end # Pack
+  
+
 end # Aqua 
   

data/lib/aqua/object/query.rb

@@ -4,12 +4,40 @@ module Aqua::Query
     klass.class_eval do
       extend ClassMethods
       include InstanceMethods
+      
+      klass.class_eval " 
+        def self.storage 
+          #{klass}::Storage
+        end  
+       " 
     end  
   end 
   
   module ClassMethods
-    def query_index( *ivars )
-    end  
+    def index_on( *ivars )
+      ivars.each do |var|
+        storage.index_on_ivar( var )
+      end  
+    end
+    
+    def query( index, opts={} )
+      opts = Mash.new( opts )
+      equals = opts.delete(:equals)
+      opts[:equals] = _encode_query( equals ) if equals
+      _build_results( storage.query( index, opts ) )
+    end
+    
+    def _encode_query( object ) 
+      CGI.escape( Aqua::Translator.pack_object( object ).pack.to_json )
+    end
+    
+    def _build_results( docs )
+      if docs.is_a? Array
+        docs.map{ |doc| build( doc ) }
+      else
+        build( doc )
+      end    
+    end        
   end
   
   module InstanceMethods

data/lib/aqua/object/stub.rb

@@ -1,35 +1,7 @@
-# NOTES: I just checked and Delegator does all its delegation through method missing, so 
-# it probably makes sense to make this all one class, with method_missing doing the work.
-# It might be faster, but harder, to pass a reference to the parent object and the way that
-# the stub is accessed as a way to replace self with the actual object instead of stubbing.
-# Not sure how that would work, but I am looking for something like self = something_else,
-# which isn't kosher. 
-
-module Aqua 
-  class TempStub
-    def initialize( method_hash ) 
-      method_hash.each do |method_name, value|
-        self.class.class_eval("
-          def #{method_name}
-            #{value.inspect}
-          end  
-        ")  
-      end  
-    end   
-  end
-  
-  module StubDelegate 
-    def __getobj__
-      @_sd_obj          # return object we are delegating to
-    end
-
-    def __setobj__(obj)
-      @_sd_obj = obj    # change delegation object
-    end  
-  end  
-    
-  class Stub < Delegator 
-    include StubDelegate
+module Aqua
+  class Stub
+    attr_accessor :delegate, :delegate_class, :delegate_id, 
+      :parent_object, :path_from_parent
     
     # Builds a new stub object which returns cached/stubbed methods until such a time as a non-cached method 
     # is requested.
@@ -39,84 +11,77 @@ module Aqua
     # @option opts [String] :class The class of the object being stubbed
     # @option opts [String] :id The id of the object being stubbed
     #
+    # @todo pass in information about parent, and path to the stub such that method missing replaces stub
+    #         with actual object being stubbed and delegated to.
     # @api semi-public
-    def initialize( opts )
-      meths = opts[:methods] || {}
-      temp_stub = TempStub.new( meths )
-      super( temp_stub )
-      @_sd_obj = temp_stub
-      self.delegate_class = opts[:class]
-      self.delegate_id = opts[:id]
-    end
+    def initialize(opts)
+      stub_methods( opts[:methods] || {} )
+      
+      self.delegate_class     = opts[:class]
+      self.delegate_id        = opts[:id]
+      self.parent_object      = opts[:parent]
+      self.path_from_parent   = opts[:path] 
+    end 
     
-    def method_missing( method, *args )
-      if __getobj__.class.to_s != delegate_class.to_s
-        load_delegate
-        # resend! 
-        if (args.size == 1 && !args.first.nil?) 
-          __getobj__.send( method.to_sym, eval(args.map{|value| "'#{value}'"}.join(', ')) )
+    def self.aqua_init( init, opts=Translator::Opts.new )
+      new( init )
+    end 
+             
+    protected 
+      
+      def stub_methods( stubbed_methods ) 
+        stubbed_methods.each do |method_name, value|
+          self.class.class_eval("
+            def #{method_name}
+              #{value.inspect}
+            end  
+          ")
+        end
+      end
+      
+      def missing_delegate_error
+        raise ObjectNotFound, "Object of class '#{delegate_class}' and id '#{delegate_id}' not found"
+      end  
+               
+      def method_missing( method, *args, &block )
+        load_delegate if delegate.nil?
+        if delegate
+          delegate.send( method, *args, &block )
         else
-          __getobj__.send( method.to_sym )
+          missing_delegate_error
         end    
-      else
-        raise NoMethodError
       end
-    end
-    
-      
-    protected 
-      attr_accessor :delegate_class, :delegate_id
       
-      def load_delegate
-        __setobj__( delegate_class.constantize.load( delegate_id ) )
+      def load_delegate 
+        self.delegate = delegate_class.constantize.load( delegate_id )
       end   
-    public
-        
-  end  
+  end
 
-  class FileStub < Delegator 
-    include StubDelegate
-    
-    # Builds a new stub object which returns cached/stubbed methods until such a time as a non-cached method 
-    # is requested.
-    #
-    # @param [Hash]
-    # @option opts [Array] :methods A hash of method names and values
-    # @option opts [String] :class The class of the object being stubbed
-    # @option opts [String] :id The id of the object being stubbed
-    #
-    # @api semi-public
+  class FileStub < Stub 
+    attr_accessor :base_class, :base_id, :attachment_id 
+      
     def initialize( opts )
-      meths = opts[:methods] || {}
-      temp_stub = TempStub.new( meths )
-      super( temp_stub )
-      @_sd_obj = temp_stub
-      self.parent = opts[:parent]
+      super( opts ) 
+      self.base_class = opts[:base_object].class
+      self.base_id =    opts[:base_id]
       self.attachment_id = opts[:id]
     end
     
-    def method_missing( method, *args )
-      if load_attempt != true
-        load_delegate 
-        self.load_attempt = true
-        # resend! 
-        if (args.size == 1 && !args.first.nil?) 
-          __getobj__.send( method.to_sym, eval(args.map{|value| "'#{value}'"}.join(', ')) )
-        else
-          __getobj__.send( method.to_sym )
-        end
-      else
-        raise NoMethodError
-      end
+    # This is what is actually called in the Aqua unpack process
+    def self.aqua_init( init, opts )
+      init['base_object'] = opts.base_object
+      init['base_id'] = opts.base_id || opts.base_object.id # this is needed when an object is loaded, not reloaded
+      super
     end
-    
       
-    protected 
-      attr_accessor :parent, :attachment_id, :load_attempt 
+    protected  
+      def missing_delegate_error 
+        raise ObjectNotFound, "Attachment '#{attachment_id}' for '#{base_class}' with id='#{base_id}' not found."
+      end  
       
       def load_delegate
-        __setobj__( parent.class::Storage.attachment( parent.id, attachment_id ) )
+        self.delegate = base_class::Storage.attachment( base_id, attachment_id )
       end   
-    public    
-  end  
+  end            
+  
 end