obstore 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 189bceb51e975e4cee66730f5eda40d6d2e5f70a
-  data.tar.gz: 6064191922ce26a55d7b2cb386e37ee066e31ac2
+  metadata.gz: 53360071404e5f944d1f8be3c691864a51dd11cc
+  data.tar.gz: a6985c19eb52cb2b6382528e314fb7ab9df7f3e0
 SHA512:
-  metadata.gz: 2bfaf6545bec341b3d79bf94592dd94ad275e1d0e2e53e533a827c7bff55fe14f4db796f0040e4b0ac636744ec73f10002d8c82b6f09a5807322bee586cf8787
-  data.tar.gz: ecf26c593a83171c30090ab75c8c846942b87b6181083bbcaf3decec610b272bf80b27cf1657ef8aa53b0306034067a8f53a4c14dfabc2387b80b034aebdf51c
+  metadata.gz: f52c3580b81d6cb080ed5db56c8ff77ccf55280ea7150625936e08458c71fb35ed8eccff20b24a2bb4182c4697a57ffa0b24cc98c189a69f7ac99e7626be29d6
+  data.tar.gz: 7369a978a06b5c84b7bd1e0c54428889ebb1affb423479778bf15474a0ad7bf41714e7cb34d21f18acae4dfac001e9676c3145d744377727d0ebbf400c80e3ea

data/lib/obstore/filestore.rb

@@ -11,21 +11,21 @@ require 'obstore/data'
 module ObStore
   class FileStore
 
-    attr_accessor :store
+    attr_accessor :_store
 
     def initialize(opts={})
       opts[:database] ||= "./tmp/obstore.db"
       opts[:threadsafe] ||= true
       opts[:atomic_writes] ||= false
-      @store = PStore.new(opts[:database], opts[:threadsafe])
-      @store.ultra_safe = opts[:atomic_writes]
+      @_store = PStore.new(opts[:database], opts[:threadsafe])
+      @_store.ultra_safe = opts[:atomic_writes]
     end
 
     # removes stale records from the pstore db
     def compact!
       keys = []
-      @store.transaction do
-        keys = @store.roots
+      @_store.transaction do
+        keys = @_store.roots
       end
       keys.each do |key|
         fetch_data_by_key key.to_sym # just fetching the stale items deletes them
@@ -33,6 +33,44 @@ module ObStore
       return true
     end
 
+    # stores data to pstore db
+    def store(key, value, opts={})
+      if key.class != Symbol
+        raise TypeError "key must be of type symbol"
+      end
+      store_data_by_key key, value, opts
+    end
+
+    # fetches saved object for the given key
+    def fetch(key)
+      if key.class != Symbol
+        raise TypeError "key must be of type symbol"
+      end
+      data = fetch_data_by_key(key)
+      if data.nil?
+        return nil
+      else
+        return data.fetch
+      end
+    end
+
+    # lists all the keys that are currently in the DBs
+    def keys
+      @_store.transaction do
+        @_store.roots
+      end
+    end
+
+    # returns boolean if atomic writes is active
+    def atomic_writes
+      @_store.ultra_safe
+    end
+
+    # sets atomic writes
+    def atomic_writes=(bool)
+      @_store.ultra_safe = bool
+    end
+
     private
 
     # marshals the data object to a string
@@ -42,11 +80,14 @@ module ObStore
 
     # un-marshals the passed string into an object
     def unmarshal(str)
+      if str.nil?
+        return nil
+      end
       YAML.load str
     end
 
-    # method used by method_missing to store data
-    def store_data_by_key(key, args)
+    # internal method used for storing data by key
+    def store_data_by_key(key, *args)
       options = {}
       if args.class == Array
         value = args.shift
@@ -54,24 +95,38 @@ module ObStore
       else
         value = args
       end
-      @store.transaction do
-        if value.nil?
-          @store.delete key.to_sym
+      @_store.transaction do
+        if value.class == ObStore::Data
+          @_store[key.to_sym] = marshal value
+        elsif value.nil?
+          @_store.delete key.to_sym
         else
-          @store[key.to_sym] = marshal ObStore::Data.new(value, options)
+          @_store[key.to_sym] = marshal ObStore::Data.new(value, options)
         end
-        @store.commit
+        @_store.commit
       end
     end
 
+    def store_obj_by_key(key, args)
+      if args.class != ObStore::Data
+        unless args.class == NilClass
+          raise TypeError "data must be of type ObStore::Data"
+        end
+      end
+      store_data_by_key key, args
+    end
+
     # method used by method_missing to fetch data
     def fetch_data_by_key(key)
-      @store.transaction do
-        data = unmarshal(@store[key.to_sym])
+      @_store.transaction do
+        data = unmarshal(@_store[key.to_sym])
+        if data.nil?
+          return data
+        end
         if data.stale?
           data = nil
-          @store.delete key.to_sym
-          @store.commit
+          @_store.delete key.to_sym
+          @_store.commit
         end
         return data
       end
@@ -79,7 +134,7 @@ module ObStore
 
     def method_missing(meth, *args, &block)
       if meth.to_s =~ /^(.+)=$/
-        store_data_by_key($1, *args)
+        store_obj_by_key($1, *args)
       elsif meth.to_s =~ /^(.+)$/
         fetch_data_by_key($1)
       else

data/lib/obstore/version.rb

@@ -5,5 +5,5 @@
 # License::   MIT
 
 module ObStore
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/spec/dummy_object.rb

@@ -0,0 +1,4 @@
+# used for testing custom object storage and retrieval
+class DummyObject
+  attr_accessor :data
+end

data/spec/lib/filestore_spec.rb

@@ -1,100 +1,191 @@
 require 'obstore/filestore'
+require './spec/dummy_object'
 
 describe ObStore::FileStore do
   before(:all) do
     begin
       Dir.mkdir './tmp'
     rescue
+      # ignored
     end
   end
 
   after(:all) do
     begin
       File.delete('./tmp/obstore.db')
+      File.delete('./tmp/keytest.db')
     rescue
+      # ignored
     end
   end
 
   describe "#initialize(options)" do
     it 'initializes a storage object' do
       s = ObStore::FileStore.new
-      expect(s.store.path).to eq("./tmp/obstore.db")
-      expect(s.store.ultra_safe).to eq(false)
+      expect(s._store.path).to eq("./tmp/obstore.db")
+      expect(s._store.ultra_safe).to eq(false)
     end
     it 'sets pstore to be ultra_safe when setting atomic_writes' do
       s = ObStore::FileStore.new(:atomic_writes=>true)
-      expect(s.store.ultra_safe).to eq(true)
+      expect(s._store.ultra_safe).to eq(true)
+    end
+
+    it 'allows you to set atomic_writes after you create the object' do
+      s = ObStore::FileStore.new
+      expect(s._store.ultra_safe).to eq(false)
+      s.atomic_writes = true
+      expect(s._store.ultra_safe).to eq(true)
     end
   end
 
-  describe "#data=(foo)" do
+  describe "#atomic_writes" do
+    it 'returns the ultra_safe status of the internal pstore' do
+      s = ObStore::FileStore.new
+      expect(s.atomic_writes).to eq(s._store.ultra_safe)
+    end
+
+    it 'allows you to set the ultra_safe status of the internal pstore' do
+      s = ObStore::FileStore.new
+      expect(s._store.ultra_safe).to eq(false)
+      s.atomic_writes = true
+      expect(s._store.ultra_safe).to eq(true)
+    end
+  end
+
+  describe "#store" do
     before(:each) do
-      @s = ObStore::FileStore.new
+      @obstore = ObStore::FileStore.new
     end
 
-    it 'allows you to set values for keys using the dot operator' do
-      @s.data = "foo"
-      expect(@s.data.fetch).to eq("foo")
+    it 'allows you to store an object to the pstore db' do
+      @obstore.store :data, "some data"
+      expect(@obstore.fetch :data).to eq("some data")
     end
 
-    it 'allows you to set expiry for the value' do
-      @s.data = Hash.new, {:expiry=>300}
-      expect(@s.data.expiry).to eq(300)
+    it 'throws a type error if the key is not a symbol' do
+      expect{@obstore.store "data", "something"}.to raise_error(TypeError)
     end
 
-    it 'allows you to pass a metadata hash' do
-      @s.data = {:foo=>"bar"}, {:metadata=>{:baz=>"foo"}}
-      expect(@s.data.baz).to eq("foo")
+    it 'handles any object' do
+      ob = DummyObject.new
+      ob.data = "foo"
+      @obstore.store :dummy, ob
+      expect(@obstore.fetch(:dummy).class).to eq(DummyObject)
+      expect(@obstore.fetch(:dummy).data).to eq("foo")
     end
 
-    it 'allows you to set expiry and metadata' do
-      @s.data = {:foo=>"bar"}, {:expiry=>600, :metadata=>{:baz=>"foo"}}
-      expect(@s.data.expiry).to eq(600)
-      expect(@s.data.baz).to eq("foo")
+    it 'handles persisting data changes to an object' do
+      ob = DummyObject.new
+      ob.data = "foo"
+      @obstore.store :dummy, ob
+      expect(@obstore.fetch(:dummy).class).to eq(DummyObject)
+      expect(@obstore.fetch(:dummy).data).to eq("foo")
+      ob.data = "bar"
+      @obstore.store :dummy, ob
+      expect(@obstore.fetch(:dummy).data).to eq("bar")
     end
 
-    it 'returns nil if the data has expired' do
-      @s.data = {:foo=>"bar"}, {:expiry=>-3}
-      expect(@s.data).to eq(nil)
+    it 'handles setting expiry' do
+      @obstore.store :data, "foo", {:expiry=>300}
+      expect(@obstore.data.expiry).to eq(300)
     end
+  end
 
-    it 'removes the data from the file if the data is stale' do
-      @s.data = {:foo=>"bar"}, {:expiry=>-3}
-      expect(@s.data).to eq(nil)
-      @s.store.transaction do
-        expect(@s.store.root?(:data)).to eq(false)
-      end
+  describe '#fetch(key)' do
+    before(:each) do
+      @obstore = ObStore::FileStore.new
     end
 
-    it 'removes the object from the store when you nil it out' do
-      @s.data = "foo"
-      expect(@s.data.fetch).to eq("foo")
-      @s.data = nil
-      @s.store.transaction do
-        expect(@s.store.root?(:data)).to eq(false)
-      end
+    it 'fetches the tracked object for the key' do
+      @obstore.store :data, "foo"
+      expect(@obstore.fetch :data).to eq("foo")
+    end
+
+    it 'fetches the actual tracked object instance' do
+      ob = DummyObject.new
+      ob.data = "bar"
+      @obstore.store :dummy, ob
+      expect(@obstore.fetch(:dummy).class).to eq(DummyObject)
+      expect(@obstore.fetch(:dummy).data).to eq("bar")
+    end
+  end
+
+  describe '#keys' do
+    it 'returns all the keys we have saved' do
+      @obstore = ObStore::FileStore.new(:database=>'./tmp/keytest.db')
+      expect(@obstore.keys).to eq([])
+      @obstore.store(:data, "foo")
+      expect(@obstore.keys.include?(:data)).to eq(true)
     end
   end
 
+  describe '#data' do
+    before(:each) do
+      @obstore = ObStore::FileStore.new
+    end
+
+    it 'fetches the ObStore::Data object' do
+      @obstore.store :data, "foo"
+      expect(@obstore.data.class).to eq(ObStore::Data)
+    end
+
+    it 'allows me to pass in an ObStore::Data object directly to be saved' do
+      @obstore.data = ObStore::Data.new("foo")
+      expect(@obstore.data.fetch).to eq("foo")
+    end
+
+    it 'allows me to nil a key out directly' do
+      @obstore.data = ObStore::Data.new("foo")
+      expect(@obstore.data.fetch).to eq("foo")
+      @obstore.data = nil
+      expect(@obstore.fetch :data).to eq(nil)
+    end
+
+    it 'throws a TypeError if passed anything other than ObStore::Data object' do
+      expect{@obstore.data = "foo"}.to raise_error(TypeError)
+    end
+
+    # TODO: persist metadata changes on update
+    #it 'persists metadata changes on update' do
+    #  @obstore.store :data, {:foo=>"bar"}, {:expiry=>400, :metadata=>{:foo=>"bar"}}
+    #  expect(@obstore.data.foo).to eq("bar")
+    #  @obstore.data.foo = "baz"
+    #  expect(@obstore.data.foo).to eq("baz")
+    #  @obstore.data.expiry = 500
+    #  expect(@obstore.data.expiry).to eq(500)
+    #end
+  end
+
   describe "#compact!" do
     before(:each) do
-      @s = ObStore::FileStore.new
-      @s.data = {:foo=>"bar"}, {:expiry=>-3}
-      @s.more_data = {:foo=>"bar"}, {:expiry=>-3}
-      @s.keep = {:foo=>"bar"}, {:expiry=>300}
-      @s.never = {:foo=>"bar"}
+      begin
+        File.delete('./tmp/obstore.db')
+        File.delete('./tmp/keytest.db')
+      rescue
+        # ignored
+      end
+      begin
+        Dir.mkdir './tmp'
+      rescue
+        # ignored
+      end
+      @obstore = ObStore::FileStore.new
+      @obstore.store :data, {:foo=>"bar"}, {:expiry=>-3}
+      @obstore.store :more_data, {:foo=>"bar"}, {:expiry=>-3}
+      @obstore.store :keep, {:foo=>"bar"}, {:expiry=>300}
+      @obstore.store :never, {:foo=>"bar"}
     end
 
     it 'removes all expired records from the file' do
-      @s.store.transaction do
-        expect(@s.store.roots.length).to eq(4)
+      @obstore._store.transaction do
+        expect(@obstore._store.roots.length).to eq(4)
       end
-      @s.compact!
-      @s.store.transaction do
-        expect(@s.store.roots.length).to eq(2)
-        expect(@s.store.root?(:keep)).to eq(true)
-        expect(@s.store.root?(:never)).to eq(true)
-        expect(@s.store.root?(:data)).to eq(false)
+      @obstore.compact!
+      @obstore._store.transaction do
+        expect(@obstore._store.roots.length).to eq(2)
+        expect(@obstore._store.root?(:keep)).to eq(true)
+        expect(@obstore._store.root?(:never)).to eq(true)
+        expect(@obstore._store.root?(:data)).to eq(false)
       end
     end
 

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: obstore
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - Michael Heijmans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-29 00:00:00.000000000 Z
+date: 2014-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
 description: ObStore allows you to save any object to a file along with metadata about
@@ -37,6 +37,7 @@ files:
 - lib/obstore/filestore.rb
 - lib/obstore/lockable.rb
 - lib/obstore/version.rb
+- spec/dummy_object.rb
 - spec/lib/data_spec.rb
 - spec/lib/filestore_spec.rb
 - spec/lib/version_spec.rb
@@ -51,12 +52,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -66,6 +67,7 @@ signing_key:
 specification_version: 4
 summary: ObStore is a smart persistent Object store.
 test_files:
+- spec/dummy_object.rb
 - spec/lib/data_spec.rb
 - spec/lib/filestore_spec.rb
 - spec/lib/version_spec.rb