machu-appengine-pstore 0.1.0 → 0.1.1

data/README.rdoc

@@ -1,17 +1,10 @@
 = appengine-pstore
 
-Description goes here.
+ * http://github.com/machu/appengine-pstore
 
-== Note on Patches/Pull Requests
- 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but
-   bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+== DESCRIPTION:
+
+The PStore interfaces for the Google App Engine Datastore.
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/appengine-pstore.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{appengine-pstore}
-  s.version = "0.1.0"
+  s.version = "0.1.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["MATSUOKA Kohei"]
-  s.date = %q{2009-09-26}
+  s.date = %q{2009-09-27}
   s.description = %q{PStore compatible interface for Google Apps Engine.}
   s.email = %q{kohei@machu.jp}
   s.extra_rdoc_files = [

data/lib/appengine-pstore.rb

@@ -1,6 +1,28 @@
+#!/usr/bin/env ruby
+# Copyright:: Copyright 2009 MATSUOKA Kohei
+#  
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#   
+#     http://www.apache.org/licenses/LICENSE-2.0
+#        
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 require 'rubygems'
 require 'appengine-apis/datastore'
 
+# from pstore.rb
+class PStore
+  # The error type thrown by all PStore methods.
+  class Error < StandardError
+  end
+end
+
 module AppEngine
   module Datastore
     class Query
@@ -23,51 +45,88 @@ module AppEngine
     end
 
     def in_transaction
-      unless AppEngine::Datastore.current_transaction(nil)
-        raise PStore::Error, "not in transaction"
+      if @transaction == nil || @transaction.active? == false
+      #unless transaction && transaction.active
+      #unless AppEngine::Datastore.current_transaction(nil)
+        raise ::PStore::Error, "not in transaction"
       end
     end
 
     def in_transaction_wr
       in_transaction
-      raise PStore::Error, "in read-only transaction" if @rdonly
+      raise ::PStore::Error, "in read-only transaction" if @rdonly
     end
     private :in_transaction, :in_transaction_wr
 
     def transaction(readonly = false)
+      raise ::PStore::Error, "nested transaction" if @transaction
       @rdonly = readonly
       @transaction = AppEngine::Datastore.begin_transaction
-      @cache = {}
-      yield self
+      # uncommited entities
+      @uncommited = {
+        :added => {},
+        :deleted => {}
+      }
+      begin
+        catch(:pstore_abort_transaction) do
+          yield self
+        end
+      rescue Exception
+        @transaction.rollback if @transaction.active?
+        raise
+      ensure
+        @transaction.commit if @transaction.active?
+        @transaction = nil
+        @uncommited = nil
+      end
+    end
+
+    def commit
+      in_transaction
       @transaction.commit
-      @transaction = nil
+      throw :pstore_abort_transaction
+    end
+
+    def abort
+      in_transaction
+      @transaction.rollback
+      throw :pstore_abort_transaction
     end
 
     def [](name)
       in_transaction
-      raise PStore::Error, "in read-only transaction" if @rdonly
-      if @cache.key?(name)
-        @cache[name]  # return latest put data
-      else
-        key = AppEngine::Datastore::Key.from_path(@parent_key, @kind, name)
+      # return uncommited data if exist
+      return @uncommited[:added][name] if @uncommited[:added].key?(name)
+      return nil if @uncommited[:deleted].key?(name)
+
+      key = AppEngine::Datastore::Key.from_path(@parent_key, @kind, dump(name))
+      begin
         entity = AppEngine::Datastore.get(@transaction, key)
         load(entity[:value])
+      rescue AppEngine::Datastore::EntityNotFound
+        nil
       end
     end
 
     def []=(name, value)
       in_transaction_wr
-      entity = AppEngine::Datastore::Entity.new(@kind, name, @parent_key)
+      entity = AppEngine::Datastore::Entity.new(@kind, dump(name), @parent_key)
       entity[:value] = dump(value)
       AppEngine::Datastore.put(@transaction, entity)
-      @cache[name] = value
+      @uncommited[:added][name] = value
+      @uncommited[:deleted].delete(name)
       value
     end
 
     def delete(name)
-      key = AppEngine::Datastore::Key.from_path(@parent_key, @kind, name)
-      AppEngine::Datastore.delete(@transaction, key)
-      @cache.delete(name)
+      in_transaction_wr
+      key = AppEngine::Datastore::Key.from_path(@parent_key, @kind, dump(name))
+      value = self[name]
+      # Datastore.delete requires array keys
+      AppEngine::Datastore.delete(@transaction, [key])
+      @uncommited[:added].delete(name)
+      @uncommited[:deleted][name] = value
+      value
     end
 
     def load(content)
@@ -81,17 +140,19 @@ module AppEngine
     def roots
       in_transaction
       query = AppEngine::Datastore::Query.new(@kind, @parent_key)
-      query.keysonly.fetch.map {|value|
-        value.key.name
-      }.concat(@cache.keys).uniq
+      db_keys = query.keysonly.fetch.map {|entity|
+        load(entity.key.name)
+      }
+      (db_keys + @uncommited[:added].keys - @uncommited[:deleted].keys).uniq
     end
 
     def root?(key)
       in_transaction
+      self.roots.include?(key)
     end
 
     def path
-      @parent_key
+      @parent_key.name
     end
   end
 end

data/spec/appengine-pstore_spec.rb

@@ -1,7 +1,200 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'appengine-pstore'
+require 'pp'
 
-describe "AppenginePstore" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+describe AppEngine::PStore do
+  # initializing datastore in memory each time
+  before :each do
+    AppEngine::Testing.install_test_datastore
+    @db = AppEngine::PStore.new('test.pstore')
+  end
+
+  after :each do
+    #it should close transactions
+    AppEngine::Datastore.active_transactions.to_a.should == []
+  end
+
+  it 'should support get/put' do
+    @db.transaction do |db|
+      db['var1'] = "hello"
+      db['var2'] = "world"
+      db['var1'].should == "hello"
+      db['var2'].should == "world"
+    end
+    @db.transaction do |db|
+      db['var1'].should == "hello"
+      db['var2'].should == "world"
+    end
+  end
+
+  it 'should support symbol key' do
+    @db.transaction do |db|
+      db[:key] = "hello"
+      db['key'] = "world"
+    end
+    @db.transaction do |db|
+      db[:key].should == "hello"
+      db['key'].should == "world"
+    end
+  end
+
+  it 'should return nil' do
+    @db.transaction do |db|
+      db['undefined'].should == nil
+      db.delete('undefined').should == nil
+    end
+  end
+
+  it 'should support multiple database' do
+    db1 = AppEngine::PStore.new('test1.pstore')
+    db2 = AppEngine::PStore.new('test2.pstore')
+    db1.transaction do |db1|
+      db2.transaction do |db2|
+        db1[:key] = "hello"
+        db2[:key] = "world"
+        db1[:key].should == "hello"
+        db2[:key].should == "world"
+      end
+    end
+
+    db1.transaction do |db1|
+      db2.transaction do |db2|
+        db1[:key].should == "hello"
+        db2[:key].should == "world"
+      end
+    end
+  end
+
+  it 'should support delete' do
+    @db.transaction do |db|
+      db[:key] = 'hello'
+    end
+    @db.transaction do |db|
+      value = db.delete(:key)
+      value.should == 'hello'
+      db[:key].should == nil
+    end
+    @db.transaction do |db|
+      db[:key].should == nil
+    end
+  end
+
+  it 'should suppert roots' do
+    @db.transaction do |db|
+      db[:key1] = "hello"
+      db[:key2] = "world"
+      db.roots.should == [:key1, :key2]
+    end
+    @db.transaction do |db|
+      db.roots.should == [:key1, :key2]
+      db.delete(:key1)
+      db[:key3] = "!"
+      db.roots.should == [:key2, :key3]
+    end
+    @db.transaction do |db|
+      db.roots.should == [:key2, :key3]
+    end
+  end
+
+  it 'should suppert root?' do
+    @db.transaction do |db|
+      db.root?(:key).should == false
+      db[:key] = "hello"
+      db.root?(:key).should == true
+    end
+    @db.transaction do |db|
+      db.root?(:key).should == true
+      db.delete(:key)
+      db.root?(:key).should == false
+    end
+    @db.transaction do |db|
+      db.root?(:key).should == false
+    end
+  end
+
+  it 'should support path' do
+    db = AppEngine::PStore.new('somewhere')
+    db.path.should == 'somewhere'
+  end
+
+  it 'should support readonly database' do
+    p = lambda {
+      @db.transaction(true) do |db|
+        db[:key] = "hello"
+      end
+    }
+    p.should raise_error PStore::Error
+    p = lambda {
+      @db.transaction(true) do |db|
+        db.delete(:key)
+      end
+    }
+    p.should raise_error PStore::Error
+  end
+
+  it 'should return block value' do
+    @db.transaction{ 'hello' }.should == 'hello'
+  end
+
+  describe 'transaction' do
+    it 'should support commit' do
+      @db.transaction do |db|
+        db[:key] = "hello"
+        db.commit
+        # never reached
+        raise StandardError
+      end
+      @db.transaction do |db|
+        db[:key].should == "hello"
+      end
+    end
+
+    it 'should support abort' do
+      @db.transaction do |db|
+        db[:key] = "hello"
+        db.abort
+        # never reached
+        raise StandardError
+      end
+      @db.transaction do |db|
+        db[:key].should == nil
+      end
+    end
+
+    it 'should abort transaction if raised any Exception' do
+      p = lambda {
+        @db.transaction do |db|
+          db[:key] = "hello"
+          # abort transaction
+          raise StandardError
+        end
+      }
+      p.should raise_error StandardError
+      @db.transaction do |db|
+        db[:key].should == nil
+      end
+    end
+
+    it 'should not support nested transaction' do
+      p = lambda {
+        @db.transaction do |db1|
+          @db.transaction do |db2|
+          end
+        end
+      }
+      p.should raise_error PStore::Error
+    end
+
+    it 'should raise PStore::Error outside transaction' do
+      p = lambda { @db[:key1] = "hello" }
+      p.should raise_error PStore::Error
+      p = lambda { @db[:key1] }
+      p.should raise_error PStore::Error
+      p = lambda { @db.delete(:key1) }
+      p.should raise_error PStore::Error
+      p = lambda { @db.roots }
+      p.should raise_error PStore::Error
+    end
   end
 end
+

data/spec/spec_helper.rb

@@ -1,9 +1,11 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'appengine-pstore'
 require 'spec'
-require 'spec/autorun'
+require 'appengine-sdk'
+AppEngine::SDK.load_apiproxy
+require 'appengine-apis/testing'
+AppEngine::Testing.install_test_env
 
 Spec::Runner.configure do |config|
-  
+  # config.include(ProtoMethods)  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: machu-appengine-pstore
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - MATSUOKA Kohei
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-26 00:00:00 -07:00
+date: 2009-09-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency