splash 0.0.1.alpha → 0.0.1.beta

data/lib/splash/connection.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Splash::Connection
   def initialize(host,db)
     @host=host
@@ -23,4 +24,4 @@ class Splash::Connection
     
   end
   
-end
+end

data/lib/splash/constraint.rb

@@ -1,11 +1,9 @@
+# -*- encoding : utf-8 -*-
 module Splash::Constraint
   
   attr_reader :description
   
-  autoload :Any, File.join( File.dirname(__FILE__), 'constraint/any' )
-  autoload :All, File.join( File.dirname(__FILE__), 'constraint/all' )
-  autoload :NotNil, File.join( File.dirname(__FILE__), 'constraint/not_nil' )
-  autoload :In, File.join( File.dirname(__FILE__), 'constraint/in' )
+  autoload_all File.join(File.dirname(__FILE__),'constraint')
   
   class Simple
     
@@ -59,4 +57,4 @@ module Splash::Constraint
   
   alias_method :to_s, :description
   
-end
+end

data/lib/splash/constraint/all.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Splash::Constraint::All < Set
   
   include Splash::Constraint
@@ -21,4 +22,4 @@ class Splash::Constraint::All < Set
     super("all!")
   end
   
-end
+end

data/lib/splash/constraint/any.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Splash::Constraint::Any < Set
   
   include Splash::Constraint
@@ -10,4 +11,4 @@ class Splash::Constraint::Any < Set
   end
   
   
-end
+end

data/lib/splash/constraint/in.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Splash::Constraint::In
   
   include Splash::Constraint
@@ -10,4 +11,4 @@ class Splash::Constraint::In
   def accept?(value)
     return value.nil? || collection.include?(value)
   end
-end
+end

data/lib/splash/constraint/not_nil.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Splash::Constraint::NotNil
   
   include Splash::Constraint
@@ -6,4 +7,4 @@ class Splash::Constraint::NotNil
     !value.nil?
   end
   
-end
+end

data/lib/splash/created_at.rb

@@ -0,0 +1,16 @@
+module Splash
+  
+  
+  
+  class CreatedAt < Time
+    
+    def self.initial_value
+      return Time.now
+    end
+    
+  end
+  
+  
+  
+  
+end

data/lib/splash/document.rb

@@ -1,38 +1,66 @@
+# -*- encoding : utf-8 -*-
 module Splash::Document
   
+  class Persister
+    def to_saveable(value)
+      return nil if value.nil?
+      return BSON::DBRef.new( value.class.collection.name , value._id )
+    end
+    
+    def from_saveable(value)
+      return nil if value.nil?
+      
+      if value.kind_of? BSON::DBRef
+        found_class = @namespace.class_for(value.namespace)
+        unless found_class <= @class
+          warn "Trying to fetch an object of type #{found_class} from #{@class}."
+          return nil
+        end
+        return found_class.conditions('_id'=>value.object_id).first
+      end
+      raise "No idea how to fetch #{value}."
+    end
+    
+    def initialize(ns,klass = Object )
+      @namespace, @class = ns, klass
+    end
+  end
+  
+  
   include Splash::Saveable
   include Splash::HasAttributes
+  include Splash::HasCollection
   include Splash::Validates
   
   class << self
     def included(base)
+      
       included_modules.each do |mod|
-        mod.included(base)
+        begin
+          mod.included(base)
+        rescue NoMethodError
+        end
       end
       
-      dd = self
+      super(base)
       
       base.instance_eval do
-        include Splash::ActsAsCollection.of(base)
+        #include Splash::ActsAsCollection.of(base)
         extend Splash::ActsAsScopeRoot
         
         def included(base)
           Splash::Document.included(base)
           super(base)
         end
+        
+        def persister
+          Splash::Document::Persister.new(self.namespace,self)
+        end
+        
+        extend_scoped! Splash::ActsAsScope::ArraylikeAccess
+        
       end
     end
-    
-    def persister
-      Splash::Saveable::MultiPersister
-    end
   end
   
-  def initialize(args={})
-    self.attributes.load(args)
-  end
-  
-  def to_saveable
-    attributes.raw
-  end
-end
+end

data/lib/splash/embed.rb

@@ -1,13 +1,35 @@
+# -*- encoding : utf-8 -*-
 module Splash::Embed
   
+  class Persister
+    def to_saveable(value)
+      return nil if value.nil?
+      return Splash::Saveable.wrap(value)
+    end
+    
+    def from_saveable(value)
+      return nil if value.nil?
+      return Splash::Saveable.load(value,@base_class)
+    end
+    
+    def initialize(klass)
+      @base_class = klass
+    end
+    
+  end
+  
   include Splash::HasAttributes
+  include Splash::Saveable
   include Splash::Validates
   
   class << self
     def included(base)
       base.extend(ClassMethods)
       included_modules.each do |mod|
-        mod.included(base)
+        begin
+          mod.included(base)
+        rescue NoMethodError
+        end
       end
     end
     
@@ -20,18 +42,16 @@ module Splash::Embed
       c.class_eval(&block)
       c
     end
+    
+    def persister
+      Splash::Embed::Persister.new(self.define{})
+    end
   end
   
   module ClassMethods
     def persister
-      Splash::Saveable::EmbedPersister
+      Splash::Embed::Persister.new(self)
     end
   end
   
-  def initialize(args={})
-    self.attributes.load(args)
-  end
-    def to_saveable
-      attributes.raw
-    end
-end
+end

data/lib/splash/has_attributes.rb

@@ -1,26 +1,21 @@
+# -*- encoding : utf-8 -*-
 module Splash
   module HasAttributes
     
     class Attributes < Hash
+      
+      alias_method :write, :[]=
+      
       def load(raw)
         raw.each do |key,value|
-          key=key.to_s
-          
-          
-          if value.kind_of? type(key).persisted_class
-            self[key]=value
-          elsif Splash::Persister.raw? value
-            @raw[key]=value
-          else
-            
-            puts value.class
-            puts type(key).persisted_class
-            raise "Don't know what to do with #{key}= #{value.inspect}"
-          end
+          self[key]=value
         end
       end
       
       def load_raw(raw)
+        raw.keys.each do |k|
+          self.delete k
+        end
         @raw.update(raw)
       end
       
@@ -32,13 +27,28 @@ module Splash
         else
           value = t.default
         end
-        return self[key]=value
+        self.write(key,value)
+        return value
+      end
+      
+      def []=(key,value)
+        return if ::NotGiven == value
+        key=key.to_s
+        if value.kind_of? type(key).type
+          self.write(key,value)
+        elsif Splash::Persister.raw? value
+          @raw[key]=value
+          self.delete(key)
+        else
+          raise "Don't know what to do with #{key}= #{value.inspect}"
+        end
       end
       
       def initialize(klass)
         super()
         @class = klass
         @raw = {}
+        complete!
       end
       
       def raw
@@ -51,6 +61,20 @@ module Splash
       end
       
       protected
+        def complete!
+          keys = Set.new
+          @class.each_attributes do |attrs|
+            attrs.each do |k,v|
+              unless keys.include?(k)
+                keys << k
+                self[k]=v.initial_value
+              end
+              
+            end
+          end
+          return self
+        end
+        
         def write_back!
           self.each do |key,value|
             @raw[key]=type(key).write(value)
@@ -65,19 +89,6 @@ module Splash
           merged_inheritable_attr :attributes,{}
         end
       end
-      
-      def get_persister(*args,&block)
-        klass = Object
-        if args.length > 0
-          if args.first.respond_to? :persister
-            klass = args.shift
-          end
-        end
-        type = (klass).persister
-        result=type.new(*args,&block)
-        result.persist_class(klass)
-        return result
-      end
     end
     
     def attributes
@@ -95,10 +106,10 @@ module Splash
     end
     
     def inspect
-      "#{self.class.to_s}{#{attributes.inspect}}"
+      "#{self.class.to_s}{#{attributes.raw.inspect}}"
     end
     
-    def to_saveable
+    def to_raw
       attributes.raw
     end
     
@@ -114,6 +125,11 @@ module Splash
       super
     end
     
+    def initialize(attr={})
+      self.attributes.load(attr)
+      super()
+    end
+    
     module ClassMethods
       
       def attribute_accessor(name)
@@ -123,24 +139,39 @@ def #{name.to_s}=(value) return attributes[#{name.to_s.inspect}] = value end
 CODE
       end
       
-      def def_attribute(name,*args,&block)
+      def attribute(name,*args,&block)
         name = name.to_s
+        each_attributes do |attrs|
+          if attrs.key? name
+            if args.size > 0 || block
+              warn "trying to add the existing attribute #{name} of #{self}"
+              break
+            end
+            return attrs[name]
+          end
+        end
         attr=attributes[name]=Splash::Attribute.new(*args, &block)
         attribute_accessor(name)
         return attr
       end
       
-      def attribute(name,create = true)
+      alias def_attribute attribute
+      
+      def attribute?(name)
         name = name.to_s
         each_attributes do |attr|
-          return attr[name] if attr.key? name
-        end
-        if create
-          return def_attribute(name)
+          return true if attr.key? name
         end
-        return nil
+        return false
+      end
+      
+      def from_raw(data)
+        c = self.new()
+        c
+        c.attributes.load_raw(data)
+        return c
       end
       
     end
   end
-end
+end

data/lib/splash/has_collection.rb

@@ -0,0 +1,79 @@
+module Splash
+  
+  module HasCollection
+    
+    def self.included(base)
+      super(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set('@is_collection_base',true)
+    end
+    
+    def store!
+      self._id=self.class.store!(self)
+      return self
+    end
+    
+    def remove!
+      return self.class.collection.remove('_id'=>self._id)
+    end
+    
+    def initialize(*args)
+      self._id = self.class.collection.pk_factory.new
+      super
+    end
+    
+    def find_self
+      self.class.with_id(self._id)
+    end
+    
+    def ==(other)
+      return ( other.kind_of?(Splash::HasCollection) and self.class.namespace == other.class.namespace and self._id == other._id )
+    end
+    
+    alias eq? ==
+    
+    module ClassMethods
+      
+      def <<(obj)
+        obj.store!
+      end
+      
+      def store!(object)
+        return self.collection.save(
+          Saveable.wrap(object)
+        );
+      end
+      
+      def namespace(*args)
+        if args.any?
+          self.namespace=args.first
+        end
+        return (@namespace || Splash::Namespace.default)
+      end
+      
+      def namespace=(arg)
+        if arg.kind_of? Splash::Namespace
+          @namespace = arg
+          @collection = nil
+        else
+          @namespace = Splash::Namespace::NAMESPACES[arg]
+          @collection = nil
+        end
+      end
+      
+      def collection(*args)
+        if args.any?
+          self.collection= args.first
+        end
+        return (@collection ||= namespace.collection_for(self))
+      end
+      
+      def collection=(arg)
+        @collection = arg
+      end
+      
+    end
+    
+  end
+  
+end