splash 0.0.1.alpha

data/lib/splash/standart_extensions/hash.rb

@@ -0,0 +1,45 @@
+require File.join File.dirname(__FILE__), "object"
+require File.join File.dirname(__FILE__), "module"
+class Hash
+  
+  DEEP_MERGER=proc{|key,value,value2|
+    if( value.kind_of?(Hash) && value2.kind_of?(Hash) )
+      value.merge(value2,&DEEP_MERGER)
+    else
+      value2
+    end
+  }
+  
+  def deep_merge(k)
+    return self if k.nil?
+    merge(k,&DEEP_MERGER)
+  end
+  
+  def deep_merge!(k)
+    return self if k.nil?
+    merge!(k,&DEEP_MERGER)
+  end
+  
+  def to_saveable
+    return self.inject({}) do |h,(k,v)|
+          h[k]=Splash::Saveable.to_saveable(v);
+          h
+      end
+  end
+  
+  def only(keys)
+    self.reject{|key,val| !keys.include? key}
+  end
+  
+  def hashmap
+    self.inject({}) do |newhash, (k,v)|
+      newhash[k] = yield(k, v)
+      newhash
+    end
+  end
+  
+  def +(hsh)
+    self.merge(hsh)
+  end
+  
+end

data/lib/splash/standart_extensions/module.rb

@@ -0,0 +1,73 @@
+class Module
+  
+  def persister
+    @persister ||= Splash::Persister
+  end
+  
+  def persister=(p)
+    @persister=p
+  end
+  
+  def named?
+    to_s[0..1]!="#<"
+  end
+  
+  def define_annotation(name)
+    self.class_eval <<-DEF,__FILE__, __LINE__
+alias_method #{(name.to_s+"!").to_sym.inspect}, #{name.inspect}
+def #{name.to_s}(*args,&block)
+  @annotations ||= []
+  @annotations << [#{(name.to_s+"!").to_sym.inspect},args,block]
+end
+DEF
+end
+
+  def merged_inheritable_attr(name,default=[],&block)
+    if block_given?
+      merger = lambda &block
+    else
+      merger = lambda{|a,b| a if b.nil?; a + b }
+    end
+    
+    self.instance_eval do
+      
+      @merged_inheritable_attr_info ||={}
+      
+      @merged_inheritable_attr_info[name] = {:default=>default,:merger => merger }
+      
+      def self.merged_inheritable_attr_info(name)
+        if @merged_inheritable_attr_info && @merged_inheritable_attr_info.key?(name)
+          return @merged_inheritable_attr_info[name]
+        end
+        superclass.merged_inheritable_attr_info(name) if superclass.respond_to?(:merged_inheritable_attr_info)
+      end
+      
+    end
+    
+    
+    
+    self.instance_eval <<-DEF,__FILE__, __LINE__
+def #{name.to_s}
+  @#{name.to_s} ||= merged_inheritable_attr_info(#{name.inspect})[:default].dup
+end
+def #{name.to_s}=(v)
+  @#{name.to_s}=v
+end
+def all_#{name.to_s}
+  unless superclass.respond_to? :all_#{name.to_s}
+    return #{name.to_s}
+  end
+  merged_inheritable_attr_info(#{name.inspect})[:merger].call(#{name.to_s},superclass.all_#{name.to_s})
+end
+def each_#{name.to_s}
+  c=self
+  begin
+    yield(c.#{name.to_s})
+    c=c.superclass
+  end while(c.respond_to? #{name.to_sym.inspect})
+end
+
+DEF
+  end
+
+end

data/lib/splash/standart_extensions/object.rb

@@ -0,0 +1,11 @@
+class Object
+  
+  def to_bson
+    self
+  end
+  
+  def persister
+    Splash::Persister
+  end
+  
+end

data/lib/splash/standart_extensions/string.rb

@@ -0,0 +1,5 @@
+class String
+  def to_bson
+    BSON::ObjectID.from_string(self)
+  end
+end

data/lib/splash/validates.rb

@@ -0,0 +1,75 @@
+require "set"
+module Splash::Validates
+  
+  class Invalid < Exception
+    
+    attr_reader :object, :validators
+    
+    def initialize(obj)
+      super
+      self.object = obj
+      self.validators = Set.new
+    end
+    
+  end
+  
+  class << self
+    def included(base)
+      base.instance_eval do
+        merged_inheritable_attr :validators,Set.new
+      end
+      base.extend(ClassMethods)
+    end
+  end
+  
+  module ClassMethods
+    def validate(*args,&block)
+      if args.first.respond_to? :valid?
+        validators << validator
+      end
+      validators << Splash::Validator.new(*args,&block)
+    end
+  end
+  
+  def valid?
+    validators = self.class.all_validators
+    
+    validators.sort! do |a,b|
+      if b.depends.include? a.field
+        -1
+      elsif a.depends.include? b.field
+        1
+      else
+        0
+      end
+    end
+    
+    return validators.all? do |validator|
+      validator.valid?(self)
+    end
+  end
+  
+  def raise_if_invalid
+    v = Invalid.new(self)
+    
+    validators = self.class.all_validators
+    
+    validators.sort! do |a,b|
+      if b.depends.include? a.field
+        -1
+      elsif a.depends.include? b.field
+        1
+      else
+        0
+      end
+    end
+    
+    validators.each do |validator|
+      v.validators << validator unless validator.valid?(self)
+    end
+    
+    raise v if v.validators.size > 0
+  end
+  
+  
+end

data/lib/splash/validator.rb

@@ -0,0 +1,24 @@
+class Splash::Validator
+  
+  attr_reader :field,:block,:description,:depends
+  
+  def valid?(object)
+    if @block
+      return @block.call(object)
+    else
+      value = object.send(@field)
+      if value.respond_to? :valid?
+        return value.valid?
+      end
+    end
+    true
+  end
+  
+  def initialize(field, description,options={},&block)
+    @field = field
+    @block = block
+    @description = description
+    @depends = (options[:depends] || Set.new)
+  end 
+  
+end

data/lib/splash.rb

@@ -0,0 +1,35 @@
+if defined? Splash
+  raise "Splash included twice!"
+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
+end

data/spec/helper.rb

@@ -0,0 +1,15 @@
+require "rubygems"
+gem "mongo"
+require "mongo"
+
+require File.join(File.dirname(__FILE__),"../../Humanized/lib/humanized")
+
+culture=Humanized::Culture.new
+culture.default_case = :nominativ
+culture.converter = Humanized::Converter.new({})
+
+
+Humanized::Culture.native=culture
+Humanized::Culture.current=culture
+
+require File.join(File.dirname(__FILE__),"../lib/splash")

data/spec/lib/annotated_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__),"../helper")
+
+describe Splash::Annotated do
+  
+  it "should work for modules" do
+    
+    module NameAnnotations
+      
+      include Splash::Annotated
+      
+      class << self
+        def included(base)
+          base.extend(ClassMethods)
+          super
+        end
+      end
+      
+      module ClassMethods
+      
+        def named(fn,name)
+          @named||={}
+          @named[fn]=name
+        end
+        
+        def name(fn)
+          return @named[fn] rescue nil
+        end
+        
+        define_annotation :named
+      end
+      
+    end
+    
+    class ClassWithSimpleAnnotations
+      
+      include NameAnnotations
+      
+      named "Nice Function!"
+      def nice
+        return 42
+      end
+      
+    end
+    
+    ClassWithSimpleAnnotations.name(:nice).should == "Nice Function!"
+    
+  end
+  
+  it "should work for classes" do
+    
+    class AnnotatedParent
+      
+      include Splash::Annotated
+      
+      class << self
+        
+        def named(fn,name)
+          @named||={}
+          @named[fn]=name
+        end
+        
+        def name(fn)
+          return @named[fn] rescue nil
+        end
+        
+        define_annotation :named
+        
+      end
+      
+    end
+    
+    class Child < AnnotatedParent
+      
+      include NameAnnotations
+      
+      named "Nice Function!"
+      def nice
+        return 42
+      end
+      
+    end
+    
+    Child.name(:nice).should == "Nice Function!"
+    
+  end
+  
+end

data/spec/lib/collection_spec.rb

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__),"../helper")
+
+describe Splash::ActsAsCollection do
+  
+  it "should support class integration" do
+    
+    class Friend
+      
+    end
+    
+    class FriendList < Array
+      
+      include Splash::ActsAsCollection.of(Friend)
+      
+    end
+    
+    FriendList.should < Splash::ActsAsCollection
+    
+    fl = FriendList.new
+    
+    fl.respond_to?(:create).should be_true
+    
+    fl.create
+    
+    fl.should have(1).item
+    
+  end
+  
+  it "should support the collection class" do
+    
+    class Friend
+      
+    end
+    
+    fl = Splash::Collection.of(Friend).new
+    
+    fl.respond_to?(:create).should be_true
+    
+    fl.create
+    
+    fl.should have(1).item
+    
+  end
+  
+  it "should support comparison" do
+    
+    
+    class User
+      
+    end
+    
+    class Admin < User
+      
+    end
+    
+    fl = Splash::Collection.of(User).new
+    
+    fl.should be_a(Splash::Collection.of(User))
+    
+    
+  end
+  
+  
+end

data/spec/lib/has_attributes_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__),"../helper")
+
+describe Splash::HasAttributes do
+  
+  describe "declaration" do
+    
+    it "should look cool and work" do
+      
+      class User
+        
+        include Splash::HasAttributes
+        
+        
+        # simple style
+        def_attribute 'name'
+        
+        # simple with type
+        def_attribute 'friends', Splash::Collection.of(User)
+        
+        def_attribute( 'mails', Splash::Collection.of(String)) do
+          
+          self.default = Splash::Collection.of(String).new
+          
+        end
+        
+      end
+      
+      User.attributes.should have(3).items
+      
+      u = User.new
+      
+      u.name.should be_nil
+      
+      u.friends.should be_nil
+      
+      u.mails.should_not be_nil
+      u.mails.should be_a(Splash::Collection.of(String))
+      
+    end
+    
+  end
+  
+end

data/spec/lib/has_constraints_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__),"../helper")
+
+describe Splash::HasConstraint do
+  
+  describe "declaration" do
+    
+    it "should work in a trivial case" do
+      
+      class Field
+        
+        include Splash::HasConstraint
+        
+      end
+      
+      f = Field.new
+      
+      f.constraint.should_not be_nil
+      
+      f.constraint.accept?(nil).should be_true
+      
+    end
+    
+    it "should give the power to write simple constraints fast" do
+      
+      class Field
+        
+        include Splash::HasConstraint
+        
+      end
+      
+      f = Field.new
+      
+      f.constraint.create "should not be nil" do |value|
+        !value.nil?
+      end
+      
+      f.constraint.create "should be a string with 5 to 10 chars" do |value|
+        value.kind_of?(String) && (5..10).include?(value.length)
+      end
+      
+      f.constraint.should have(2).items
+      
+      f.constraint.accept?(nil).should be_false
+      
+      f.constraint.accept?("aaa").should be_false
+      
+      f.constraint.accept?("aaaaa").should be_true
+      
+    end
+    
+  end
+  
+end

data/spec/lib/inheritance_spec.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__),"../helper")
+
+describe "inheritance" do
+  
+  it "should generate normal methods" do
+    
+    class A
+      
+      merged_inheritable_attr :a
+      merged_inheritable_attr :b,"b"
+      
+    end
+    
+    A.respond_to?(:a).should be_true
+    A.respond_to?(:b).should be_true
+    
+    A.b.should == "b"
+    
+    A.all_b.should == "b"
+    
+    
+  end
+  
+  it "should generate inheritable methods" do
+    
+    class A
+      
+      merged_inheritable_attr :a
+      merged_inheritable_attr :b,"b" do |a,b|
+        a + b
+      end
+      
+    end
+    
+    class B < A
+      
+    end
+    
+    class C < B
+      merged_inheritable_attr :c
+    end
+    
+    A.a << 1
+    
+    B.respond_to?(:a).should be_true
+    B.respond_to?(:b).should be_true
+    
+    B.b = "c"
+    
+    B.a << 2
+    
+    B.all_b.should == "cb"
+    
+    C.all_b.should == "bcb"
+    
+    C.a << 3
+    
+    A.a.should have(1).item
+    A.all_a.should have(1).item
+    
+    B.a.should have(1).item
+    B.all_a.should have(2).items
+    
+    C.a.should have(1).item
+    C.all_a.should have(3).items
+    
+  end
+  
+end