splash 0.0.1.alpha

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+gem 'rspec'
+require 'spec/version'
+require 'spec/rake/spectask'
+require 'spec/ruby'
+
+task :default => [:spec] 
+
+spec = Gem::Specification.load "splash.gemspec"
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/lib/splash/acts_as_collection.rb

@@ -0,0 +1,55 @@
+module Splash::ActsAsCollection
+  
+  include Enumerable
+  
+  def self.of(klass)
+    m = Module.new
+    s = self
+    m.class_eval do
+      include(s)
+    end
+    m.collection_class = klass
+    return m
+  end
+  
+  class << self
+    def included(base)
+      if base.kind_of? Class
+        base.extend(ClassMethods)
+      else
+        base.extend(SubModuleMethods)
+      end
+      
+    end
+  end
+  
+  module SubModuleMethods
+    attr_accessor :collection_class
+    
+    def included(base)
+      base.extend(ClassMethods)
+      s = self
+      base.instance_eval do
+        @collection_class = s.collection_class
+      end
+    end
+  end
+  
+  module ClassMethods
+    attr_reader :collection_class
+  end
+  
+  def create(*args,&block)
+    object=self.class.collection_class.new(*args,&block)
+    self << object
+    return object
+  end
+  
+  def accepts?(object)
+    return object === collection_class
+  end
+  
+  def include?(object)
+    accepts?(object) && super
+  end
+end

data/lib/splash/acts_as_scope.rb

@@ -0,0 +1,118 @@
+module Splash
+  module ActsAsScope
+    include QueryInterface
+    
+    
+    # the following methods have to be defined
+    # when including this Module:
+    # - collection
+    # - scope_root
+    
+    
+    def scope_options
+      @scope_options ||= Splash::Scope::Options.new
+    end
+    
+    def query(options)
+      Scope.new(self,scope_options.merge(options))
+    end
+    
+    def dup
+      
+    end
+    
+    def all
+      clone
+    end
+    
+    def each(&block)
+      self.clone.scope_cursor.each do |o|
+        yield Saveable.load(o,self)
+      end
+      self
+    end
+    
+    def to_a
+      result = []
+      each do |object|
+        result << object
+      end
+      return result
+    end
+    
+    def has_next?
+      scope_cursor.has_next?
+    end
+    
+    def next_document
+      nd = scope_cursor.next_document
+      return nil if nd.nil?
+      return Saveable.load(nd,self)
+    end
+    
+    def first
+      self.clone.limit(1).next_document
+    end
+    
+    def clone
+      return Scope.new(self.scope_root,scope_options.dup)
+    end
+    
+    def next_raw_document
+      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
+    
+    def scope_root?
+      false
+    end
+    
+    def <<(object)
+    end
+  
+    def scoped_methods(*modules,&block)
+      
+    end
+    
+    protected
+      def scope_cursor()
+        @scope_cursor ||= find!(scope_options.selector,scope_options.options)
+      end
+      
+      def unset_scope_cursor()
+        @scope_cursor=nil
+      end
+      
+      def query!(options)
+        @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)
+      end
+  end
+end

data/lib/splash/acts_as_scope_root.rb

@@ -0,0 +1,10 @@
+module Splash::ActsAsScopeRoot
+  include Splash::ActsAsScope
+  
+  def scope_root
+    self
+  end
+  def scope_root?
+    true
+  end
+end

data/lib/splash/annotated.rb

@@ -0,0 +1,34 @@
+module Splash::Annotated
+  
+  class << self
+    def included(base)
+      base.extend(ClassMethods)
+    end
+  end
+  
+  
+  module ClassMethods
+  
+    def method_added(meth)
+      apply_annotations(meth)
+      super
+    end
+    
+    def apply_annotations(meth)
+      return if @annotations.nil?
+      @annotations.each do |(fn,args,block)|
+        args.unshift(meth)
+        self.send(fn,*args,&block)
+      end
+      @annotations=[]
+      return nil
+    end
+    
+    def included(base)
+      included_modules.each do |mod|
+        mod.included(base)
+      end
+    end
+    
+  end
+end

data/lib/splash/application.rb

@@ -0,0 +1,36 @@
+module Splash
+  module Application
+    class << self
+      def respond(request)
+        
+  
+        
+      end
+      
+      
+      def call(env)
+        t='<form action="" method="post">
+    <p>
+      <input id="openid_identifier" name="openid[identifier][id]" type="text" />
+    </p>
+
+    <p>
+      <input name="commit" type="submit" value="Sign in" />
+    </p>
+  </form>'
+        request=Rack::Request.new(env)
+        if resp = env["rack.openid.response"]
+          if resp.status == :missing
+            return [401, {"WWW-Authenticate" => "OpenID identifier=\"#{request["openid_identifier"]}\""}, []]
+          else
+            env["rack.session"]["user"]=resp.identity_url
+            return [200,{'Content-Type' => 'text/html'},'<html>Welcome!<pre>'+(env.to_yaml)+'</pre></html>']
+          end
+        elsif request["openid_identifier"]
+          return [401, {"WWW-Authenticate" => "OpenID identifier=\"#{request["openid_identifier"]}\""}, []]
+        end
+        return [200,{'Content-Type' => 'text/html'},'<html>'+t+'<pre>'+(request.to_yaml)+'</pre></html>']
+      end
+    end
+  end
+end

data/lib/splash/attribute.rb

@@ -0,0 +1,45 @@
+class Splash::Attribute
+  
+  include ::Humanized
+  include Splash::HasConstraint
+  
+  attr_accessor :persister, :type, :default
+  
+  def initialize(t=nil,&block)
+    self.type=t if t
+    instance_eval &block if block_given?
+  end
+  
+  def type= t
+    @persister = Splash::HasAttributes.get_persister(t)
+    @type = t
+  end
+  
+  def persisted_by(*args,&block)
+    @persister = Splash::HasAttributes.get_persister(*args, &block)
+  end
+  
+  def read(value)
+    return value unless @persister
+    @persister.read(value)
+  end
+  
+  def write(value)
+    return value unless @persister
+    @persister.write(value)
+  end
+  
+  def persisted_class
+    return Object unless @persister
+    @persister.persisted_class
+  end
+  
+  def missing()
+    if self.default
+      self.default.clone
+    else
+      nil
+    end
+  end
+  
+end

data/lib/splash/attributed_struct.rb

@@ -0,0 +1,8 @@
+class Splash::AttributedStruct
+  
+  include Splash::HasAttributes
+  
+  def initialize(attr={})
+    self.attributes.load(attr)
+  end
+end

data/lib/splash/collection.rb

@@ -0,0 +1,52 @@
+class Splash::Collection < Array
+  include Splash::ActsAsCollection
+  
+  COLLECTION_CLASSES = {}
+  
+  def self.of(klass)
+    
+    return COLLECTION_CLASSES[klass] if COLLECTION_CLASSES.key? klass
+    
+    c = Class.new(self)
+    c.instance_eval do
+      @collection_class = klass
+    end
+    
+    COLLECTION_CLASSES[klass] = c
+    return c
+  end
+  
+
+  class Persister < Splash::Persister
+
+    def read(val)
+      return nil if val.nil?
+      nu=persisted_class.new
+      val.inject(nu){|memo,e|
+        memo << @persister.read(e)
+        memo
+      }
+    end
+    
+    def write(val)
+      return nil if val.nil?
+      val.inject([]){|memo,e|
+        memo << @persister.write(e)
+        memo
+      }
+    end
+    
+    def persist_class(col)
+      @persister=Splash::HasAttributes.get_persister(col.collection_class)
+      super
+    end
+    
+  end
+  
+  class << self
+    def persister
+      return Splash::Collection::Persister
+    end
+  end
+
+end

data/lib/splash/connection.rb

@@ -0,0 +1,26 @@
+class Splash::Connection
+  def initialize(host,db)
+    @host=host
+    @db=db
+  end
+  
+  def get(id)
+    Net::HTTP.start("localhost", 5984){|http|
+      http.get('/splash/'+id)
+    }.body.parse_json
+  end
+  
+  def put(id,val)
+    id = id.to_s
+    req=Net::HTTP::Put.new('/splash/'+id)
+    req.set_content_type("application/json")
+    Net::HTTP.start("localhost", 5984){|http|
+      http.request(req,val.to_json)
+    }.body
+  end
+  
+  def uuid
+    
+  end
+  
+end

data/lib/splash/constraint/all.rb

@@ -0,0 +1,24 @@
+class Splash::Constraint::All < Set
+  
+  include Splash::Constraint
+  include Splash::ActsAsCollection.of(Splash::Constraint)
+  
+  def accept?(value)
+    self.all? do |constr|
+      constr.accept?(value)
+    end
+  end
+  
+  def not_accepting(value)
+    result = Splash::Constraint::All.new
+    self.each do |constr|
+     result << constr unless constr.accept?(value)
+    end
+    return result
+  end
+  
+  def initialize
+    super("all!")
+  end
+  
+end

data/lib/splash/constraint/any.rb

@@ -0,0 +1,13 @@
+class Splash::Constraint::Any < Set
+  
+  include Splash::Constraint
+  include Splash::ActsAsCollection.of(Splash::Constraint)
+  
+  def accept?(value)
+    self.all? do |constr|
+      constr.accept?(value)
+    end
+  end
+  
+  
+end

data/lib/splash/constraint/in.rb

@@ -0,0 +1,13 @@
+class Splash::Constraint::In
+  
+  include Splash::Constraint
+  
+  def initialize(collection,desc="")
+    @collection = collection
+    super(desc)
+  end
+  
+  def accept?(value)
+    return value.nil? || collection.include?(value)
+  end
+end

data/lib/splash/constraint/not_nil.rb

@@ -0,0 +1,9 @@
+class Splash::Constraint::NotNil
+  
+  include Splash::Constraint
+  
+  def accept?(value)
+    !value.nil?
+  end
+  
+end

data/lib/splash/constraint.rb

@@ -0,0 +1,62 @@
+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' )
+  
+  class Simple
+    
+    include Splash::Constraint
+    
+    def initialize(descr,&block)
+      @description = descr
+      @block = block
+    end
+    
+    def accept?(value)
+      return @block.call(value)
+    end
+    
+  end
+  
+  def self.new(*args,&block)
+    if self == Splash::Constraint
+      return Simple.new(*args,&block)
+    end
+    super
+  end
+  
+  def self.and(*args)
+    if args.length == 0
+      return Splash::Constraint::All.new
+    elsif args.length == 1
+      return args.first
+    else
+      result = Splash::Constraint::All.new
+      args.each do |constr|
+        if constr.kind_of? Splash::Constraint::All
+          result += constr
+        else
+          result << constr
+        end
+        
+      end
+      return result
+    end
+  end
+  
+  def not_accepting(value)
+    return self unless self.accept?(value)
+  end
+  
+  def initialize(descr)
+    @description = descr
+    super()
+  end
+  
+  alias_method :to_s, :description
+  
+end

data/lib/splash/document.rb

@@ -0,0 +1,38 @@
+module Splash::Document
+  
+  include Splash::Saveable
+  include Splash::HasAttributes
+  include Splash::Validates
+  
+  class << self
+    def included(base)
+      included_modules.each do |mod|
+        mod.included(base)
+      end
+      
+      dd = self
+      
+      base.instance_eval do
+        include Splash::ActsAsCollection.of(base)
+        extend Splash::ActsAsScopeRoot
+        
+        def included(base)
+          Splash::Document.included(base)
+          super(base)
+        end
+      end
+    end
+    
+    def persister
+      Splash::Saveable::MultiPersister
+    end
+  end
+  
+  def initialize(args={})
+    self.attributes.load(args)
+  end
+  
+  def to_saveable
+    attributes.raw
+  end
+end

data/lib/splash/embed.rb

@@ -0,0 +1,37 @@
+module Splash::Embed
+  
+  include Splash::HasAttributes
+  include Splash::Validates
+  
+  class << self
+    def included(base)
+      base.extend(ClassMethods)
+      included_modules.each do |mod|
+        mod.included(base)
+      end
+    end
+    
+    def define(&block)
+      c=Class.new()
+      mod = self
+      c.instance_eval do
+        include mod
+      end
+      c.class_eval(&block)
+      c
+    end
+  end
+  
+  module ClassMethods
+    def persister
+      Splash::Saveable::EmbedPersister
+    end
+  end
+  
+  def initialize(args={})
+    self.attributes.load(args)
+  end
+    def to_saveable
+      attributes.raw
+    end
+end