splash 0.0.1.alpha → 0.0.1.beta

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org/'
+
+gem 'bson_ext'
+
+gemspec

data/lib/splash.rb

@@ -1,35 +1,31 @@
+# -*- encoding : utf-8 -*-
 if defined? Splash
   raise "Splash included twice!"
 end
 
+Dir[File.join(File.dirname(__FILE__),"/standart_extensions/*.rb")].each do |path|
+  require path
+end
+
+class NotGivenClass
+  class << self
+    def instance
+      return (@instance ||= self.new)
+    end
+  end
+end
+NotGiven = NotGivenClass.instance
+class NotGivenClass
+  class << self
+    undef :new, :allocate
+  end
+end
+
 module Splash
   
-  DIR = File.dirname(__FILE__)
   
-  autoload :ActsAsCollection,DIR+"/splash/acts_as_collection"
-  autoload :ActsAsScope,DIR+"/splash/acts_as_scope"
-  autoload :ActsAsScopeRoot,DIR+"/splash/acts_as_scope_root"
-  autoload :Annotated,DIR+"/splash/annotated"
-  autoload :Scope,DIR+"/splash/scope"
-  autoload :Entity,DIR+"/splash/entity"
-  autoload :Validates,DIR+"/splash/validates"
-  autoload :Saveable,DIR+"/splash/saveable"
-  autoload :HasAttributes,DIR+"/splash/has_attributes"
-  autoload :NameSpace,DIR+"/splash/namespace"
-  autoload :Persister, DIR+"/splash/persister"
-  autoload :Lazy,DIR+"/splash/lazy"
-  autoload :QueryInterface,DIR+"/splash/query_interface"
-  autoload :Embed,DIR+"/splash/embed"
-  autoload :Document,DIR+"/splash/document"
-  autoload :Collection,DIR+"/splash/collection"
-  autoload :ScopeDelegator,DIR+"/splash/scope_delegator"
-  autoload :Attribute, DIR+"/splash/attribute"
-  autoload :HasConstraint, DIR+"/splash/has_constraint"
-  autoload :Constraint, DIR+"/splash/constraint"
-  autoload :AttributedStruct, DIR+"/splash/attributed_struct"
-  autoload :Password, DIR+"/splash/password"
   
-end
-Dir[Splash::DIR+"/splash/standart_extensions/*.rb"].each do |path|
-  require path
+  
+  autoload_all File.join(File.dirname(__FILE__),'splash')
+  
 end

data/lib/splash/acts_as_collection.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Splash::ActsAsCollection
   
   include Enumerable
@@ -46,10 +47,10 @@ module Splash::ActsAsCollection
   end
   
   def accepts?(object)
-    return object === collection_class
+    return object.kind_of? collection_class
   end
   
   def include?(object)
     accepts?(object) && super
   end
-end
+end

data/lib/splash/acts_as_scope.rb

@@ -1,6 +1,44 @@
+# -*- encoding : utf-8 -*-
 module Splash
   module ActsAsScope
+    
+    module ArraylikeAccess
+      def [](*args)
+        if args.size == 1
+          # range
+          if args.first.kind_of? Range
+            range = args.first
+            offset = range.first.to_int
+            last = range.last.to_int
+            if last == -1 and !range.exclude_end?
+              return query( :skip => offset )
+            end
+            if last < -1 
+              raise "ranges with negative ends are not supported ( except -1 for no limit )"
+            end
+            limit = ( last - offset ) - ( range.exclude_end? ? 1 : 0 )
+            return query( :limit => limit, :skip => offset )
+          else
+            # id query
+            return query( :conditions => {'_id'=>args.first} ).first
+          end
+        elsif args.size == 2
+          offset = args[0].to_int
+          limit = args[1].to_int
+          return query( :limit => limit, :skip => offset )
+        end
+        raise "bag arguments #{args.inspect}, expected a range or a limit and an offset"
+      end
+    end
+    
+    module HashlikeAccess
+      def [](key)
+        return query( :conditions => {'_id'=>key} ).first.value
+      end
+    end
+    
     include QueryInterface
+    include Scope::MapReduceInterface
     
     
     # the following methods have to be defined
@@ -26,8 +64,16 @@ module Splash
     end
     
     def each(&block)
-      self.clone.scope_cursor.each do |o|
-        yield Saveable.load(o,self)
+      a = block.arity
+      if a == 1
+        self.clone.scope_cursor.each do |o|
+          yield Saveable.load(o,self.scope_root)
+        end
+      elsif a == 2
+        self.clone.scope_cursor.each do |o|
+          l = Saveable.load(o,self.scope_root)
+          yield(l._id,l.value)
+        end
       end
       self
     end
@@ -40,6 +86,14 @@ module Splash
       return result
     end
     
+    def to_h
+      result = {}
+      each do |key,value|
+        result[key]=value
+      end
+      return result
+    end
+    
     def has_next?
       scope_cursor.has_next?
     end
@@ -47,11 +101,11 @@ module Splash
     def next_document
       nd = scope_cursor.next_document
       return nil if nd.nil?
-      return Saveable.load(nd,self)
+      return Saveable.load(nd,self.scope_root)
     end
     
     def first
-      self.clone.limit(1).next_document
+      self.limit(1).next_document
     end
     
     def clone
@@ -62,26 +116,6 @@ module Splash
       scope_cursor.next_document
     end
     
-    def inspect
-      scope_options.inspect
-    end
-
-=begin
-    def finish!
-      self.scope_cursor
-      self
-    end
-    
-    def finished?
-      !@scope_cursor.nil?
-    end
-    
-    def reset!
-      self.unset_scope_cursor
-      self
-    end
-=end
-    
     def count
       self.clone.scope_cursor.count
     end
@@ -91,15 +125,33 @@ module Splash
     end
     
     def <<(object)
-    end
-  
-    def scoped_methods(*modules,&block)
-      
+      @scope_options.writeback(object)
+      if scope_root?
+        super(object)
+      else
+        scope_root.<<(object)
+        warn "object #{object} was writen to scope #{self} but won't be findable" unless complies_with?(object)
+        return object
+      end
     end
     
+    def complies_with?(object)
+      @scope_options.selector.matches?(object)
+    end
+
+    def explain
+      self.scope_root.collection.find(*find_options).explain()
+    end
+
+    def update(*args)
+      options = find_options
+      self.scope_root.collection.update(options[0],*args)
+    end
+
     protected
+      
       def scope_cursor()
-        @scope_cursor ||= find!(scope_options.selector,scope_options.options)
+        @scope_cursor ||= find!
       end
       
       def unset_scope_cursor()
@@ -110,9 +162,21 @@ module Splash
         @scope_options = scope_options.merge(options)
       end
     
-      def find!(selector,options)
-        selector["Type"]=self.scope_root.to_s
-        self.scope_root.collection.find(selector,options)
+      def find!
+        self.scope_root.collection.find(*find_options)
       end
+      
+      def update!(*args)
+        
+      end
+      
+      def find_options
+        selector,options = scope_options.selector,scope_options.options
+        if self.scope_root.kind_of? Splash::Saveable
+          selector["Type"]=self.scope_root.to_s
+        end
+        return [selector,options]
+      end
+      
   end
-end
+end

data/lib/splash/acts_as_scope_root.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Splash::ActsAsScopeRoot
   include Splash::ActsAsScope
   
@@ -7,4 +8,4 @@ module Splash::ActsAsScopeRoot
   def scope_root?
     true
   end
-end
+end

data/lib/splash/annotated.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Splash::Annotated
   
   class << self
@@ -31,4 +32,4 @@ module Splash::Annotated
     end
     
   end
-end
+end

data/lib/splash/application.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 module Splash
   module Application
     class << self
@@ -33,4 +34,4 @@ module Splash
       end
     end
   end
-end
+end

data/lib/splash/attribute.rb

@@ -1,45 +1,63 @@
+# -*- encoding : utf-8 -*-
 class Splash::Attribute
   
-  include ::Humanized
   include Splash::HasConstraint
   
-  attr_accessor :persister, :type, :default
+  NIL_LAMBDA = lambda{ nil }
   
-  def initialize(t=nil,&block)
-    self.type=t if t
+  attr_accessor :persister, :type
+  
+  def default(fn=nil,*args,&block)
+    if block_given?
+      @default_block = block
+    elsif !fn.nil? 
+      @default_block = lambda{ self.send(fn,*args) }
+    else
+      type.instance_eval &@default_block
+    end
+  end
+  
+  def initialize(t=Object,&block)
+    self.type = t
+    @default_block = NIL_LAMBDA
     instance_eval &block if block_given?
   end
   
   def type= t
-    @persister = Splash::HasAttributes.get_persister(t)
+    @persister = t.persister
     @type = t
   end
   
-  def persisted_by(*args,&block)
-    @persister = Splash::HasAttributes.get_persister(*args, &block)
+  def persisted_by(p)
+    @persister = p
   end
   
+  # persisting interface
   def read(value)
-    return value unless @persister
-    @persister.read(value)
+    @persister.from_saveable(value)
   end
   
   def write(value)
-    return value unless @persister
-    @persister.write(value)
+    @persister.to_saveable(value)
   end
   
-  def persisted_class
-    return Object unless @persister
-    @persister.persisted_class
+  # type interface
+  def missing
+    self.default
   end
   
-  def missing()
-    if self.default
-      self.default.clone
-    else
-      nil
-    end
+  def writeable?
+    true
+  end
+  
+  def initial_value
+    return type.initial_value if type && type.respond_to?(:initial_value)
+    ::NotGiven
+  end
+  
+  def before_write(value)
+    return type.before_write(value) if type && type.respond_to?(:before_write)
+    value
   end
   
-end
+end

data/lib/splash/attributed_struct.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Splash::AttributedStruct
   
   include Splash::HasAttributes
@@ -5,4 +6,4 @@ class Splash::AttributedStruct
   def initialize(attr={})
     self.attributes.load(attr)
   end
-end
+end

data/lib/splash/callbacks.rb

@@ -0,0 +1,37 @@
+# -*- encoding : utf-8 -*-
+module Splash::Callbacks
+  
+  protected
+  def run_callbacks(name,*args)
+    regex = Regexp.new("^#{Regexp.escape name.to_s}"_)
+    self.methods.each do |meth|
+      if meth.to_s ~= regex
+        self.send(meth,*args)
+      end
+    end
+  end
+  
+  def with_callbacks(name,*args)
+    run_callbacks('before_' + name.to_s,*args)
+    result = yield
+    run_callbacks('after_' + name.to_s,*args)
+    return result
+  end
+  
+  module ClassMethods
+    
+    def with_callbacks(fn)
+      def ___callbacked()
+        
+      end
+      alias_method(fn +'_without_callbacks',fn)
+      
+      self.define_method(fn+'_with_callback') do
+        fn
+      end
+    end
+    
+    define_annotation :with_callbacks
+    
+  
+end

data/lib/splash/collection.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 class Splash::Collection < Array
   include Splash::ActsAsCollection
   
@@ -17,36 +18,38 @@ class Splash::Collection < Array
   end
   
 
-  class Persister < Splash::Persister
+  class Persister
 
-    def read(val)
+    attr_accessor :entry_persister
+
+    def from_saveable(val)
       return nil if val.nil?
-      nu=persisted_class.new
+      nu=@base_class.new
       val.inject(nu){|memo,e|
-        memo << @persister.read(e)
+        memo << @entry_persister.from_saveable(e)
         memo
       }
     end
     
-    def write(val)
+    def to_saveable(val)
       return nil if val.nil?
       val.inject([]){|memo,e|
-        memo << @persister.write(e)
+        memo << @entry_persister.to_saveable(e)
         memo
       }
     end
     
-    def persist_class(col)
-      @persister=Splash::HasAttributes.get_persister(col.collection_class)
-      super
+    def initialize(klass, entry_persister)
+      @base_class = klass
+      @entry_persister = entry_persister
     end
     
   end
   
   class << self
     def persister
-      return Splash::Collection::Persister
+      return Splash::Collection::Persister.new(self, @collection_class.persister)
     end
   end
 
-end
+end