obstore 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 189bceb51e975e4cee66730f5eda40d6d2e5f70a
+  data.tar.gz: 6064191922ce26a55d7b2cb386e37ee066e31ac2
+SHA512:
+  metadata.gz: 2bfaf6545bec341b3d79bf94592dd94ad275e1d0e2e53e533a827c7bff55fe14f4db796f0040e4b0ac636744ec73f10002d8c82b6f09a5807322bee586cf8787
+  data.tar.gz: ecf26c593a83171c30090ab75c8c846942b87b6181083bbcaf3decec610b272bf80b27cf1657ef8aa53b0306034067a8f53a4c14dfabc2387b80b034aebdf51c

data/lib/obstore/data.rb

@@ -0,0 +1,92 @@
+# This provides the data object that obstore uses to save your data
+# and retrieve your data with metadata
+#
+# Author::    Michael Heijmans  (mailto:parabuzzle@gmail.com)
+# Copyright:: Copyright (c) 2014 Michael Heijmans
+# License::   MIT
+
+require 'yaml'
+require 'obstore/lockable'
+
+module ObStore
+  class Data
+
+    include ObStore::Lockable
+
+    attr_accessor :expiry
+    attr_reader :updated, :data
+
+    def initialize(data=nil, options={})
+      @expiry = options[:expiry] # in seconds
+      @data = {}
+      store_data_by_key :data, data
+      @updated = Time.now
+      if options[:metadata]
+        options[:metadata].each do |key, value|
+          store_data_by_key key, value
+        end
+      end
+    end
+
+    # returns the object you had saved
+    def fetch
+      fetch_data_by_key(:data)
+    end
+
+    # returns boolean value if data has expired
+    def stale?
+      if @expiry
+        if ts < Time.now.to_i - @expiry
+          return true
+        end
+      end
+      return false
+    end
+
+    # Saves the object
+    def save(data)
+      self.data=data
+    end
+
+    # custom setter for data attribute that sets the update time
+    def data=(data)
+      store_data_by_key(:data, data)
+    end
+
+    # custom getter for retrieving data from the data hash
+    def data
+      fetch_data_by_key(:data)
+    end
+
+    # helper method to return the timestamp as an int
+    def ts
+      with_mutex { @updated.to_i }
+    end
+
+    private
+
+    # method used by method_missing to store meta data
+    def store_data_by_key(key, value)
+      with_mutex {
+        @data.store key.to_sym, value
+        @updated = Time.now
+      }
+    end
+
+    # method used by method_missing to fetch meta data
+    def fetch_data_by_key(key)
+      with_mutex { @data[key.to_sym] }
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /^(.+)=$/
+        store_data_by_key($1, *args)
+      elsif meth.to_s =~ /^(.+)$/
+        fetch_data_by_key($1)
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/obstore/filestore.rb

@@ -0,0 +1,91 @@
+# Provides the wrapper for pstore
+#
+# Author::    Michael Heijmans  (mailto:parabuzzle@gmail.com)
+# Copyright:: Copyright (c) 2014 Michael Heijmans
+# License::   MIT
+
+require 'pstore'
+require 'yaml'
+require 'obstore/data'
+
+module ObStore
+  class FileStore
+
+    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]
+    end
+
+    # removes stale records from the pstore db
+    def compact!
+      keys = []
+      @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
+      end
+      return true
+    end
+
+    private
+
+    # marshals the data object to a string
+    def marshal(obj)
+      YAML.dump obj
+    end
+
+    # un-marshals the passed string into an object
+    def unmarshal(str)
+      YAML.load str
+    end
+
+    # method used by method_missing to store data
+    def store_data_by_key(key, args)
+      options = {}
+      if args.class == Array
+        value = args.shift
+        options = args.shift
+      else
+        value = args
+      end
+      @store.transaction do
+        if value.nil?
+          @store.delete key.to_sym
+        else
+          @store[key.to_sym] = marshal ObStore::Data.new(value, options)
+        end
+        @store.commit
+      end
+    end
+
+    # method used by method_missing to fetch data
+    def fetch_data_by_key(key)
+      @store.transaction do
+        data = unmarshal(@store[key.to_sym])
+        if data.stale?
+          data = nil
+          @store.delete key.to_sym
+          @store.commit
+        end
+        return data
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      if meth.to_s =~ /^(.+)=$/
+        store_data_by_key($1, *args)
+      elsif meth.to_s =~ /^(.+)$/
+        fetch_data_by_key($1)
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/obstore/lockable.rb

@@ -0,0 +1,21 @@
+# Provides semaphore support to an object
+#
+# Author::    Michael Heijmans  (mailto:parabuzzle@gmail.com)
+# Copyright:: Copyright (c) 2014 Michael Heijmans
+# License::   MIT
+
+require 'thread'
+
+module ObStore
+  module Lockable
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+    def with_mutex
+      mutex.synchronize { yield }
+    end
+
+  end
+end

data/lib/obstore/version.rb

@@ -0,0 +1,9 @@
+# Provides the Version Constant
+#
+# Author::    Michael Heijmans  (mailto:parabuzzle@gmail.com)
+# Copyright:: Copyright (c) 2014 Michael Heijmans
+# License::   MIT
+
+module ObStore
+  VERSION = "0.0.1"
+end

data/lib/obstore.rb

@@ -0,0 +1,28 @@
+# This library allows you to persist objects with meta data
+# ObStore supports data expiry and is designed with thread safety
+#
+# Author::    Michael Heijmans  (mailto:parabuzzle@gmail.com)
+# Copyright:: Copyright (c) 2014 Michael Heijmans
+# License::   MIT
+
+module ObStore
+
+  # require library file that was passed
+  def self.require_lib(lib)
+    require lib
+  end
+
+  # iterates through the passed in array of
+  # library paths and requires each of them
+  def self.require_libs(libs)
+    libs.each do |lib|
+      self.require_lib(lib)
+    end
+  end
+
+end
+
+$:.concat [File.expand_path('../', __FILE__),File.expand_path('../obstore', __FILE__)]
+
+# Require all ruby files in the obstore directory
+ObStore.require_libs Dir.glob(File.expand_path('../obstore', __FILE__) + '/*.rb')

data/spec/lib/data_spec.rb

@@ -0,0 +1,101 @@
+require 'obstore/data'
+
+describe ObStore::Data do
+  before(:all) do
+    begin
+      Dir.mkdir './tmp'
+    rescue
+    end
+  end
+
+  after(:all) do
+    begin
+      File.delete('./tmp/obstore.db')
+    rescue
+    end
+  end
+
+  describe "#initialize(data=nil, options={})" do
+    it 'initalizes an object with nil data' do
+      expect(ObStore::Data.new.data).to eq(nil)
+    end
+    it 'lets you initialize it with a passed in object' do
+      expect(ObStore::Data.new(Hash.new).data.class).to eq(Hash)
+    end
+    it 'sets a nil expiry by default' do
+      expect(ObStore::Data.new.expiry).to eq(nil)
+    end
+    it 'lets you set expiry' do
+      expect(ObStore::Data.new(Hash.new, {:expiry=>300}).expiry).to eq(300)
+    end
+    it 'lets you set any extra metadata you want' do
+      expect(ObStore::Data.new(Hash.new, {:metadata=>{:foo=>"bar"}}).foo).to eq("bar")
+    end
+  end
+
+  describe "#fetch" do
+    it 'returns the object we are tracking' do
+      expect(ObStore::Data.new(Hash.new).fetch.class).to eq(Hash)
+    end
+  end
+
+  describe "#save(data)" do
+    it 'is a wrapper that sets the data we are tracking' do
+      o = ObStore::Data.new(Hash.new)
+      expect(o.fetch.class).to eq(Hash)
+      o.save "test"
+      expect(o.fetch).to eq("test")
+    end
+  end
+
+  describe "#data=(data)" do
+    before(:each) do
+      @o = ObStore::Data.new("test")
+    end
+
+    it 'sets the data we are tracking' do
+      expect(@o.fetch).to eq("test")
+      @o.data = "test2"
+      expect(@o.fetch).to eq("test2")
+    end
+
+    it 'updates the timestamp along with the save' do
+      ts = @o.ts
+      sleep 1
+      @o.data = "test2"
+      expect(@o.ts).not_to eq(ts)
+    end
+  end
+
+  describe "#stale?" do
+    before(:each) do
+      @o = ObStore::Data.new("test")
+    end
+    it 'returns false if there is no expiry set' do
+      expect(@o.stale?).to eq(false)
+    end
+    it 'returns false if the data is not stale' do
+      @o.expiry = 300
+      expect(@o.stale?).to eq(false)
+    end
+    it 'return true if the data is stale' do
+      @o.expiry = 1
+      sleep 2
+      expect(@o.stale?).to eq(true)
+    end
+  end
+
+  describe "#data" do
+    it 'returns the object we are tracking' do
+      expect(ObStore::Data.new("test").data).to eq("test")
+    end
+  end
+
+  describe "#ts" do
+    it 'returns the int version of the timestamp' do
+      expect(ObStore::Data.new("test").ts.class).to eq(Fixnum)
+    end
+  end
+
+
+end

data/spec/lib/filestore_spec.rb

@@ -0,0 +1,103 @@
+require 'obstore/filestore'
+
+describe ObStore::FileStore do
+  before(:all) do
+    begin
+      Dir.mkdir './tmp'
+    rescue
+    end
+  end
+
+  after(:all) do
+    begin
+      File.delete('./tmp/obstore.db')
+    rescue
+    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)
+    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)
+    end
+  end
+
+  describe "#data=(foo)" do
+    before(:each) do
+      @s = 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")
+    end
+
+    it 'allows you to set expiry for the value' do
+      @s.data = Hash.new, {:expiry=>300}
+      expect(@s.data.expiry).to eq(300)
+    end
+
+    it 'allows you to pass a metadata hash' do
+      @s.data = {:foo=>"bar"}, {:metadata=>{:baz=>"foo"}}
+      expect(@s.data.baz).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")
+    end
+
+    it 'returns nil if the data has expired' do
+      @s.data = {:foo=>"bar"}, {:expiry=>-3}
+      expect(@s.data).to eq(nil)
+    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
+    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
+    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"}
+    end
+
+    it 'removes all expired records from the file' do
+      @s.store.transaction do
+        expect(@s.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)
+      end
+    end
+
+  end
+
+end

data/spec/lib/version_spec.rb

@@ -0,0 +1,7 @@
+require 'obstore/version'
+
+describe 'ObStore::VERSION' do
+  it 'returns a version string' do
+    expect(ObStore::VERSION.class).to eq(String)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# This file is loaded before rspec tests are run
+require 'simplecov'
+require 'simplecov-rcov'
+require 'coveralls'
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_group 'lib', 'lib'
+  #SimpleCov.minimum_coverage 75
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::RcovFormatter
+  ]
+end if ENV["COVERAGE"]
+
+Coveralls.wear!

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: obstore
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Heijmans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-29 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
+  that object. You can also set an expiry for an object and ObStore will lazily delete
+  the data for you.
+email: parabuzzle@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/obstore.rb
+- lib/obstore/data.rb
+- lib/obstore/filestore.rb
+- lib/obstore/lockable.rb
+- lib/obstore/version.rb
+- spec/lib/data_spec.rb
+- spec/lib/filestore_spec.rb
+- spec/lib/version_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/parabuzzle/obstore
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: ObStore is a smart persistent Object store.
+test_files:
+- spec/lib/data_spec.rb
+- spec/lib/filestore_spec.rb
+- spec/lib/version_spec.rb
+- spec/spec_helper.rb