bomberstudios-stone 0.2

data/lib/stone.rb

@@ -0,0 +1,55 @@
+require 'fileutils'
+require 'rubygems'
+require 'validatable'
+require 'english/inflect'
+require 'yaml'
+
+require File.expand_path(File.dirname(__FILE__) + '/stone/core_ext/enumerable')
+require File.expand_path(File.dirname(__FILE__) + '/stone/core_ext/string')
+require File.expand_path(File.dirname(__FILE__) + '/stone/core_ext/symbol')
+require File.expand_path(File.dirname(__FILE__) + '/stone/core_ext/datetime')
+require File.expand_path(File.dirname(__FILE__) + '/stone/query')
+require File.expand_path(File.dirname(__FILE__) + '/stone/data_store')
+require File.expand_path(File.dirname(__FILE__) + '/stone/callbacks')
+require File.expand_path(File.dirname(__FILE__) + '/stone/resource')
+
+STONE_ROOT = Dir.pwd
+
+module Stone
+  class << self
+
+    # For spec stuff only
+    def empty_datastore
+      if File.exists? STONE_ROOT/"sandbox_for_specs/datastore"
+        FileUtils.rm_rf STONE_ROOT/"sandbox_for_specs/datastore"
+      end
+    end
+
+    # Creates or updates a datastore at +path+
+    # === Parameters
+    # +path+<String>:: 
+    #   Path to create or update datastore (usually an application's root)
+    # +resources+<Array>:: A list of resources that exist for the application
+    def start(path, resources, framework = nil)
+      DataStore.local_dir = path/"datastore"
+
+      # create the datastore dir unless it exists
+      FileUtils.mkdir_p(DataStore.local_dir) unless File.exists?(DataStore.local_dir)
+
+      # create a .stone_metadata that contains the resource locations
+      # for Stone::Utilities to use
+      File.open(DataStore.local_dir/".stone_metadata", "w") do |out|
+        YAML.dump({:rsrc_path => File.dirname(resources.first)}, out)
+      end unless File.exists?(DataStore.local_dir/".stone_metadata")
+
+      # load each resource unless a framework has already done it
+      resources.each do |resource|
+        require resource unless framework == :merb || framework == :rails
+        name = File.basename(resource,".rb").pluralize
+        unless File.exists? DataStore.local_dir/name
+          FileUtils.mkdir_p(DataStore.local_dir/name)
+        end
+      end
+    end
+  end # self
+end # Stone

data/lib/stone/callbacks.rb

@@ -0,0 +1,50 @@
+module Stone
+  class Callbacks < Hash
+    
+    CALLBACKS = [
+      :before_save,
+      :after_save,
+      :before_create,
+      :after_create,
+      :before_destroy,
+      :after_destroy
+      ]
+    
+    class << self
+      
+    end # self
+    
+    # Registers the +klass+ with the current instance of Callbacks in Resource
+    # === Parameters
+    # +klass+:: The class to be registered
+    def register_klass(klass)
+      self[klass.to_s.make_key] = {}
+      CALLBACKS.each do |cb_sym|
+        self[klass.to_s.make_key][cb_sym] = []
+      end
+    end
+    
+    # Adds a given +meth+ to the +cb_sym+ array in the current Callbacks 
+    # hash based on +klass+
+    # === Parameters
+    # +cb_sym+:: where +meth+ will be added
+    # +meth+:: method to be added
+    # +klass+:: determines which +cb_sym+ array will be used
+    def register(cb_sym, meth, klass)
+      self[klass.to_s.make_key][cb_sym] << meth
+    end
+    
+    # Sends any methods registered under +cb_sym+ to +obj+
+    # === Parameters
+    # +cb_sym+:: Used to retrieve the methods to send
+    # +obj+:: The object to which the retrieved methods are sent
+    def fire(cb_sym, obj)
+      unless obj.model == :class
+        self[obj.model][cb_sym].each do |meth|
+          obj.send(meth) unless meth.blank?
+        end
+      end
+      true
+    end
+  end # Callbacks
+end # Stone

data/lib/stone/core_ext/datetime.rb

@@ -0,0 +1,18 @@
+# Fixes the bug with YAML and DateTime, where
+# YAML::load(DateTime.now.to_yaml).class == Time
+require "yaml"
+class DateTime
+  yaml_as "tag:ruby.yaml.org,2002:datetime"
+  def DateTime.yaml_new(klass, tag, val)
+    if String === val
+      self.parse(val)
+    else
+      raise YAML::TypeError, "Invalid DateTime: " + val.inspect
+    end
+  end
+  def to_yaml( opts = {} )
+    YAML::quick_emit( object_id, opts ) do |out|
+      out.scalar( taguri, self.to_s, :plain )
+    end
+  end
+end

data/lib/stone/core_ext/enumerable.rb

@@ -0,0 +1,5 @@
+module Enumerable
+  def blank?
+    return self.size <= 0
+  end
+end

data/lib/stone/core_ext/string.rb

@@ -0,0 +1,12 @@
+class String #:nodoc:
+  def /(o)
+    File.join(self, o.to_s)
+  end
+  def make_key
+    self.downcase.to_sym
+  end
+  # From Ruby Facets
+  def titlecase
+    gsub(/\b\w/){$&.upcase}
+  end
+end

data/lib/stone/core_ext/symbol.rb

@@ -0,0 +1,25 @@
+class Symbol
+  def gt;   Stone::Query.new(self.to_s, :gt);   end
+  def gte;  Stone::Query.new(self.to_s, :gte);  end
+  def lt;   Stone::Query.new(self.to_s, :lt);   end
+  def lte;  Stone::Query.new(self.to_s, :lte);  end
+  
+  def includes
+    Stone::Query.new(self.to_s, :includes)
+  end
+  
+  def matches
+    Stone::Query.new(self.to_s, :matches)
+  end
+  
+  def equals
+    Stone::Query.new(self.to_s, :equals)
+  end
+  
+  def not
+    Stone::Query.new(self.to_s, :not)
+  end
+  def blank?
+    return self.to_s.size <= 0
+  end
+end

data/lib/stone/data_store.rb

@@ -0,0 +1,70 @@
+module Stone
+  # An in-memory representation of the file-based datastore
+  class DataStore
+    
+    class << self
+      attr_accessor :local_dir
+
+      # Loads yaml files specific to the resource represented by +sym+
+      # === Parameters
+      # +sym+::
+      #   Symbol representing resource data to load
+      def load_data(sym)
+        ymls = Dir.glob(self.local_dir/sym.to_s.pluralize/"*.yml").sort { |a,b| File.basename(a,".yml").to_i - File.basename(b,".yml").to_i }
+        objs = []
+        unless ymls.empty?
+          ymls.each do |yml|
+            obj = YAML.load_file yml
+            objs << [obj.id, obj]
+          end
+        end
+        return objs
+      end
+      
+      # If the object already exists (id was found),
+      # this returns +put+(update), else +post+(create)
+      # === Parameters
+      # +obj+::
+      #   The instantiated resource to be saved
+      # +store+:: 
+      #   DataStore object
+      def determine_save_method(obj, store)
+        store.resources[obj.model].each do |o|
+          return :put if o[0] == obj.id
+        end
+        :post
+      end
+      
+      # Persist the object via YAML
+      # === Parameters
+      # +obj+:: The object to be persisted
+      def write_yaml(obj)
+        path = self.local_dir/obj.models/"#{obj.id}.yml"
+        File.open(path, 'w') do |out|
+          YAML.dump(obj, out)
+        end
+      end
+      
+      # Removes object's yaml file
+      # === Parameters
+      # +id+:: id of the object to be removed
+      # +klass_dir+:: directory in which object resides
+      def delete(id, klass_dir)
+        raise "Object could not be found" \
+          unless File.exists?(self.local_dir/klass_dir/"#{id}.yml")
+            
+        FileUtils.remove_file(self.local_dir/klass_dir/"#{id}.yml")
+        true
+      end
+    end # self
+    
+    def initialize
+      @resources = {}
+    end
+    
+    def resources
+      @resources
+    end
+    
+  end # DataStore
+end # Stone

data/lib/stone/query.rb

@@ -0,0 +1,44 @@
+module Stone
+  # Represents a single query condition
+  class Query
+    
+    attr_accessor :field, :op
+    
+    def initialize(field,op)
+      self.field = field
+      self.op = case op
+                  when :gt
+                    ".>"
+                  when :lt
+                    ".<"
+                  when :gte
+                    ".>="
+                  when :lte
+                    ".<="
+                  when :includes
+                    ".include?"
+                  when :matches
+                    ".=~"
+                  when :equals
+                    ".=="
+                  when :not
+                    ".!="
+                  end
+    end
+    
+    # Builds an expression from the conditions given during first or all
+    # === Parameters
+    # +arg+:: Some conditional argument
+    def expression_for(arg)
+      if arg.is_a? String
+        "#{self.field}#{self.op}('#{arg}')"
+      elsif arg.is_a? Regexp
+        "#{self.field}#{self.op}(#{arg.inspect})"
+      elsif arg.is_a? Date
+        "#{self.field}#{self.op}(DateTime.parse('#{arg}'))"
+      else
+        "#{self.field}#{self.op}(#{arg})"
+      end
+    end
+  end 
+end

data/lib/stone/resource.rb

@@ -0,0 +1,472 @@
+module Stone
+  # Adds the ability to persist any class it is included in
+  # === Example
+  #
+  # class Post
+  #   include Stone::Resource
+  # 
+  #   field :body, String
+  # end
+  #
+  module Resource
+
+    attr_accessor :id
+
+    class << self
+      def included(base)
+        rsrc_sym = base.to_s.make_key
+
+        @@callbacks ||= Callbacks.new
+        @@callbacks.register_klass(base)
+
+        @@store ||= DataStore.new
+
+        base.send(:extend, self)
+        base.send(:include, ::Validatable)
+
+        # rspec breaks if its classes have their contructor overwritten
+        unless base.to_s.downcase =~ /(spec::example::examplegroup::subclass_\d|blah)/
+          # allow object to be created with a hash of attributes...
+          # [] allows for obj[attribute] retrieval
+          # to_s allows for stupid Rails to work
+          base.class_eval <<-EOS, __FILE__, __LINE__
+            def initialize(hash = {})
+              self.id = self.next_id_for_klass(self.class)
+              unless hash.blank?
+                update_attributes(hash)
+              end
+              @@fields[self.model].each do |f|
+                instance_variable_set("@"+f[:name].to_s,[]) if f[:klass] == Array
+              end
+            end
+
+            def to_s
+              id
+            end
+
+            def [](sym)
+              self.send(sym)
+            end
+          EOS
+        end
+
+        unless @@store.resources.include?(rsrc_sym)
+          @@store.resources[rsrc_sym] = DataStore.load_data(rsrc_sym)
+        end
+      end
+    end # self
+
+    @@fields = {}
+
+    # Adds a given field to @@fields and inserts an accessor for that
+    # field into klass
+    # === Parameters
+    # +name+<String>::
+    #
+    def field(name, klass, arg = nil)
+      if arg && arg[:unique] == true
+        unique = true
+      else
+        unique = false
+      end
+      klass_sym = self.to_s.make_key
+      unless @@fields[klass_sym]
+        @@fields[klass_sym] = [{:name => name, 
+                                :klass => klass, 
+                                :unique => unique}]
+      else
+        @@fields[klass_sym] << {:name => name, 
+                                :klass => klass, 
+                                :unique => unique}
+      end
+      name = name.to_s
+      # add accessor for given field
+      unless klass == Array
+        self.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            @#{name}
+          end
+          def #{name}=(value)
+            @#{name} = value
+          end
+        EOS
+      else
+        self.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            @#{name}
+          end
+        EOS
+      end
+      self.send(:define_method,"next_by_#{name}") {
+        self.next(name.to_sym)
+      }
+      self.send(:define_method,"prev_by_#{name}") {
+        self.prev(name.to_sym)
+      }
+    end # field
+
+    def model
+      self.class.to_s.downcase.to_sym
+    end
+    def models
+      self.class.to_s.downcase.pluralize
+    end
+
+    # Registers the given method with the current instance of Callbacks. Upon
+    # activation (in this case, right before Resource.save is executed), the
+    # +meth+ given is called against the object being, in this case, saved.
+    #
+    # Note that there is no before_validation callback, because Stone
+    # before_save triggers before validations occur anyway
+    # === Parameters
+    # +meth+:: The method to be registered
+    def before_save(meth)
+      @@callbacks.register(:before_save, meth, self)
+    end
+
+    # See before_save
+    def after_save(meth)
+      @@callbacks.register(:after_save, meth, self)
+    end
+
+    # See before_save
+    def before_create(meth)
+      @@callbacks.register(:before_create, meth, self)
+    end
+
+    # See before_save
+    def after_create(meth)
+      @@callbacks.register(:after_create, meth, self)
+    end
+
+    # See before_save
+    def before_delete(meth) 
+      @@callbacks.register(:before_delete, meth, self)
+    end
+
+    # See before_save
+    def after_delete(meth)
+      @@callbacks.register(:after_delete, meth, self)
+    end
+
+    # Registers a one-to-many relationship for +resource+
+    # === Parameters
+    # +resource+::
+    #   the resource of which this class has many
+    def has_many(resource, *args)
+      self.class_eval <<-EOS, __FILE__, __LINE__
+        def #{resource.to_s}
+          #{resource.to_s.singularize.titlecase}.all("#{self.to_s.downcase}_id".to_sym.equals => self.id)
+        end
+      EOS
+    end
+
+    # Registers a one-to-one relationship for +resource+
+    # === Parameters
+    # +resource+::
+    #   the resource of which this class has one
+    def has_one(resource, *args)
+      field "#{resource.to_s}_id".to_sym, Fixnum
+    end
+
+    # Registers a belongs_to association for +resource+
+    # === Parameters
+    # +resource+ :: The resource to which this class belongs
+    def belongs_to(resource, *args)
+      field "#{resource.to_s}_id".to_sym, Fixnum
+      self.class_eval <<-EOS, __FILE__, __LINE__
+        def #{resource.to_s} 
+          #{resource.to_s.titlecase}[self.#{resource.to_s}_id]
+        end
+      EOS
+    end
+
+    # Registers a many-to-many association using an array of +resource+
+    # ids.
+    # === Parameters
+    # +resource+::
+    #   The resource of which this class belongs to and has many
+    def has_and_belongs_to_many(resource, *args)
+      field resource, Array
+    end
+
+    alias_method :habtm, :has_and_belongs_to_many
+
+    # Returns the first object matching +conditions+, or the first object
+    # if no conditions are specified
+    # === Parameters
+    # +conditions+::
+    #   A hash representing one or more Ruby expressions
+    def first(conditions = nil)
+      unless conditions
+        return @@store.resources[self.to_s.make_key].first[1]
+      else
+        return find(conditions, self.to_s.make_key)[0]
+      end
+    end
+
+    # Returns all objects matching +conditions+, or all objects if no
+    # conditions are specified
+    # === Parameters
+    # +conditions+::
+    #   A hash representing one or more Ruby expressions
+    def all(conditions = nil)
+      objs = []
+      # check for order conditions, make conditions nil if an order condition
+      # is the only one passed to Resource.all
+      if conditions && conditions[:order]
+        order = conditions[:order].to_a.flatten
+        conditions.delete(:order)
+        conditions = nil if conditions.empty?
+      end
+      # Don't bother getting into crazy object searches if there are no
+      # conditions -- just grab the objects directly out of the current 
+      # store
+      unless conditions
+        @@store.resources[self.to_s.make_key].each do |o|
+          objs << o[1]
+        end
+      else
+        objs = find(conditions, self.to_s.make_key)
+      end
+      if order
+        raise "Order should be passed with :asc or :desc, got #{order[1].inspect}" \
+          unless [:asc,:desc].include? order[1]
+        # FIXME: something about this breaks under certain conditions 
+        # that I can't find yet
+        begin
+          objs.sort! {|x,y| x.send(order[0]) <=> y.send(order[0])}
+        rescue
+        end
+        objs.reverse! if order[1] == :desc
+      end
+      objs
+    end
+
+    # Synonymous for get
+    # === Parameters
+    # +id+:: id of the object to retrieve
+    def [](id)
+      raise "Expected Fixnum, got #{id.class} for #{self.to_s}[]" \
+        unless id.class == Fixnum || id.to_i
+      get(id)
+    end
+
+    def fields
+      @@fields
+    end
+
+    # Deletes the object with +id+ from the current DataStore instance and
+    # its corresponding yaml file
+    def delete(id)
+      fire(:before_delete)
+      DataStore.delete(id, self.to_s.downcase.pluralize)
+      @@store.resources[self.to_s.make_key].each_with_index do |o,i|
+        @@store.resources[self.to_s.make_key].delete_at(i) if o[0] == id
+      end
+      fire(:after_delete)
+      true
+    end
+
+    # Allow for retrieval of an object in the current DataStore instance by id
+    # === Parameters
+    # +id+:: id of the object to retrieve 
+    def get(id)
+      id = id.to_i
+      raise "Expected Fixnum, got #{id.class} for #{self.to_s}.get" \
+        unless id.class == Fixnum
+      @@store.resources[self.to_s.make_key].each do |o|
+        return o[1] if o[0] == id
+      end
+      nil
+    end
+    alias_method :find_by_id, :get
+
+    # Puts the attribute changes in +hash+
+    # === Parameters
+    # +hash+:: the attributes to change
+    def update_attributes(hash)
+      hash.each_key do |k|
+        k = k.to_sym
+        if hash[k].is_a? Hash
+          update_attributes(hash[k])
+        else
+          self.send(k.to_s+"=", hash[k]) if field_declared?(k,self.class)
+        end
+      end
+      self.save
+    end
+
+    # Determine the next id number to use based on the last stored object's id
+    # of class +klass+
+    # === Parameters
+    # +klass+:: The class of the object to be saved
+    def next_id_for_klass(klass)
+      sym = klass.to_s.make_key
+      if @@store.resources.has_key?(sym) && !@@store.resources[sym].blank?
+        return @@store.resources[sym].last[0] + 1
+      else
+        return 1
+      end
+    end
+
+    # Save an object to the current DataStore instance.
+    def save
+      return false unless self.fields_are_valid?
+      fire(:before_save)
+      return false unless self.valid?
+      sym = DataStore.determine_save_method(self, @@store)
+      self.class.send(sym, self)
+      fire(:after_save)
+    end
+
+    # Determines whether the field classes of a given object match the field
+    # class declarations
+    def fields_are_valid?
+      klass_sym = self.model
+      @@fields[klass_sym].each do |field|
+        unless self.send(field[:name]).class == field[:klass] || self.send(field[:name]) == nil || self.already_exists?
+          return false 
+        end
+        if field[:unique] == true
+          return false if self.class.first(field[:name] => self.send(field[:name])) && !self.already_exists?
+        end
+      end
+      true
+    end
+
+    # Needed for Rails to work
+    def new_record?
+      !already_exists?
+    end
+
+    # Finds out if the object is already in the current DataStore instance
+    def already_exists?
+      DataStore.determine_save_method(self, @@store) == :put
+    end
+
+    def next(order_by = :id)
+      self.class.all(order_by.gt => self.send(order_by), :order => {order_by => :desc})[0]
+    end
+    def prev(order_by = :id)
+      self.class.all(order_by.lt => self.send(order_by), :order => {order_by => :desc})[0]
+    end
+
+    private
+
+    # Fires the given callback in the current instance of Callbacks
+    # === Parameters
+    # +cb_sym+:: The symbol for the callback (e.g. :before_save)
+    def fire(cb_sym)
+      @@callbacks.fire(cb_sym, self)
+      true
+    end
+
+    # Creates a yaml file for +obj+ and adds +obj+ to the current DataStore
+    # instance
+    # === Parameters
+    # +obj+:: The object to be saved
+    def post(obj)
+      fire(:before_create)
+      obj.created_at = DateTime.now if field_declared?(:created_at,obj.class)
+      obj.updated_at = DateTime.now if field_declared?(:updated_at,obj.class)
+      DataStore.write_yaml(obj)
+      @@store.resources[obj.model] << [obj.id, obj]
+      fire(:after_create)
+    end
+
+    # Updates the yaml file for +obj+ and overwrites the old object in the
+    # the current DataStore instance
+    # === Parameters
+    # 
+    def put(obj)
+      obj.updated_at = DateTime.now if field_declared?(:updated_at,obj.class)
+      DataStore.write_yaml(obj)
+      @@store.resources[obj.model].each do |o|
+        o[1] = obj if o[0] == obj.id
+      end
+      true
+    end
+
+    # Find an object according to +conditions+ provided
+    # === Parameters
+    # +conditions+:: A plain string representation of a set of conditions
+    # +key+:: 
+    #   A symbol representing the class of objects to look for in the current
+    #   DataStore instance
+    def find(conditions, key) #:doc:
+      objs = []
+
+      if conditions.is_a? Hash
+        unless conditions.to_a.flatten.map {|e| e.is_a? Query}.include?(true)
+          conds = conditions.to_a.flatten
+          @@store.resources[key].each do |o|
+            objs << o[1] if o[1].send(conds[0]) == conds[1]
+          end
+        else
+          parsed_conditions = parse_conditions(conditions)
+          @@store.resources[key].each do |o|
+            objs << o[1] if matches_conditions?(o[1], parsed_conditions)
+          end
+        end
+      else
+        raise "Resource.find expects a Hash, got a #{conditions.class}"
+      end
+      objs
+    end
+
+    # Checks the list of fields for a given +klass+ to see if +field+
+    # is included
+    # === Parameters
+    # +field+:: The field to look for
+    # +klass+:: The class to look in 
+    def field_declared?(field,klass)
+      @@fields[klass.to_s.make_key].each do |f|
+        return true if f[:name] == field
+      end
+      false
+    end
+
+    # Executes and evaluates the expressions in +conds+ against 
+    # the +obj+ provided, and then evaluates those results against
+    # the conditionals ("&&") in +conds+
+    # === Parameters
+    # +obj+:: The object to compare against
+    # +conds+:: 
+    #   A set of expressions (name == 'nick') and their conditionals
+    #   ('&&')
+    def matches_conditions?(obj, conds) #:doc:
+      tf_ary = []
+      conds.each_with_index do |cond,i|
+        # build an array like [true, "&&", false, "&&", true]
+        if i % 2 == 0
+          begin
+            bool = obj.instance_eval(cond)
+            bool = false unless bool
+            bool = true if bool.class == Fixnum
+            tf_ary << bool
+          rescue
+            tf_ary << false
+          end
+        else
+          tf_ary << cond
+        end
+      end
+      # evaluate the true/false array
+      eval(tf_ary.join)
+    end
+
+    # Turns conditions into a set of expressions that can be evaluated
+    def parse_conditions(hash)
+      conds = []
+      hash.each do |k,v|
+        conds << k.expression_for(v)
+        conds << "&&"
+      end
+      conds.pop
+      conds
+    end
+
+  end # Resource
+
+end # Stone

data/lib/stone/version.rb

@@ -0,0 +1,9 @@
+module Stone #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: bomberstudios-stone
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: 
+- "Ale Mu\xC3\xB1oz"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-11 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: Super-simple data persistence layer created for small applications.
+email: bomberstudios@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/stone.rb
+- lib/stone/callbacks.rb
+- lib/stone/data_store.rb
+- lib/stone/query.rb
+- lib/stone/resource.rb
+- lib/stone/version.rb
+- lib/stone/core_ext/datetime.rb
+- lib/stone/core_ext/enumerable.rb
+- lib/stone/core_ext/string.rb
+- lib/stone/core_ext/symbol.rb
+has_rdoc: false
+homepage: http://github.com/bomberstudios/stone/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.5
+  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: Super-simple data persistence layer created for small applications.
+test_files: []
+