rkh-stored_hash 0.1.0

data/lib/stored_hash.rb

@@ -0,0 +1,126 @@
+require "yaml"
+require "thread"
+
+# This is a drop in replacement for Hash.
+# It does act just the same but reads/writes from a yaml
+# file whenever the hash or the file changes.
+# This is much slower than a hash, as you might guess.
+# A StoredHash is thread-safe.
+class StoredHash
+
+  attr_reader :file
+
+  class << self
+    alias load new
+  end
+
+  def initialize file, *args, &block
+    @data  = Hash.new(*args, &block)
+    @file  = file
+    @mutex = Mutex.new
+  end
+
+  def == other
+    super or @data == other
+  end
+
+  [:to_yaml, :inspect, :eql?, :hash].each do |name|
+    define_method(name) do |*args|
+      method_missing(name, *args)
+    end
+  end
+
+  [:dup, :clone].each do |name|
+    define_method(name) do
+      @mutex.synchronize do
+        super.instance_eval do
+          @mutex = Mutex.new
+          @data  = @data.send name
+          self
+        end
+      end
+    end
+  end
+
+  # Here is where the magic happens. Before any method is called on the hash
+  # we'll check the file for changes (of course only reading the file if it
+  # has been changed). After the method terminated we check whether the hash
+  # has been changed and if so, we write it to the file.
+  def method_missing(*args, &blk)
+    synchronize do |file|
+      update file if should_update? file
+      @old_data ||= duplicate_data
+      result = @data.send(*args, &blk)
+      write if should_write?
+      return self if result == @data
+      result
+    end
+  end
+
+  def to_hash
+    @data.dup
+  end
+
+  def is_a? whatever
+    super whatever or @data.is_a? whatever
+  end
+
+  private
+
+  def should_update? file
+    not @mtime or file.mtime >= @mtime
+  end
+
+  def update file
+    @data.replace YAML.load(file.read)
+    @mtime    = file.mtime
+    @old_data = duplicate_data
+  end
+
+  def duplicate_data
+    @data.respond_to?(:deep_clone) ? @data.deep_clone : @data.dup
+  end
+
+  def should_write?
+    @data != @old_data
+  end
+
+  def write
+    yaml = @data.to_yaml
+    begin
+      YAML.load yaml
+    rescue ArgumentError
+      @data.replace @old_data
+      raise ArgumentError, "Unable to store object as yaml."
+    end
+    File.open(@file, "w") { |f| f.write(yaml) }
+    @mtime = File.mtime(@file)
+    @old_data = duplicate_data
+  end
+
+  # Not only do we want to synchronize threads, but processes, too.
+  def synchronize
+    @mutex.synchronize do
+      unless File.exists?(@file)
+        File.open(@file, "w") { |f| f.write(Hash.new.to_yaml) }
+      end
+      File.open(@file, "r") do |file|
+        begin
+          file.flock(File::LOCK_EX)
+          result = yield(file)
+        ensure
+          file.flock(File::LOCK_UN)
+        end
+        result
+      end
+    end
+  end
+
+end
+
+class Hash
+  def store file
+    StoredHash.new(file).replace self
+  end
+end
+

data/spec/stored_hash_spec.rb

@@ -0,0 +1,105 @@
+$: << File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'stored_hash'
+require 'fileutils'
+
+describe StoredHash do
+
+  before :each do
+    @stored_hash = StoredHash.new "/tmp/test#{Time.now.to_i}.yml"
+    @some_hashes = [ {}, {0 => 1, 2 => 3, 4 => 5}, {"foo" => [{:bar => "blah"}]} ]
+    def with_some_hash
+      @some_hashes.each do |a_hash|
+        @stored_hash.replace a_hash
+        yield a_hash
+        @stored_hash.replace Hash.new
+      end
+    end
+  end
+
+  after :each do
+    FileUtils.rm @stored_hash.file
+  end
+
+  it "should write and read correctly" do
+    10.times do |i|
+      ["i", "i.to_s", "i.to_s.to_sym", "'abc ' * i"].each do |code|
+        value = eval(code)
+        [i, code, value].each do |key|
+          @stored_hash[key] = value
+          @stored_hash[key].should == value
+        end
+      end
+    end
+  end
+
+  it "should behave like a Hash#inspect" do
+    with_some_hash { |a_hash| @stored_hash.inspect.should == a_hash.inspect }
+  end
+
+  it "should behave like a Hash#to_yaml" do
+    with_some_hash { |a_hash| @stored_hash.to_yaml.should == a_hash.to_yaml }
+  end
+
+  it "should behave like a Hash#inspect" do
+    with_some_hash { |a_hash| @stored_hash.inspect.should == a_hash.inspect }
+  end
+
+  it "should behave like a Hash#hash" do
+    with_some_hash { |a_hash| @stored_hash.hash.should == a_hash.hash }
+  end
+
+  it "should behave like a Hash#eql?" do
+    with_some_hash do |a_hash|
+      @some_hashes.each do |another_hash|
+        @stored_hash.eql?(another_hash).should == a_hash.eql?(another_hash)
+      end
+    end
+  end
+
+  it "should behave like a Hash#== for other hashes" do
+    with_some_hash do |a_hash|
+      @some_hashes.each do |another_hash|
+        @stored_hash.==(another_hash).should == a_hash.==(another_hash)
+      end
+    end
+  end
+
+  it "should return true for #is_a?(Hash)" do
+    with_some_hash { @stored_hash.is_a?(Hash).should == true }
+  end
+
+  it "should equal an empty hash after #clear" do
+    with_some_hash do
+      @stored_hash.clear
+      @stored_hash.should == {}
+      @stored_hash.size.should == 0
+      @stored_hash.empty?.should == true
+    end
+  end
+
+  it "should properly delete items" do
+    with_some_hash do
+      a_key = @stored_hash.keys.first
+      @stored_hash.delete(a_key).should @stored_hash[a_key]
+      @stored_hash.include?(a_key).should == false
+    end
+  end
+
+  it "should be thread safe" do
+    thread_number = 5
+    max_count     = 10
+    threads       = []
+    thread_number.times do |tnum|
+      threads << Thread.new(tnum) do |t|
+        max_count.times do |i|
+          @stored_hash["#{t} #{i}"] = 0
+        end
+      end
+    end
+    threads.each { |t| t.join }
+    @stored_hash.size.should == (thread_number * max_count)
+  end
+
+end
+

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+name: rkh-stored_hash
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-11 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: konstantin.mailinglists@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/stored_hash.rb
+- spec/stored_hash_spec.rb
+has_rdoc: true
+homepage: http://github.com/rkh/stored_hash
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: synchronize a hash with a yaml-file
+test_files: []
+