splash 0.0.1.alpha

data/lib/splash/has_attributes.rb

@@ -0,0 +1,146 @@
+module Splash
+  module HasAttributes
+    
+    class Attributes < Hash
+      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
+        end
+      end
+      
+      def load_raw(raw)
+        @raw.update(raw)
+      end
+      
+      def [](key)
+        return super if( self.key? key )
+        t=type(key)
+        if( @raw.key? key )
+          value = t.read(@raw[key])
+        else
+          value = t.default
+        end
+        return self[key]=value
+      end
+      
+      def initialize(klass)
+        super()
+        @class = klass
+        @raw = {}
+      end
+      
+      def raw
+        write_back!
+        return @raw
+      end
+      
+      def type(key)
+        return @class.attribute(key)
+      end
+      
+      protected
+        def write_back!
+          self.each do |key,value|
+            @raw[key]=type(key).write(value)
+          end
+        end
+    end
+    
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+        base.instance_eval do
+          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
+      @attributes ||= Attributes.new(self.class)
+    end
+    
+    def attribute(name)
+      self.class.attribute(name)
+    end
+    
+    def respond_to?(meth)
+      return true if meth =~/^([a-zA-Z_]+)\?$/
+      return true if meth =~ /^([a-zA-Z_]+)=$/
+      super(meth)
+    end
+    
+    def inspect
+      "#{self.class.to_s}{#{attributes.inspect}}"
+    end
+    
+    def to_saveable
+      attributes.raw
+    end
+    
+    def method_missing(meth,*args,&block)
+      if( meth.to_s =~ /^([a-zA-Z_]+)=$/ && args.size == 1 )
+        # setter
+        return attributes[$1]=args.first
+      elsif( meth.to_s =~ /^([a-zA-Z_]+)$/ && args.size == 0 )
+        return attributes[$1]
+      elsif( meth.to_s =~ /^([a-zA-Z_]+)\?$/ && args.size == 0 )
+        return attributes.key?(meth.to_s) 
+      end
+      super
+    end
+    
+    module ClassMethods
+      
+      def attribute_accessor(name)
+        self.class_eval <<-CODE, __FILE__, __LINE__
+def #{name.to_s}() return attributes[#{name.to_s.inspect}] end
+def #{name.to_s}=(value) return attributes[#{name.to_s.inspect}] = value end
+CODE
+      end
+      
+      def def_attribute(name,*args,&block)
+        name = name.to_s
+        attr=attributes[name]=Splash::Attribute.new(*args, &block)
+        attribute_accessor(name)
+        return attr
+      end
+      
+      def attribute(name,create = true)
+        name = name.to_s
+        each_attributes do |attr|
+          return attr[name] if attr.key? name
+        end
+        if create
+          return def_attribute(name)
+        end
+        return nil
+      end
+      
+    end
+  end
+end

data/lib/splash/has_constraint.rb

@@ -0,0 +1,9 @@
+require "set"
+
+module Splash::HasConstraint
+  
+  def constraint
+    @constraint ||= Splash::Constraint::All.new
+  end
+  
+end

data/lib/splash/namespace.rb

@@ -0,0 +1,67 @@
+require "logger"
+module Splash
+  class NameSpace
+    
+    URI_MATCHER = /^mongodb:\/\/([^\/:@]+)(:\d+|)\/(.*)/
+    
+    LOGGER = ::Logger.new(STDOUT)
+    #LOGGER.level = Logger::WARN
+    
+    attr_reader :db
+    
+    def self.default
+      @default ||= self.new
+    end
+    
+    def self.default=(value)
+      @default = value
+    end
+    
+    def initialize(uri='mongodb://localhost/splash')
+      match = URI_MATCHER.match(uri)
+      if match.nil?
+        @db = Mongo::Connection.from_uri(uri,:logger=>LOGGER)
+      else
+        @db = Mongo::Connection.new(match[1],match[2].length==0 ? nil : match[2].to_i,:logger=>LOGGER).db(match[3])
+      end
+    end
+    
+    def clear!
+      @db.collections.each do |collection|
+        begin
+          collection.drop
+        rescue Mongo::OperationFailure
+        end
+      end
+      return true
+    end
+    
+    def collection_for(klass)
+      @class_collection_map ||= {}
+      @top_classes ||={}
+      return @class_collection_map[klass] if( @class_collection_map.key? klass)
+      
+      
+      classes=Saveable.get_class_hierachie(klass)
+      
+      collection=@db.collection(classes.last.to_s.gsub(/(<?[a-z])([A-Z])/){ |c| c[0,1]+"_"+c[1,2].downcase }.gsub("::",".").downcase)
+      
+      @top_classes[collection.name] = classes.last
+      
+      classes.each do |klass|
+        @class_collection_map[klass]=collection
+      end
+      
+      return collection
+    end
+    
+    def class_for(collection_name)
+      @top_classes[collection_name]
+    end
+    
+    def dereference(dbref)
+      self.class_for(dbref.namespace)[dbref.object_id]
+    end
+    
+  end
+end

data/lib/splash/password.rb

@@ -0,0 +1,31 @@
+require 'digest/sha1'
+require 'securerandom'
+
+class Splash::Password
+  
+  include Splash::Embed
+  
+  DIGESTER = Digest::SHA1
+  
+  def_attribute( 'salt' )
+  
+  def_attribute( 'hash' )
+  
+  def matches?(string)
+    DIGESTER.hexdigest("#{string}#{self.salt}") == self.hash
+  end
+  
+  def initialize(str_or_args={})
+    if str_or_args.kind_of? String
+      slt = SecureRandom.hex
+      hash = DIGESTER.hexdigest("#{str_or_args}#{slt}")
+      super({'salt'=>slt,'hash'=>hash})
+    elsif str_or_args.kind_of? Hash
+      super(str_or_args)
+    else
+      super({})
+    end
+  end
+  
+  
+end

data/lib/splash/persister.rb

@@ -0,0 +1,66 @@
+class Splash::Persister
+  
+  RAW_TYPES=[String,NilClass,Numeric,FalseClass,TrueClass,BSON::ObjectID,Time]
+  
+  attr_reader :persisted_class
+  
+  def read(value)
+    return value
+  end
+  
+  def write(value)
+    return value
+  end
+  
+  def self.raw?(value)
+    return true if RAW_TYPES.any? do |type| value.class == type end
+    if value.kind_of?(Hash) || value.kind_of?(Array)
+      value.each do |key,val|
+        return false unless self.raw?(key)
+        return false unless self.raw?(val)
+      end
+      return true
+    elsif value.kind_of?(Array)
+      value.each do |sub|
+        return false unless self.raw?(sub)
+      end
+      return true
+    end
+    return false
+  end
+  
+  def initialize(config={},&block)
+    self.config= default_config.merge(config)
+    if block_given?
+      instance_eval &block
+    end
+  end
+  
+  def persist_class(klass)
+    @persisted_class=klass
+  end
+  
+  def persisted_class()
+    @persisted_class
+  end
+  
+  def bind_to(klass)
+    
+  end
+  
+  def default(object)
+    @config[:default]
+  end
+  
+  def missing(object)
+    nil
+  end
+  
+  protected
+    def default_config
+      {:default=>nil,:read=>nil,:write=>nil}
+    end
+    def config=(conf)
+      @config=conf
+    end
+end

data/lib/splash/query_interface.rb

@@ -0,0 +1,84 @@
+module Splash
+  module QueryInterface
+    
+    %w(preload nopreload limit conditions fieldmode with_id extend_scoped sort).each do |fct|
+      class_eval <<-CODE, __FILE__,__LINE__
+def #{fct}(*args,&block)
+  query(query_#{fct}(*args,&block))
+end
+def #{fct}!(*args,&block)
+  query!(query_#{fct}(*args,&block))
+end
+protected :#{fct}!
+CODE
+    end
+    
+    protected
+    
+      def query_preload(*field)
+        fields=field.flatten.inject({}){|hsh,key|
+          hsh[key.to_s]=1
+          hsh
+        }
+        return {:fields=>fields}
+      end
+      
+      def query_nopreload(*field)
+        fields=field.flatten.inject({}){|hsh,key|
+          hsh[key.to_s]=0
+          hsh
+        }
+        return {:fields=>fields}
+      end
+      
+      def query_limit(limit)
+        return {:limit=>limit}
+      end
+      
+      def query_conditions(conditions)
+        return {:selector=>conditions}
+      end
+      
+      def query_default_attributes(values)
+        
+      end
+      
+      def query_with_id(*args)
+        ids=args.flatten.map &:to_bson
+        if ids.size == 1
+          return {:selector=>{"_id"=>ids.first}}
+        else
+          return {:selector=>{"_id"=>{"$in"=>ids}}}
+        end
+      end
+      def query_fieldmode(type)
+        return {:fieldmode=>type}
+      end
+      
+      def query_sort(*args)
+        result=[]
+        args.each do |arg|
+          if arg.kind_of? String
+            result << [arg,'ascending']
+          elsif arg.kind_of? Hash
+            result += arg.to_a
+          end
+        end
+        return {:sort=>result}
+      end
+      
+      def query_extend_scoped(*modules,&block)
+        if block_given?
+          m=Module.new
+          m.class_eval &block
+          modules << m
+        end
+        
+        modules.each do |mod|
+          self.extend(mod)
+        end
+        
+        return {:extend_scoped => modules}
+      end
+  end
+end

data/lib/splash/saveable.rb

@@ -0,0 +1,141 @@
+module Splash
+  module Saveable
+    class Persister < Splash::Persister
+      def write(value)
+        return nil if value.nil?
+        return value._id
+      end
+      
+      def read(value)
+        return nil if value.nil?
+        return persisted_class.with_id(value).first
+      end
+    end
+    
+    class MultiPersister < Splash::Persister
+      def write(value)
+        return nil if value.nil?
+        return BSON::DBRef.new(value.class.collection.name,value._id)
+      end
+      
+      def read(value)
+        return nil if value.nil?
+        return @persisted_class.namespace.dereference(value)
+      end
+    end
+    
+    class EmbedPersister < Splash::Persister
+      def write(value)
+        return nil if value.nil?
+        return Saveable.wrap(value)
+      end
+      
+      def read(value)
+        return nil if value.nil?
+        return Saveable.load(value,persisted_class)
+      end
+    end
+    
+    self.persister= MultiPersister
+    
+    
+    UPPERCASE=65..90
+    
+    class << self
+      def included(base)
+        base.extend(ClassMethods)
+        base.persister=Splash::Saveable::Persister
+      end
+      
+      def unwrap(keys)
+        keys.inject({}) do |hsh,(key,val)| hsh[key]=val unless UPPERCASE.include? key[0]; hsh end
+      end
+      
+      def wrap(object)
+        object.to_saveable.merge("Type"=>Saveable.get_class_hierachie(object.class).map(&:to_s))
+      end
+      
+      def load(keys,klass=Hash)
+        if keys.nil?
+          keys={}
+        end
+        if keys["Type"]
+          klass = Kernel.eval(keys["Type"].first)
+        end
+        k = klass.new()
+        k.attributes.load_raw(self.unwrap(keys))
+        return k
+      end
+      
+      def to_saveable(obj)
+        if obj.respond_to? :to_saveable
+          return obj.to_saveable
+        end
+        return obj
+      end
+      
+      def get_class_hierachie(klass)
+        base=[]
+        begin
+          if klass.named?
+            base << klass
+          end
+          #return base unless klass.instance_of? Class
+          klass = klass.superclass
+        end while ( klass < Splash::HasAttributes )
+        return base
+      end
+    end
+    
+    def namespace
+      self.class.namespace
+    end
+    
+    def storable_id
+      self.attributes["_id"]
+    end
+    
+    def store!
+      self.attributes["_id"]=self.class.store!(self)
+      return self
+    end
+    
+    def remove!
+      return self.class.collection.remove('_id'=>self._id)
+    end
+    
+    def stored?
+      return !storable_id.nil?
+    end
+    
+    def find_self
+      self.class.with_id(self.storable_id)
+    end
+    
+    module ClassMethods
+      
+      def store!(object)
+        return self.collection.save(
+          Saveable.wrap(object)
+        );
+      end
+      
+      def namespace
+        @namespace ||= Splash::NameSpace.default
+      end
+      
+      def collection
+        @collection ||= namespace.collection_for(self)
+      end
+      
+      def [](*args)
+        a=args.flatten
+        if a.length == 1 
+          return with_id(a).first
+        else
+          return with_id(a).finish!
+        end
+      end
+    end
+  end
+end

data/lib/splash/scope/options.rb

@@ -0,0 +1,58 @@
+class Splash::Scope::Options
+  
+  OPTION_KEYS=[:fields,:limit,:sort]
+  def self.cast(hsh)
+    if hsh.kind_of? self
+      return hsh
+    end
+    return self.new(hsh)
+  end
+  
+  def initialize(hsh=nil)
+    @options={:selector=>{},:fieldmode=>:exclude,:extend_scoped=>[],:limit=>0,:sort=>[]}
+    @options.merge! hsh if hsh
+    @options.freeze
+  end
+  
+  def merge(options)
+    self.class.new(Splash::Scope::Options.merge_options(@options,options))
+  end
+  
+  def self.merge_options(a,b)
+    return {
+      :selector => a[:selector].deep_merge(b[:selector]),
+      :fieldmode => (b[:fieldmode] || a[:fieldmode]),
+      :extend_scoped => (a[:extend_scoped] + (b[:extend_scoped] || [])),
+      :limit => (b[:limit] || a[:limit]),
+      :sort => (a[:sort] + (b[:sort] || []))
+    }
+  end
+  
+  def extensions
+    @options[:extend_scoped] || []
+  end
+  
+  def to_h
+    @options
+  end
+  
+  def selector
+    @options[:selector]
+  end
+  
+  def options
+    opt=@options.reject{|key,value| !(OPTION_KEYS.include? key)}
+    if opt.key? :fields
+      if @options[:fieldmode]==:eager
+        opt.delete :fields
+      else
+        fieldmode = (@options[:fieldmode]==:include ? 0 : 1)
+        opt[:fields]=opt[:fields].reject{|key,value|
+          value == fieldmode
+        }
+      end
+      
+    end
+    return opt
+  end
+end

data/lib/splash/scope.rb

@@ -0,0 +1,46 @@
+require "delegate"
+module Splash
+  class Scope
+    
+    autoload :Options,Splash::DIR+"/splash/scope/options"
+    
+    include Splash::ActsAsScope
+
+    def initialize(parent,options)
+      @parent_scope=parent.scope_root
+      @scope_options=options
+    end
+    
+    def scope_root?
+      false
+    end
+    
+    def scope_root
+      @parent_scope
+    end
+    
+    def respond_to?(meth)
+      load_scope_extensions!
+      super
+    end
+    
+    private
+      def load_scope_extensions!
+        unless @scope_extesions_loaded
+          @scope_options.extensions.each do |mod|
+            self.extend(mod)
+          end
+          @scope_extesions_loaded = true
+          return true
+        end
+        return false
+      end
+      def method_missing(meth,*args,&block)
+        if load_scope_extensions!
+          return self.send(meth,*args,&block)
+        end
+        super
+      end
+    
+  end
+end

data/lib/splash/scope_delegator.rb

@@ -0,0 +1,14 @@
+class Splash::ScopeDelegator < Delegator
+  def initialize(obj)
+    
+  end
+  
+  def respond_to?(meth)
+    
+  end
+  
+  private
+    def method_missing(meth,*args,&block)
+      
+    end
+end

data/lib/splash/scope_options.rb

@@ -0,0 +1,31 @@
+class ScopeOptions
+  
+  def self.cast(hsh)
+    if hsh.kind_of? self
+      return hsh
+    end
+    return self.new(hsh)
+  end
+  
+  def initialize(hsh=nil)
+    @options={:selector=>{},:limit=>-1}
+    @options.merge! hsh if hsh
+    
+    @options.freeze
+  end
+  
+  def merge(options)
+    self.class.new(@options.merge(options.to_h))
+  end
+  
+  def to_h
+    @options
+  end
+  
+  def selector
+    @options[:selector]
+  end
+  def options
+    @options.reject{|key,value| key == :selector}
+  end
+end