splash 0.0.1.alpha → 0.0.1.beta

data/lib/splash/has_constraint.rb

@@ -1,3 +1,4 @@
+# -*- encoding : utf-8 -*-
 require "set"
 
 module Splash::HasConstraint
@@ -6,4 +7,4 @@ module Splash::HasConstraint
     @constraint ||= Splash::Constraint::All.new
   end
   
-end
+end

data/lib/splash/map_reduce.rb

@@ -0,0 +1,124 @@
+module Splash
+  
+  module MapReduce
+    
+    # hack!
+    # If we would set a constant to the class, it would be named to that constant.
+    # Yet, we don't want that.
+    BASE = [Class.new{
+      
+      include Splash::Document
+      
+    }].freeze
+    
+    module ClassMethods
+      
+      def from_callback(callback,map,reduce,options,&block)
+        thiz = self
+        
+        map = BSON::Code.new(map) if map.kind_of? String
+        reduce = BSON::Code.new(reduce) if reduce.kind_of? String
+        
+        map.freeze
+        reduce.freeze
+        
+        options.freeze
+        callback.freeze
+        
+        c = Class.new(BASE.first) do
+          
+          ex = class << self
+            self.method(:define_method)
+          end
+          
+          if map
+            ex.call(:map) do
+              return map
+            end
+          else
+            ex.call(:map) do
+              raise NoMethod, "No map function given and 'map' not implemented."
+            end
+          end
+          
+          if reduce
+            ex.call(:reduce) do
+              return reduce
+            end
+          else
+            ex.call(:reduce) do
+              raise NoMethod, "No reduce function given and 'reduce' not implemented."
+            end
+          end
+          
+          ex.call(:map_reduce_callback) do
+            return callback
+          end
+          ex.call(:map_reduce_base_options) do
+            return options
+          end
+          
+          class << self
+            private :map_reduce_callback
+          end
+          
+          extend thiz
+          
+        end
+        if block_given?
+          c.class_eval &block
+        end
+        return c
+      end
+      
+    end
+    
+    def self.[](scope, map=nil, reduce=nil, options={},&block)
+      return scope.map_reduce(map, reduce, options.merge(:keeptemp => true),&block)
+    end
+    
+    module Temporary
+      
+      include Splash::MapReduce
+      extend Splash::MapReduce::ClassMethods
+      
+      def collection
+        refresh!
+        super
+      end
+      
+      def map_reduce_options
+        options = map_reduce_base_options.dup
+        options[:keeptemp] = false
+        options[:raw] = true
+        options[:out] = nil
+        return options
+      end
+      
+    end
+    
+    module Permanent
+      
+      include Splash::MapReduce
+      extend Splash::MapReduce::ClassMethods
+      
+      def map_reduce_options
+        options = map_reduce_base_options.dup
+        options[:keeptemp] = true
+        options[:raw] = true
+        options[:out] = self.collection.name
+        return options
+      end
+      
+    end
+    
+    def refresh!
+      result = map_reduce_callback.call(map,reduce,self.map_reduce_options)
+      self.collection = self.namespace.collection(result["result"])
+      return result.except(["result","ok"])
+    end
+    
+    
+  end
+  
+end

data/lib/splash/matcher.rb

@@ -0,0 +1,160 @@
+# -*- encoding : utf-8 -*-
+module Splash
+  
+  class Matcher < Hash
+    
+    WHERE = '$where'
+    
+    OR = '$or'
+    
+    
+    ATOMS = Hash.new do |hash,key|
+      hash[key] = lambda{|value,matcher| false}
+    end
+    ATOMS['$neq'] = lambda{|value,matcher| value != matcher }
+    ATOMS['$in'] = lambda{|value,matcher| matcher.contains? value }
+    ATOMS['$nin'] = lambda{|value,matcher| !(matcher.contains? value) }
+    ATOMS['$lt'] = lambda{|value,matcher| matcher > value }
+    ATOMS['$leq'] = lambda{|value,matcher| matcher >= value }
+    ATOMS['$gt'] = lambda{|value,matcher| matcher < value }
+    ATOMS['$geq'] = lambda{|value,matcher| matcher <= value }
+    ATOMS['$elemMatch'] = lambda{|value,matcher| Matcher.cast(matcher).matches_any?(value) }
+    ATOMS['$not'] = lambda{|value,matcher|
+      if matcher.kind_of? Regexp
+        value !~ matcher
+      else
+        !Matcher.cast(matcher).matches?(value)
+      end
+    }
+    ATOMS['$all'] = lambda{|value,matcher|
+      matcher.all? do |sub|
+        Matcher.match_atomic(value,sub)
+      end
+    }
+    ATOMS['$type'] = lambda{|value,matcher|
+      if value.kind_of? Array
+        value.any? do |sub|
+          BSON.types_for_object(sub).include? matcher
+        end
+      else
+        BSON.types_for_object(value).include? matcher
+      end
+      }
+    
+    
+    def self.match_atomic(value,matcher)
+      if matcher.kind_of? Hash
+        matcher.each do |function,arg|
+          return false unless ATOMS[function].call(value,arg)
+        end
+      elsif matcher.kind_of? Regexp
+        return false unless value =~ matcher
+      elsif value.kind_of? Array
+        return false unless value.include? matcher
+      else
+        return false unless value == matcher
+      end
+      return true
+    end
+    
+    def matches?(object)
+      self.each do |key,matcher|
+        if key == OR
+          return false unless matcher.any? do |sub|
+            Matcher.cast(sub).matches?(object)
+          end
+          next
+        elsif key == WHERE
+          # 
+          # johnson anyone?
+          # 
+          return true
+        end
+        value = get_value(object,key)
+        
+        return false unless Matcher.match_atomic(value,matcher)
+      end
+      return true
+    end
+    
+    def matches_any?(array)
+      array.any? do |obj|
+        self.matches? obj
+      end
+    end
+    
+    def self.cast(hsh)
+      return hsh if hsh.kind_of? Matcher
+      return self.new.update(hsh) if hsh.kind_of? Hash
+      raise "can't convert #{hsh.inspect} to matcher"
+    end
+    
+    def and(other)
+      result = Matcher.new
+      other.each do |k,v|
+        if k == OR
+          result[OR] = (self[OR] || []) + v
+        elsif k == WHERE
+          if self.key?(k) # ierkssss!
+            warn "$where can't be merged!"
+          end
+          result[k]=v
+        elsif self.key?(k)
+          if self[k].kind_of? Hash and v.kind_of? Hash
+            result[k] = self[k].merge(v)
+          elsif self[k].kind_of? Hash or v.kind_of? Hash
+            hsh, simple = v , self[k]
+            if simple.kind_of? Hash
+              hsh, simple = simple, hsh
+            end
+            hsh = hsh.dup
+            hsh['$all'] ||= []
+            hsh['$all'] << simple
+            result[k] = hsh
+          else
+            result[k]={'$all'=>[self[k],v]}
+          end
+        else
+          result[k]=v
+        end
+      end
+      self.each do |k,v|
+        result[k]=v unless result.key?(k)
+      end
+      return result
+    end
+    
+    def or(other)
+      Matcher.cast({
+        OR => (self.dnf + other.dnf)
+      })
+    end
+    
+    def dnf
+      base = self.dup
+      self_or = base.delete(OR,[Matcher.new])
+      return self_or.map do |sub|
+        sub.and(base)
+      end
+    end
+    
+    def self.and(*args)
+      args.compact!
+      return nil unless args.any?
+      result = Matcher.new
+      args.each do |arg|
+        result = result.and(Matcher.cast(arg))
+      end
+      return result
+    end
+    
+    protected
+      def get_value(object,key)
+        key.split('.').each do |part|
+          object = object.send(part)
+          return nil if object.nil?
+        end
+        return object
+      end
+  end
+end

data/lib/splash/namespace.rb

@@ -1,29 +1,93 @@
+# -*- encoding : utf-8 -*-
 require "logger"
+require "delegate"
 module Splash
-  class NameSpace
+  class Namespace
+    
+    NAMESPACES = Hash.new do |hash,key|
+      if( key == :default )
+        hash[:default] = Namespace.new
+      else
+        raise "unknow namespace #{key.inspect}"
+      end
+    end
+    
+    class ClassNotFound < NameError
+    end
     
-    URI_MATCHER = /^mongodb:\/\/([^\/:@]+)(:\d+|)\/(.*)/
     
-    LOGGER = ::Logger.new(STDOUT)
+    URI_MATCHER = /^mongodb:\/\/([^\/:@]+)(:\d+|)\/(.*)/.freeze
+    
+    #LOGGER = ::Logger.new(STDOUT)
     #LOGGER.level = Logger::WARN
     
     attr_reader :db
     
+    class LoggerDelegator < Logger
+      
+      def initialize
+        super(nil)
+      end
+      
+      def add(*args,&block)
+        Splash::Namespace.logger.add(*args,&block)
+      end
+
+      def <<(msg)
+        Splash::Namespace.logger << msg
+      end
+      
+    end
+    
+    class << self
+      attr_accessor :logger
+    end
+    
+    self.logger = ::Logger.new(STDOUT)
+    self.logger.level = Logger::WARN
+    
     def self.default
-      @default ||= self.new
+      NAMESPACES[:default]
     end
     
     def self.default=(value)
-      @default = value
+      NAMESPACES[:default] = value
+    end
+    
+    def class_to_collection_name(klass_name,recheck = true)
+      cn = klass_name.gsub(/(<?[a-z])([A-Z])/){ |c| c[0,1]+"_"+c[1,2].downcase }
+      cn.gsub!(/::([A-Z])/){|d| "." + (d[2,1].downcase) }
+      cn[0...1] = cn[0...1].downcase
+      if recheck
+        raise "#{klass_name} won't be findable as #{cn} ( got: #{self.collection_to_class_name(cn,false)} )" if self.collection_to_class_name(cn,false) != klass_name
+      end
+      return cn
+    end
+    
+    def collection_to_class_name(collection_name, recheck = true)
+      kn = collection_name.gsub(/_([a-z])/){|c| c[1,2].upcase }
+      kn.gsub!(/\.[a-z]/){|c| '::'+c[1,1].upcase}
+      kn[0...1] = kn[0...1].upcase
+      if recheck
+        raise "#{collection} won't find a class #{kn} ( got: #{self.class_to_collection_name(kn,false)} )" if self.class_to_collection_name(kn,false) != collection_name
+      end
+      return kn
     end
     
     def initialize(uri='mongodb://localhost/splash')
       match = URI_MATCHER.match(uri)
       if match.nil?
-        @db = Mongo::Connection.from_uri(uri,:logger=>LOGGER)
+        @db = Mongo::Connection.from_uri(uri,:logger=>LoggerDelegator.new)
       else
-        @db = Mongo::Connection.new(match[1],match[2].length==0 ? nil : match[2].to_i,:logger=>LOGGER).db(match[3])
+        @db = Mongo::Connection.new(match[1],match[2].length==0 ? nil : match[2].to_i,:logger=>LoggerDelegator.new).db(match[3])
       end
+      @uri = uri
+      #@class_collection_map = {}
+      #@top_classes = {}
+    end
+    
+    def to_s
+      @uri
     end
     
     def clear!
@@ -33,18 +97,55 @@ module Splash
         rescue Mongo::OperationFailure
         end
       end
+      #@top_classes.clear
+      #@class_collection_map.clear
       return true
     end
     
     def collection_for(klass)
-      @class_collection_map ||= {}
-      @top_classes ||={}
+      thiz = self
+      last_named = nil
+      klass.self_and_superclasses do |k|
+        unless k.respond_to?(:namespace)
+          break
+        end
+        unless k.namespace == thiz
+          raise "Namespace mismatch: #{k} ( namespace: #{k.namespace.to_s} ) is a Superclass of #{klass} ( namespace: #{thiz.to_s} )."
+        end
+        if k.named?
+          last_named = k
+        end
+        if last_named and k.instance_variable_defined?('@is_collection_base')
+          return collection(self.class_to_collection_name(last_named.to_s))
+        end
+      end
+      raise "Couldn't find a collection for #{klass}!"
+      return nil
+=begin
       return @class_collection_map[klass] if( @class_collection_map.key? klass)
       
       
-      classes=Saveable.get_class_hierachie(klass)
+      classes=[]
+      
+      thiz = self
+      
+      klass.self_and_superclasses do |k|
+        if @class_collection_map.key? k
+          collection = @class_collection_map[k]
+          classes.each do |sk|
+            @class_collection_map[sk]=collection
+          end
+          return collection
+        elsif k.named? and k.respond_to?(:namespace) && k.namespace == thiz
+          classes.push(k)
+        else
+          break
+        end
+      end
       
-      collection=@db.collection(classes.last.to_s.gsub(/(<?[a-z])([A-Z])/){ |c| c[0,1]+"_"+c[1,2].downcase }.gsub("::",".").downcase)
+      @class_collection_map.key? classes.last
+      
+      collection=@db.collection(self.class_to_collection_name(classes.last.to_s))
       
       @top_classes[collection.name] = classes.last
       
@@ -53,15 +154,48 @@ module Splash
       end
       
       return collection
+=end
     end
-    
+=begin
     def class_for(collection_name)
-      @top_classes[collection_name]
+      return @top_classes[collection_name] if @top_classes[collection_name]
+      return @top_classes[collection_name] = Kernel.const_get(collection_to_class_name(collection_name))
+    end
+=end
+    def class_for(collection_name)
+      begin
+        return collection_to_class_name(collection_name).split('::').inject(Kernel) do |memo,obj|
+          memo.const_get(obj)
+        end
+      catch NameError => e
+        raise ClassNotFound.new('No Class found for ' + collection_name +'. Error received: ' + e.message)
+      end
+      
+      #return Kernel.const_get(collection_to_class_name(collection_name))
     end
     
     def dereference(dbref)
-      self.class_for(dbref.namespace)[dbref.object_id]
+      begin
+        klass = self.class_for(dbref.namespace) 
+        return Saveable.load( @db.dereference(dbref), klass)
+      rescue ClassNotFound => e
+        warn e.message
+      end
+      return Saveable.load( @db.dereference(dbref) )
+      #self.class_for(dbref.namespace).conditions('_id'=>dbref.object_id).first
     end
     
+    def collection(name)
+      @db.collection(name)
+    end
+=begin
+    def register(klass,collection,top=true)
+      collection = self.collection(collection) if collection.kind_of? String
+      @class_collection_map[klass] = collection
+      if top
+        @top_classes[collection.name] = klass
+      end
+    end
+=end
   end
-end
+end