toad_spawn 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+sandbox

data/.rvmrc

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.8.7" > .rvmrc
+environment_id="ruby-1.8.7-p370@toad_spawn"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.15.8 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in toad_spawn.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Andy White
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# ToadSpawn
+
+A basic persistent hash. Behaves similar to a normal hash but the key value
+pairs persist between instantiations. The keys must be symbols and only 
+strings, floats and fixnums can be stored as their original types, anything 
+else is converted to a string. A simple file based store is used under the 
+hood.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'toad_spawn'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install toad_spawn
+
+## Usage
+
+Say you want a simple key/value based persistent data store:
+
+    whatever = ToadSpawn::Base.new('/path/folder/A') 
+    
+The path argument must be an existing, writable folder and gives the ToadSpawn
+it's uniqueness. If you instantiate ToadSpawn with this path anywhere again, 
+it will have the same data.
+
+So later, or in another program:
+    
+    data = ToadSpawn::Base.new('/path/folder/A') 
+    
+    data[:string] = 'ant'
+    data[:float]  = 1.2345
+    data[:fixnum] = 1001
+    
+    data[:string] # => 'ant'
+    data[:float]  # => 1.2345
+    data[:fixnum] # => 1001
+    
+    another_spawn = ToadSpawn::Base.new('/path/folder/B')
+    another_spawn.size  # => 0
+    
+These methods work just like in Hash:
+
+    data.to_hash          # => {:string => 'ant', :float => 1.2345, :fixnum => 1001}
+    data.empty?           # => false
+    data.any?             # => true
+    data.has_key?(:float) # => true
+    data.has_value?(100)  # => false
+    data.keys             # => [:string, :float, :fixnum]
+    data.values           # => ['ant', 1.2345, 1001]
+    data.size             # => 3
+    data.delete(:float)   # => deletes the value and returns it: 1.2345
+    data.clear            # => clears the ToadSpawn and returns {}
+
+### Don't forget to flush!
+
+Because ToadSpawn uses caching under the hood to improve performance, please 
+be aware that it is not automatically mutiprocess safe - meaning that if a spawn is 
+instantiated and another process opens the same spawn and changes an element,
+that change will not be seen by the original spawn - until it is 
+re-instantiated or the *flush* method is called to re-read the filesystem.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/fixtures/afile.txt

@@ -0,0 +1 @@
+a file

data/fixtures/long.txt

@@ -0,0 +1,28 @@
+TravelBloggers Unite ‏@tbloggersunite
+That awkward moment when Fábio Coentrão spoils a perfectly good photo #TBUPOR
+Expand
+ Reply  Retweet  Favorite Buffer
+2h Paul Ricketts ‏@sifu33
+I liked a @YouTube video from @kungfujack1 http://youtu.be/3P6xk1xZXyA?a KungFuJack Goes For A Stroll
+ View media
+ Reply  Retweet  Favorite Buffer
+2h Jayne Gorman ‏@jayneytravels
+And I won the business card draw (again!) Framed photo of @Melbourne street art is mine! #greatjourneys
+Expand
+ Reply  Retweet  Favorite Buffer
+2h Mike Phillips ‏@mcphillips
+RT @GFQNetwork: What the Tech is live at 4pm ET W/ Paul @thurrott and @andrewzarian. Watch and chat with us http://www.gfqlive.tv
+Expand
+ Reply  Retweet  Favorite Buffer
+2h Keith Fowler ‏@Keith_Fowler
+Seeing the Ukelele Orchestra of Great Britain @Worthingtheaters Yay!
+Expand
+ Reply  Retweet  Favorite Buffer
+9h Jane Hames ‏@glidetraining
+Just 12 spaces left for @mumpre
+==============
+
+Element Reference—If passed a single Fixnum, returns the code of the character at that position. If passed two Fixnum objects, returns a substring starting at the offset given by the first, and a length given by the second. If given a range, a substring containing characters at offsets given by the range is returned. In all three cases, if an offset is negative, it is counted from the end of str. Returns nil if the initial offset falls outside the string, the length is negative, or the beginning of the range is greater than the end.
+
+If a Regexp is supplied, the matching portion of str is returned. If a numeric parameter follows the regular expression, that component of the MatchData is returned instead. If a String is given, that string is returned if it occurs in str. In both cases, nil is returned if there is no match.
+

data/lib/toad_spawn.rb

@@ -0,0 +1,3 @@
+require "toad_spawn/version"
+require "toad_spawn/base"
+

data/lib/toad_spawn/base.rb

@@ -0,0 +1,106 @@
+module ToadSpawn
+  class Base
+    def initialize(path)
+      raise "Directory does not exist" unless File.exist?(path)
+      raise "Not a directory" unless File.directory?(path)
+      raise "Not writable" unless File.writable?(path)
+      @path = path
+      flush
+    end
+    
+    def key_file_path(key)
+      File.join(@path, key.to_s + ".value")
+    end
+    
+    def format(key, value)
+      "#{value.class}\n#{value}"
+    end
+    
+    def klass(data)
+      data[/^(.+)\n/,1]
+    end
+    
+    def value(data)
+      data.sub(/^.+\n/,'')
+    end
+    
+    def cast(value, klass)
+      case klass
+      when 'Fixnum'
+        value.to_i
+      when 'Float'
+        value.to_f
+      else
+        value.to_s
+      end
+    end
+    
+    def []=(key, value)
+      File.open(key_file_path(key), "w") do |f|
+        f.write format(key, value)
+      end
+      @cache[key] = cast(value, value.class.to_s)
+    end
+    
+    def read_file(path)
+      data = File.read(path)
+      [File.basename(path, ".value").to_sym, cast(value(data), klass(data))]
+    end
+    
+    def [](key)
+      @cache[key]
+    end
+    
+    def flush
+      @cache = {}
+      Dir.glob("#{@path}/*.value").each do |path|
+        key, value = read_file(path)
+        @cache[key] = value
+      end
+    end
+    
+    def to_hash
+      @cache
+    end
+    
+    def any?
+      @cache.any?
+    end
+    
+    def empty?
+      @cache.empty?
+    end
+    
+    def delete(key)
+      File.delete key_file_path(key)
+      @cache.delete(key)
+    end
+    
+    def has_key?(key)
+      @cache.has_key?(key)
+    end
+    
+    def has_value?(value)
+      @cache.has_value?(value)
+    end
+    
+    def keys
+      @cache.keys
+    end
+    
+    def values
+      @cache.values
+    end
+    
+    def size
+      @cache.size
+    end
+    
+    def clear
+      Dir.glob("#{@path}/*.value").each do |path|
+        File.delete(path)
+      end
+      @cache = {}
+    end
+  end
+end

data/lib/toad_spawn/version.rb

@@ -0,0 +1,3 @@
+module ToadSpawn
+  VERSION = "0.0.1"
+end

data/spec/helper.rb

@@ -0,0 +1,14 @@
+def fixtures(path = nil)
+  fixtures_path = File.join(File.dirname(__FILE__), '..', 'fixtures')
+  path.nil? ? fixtures_path : File.join(fixtures_path, path)
+end
+
+def sandbox(path = nil)
+  sandbox_path = File.join(File.dirname(__FILE__), '..', 'sandbox')
+  path.nil? ? sandbox_path : File.join(sandbox_path, path)
+end
+
+def reset_sandbox
+  system "rm -fr #{sandbox}"
+  system "mkdir #{sandbox}"
+end

data/spec/toad_spawn_spec.rb

@@ -0,0 +1,201 @@
+require 'toad_spawn/base'
+require File.dirname(__FILE__) + '/helper'
+
+describe ToadSpawn::Base do
+  before(:each) do
+    reset_sandbox
+  end
+  
+  describe "Path validation" do
+    it "Raise error if directory absent" do
+      lambda { ToadSpawn::Base.new('does/not/exist') } .should raise_error 'Directory does not exist'
+    end
+    
+    it "Raise error if not a directory" do
+      lambda { ToadSpawn::Base.new(fixtures('afile.txt')) } .should raise_error 'Not a directory'
+    end
+    
+    it "Raise error if not writable" do
+      lambda { ToadSpawn::Base.new('/bin') } .should raise_error 'Not writable'
+    end
+  end
+  
+  describe "Setting and reading data" do
+    before(:each) do
+      @db_folder = sandbox('spawn')
+      system "mkdir #{@db_folder}"
+      @data = ToadSpawn::Base.new(@db_folder)
+    end
+    
+    it "#key_file_path" do
+      @data.key_file_path(:foobar).should == File.join(@db_folder, 'foobar.value')
+    end
+    
+    it "returns nil if key does not exist" do
+      @data[:aardvarks] == nil
+    end
+    
+    it "set and read string" do
+      @data[:foo] = 'bar'
+      @data[:foo].should == 'bar'
+    end
+
+    it "set and read complex string" do
+      @data[:long] = File.read(fixtures('long.txt'))
+      @data[:long].should == File.read(fixtures('long.txt'))
+    end
+
+    it "set and read Fixnum" do
+      @data[:fixnum] = 1001
+      @data[:fixnum].should == 1001
+    end
+
+    it "set and read Float" do
+      @data[:fixnum] = 1.2345
+      @data[:fixnum].should == 1.2345
+    end
+  end
+  
+  describe "Persistence" do
+    before(:each) do
+      @folder = sandbox
+      @first = ToadSpawn::Base.new(@folder)
+      @first[:foo] = 'bam'
+      @first[:bar] = 22.2
+    end
+    
+    it "second should be same data as first" do      
+      second = ToadSpawn::Base.new(@folder)
+      second[:foo].should == 'bam'
+      second[:bar].should == 22.2
+    end
+    
+    it "changes in first should be reflected in second" do
+      @first.delete(:foo)
+      second = ToadSpawn::Base.new(@folder)
+      second[:foo].should == nil
+    end
+    
+    describe "flushing" do
+      it "should see same data when flushed" do
+        second = ToadSpawn::Base.new(@folder)
+        second.size.should == 2
+        @first.delete(:foo)
+        second.size.should == 2
+        second.flush
+        second.size.should == 1
+      end
+    end
+  end
+  
+  describe "Data functions" do
+    before(:each) do
+      reset_sandbox
+      @folder1 = sandbox('1')
+      @folder2 = sandbox('2')
+      Dir.mkdir @folder1
+      Dir.mkdir @folder2
+      @data = ToadSpawn::Base.new(@folder1)
+      @data[:one]   = 'a'
+      @data[:two]   = 2
+      @data[:three] = 0.3
+    end
+    
+    describe "#to_hash" do
+      it "should return a hash" do
+        @data.to_hash.should == {:one => 'a', :two => 2, :three => 0.3}
+      end
+    end
+    
+    describe "#empty?" do
+      it "should deem it empty" do
+        ToadSpawn::Base.new(@folder2).empty?.should be_true
+      end
+      
+      it "should deem it not empty" do
+        @data.empty?.should be_false
+      end
+    end
+
+    describe "#any?" do
+      it "should deem it empty" do
+        ToadSpawn::Base.new(@folder2).any?.should be_false
+      end
+      
+      it "should deem it not empty" do
+        @data.any?.should be_true
+      end
+    end
+    
+    describe "#has_key?" do
+      it "should find the key" do
+        @data.has_key?(:three).should be_true
+      end
+
+      it "should not find the key" do
+        @data.has_key?(:boomerangs).should be_false
+      end
+    end
+    
+    describe "#has_value?" do
+      it "should find the value" do
+        @data.has_value?(2).should be_true
+      end
+
+      it "should not find the value" do
+        @data.has_value?('some aardvarks').should be_false
+      end
+    end
+    
+    describe "#keys" do
+      it "should return keys as array" do
+        keys = @data.keys
+        keys.class.should == Array
+        keys.size.should == 3
+        keys.include?(:one).should be_true
+        keys.include?(:two).should be_true
+        keys.include?(:three).should be_true
+      end
+    end
+    
+    describe "#values" do
+      it "should return values as array" do
+        vals = @data.values
+        vals.class.should == Array
+        vals.size.should == 3
+        vals.include?('a').should be_true
+        vals.include?(2).should be_true
+        vals.include?(0.3).should be_true
+      end
+    end
+    
+    describe "#size" do
+      it "should measure a full" do
+        @data.size.should == 3
+      end
+
+      it "should measure a zero" do
+        ToadSpawn::Base.new(@folder2).size.should == 0
+      end
+    end
+    
+    describe "#delete" do
+      it "should delete an element" do
+        @data.delete(:three)
+        @data[:three].should be_nil
+        @data.size.should == 2
+      end
+      
+      it "should return deleted element" do
+        @data.delete(:two).should == 2
+      end
+    end
+    
+    describe "#clear" do
+      it "should delete all elements" do
+        @data.clear
+        @data.size.should == 0
+      end
+    end
+  end
+end

data/toad_spawn.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'toad_spawn/version'
+
+Gem::Specification.new do |s|
+  s.name          = "toad_spawn"
+  s.version       = ToadSpawn::VERSION
+  s.authors       = ["Andy White"]
+  s.email         = ["andy@wireworldmedia.co.uk"]
+  s.description   = %q{A persistant, file based hash}
+  s.summary       = %q{A basic persistent hash. Behaves similar to a normal hash but the key value
+pairs persist between instantiations. The keys must be symbols and only 
+strings, floats and fixnums can be stored as their original types, anything 
+else is converted to a string. A simple file based store is used under the 
+hood.}
+  s.homepage      = ""
+  
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.add_development_dependency "rspec", "~> 2.11.0"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: toad_spawn
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andy White
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-12 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 11
+        - 0
+        version: 2.11.0
+  type: :development
+  version_requirements: *id001
+description: A persistant, file based hash
+email: 
+- andy@wireworldmedia.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fixtures/afile.txt
+- fixtures/long.txt
+- lib/toad_spawn.rb
+- lib/toad_spawn/base.rb
+- lib/toad_spawn/version.rb
+- spec/helper.rb
+- spec/toad_spawn_spec.rb
+- toad_spawn.gemspec
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A basic persistent hash. Behaves similar to a normal hash but the key value pairs persist between instantiations. The keys must be symbols and only  strings, floats and fixnums can be stored as their original types, anything  else is converted to a string. A simple file based store is used under the  hood.
+test_files: 
+- spec/helper.rb
+- spec/toad_spawn_spec.rb