state 0.4.2

data/README

@@ -0,0 +1,160 @@
+NAME
+  state
+
+SYNOPSIS
+  platform agnostic persistent state for ruby processes based on sqlite
+
+DESCRIPTION
+  state provides an extremely simple to use state mechanism for ruby programs
+  which require state between invocations.  the storage is based on sqlite and
+  is therefore platform agnostic.  using state is no more difficult that using
+  a hash - only that hash will persist between invocations your ruby program.
+  see the samples and specs for details.
+
+INSTALL
+  gem install state
+
+URIS
+  http://codeforpeople.com/lib/ruby/
+  http://rubyforge.org/projects/codeforpeople/
+
+SAMPLES
+
+  <========< sample/a.rb >========>
+
+  ~ > cat sample/a.rb
+
+    require 'state'
+    
+    # state provides persistent state for processes.  usage requires simply
+    # accesses the state in a hash-like way.
+    #
+    
+    # one process can create state
+    #
+      child do
+        State.clear
+        State['key'] = 'value'
+      end
+    
+    # and later processes can have access to it
+    #
+      2.times do |i|
+        child do
+          value = State['key']
+          puts "child[#{ i }] => #{ value.inspect }"
+        end
+      end
+    
+    
+    BEGIN {
+      # we use fork just for demonstation, but this works on windows too ;-)
+      #
+        def child &block
+          Process.waitpid fork(&block)
+        end
+    }
+    
+
+  ~ > ruby sample/a.rb
+
+    child[0] => "value"
+    child[1] => "value"
+
+
+  <========< sample/b.rb >========>
+
+  ~ > cat sample/b.rb
+
+    require 'state'
+    
+    # state will store it's db in a subdirectory (.state) of your home directory,
+    # the default database is ~/.state/global, but you may specify a name to
+    # create a new database
+    #
+    
+      db = State.for 'foobar'
+    
+      db.clear
+    
+      puts db.path
+    
+      10.times{|i| db[i] = i}
+    
+      puts db.keys.inspect 
+
+  ~ > ruby sample/b.rb
+
+    /Users/ahoward/.state/foobar
+    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+
+  <========< sample/c.rb >========>
+
+  ~ > cat sample/c.rb
+
+    require 'state'
+    
+    # of course you can specify and absolute path
+    #
+    
+      db = State.for :path => '/tmp/state'
+    
+      db.clear
+    
+      puts db.path
+
+  ~ > ruby sample/c.rb
+
+    /tmp/state
+
+
+  <========< sample/d.rb >========>
+
+  ~ > cat sample/d.rb
+
+    require 'state'
+    
+    # in general the interface for state is like that of a hash, see the specs for
+    # more details
+    
+      db = State.for 'foobar'
+    
+      db.clear
+    
+      10.times{|i| db[i] = i**2}
+      5.times{|i| db.delete i}
+    
+      p db.keys
+      p db.values
+    
+    # use the update method for atomic read-update of a key/val pair
+    
+      db['key'] = 42
+    
+      p :current => db['key']
+    
+      db.update 'key' do |old|
+        p :old => old
+        new = 42.0
+      end
+    
+      p :update => db['key']
+      
+      
+
+  ~ > ruby sample/d.rb
+
+    [5, 6, 7, 8, 9]
+    [25, 36, 49, 64, 81]
+    {:current=>42}
+    {:old=>42}
+    {:update=>42.0}
+
+
+HISTORY
+  0.4.2
+    initial version
+
+AUTHORS
+  ara.t.howard

data/gemspec.rb

@@ -0,0 +1,39 @@
+#! /usr/bin/env gem build
+
+lib, version = File::basename(File::dirname(File::expand_path(__FILE__))).split %r/-/, 2
+
+require 'rubygems'
+
+Gem::Specification::new do |spec|
+  $VERBOSE = nil
+
+  shiteless = lambda do |list|
+    list.delete_if do |file|
+      file =~ %r/\.svn/ or
+      file =~ %r/\.tmp/
+    end
+  end
+
+  spec.name = lib 
+  spec.version = version 
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = lib 
+
+  spec.files = shiteless[Dir::glob("**/**")]
+  spec.executables = shiteless[Dir::glob("bin/*")].map{|exe| File::basename exe}
+  
+  spec.require_path = "lib" 
+
+  spec.has_rdoc = File::exist? "doc" 
+  spec.test_suite_file = "test/#{ lib }.rb" if File::directory? "test"
+  #spec.add_dependency 'lib', '>= version'
+  spec.add_dependency 'sqlite3'
+  spec.add_dependency 'fattr'
+
+  spec.extensions << "extconf.rb" if File::exists? "extconf.rb"
+
+  spec.rubyforge_project = 'codeforpeople'
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://codeforpeople.com/lib/ruby/#{ lib }/"
+end

data/gen_readme.rb

@@ -0,0 +1,35 @@
+#! /usr/bin/env ruby
+
+require 'pathname'
+
+$VERBOSE=nil
+
+def indent s, n = 2
+  ws = ' ' * n
+  s.gsub %r/^/, ws 
+end
+
+template = IO::read 'README.tmpl'
+
+samples = ''
+prompt = '~ > '
+
+Dir['sample*/*'].sort.each do |sample|
+  samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+
+  cmd = "cat #{ sample }" 
+  samples << indent(prompt + cmd, 2) << "\n\n" 
+  samples << indent(`#{ cmd }`, 4) << "\n" 
+
+  cmd = "ruby #{ sample }" 
+  samples << indent(prompt + cmd, 2) << "\n\n" 
+
+  cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -Ilib #{ sample })'" 
+  #cmd = "ruby -Ilib #{ sample }" 
+  samples << indent(`#{ cmd } 2>&1`, 4) << "\n" 
+end
+
+#samples.gsub! %r/^/, '  '
+
+readme  = template.gsub %r/^\s*@samples\s*$/, samples
+print readme 

data/install.rb

@@ -0,0 +1,214 @@
+#!/usr/bin/env ruby
+require 'rbconfig'
+require 'find'
+require 'ftools'
+require 'tempfile'
+include Config
+
+LIBDIR      = "lib"
+LIBDIR_MODE = 0644
+
+BINDIR      = "bin"
+BINDIR_MODE = 0755
+
+
+$srcdir            = CONFIG["srcdir"]
+$version           = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+$libdir            = File.join(CONFIG["libdir"], "ruby", $version)
+$archdir           = File.join($libdir, CONFIG["arch"])
+$site_libdir       = $:.find {|x| x =~ /site_ruby$/}
+$bindir            = CONFIG["bindir"] || CONFIG['BINDIR']
+$ruby_install_name = CONFIG['ruby_install_name'] || CONFIG['RUBY_INSTALL_NAME'] || 'ruby'
+$ruby_ext          = CONFIG['EXEEXT'] || ''
+$ruby              = File.join($bindir, ($ruby_install_name + $ruby_ext))
+
+if !$site_libdir
+  $site_libdir = File.join($libdir, "site_ruby")
+elsif $site_libdir !~ %r/#{Regexp.quote($version)}/
+  $site_libdir = File.join($site_libdir, $version)
+end
+
+def install_rb(srcdir=nil, destdir=nil, mode=nil, bin=nil)
+#{{{
+  path   = []
+  dir    = []
+  Find.find(srcdir) do |f|
+    next unless FileTest.file?(f)
+    next if (f = f[srcdir.length+1..-1]) == nil
+    next if (/CVS$/ =~ File.dirname(f))
+    next if (/\.svn/ =~ File.dirname(f))
+    next if f =~ %r/\.lnk/
+    next if f =~ %r/\.svn/
+    next if f =~ %r/\.swp/
+    next if f =~ %r/\.svn/
+    path.push f
+    dir |= [File.dirname(f)]
+  end
+  for f in dir
+    next if f == "."
+    next if f == "CVS"
+    File::makedirs(File.join(destdir, f))
+  end
+  for f in path
+    next if (/\~$/ =~ f)
+    next if (/^\./ =~ File.basename(f))
+    unless bin
+      File::install(File.join(srcdir, f), File.join(destdir, f), mode, true)
+    else
+      from = File.join(srcdir, f)
+      to = File.join(destdir, f)
+      shebangify(from) do |sf|
+        $deferr.print from, " -> ", File::catname(from, to), "\n"
+        $deferr.printf "chmod %04o %s\n", mode, to 
+        File::install(sf, to, mode, false)
+      end
+    end
+  end
+#}}}
+end
+def shebangify f
+#{{{
+  open(f) do |fd|
+    buf = fd.read 42 
+    if buf =~ %r/^\s*#\s*!.*ruby/o
+      ftmp = Tempfile::new("#{ $$ }_#{ File::basename(f) }")
+      begin
+        fd.rewind
+        ftmp.puts "#!#{ $ruby  }"
+        while((buf = fd.read(8192)))
+          ftmp.write buf
+        end
+        ftmp.close
+        yield ftmp.path
+      ensure
+        ftmp.close!
+      end
+    else
+      yield f
+    end
+  end
+#}}}
+end
+def ARGV.switch
+#{{{
+  return nil if self.empty?
+  arg = self.shift
+  return nil if arg == '--'
+  if arg =~ /^-(.)(.*)/
+    return arg if $1 == '-'
+    raise 'unknown switch "-"' if $2.index('-')
+    self.unshift "-#{$2}" if $2.size > 0
+    "-#{$1}"
+  else
+    self.unshift arg
+    nil
+  end
+#}}}
+end
+def ARGV.req_arg
+#{{{
+  self.shift || raise('missing argument')
+#}}}
+end
+def linkify d, linked = []
+#--{{{
+  if test ?d, d
+    versioned = Dir[ File::join(d, "*-[0-9].[0-9].[0-9].rb") ]
+    versioned.each do |v| 
+      src, dst = v, v.gsub(%r/\-[\d\.]+\.rb$/, '.rb')
+      lnk = nil
+      begin
+        if test ?l, dst
+          lnk = "#{ dst }.lnk"
+          puts "#{ dst } -> #{ lnk }"
+          File::rename dst, lnk
+        end
+        unless test ?e, dst
+          puts "#{ src } -> #{ dst }"
+          File::copy src, dst 
+          linked << dst
+        end
+      ensure
+        if lnk
+          at_exit do
+            puts "#{ lnk } -> #{ dst }"
+            File::rename lnk, dst
+          end
+        end
+      end
+    end
+  end
+  linked
+#--}}}
+end
+
+
+#
+# main program
+#
+
+libdir = $site_libdir
+bindir = $bindir
+no_linkify = false
+linked = nil
+help = false
+
+usage = <<-usage
+  #{ File::basename $0 }
+    -d, --destdir    <destdir>
+    -l, --libdir     <libdir>
+    -b, --bindir     <bindir>
+    -r, --ruby       <ruby>
+    -n, --no_linkify
+    -s, --sudo
+    -h, --help
+usage
+
+begin
+  while switch = ARGV.switch
+    case switch
+    when '-d', '--destdir'
+      libdir = ARGV.req_arg
+    when '-l', '--libdir'
+      libdir = ARGV.req_arg
+    when '-b', '--bindir'
+      bindir = ARGV.req_arg
+    when '-r', '--ruby'
+      $ruby = ARGV.req_arg
+    when '-n', '--no_linkify'
+      no_linkify = true
+    when '-s', '--sudo'
+      sudo = 'sudo' 
+    when '-h', '--help'
+      help = true
+    else
+      raise "unknown switch #{switch.dump}"
+    end
+  end
+rescue
+  STDERR.puts $!.to_s
+  STDERR.puts usage
+  exit 1
+end    
+
+if help
+  STDOUT.puts usage
+  exit
+end
+
+system "#{ sudo } #{ $ruby } pre-install.rb" if test(?s, 'pre-install.rb')
+
+unless no_linkify
+  linked = linkify('lib') + linkify('bin')
+end
+
+system "#{ $ruby } extconf.rb && make && #{ sudo } make install" if test(?s, 'extconf.rb')
+
+install_rb(LIBDIR, libdir, LIBDIR_MODE)
+install_rb(BINDIR, bindir, BINDIR_MODE, bin=true)
+
+if linked
+  linked.each{|path| File::rm_f path}
+end
+
+system "#{ sudo } #{ $ruby } post-install.rb" if test(?s, 'post-install.rb')

data/lib/state.rb

@@ -0,0 +1,213 @@
+require 'fileutils'
+
+require 'rubygems'
+require 'sqlite3'
+require 'fattr'
+
+module State
+  def for *argv, &block
+    options = (Hash === argv.last ? argv.pop : {})
+    name = argv.first 
+    name ||= 'global' if(options.empty? and name.nil?)
+
+    default_path = File.join(rootdir, clean(name)) if name
+    path = getopt(:path, options, default_path)
+
+    db.new path, options
+  end
+
+  alias_method 'new', 'for'
+
+  fattr :home do
+    home =
+      catch :home do
+        ["HOME", "USERPROFILE"].each do |key|
+          throw(:home, ENV[key]) if ENV[key]
+        end
+        if ENV["HOMEDRIVE"] and ENV["HOMEPATH"]
+          throw(:home, "#{ ENV['HOMEDRIVE'] }:#{ ENV['HOMEPATH'] }")
+        end
+        File.expand_path("~") rescue(File::ALT_SEPARATOR ? "C:/" : "/")
+      end
+    File.expand_path home
+  end
+
+  fattr :dotdir do
+    '.state'
+  end
+
+  fattr :rootdir do
+    root = File.join home, dotdir 
+    FileUtils.mkdir_p root
+    root
+  end
+
+  def clean name
+    fugly = %r/[^a-zA-Z0-9_-]/
+    name.gsub fugly, '_'
+  end
+
+  def getopt key, hash, default = nil
+    return hash.fetch(key) if hash.has_key?(key)
+    key = key.to_s
+    return hash.fetch(key) if hash.has_key?(key)
+    key = key.to_sym
+    return hash.fetch(key) if hash.has_key?(key)
+    default
+  end
+
+  class Db
+    fattr('path'){ }
+    fattr('db'){ SQLite3::Database.new(path) }
+    fattr('table'){ 'state' }
+    fattr('schema'){
+      <<-sql
+        create table #{ table }(
+          key blob,
+          val blob,
+          primary key(key)
+        )
+      sql
+    }
+  
+    def initialize path, options = {}
+      self.path = path
+      db!
+      migrate!
+    end
+
+    def clear
+      db.execute "delete from #{ table }"
+    end
+
+    def delete key
+      db.execute "delete from #{ table } where key=?", blob(key)
+    end
+
+    def size
+      db.query("select count(*) from #{ table }") do |result|
+        return result.each{|row| break Integer(row.first)}
+      end
+    end
+
+    def each
+      db.query("select * from #{ table }") do |result|
+        result.each do |row|
+          key, val, *ignored = row
+          yield load(key), load(val)
+        end
+      end
+    end
+    include ::Enumerable
+
+    def keys
+      map{|pair| pair.first}
+    end
+
+    def values 
+      map{|pair| pair.last}
+    end
+
+    def [] key
+      db.query("select val from #{ table } where key=?", blob(key)) do |result|
+        val = result.each{|row| break row.first}
+        return( val ? load(val) : val )
+      end
+    end
+    alias_method 'get', '[]'
+
+    def []= key, val
+      key, val = blob(key), blob(val)
+
+      transaction do
+        begin
+          statement = "insert into #{ table }(key, val) values (?, ?)"
+          db.execute statement, key, val
+          return val
+        rescue Object
+          begin
+            statement = "update #{ table } set val=? where key=?"
+            db.execute statement, val, key
+            return val
+          rescue Object
+            begin
+              statement = "delete from #{ table } where key=?"
+              db.execute statement, key
+              statement = "insert into #{ table }(key, val) values (?, ?)"
+              db.execute statement, key, val
+              return val
+            rescue Object
+            end
+          end
+        end
+      end
+    end
+    alias_method 'set', '[]='
+
+    def update key, *val, &block
+      if block and not val.empty?
+        raise ArgumentError, 'both block and value' 
+      end
+
+      if val.empty? and block.nil?
+        raise ArgumentError, 'no update value'
+      end
+
+      transaction do
+        old = get key 
+        val = (block ? block.call(old) : val.first)
+        set key, val
+      end
+    end
+
+    def transaction &block
+      if defined?(@transaction) and @transaction
+        block.call db
+      else
+        @transaction = true
+        begin
+          db.transaction{ block.call db }
+        ensure
+          @transaction = false
+        end
+      end
+    end
+
+    def blob val
+      SQLite3::Blob.new dump(val)
+    end
+
+    def dump value
+      Marshal.dump(value)
+    end
+
+    def load value
+      Marshal.load value
+    end
+
+    def migrate!
+      begin
+        db.execute "select count(*) from #{ table }"
+      rescue Object
+        db.execute schema
+      end
+    end
+  end
+
+  def db
+    Db
+  end
+
+  fattr(:global){ State.for('global') }
+
+  def method_missing m, *a, &b
+    super unless global.respond_to?(m)
+    global.send(m, *a, &b)
+  end
+
+  extend self
+end
+
+def State *a, &b
+  State.for *a, &b
+end

data/lib/state.rb.bak

@@ -0,0 +1,85 @@
+
+require 'stringio'
+
+require 'rubygems'
+require 'amalgalite'
+require 'sqlite'
+require 'fattr'
+
+module State
+  def for program = __FILE__
+  end
+
+  class Db
+    fattr('path'){ }
+    fattr('db'){ Amalgalite::Database.new(path) }
+    fattr('table'){ 'state' }
+    fattr('schema'){
+      <<-sql
+        create table #{ table }(
+          key blob,
+          value blob,
+          primary key(key)
+        )
+      sql
+    }
+  
+    def initialize path
+      self.path = path
+      db!
+      migrate!
+    end
+
+    def []
+    end
+
+    def []= key, value
+      db.execute "insert into #{ table }(key, value) values ($key, $value)",
+        blob_pair(key, value)
+    end
+
+    def blob_pair key, value
+      { "$key" => blob_key(key), "$value" => blob_value(value) }
+    end
+
+    def blob_key value
+      blob value, 'key'
+    end
+
+    def blob_value value
+      blob value, 'value'
+    end
+
+    def blob value, column
+      Amalgalite::Blob.new(
+        :io => io(dump(value)),
+        :column => column(column)
+      )
+    end
+
+    def io value
+      StringIO.new value
+    end
+
+    def dump value
+      Marshal.dump value
+    end
+
+    def column column
+      db.schema.tables[table].columns[column]
+    end
+
+    def migrate!
+      unless db.schema.tables[table]
+        db.execute schema
+        db.reload_schema!
+      end
+    end
+  end
+
+  extend self
+end
+
+def State *a, &b
+  State.for *a, &b
+end

data/sample/a.rb

@@ -0,0 +1,31 @@
+require 'state'
+
+# state provides persistent state for processes.  usage requires simply
+# accesses the state in a hash-like way.
+#
+
+# one process can create state
+#
+  child do
+    State.clear
+    State['key'] = 'value'
+  end
+
+# and later processes can have access to it
+#
+  2.times do |i|
+    child do
+      value = State['key']
+      puts "child[#{ i }] => #{ value.inspect }"
+    end
+  end
+
+
+BEGIN {
+  # we use fork just for demonstation, but this works on windows too ;-)
+  #
+    def child &block
+      Process.waitpid fork(&block)
+    end
+}
+

data/sample/b.rb

@@ -0,0 +1,16 @@
+require 'state'
+
+# state will store it's db in a subdirectory (.state) of your home directory,
+# the default database is ~/.state/global, but you may specify a name to
+# create a new database
+#
+
+  db = State.for 'foobar'
+
+  db.clear
+
+  puts db.path
+
+  10.times{|i| db[i] = i}
+
+  puts db.keys.inspect 

data/sample/c.rb

@@ -0,0 +1,10 @@
+require 'state'
+
+# of course you can specify and absolute path
+#
+
+  db = State.for :path => '/tmp/state'
+
+  db.clear
+
+  puts db.path

data/sample/d.rb

@@ -0,0 +1,29 @@
+require 'state'
+
+# in general the interface for state is like that of a hash, see the specs for
+# more details
+
+  db = State.for 'foobar'
+
+  db.clear
+
+  10.times{|i| db[i] = i**2}
+  5.times{|i| db.delete i}
+
+  p db.keys
+  p db.values
+
+# use the update method for atomic read-update of a key/val pair
+
+  db['key'] = 42
+
+  p :current => db['key']
+
+  db.update 'key' do |old|
+    p :old => old
+    new = 42.0
+  end
+
+  p :update => db['key']
+  
+  

data/spec/helper.rb

@@ -0,0 +1,51 @@
+module Spec
+  require 'fileutils'
+
+  @rootdir ||= File.expand_path(File.dirname(File.dirname(__FILE__)))
+  @libdir ||= File.join(@rootdir, 'lib') 
+  @bindir ||= File.join(@rootdir, 'bin') 
+  @specdir ||= File.join(@rootdir, 'spec') 
+
+  def dir which, *parts
+    ivar = "@#{ which }dir"
+    dir = instance_variable_get(ivar)
+    if parts.empty?
+      dir
+    else
+      parts = parts.flatten.compacet.map{|part| part.to_s}
+      File.join(dir, *parts)
+    end
+  end
+
+  %w( root lib bin spec ).each do |which|
+    define_method("#{ which }dir"){|*parts| dir which, *parts}
+  end
+
+  def pid
+    @pid ||= Process.pid
+  end
+
+  def fu
+    FileUtils
+  end
+
+  def tmpdir &block
+    path = File.join specdir, 'tmp', pid.to_s
+    fu.mkdir_p path
+    at_exit{ fu.rm_rf path}
+    if block
+      begin
+        Dir.chdir(path, &block)
+      ensure
+        fu.rm_rf path
+      end
+    else
+      path
+    end
+  end
+
+  extend self
+
+  STDOUT.sync = true
+  STDERR.sync = true
+end

data/spec/state.rb

@@ -0,0 +1,274 @@
+#! /usr/bin/env bacon
+
+require 'rubygems'
+require 'bacon'
+
+describe 'state db' do
+  it 'should initialize a new db when none exists' do
+    Spec.tmpdir do
+      path = 'state.db'
+      db = State::Db.new path
+      db.path.should == path
+      exists = test(?s, db.path) ? true : false
+      exists.should == true
+    end
+  end
+
+  it 'should re-use an existing db' do
+    path = 'state.db'
+    buf = nil
+
+    Spec.tmpdir do
+      db = State::Db.new path
+      buf = IO.read db.path
+    end
+
+    Spec.tmpdir do
+      open(path,'wb+'){|f| f.write buf}
+
+      before = File.stat path
+
+      db = State::Db.new path
+      db.path.should == path
+      exists = test(?s, db.path) ? true : false
+      exists.should == true
+
+      after = File.stat path
+
+      before.should == after
+    end
+  end
+
+  it 'should store key/value pairs' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        v = hash[k]
+        raised =
+          begin
+            db[k] = v
+            false
+          rescue Object
+            true
+          end
+        raised.should == false
+      end
+    end
+  end
+
+  it 'should read key/value pairs' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        v = hash[k]
+        db[k] = v
+        v.should == db[k]
+      end
+
+      hash.keys.sort.each do |k|
+        v = hash[k]
+        v.should == db[k]
+      end
+    end
+  end
+
+  it 'should clobber key/value pairs' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        2.times do |i|
+          v = "#{ hash[k] }_#{ i }"
+          db[k] = v
+          db[k].should == v 
+        end
+      end
+    end
+  end
+
+  it 'should know how many key/value pairs it has' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        db[k] = hash[k]
+      end
+
+      db.size.should == hash.size
+    end
+  end
+
+  it 'should be able to clear all key/value pairs' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        db[k] = hash[k]
+      end
+
+      db.size.should == hash.size
+
+      db.clear
+
+      db.size.should == 0
+    end
+  end
+
+  it 'should be able to delete specific key/value pairs' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        db[k] = hash[k]
+      end
+
+      db.size.should == hash.size 
+
+      hash.keys.sort.each do |k|
+        hash.delete k
+        db.delete k
+        db.size.should == hash.size 
+      end
+    end
+  end
+
+  it 'should iterate with an each method, map,  and be enumerable' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      (Enumerable === db).should == true
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        db[k] = hash[k]
+      end
+
+      result = {}
+      db.each do |k,v|
+        result[k] = v
+      end
+      result.should == hash
+
+      db.map.should == hash.map
+    end
+  end
+
+  it 'should support atomic update of a key/value pair' do
+    Spec.tmpdir do
+      db = State::Db.new 'state.db' 
+
+      hash = {
+        'a' => 'a',
+        'b' => 0,
+        'c' => [],
+        'd' => hash
+      }
+
+      hash.keys.sort.each do |k|
+        db.update k, hash[k]
+        db[k].should == hash[k]
+      end
+
+      hash.keys.sort.each do |k|
+        db.update k, hash[k]
+        db[k].should == hash[k]
+      end
+
+      hash.keys.sort.each do |k|
+        db.update(k){ hash[k] }
+        db[k].should == hash[k]
+      end
+
+      hash.keys.sort.each do |k|
+        v = hash[k].to_s + '!'
+        db.update(k){ v } 
+        db[k].should == v 
+      end
+    end
+  end
+end
+
+describe 'state' do
+  it 'can find a writable home directory' do
+    found = test(?w, State.home) ? true : false
+    found.should == true
+  end
+
+  it 'can bootstrap a db into a subdir of the home directory based on a name' do
+    db = State 'foobar'
+    exists = test(?s, db.path) ? true : false
+    exists.should == true
+    File.dirname(db.path).should == State.rootdir
+  end
+
+  it 'can bootstrap a db into a named path' do
+    Spec.tmpdir do
+      db = State :path => 'foobar'
+      exists = test(?s, db.path) ? true : false
+      exists.should == true
+      File.expand_path(db.path).should == File.expand_path('./foobar') 
+    end
+  end
+end
+
+
+BEGIN {
+  rootdir = File.expand_path(File.dirname(File.dirname(__FILE__)))
+
+  libdir = File.join(rootdir, 'lib')
+  glob = File.join(libdir, '*.rb')
+  Dir[glob].each{|lib| require lib}
+
+  specdir = File.join(rootdir, 'spec')
+  require(File.join(specdir, 'helper'))
+}

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: state
+version: !ruby/object:Gem::Version 
+  version: 0.4.2
+platform: ruby
+authors: 
+- Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-10 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: fattr
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: ara.t.howard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin
+- db
+- gemspec.rb
+- gen_readme.rb
+- install.rb
+- lib
+- lib/state.rb
+- lib/state.rb.bak
+- README
+- sample
+- sample/a.rb
+- sample/b.rb
+- sample/c.rb
+- sample/d.rb
+- spec
+- spec/helper.rb
+- spec/state.rb
+- spec/tmp
+has_rdoc: false
+homepage: http://codeforpeople.com/lib/ruby/state/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: codeforpeople
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: state
+test_files: []
+