aqua 0.1.6

data/lib/aqua/store/storage.rb

@@ -0,0 +1,59 @@
+# This is the interface between an individual object and the Storage representation.
+# The storage engine should provide a module that gets included into the Mash. The 
+# module should minimally provide this interface to the object:
+#
+#   InstanceMethods
+#     @inteface_level optional If no initialization is included. Then the Mash initialization will be used.
+#     initialize( hash )
+#       @param [optional Hash]
+#       @return [Aqua::Storage] the new storage instance
+#     
+#     @interface_level mandatory
+#     commit
+#       @return [Aqua::Storage] saved storage object
+#       @raise [Aqua::ObjectNotFound] if another error occurs in the engine, that should be raised instead 
+#         any of the Aqua Exceptions 
+# 
+#     @interface_level mandatory
+#     id
+#       @param none
+#       @return id object, whether String, Fixnum or other object as the store chooses
+# 
+#     @interface_level mandatory
+#     id=( custom_id )
+#       The library expects to save an object with a custom id. Id= method can set limits on the 
+#       types of objects that can be used as an id. Minimally it should support Strings. 
+#       @param String, Fixnum, or any other reasonable class
+#
+#     @interface_level mandatory
+#     new?
+#       The equivalent of AR's new_record? and can be used to set create hooks or determine how to handle
+#       object queries about whether it has changed. 
+#       @return [true, false]
+#   
+#    ClassMethods
+#     @interface_level mandatory
+#     load( id, class ) 
+#       The'load'  
+#       @param [String, Fixnum] The id used by the system to 
+#       @return [Aqua::Storage]
+#       @raise [Aqua::ResourceNotFound] if another error occurs in the engine, that should be raised instead 
+#         any of the Aqua Exceptions 
+#
+# Other methods used for the storage engine can be added as needed by the engine. 
+#
+# If no storage engine is configured before this class is used, CouchDB will automatically be used
+# as an engine.
+module Aqua
+  class Storage < Mash 
+    # auto loads the default store to CouchDB if Store is used without Aqua configuration of a store 
+    def method_missing( method, *args )
+      if respond_to?( :commit ) 
+        raise NoMethodError
+      else
+        Aqua.set_storage_engine # to default, currently CouchDB   
+        send( method.to_sym, eval(args.map{|value| "'#{value}'"}.join(', ')) ) # resend!
+      end  
+    end 
+  end # Storage    
+end # Aqua 

data/lib/aqua/support/initializers.rb

@@ -0,0 +1,216 @@
+# AQUA INITIALIZATION
+# Some object store state in a fundamental way, not in instance variables, that needs to be initialized.
+# Examples: Array, Numeric types, Hashes, Time ...
+# You can make any object requiring this initialization savable to aqua by
+#  * including the Aqua::To module and extending the Aqua::From module
+#  * building your own methods for #to_aqua, #to_aqua_init, MyClass.aqua_init
+# See set.rb in this file for more an example
+module Aqua
+  module Initializers 
+    def self.included( klass ) 
+      klass.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+        
+        unless methods.include?( :hide_attributes )
+          include Aqua::Pack::HiddenAttributes
+        end
+      end
+    end
+    
+    module InstanceMethods 
+      def to_aqua( base_object )
+        hash = { 
+          'class' => to_aqua_class, 
+          'init' => to_aqua_init( base_object ) 
+        }
+        ivars = _pack_instance_vars( base_object )
+        hash.merge!( ivars ) if ivars
+        hash
+      end
+      
+      def to_aqua_class
+        self.class.to_s
+      end  
+      
+      def _pack_instance_vars( base_object ) 
+        { 'ivars' => base_object._pack_ivars( self ) } if instance_variables.size > 0 
+      end  
+  
+      def to_aqua_init( base_object ) 
+        self.to_s
+      end 
+    end # InstanceMethods
+    
+    module ClassMethods 
+      def aqua_init( init ) 
+        new( init )
+      end    
+    end # ClassMethods   
+    
+  end # Initializers
+         
+end  
+
+[ TrueClass, FalseClass, Time, Date, Fixnum, Bignum, Float, Rational, Hash, Array, OpenStruct, Range, File, Tempfile].each do |klass|
+  klass.class_eval { include Aqua::Initializers }
+end 
+
+class TrueClass
+  def self.aqua_init( init )
+    true
+  end
+  
+  def to_aqua( base_object )
+    true
+  end 
+end
+
+class FalseClass
+  def self.aqua_init( init )
+    false
+  end
+  
+  def to_aqua( base_object )
+    false
+  end
+end   
+
+class Date
+  hide_attributes :sg, :of, :ajd
+  
+  def self.aqua_init( init )
+    parse( init )
+  end
+end
+
+class Time 
+  def self.aqua_init( init )
+    parse( init )
+  end
+end
+
+class Fixnum
+  def self.aqua_init( init )
+    init.to_i
+  end
+end
+
+class Bignum
+  def self.aqua_init( init )
+    init.to_i
+  end
+end  
+   
+class Float
+  def self.aqua_init( init )
+    init.to_f
+  end
+end 
+
+class Range
+  def self.aqua_init( init ) 
+    eval( init )
+  end
+end     
+
+class Rational
+  def to_aqua_init( base_object ) 
+    self.to_s.match(/(\d*)\/(\d*)/).to_a.slice(1,2)
+  end 
+  
+  def self.aqua_init( init )
+    Rational( init[0].to_i, init[1].to_i )
+  end  
+end
+
+class Hash
+  def to_aqua_init( base_object )
+    return_hash = {}
+    self.each do |raw_key, value|
+      key_class = raw_key.class
+      if key_class == Symbol
+        key = ":#{raw_key.to_s}"
+      elsif key_class == String
+        key = raw_key
+      else 
+        index = base_object._build_object_key( raw_key )
+        key = "/OBJECT_#{index}"
+      end     
+      return_hash[key] = base_object._pack_object( value ) 
+    end
+    return_hash  
+  end
+  
+  def self.aqua_init( init )
+    new.replace( init )
+  end 
+end
+
+class Array
+  def to_aqua_init( base_object )
+    return_arr = []
+    self.each do |obj|
+      return_arr << base_object._pack_object( obj )
+    end
+    return_arr   
+  end
+  
+  def self.aqua_init( init )
+    new.replace( init )
+  end 
+end
+
+class OpenStruct
+  hide_attributes :table
+  
+  def to_aqua_init( base_object )
+    instance_variable_get("@table").to_aqua_init( base_object )
+  end  
+end 
+
+module Aqua
+  module FileInitializations 
+    def to_aqua( base_object )
+      hash = { 
+        'class' => to_aqua_class, 
+        'init' => to_aqua_init( base_object ),
+        'methods' => {
+          'content_type' => MIME::Types.type_for( path ).first,
+          'content_length' => stat.size
+        } 
+      }
+      ivars = _pack_instance_vars( base_object )
+      hash.merge!( ivars ) if ivars
+      hash
+    end  
+    
+    def to_aqua_class
+      'Aqua::FileStub'
+    end   
+       
+    def filename
+      path.match(/([^\/]*)\z/).to_s
+    end
+    
+    def to_aqua_init( base_object )
+      name = filename
+      base_object._pack_file(name, self)
+      "/FILE_#{name}"      
+    end  
+  end # FileInitializations
+end # Aqua
+   
+class File
+  include Aqua::FileInitializations        
+end
+
+class Tempfile
+  include Aqua::FileInitializations
+  
+  hide_attributes :clean_proc, :data, :tmpname, :tmpfile, :_dc_obj
+  
+  def filename
+    path.match(/([^\/]*)\.\d*\.\d*\z/).captures.first
+  end
+end       

data/lib/aqua/support/mash.rb

@@ -0,0 +1,144 @@
+# Taken from RAILS, see RAIL'S LICENSE for usage
+
+# This class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+# and they get the same value for both keys.
+unless defined?(HashWithIndifferentAccess)
+  class Hash
+    def with_indifferent_access
+      hash = HashWithIndifferentAccess.new(self)
+      hash.default = self.default
+      hash
+    end
+  end  
+  
+  class HashWithIndifferentAccess < Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    # 
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    # 
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    # 
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    # 
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      HashWithIndifferentAccess.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super other_hash.with_indifferent_access
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def symbolize_keys!; self end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          value.with_indifferent_access
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+        else
+          value
+        end
+      end
+  end
+
+  Mash = HashWithIndifferentAccess unless defined?( Mash ) # because Mash is easier to write, thanks Merb!
+
+end
+        

data/lib/aqua/support/set.rb

@@ -0,0 +1,23 @@
+# require this file if you want to use sets with your Aquatic objects
+require 'set'
+
+class Set 
+  include Aqua::Initializers  
+  
+  def to_aqua( base_object )
+    hash = { 
+      'class' => self.class.to_s, 
+      'init' => to_aqua_init( base_object ) 
+    }
+    if (instance_variables - ['@hash']).size > 0 
+      hash.merge!({ 'ivars' => base_object._pack_ivars( self ) })
+    end
+    hash
+  end   
+
+  def to_aqua_init( base_object )
+    # keys returns an array
+    # to_aqua_init will ensure that each of the objects is unpacked to aqua 
+    instance_variable_get("@hash").keys.to_aqua_init( base_object )
+  end    
+end  

data/lib/aqua/support/string_extensions.rb

@@ -0,0 +1,121 @@
+# This is taken from Extlib. Their license applies:
+# Copyright (c) 2008 Sam Smoot.
+#  
+# 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.      
+# 
+# These couple of methods are added to the String class 
+# for easy file negotiation and metaprogramming.
+# Module and methods are only loaded when ActiveSupport 
+# and Extlib is not detected
+unless defined?( ActiveSupport ) || defined?( Extlib )
+  module Extlib
+ 
+    # = English Nouns Number Inflection.
+    #
+    # This module provides english singular <-> plural noun inflections.
+    module Inflection
+ 
+      class << self
+        # Take an underscored name and make it into a camelized name
+        #
+        # @example
+        #   "egg_and_hams".classify #=> "EggAndHam"
+        #   "post".classify #=> "Post"
+        #
+        def classify(name)
+          camelize(singularize(name.to_s.sub(/.*\./, '')))
+        end
+ 
+        # By default, camelize converts strings to UpperCamelCase.
+        #
+        # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+        #
+        # @example
+        #   "active_record".camelize #=> "ActiveRecord"
+        #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+        #
+        def camelize(lower_case_and_underscored_word, *args)
+          lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+        end
+ 
+ 
+        # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+        #
+        # Changes '::' to '/' to convert namespaces to paths.
+        #
+        # @example
+        #   "ActiveRecord".underscore #=> "active_record"
+        #   "ActiveRecord::Errors".underscore #=> active_record/errors
+        #
+        def underscore(camel_cased_word)
+          camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+        end
+ 
+        # Capitalizes the first word and turns underscores into spaces and strips _id.
+        # Like titleize, this is meant for creating pretty output.
+        #
+        # @example
+        #   "employee_salary" #=> "Employee salary"
+        #   "author_id" #=> "Author"
+        def humanize(lower_case_and_underscored_word)
+          lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+        end
+ 
+        # Constantize tries to find a declared constant with the name specified
+        # in the string. It raises a NameError when the name is not in CamelCase
+        # or is not initialized.
+        #
+        # @example
+        #   "Module".constantize #=> Module
+        #   "Class".constantize #=> Class
+        def constantize(camel_cased_word)
+          unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+            raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+          end
+ 
+          Object.module_eval("::#{$1}", __FILE__, __LINE__)
+        end
+      end
+    
+    end  
+  end
+ 
+  class String
+    def constantize
+      Extlib::Inflection.constantize( self )
+    end  
+    
+    def humanize
+      Extlib::Inflection.humanize( self )
+    end  
+    
+    def underscore
+      Extlib::Inflection.underscore( self )
+    end
+    
+    def classify
+      Extlib::Inflection.classify( self )
+    end    
+  end  
+end