yaml_record 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/*

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011, Nico Taing, Miso, Inc.
+
+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,76 @@
+# YAML RECORD #
+
+## Introduction ##
+
+YAML Record allows you to persist data to a yaml file and manage it with activemodel API
+
+## Installation ##
+
+    gem install yaml_record
+    
+## Usage ##
+
+To use YAML Record add gem to your Gemfile
+
+    # Gemfile
+    gem 'yaml_record'
+    
+Next define your YAML Record class 
+    
+    class Post < YamlRecord::Base
+      # Declare your properties
+      properties :title, :body, :user_id
+      
+      # Declare source file path
+      source Rails.root.join("config/posts")
+    end
+    
+Use as any activerecord object.
+
+Retrieve all items:
+
+    Post.all => [@p1, @p2]
+    
+Retrieve item by ID:
+
+    Post.find("a1b2") => @p1
+    
+Retrieve by attribute
+
+    Post.find_by_attribute(:title, "some title") => @p
+    
+Initialize post:
+
+    @p = Post.new(:title => "...", :body => "...", :user_id => 5)
+    
+Save post:
+
+    @p.save
+    # or Post.create(:title => "...", :body => "...", :user_id => 5)
+    
+Access attributes
+
+    @p = Post.find("a1b2")
+    @p.title => "..."
+    
+Assign attributes 
+
+    @p.title = "new title"
+
+Update attributes
+
+    @p.update_attributes(:title => "new title")
+    
+Destroy record
+
+    @p.destroy
+
+## Contributors ##
+
+Created at Miso by Nico Taing and Nathan Esquenazi
+
+Contributors are welcome!
+
+## License ##
+
+YAML Record is Copyright © 2011 Nico Taing, Miso. It is free software, and may be redistributed under the terms specified in the MIT-LICENSE file.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+include Rake::DSL
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new("test") do |test|
+  test.pattern = "test/**/*_test.rb"
+  test.verbose = true
+end

data/lib/yaml_record/base.rb

@@ -0,0 +1,371 @@
+module YamlRecord
+  class Base  
+    attr_accessor :attributes, :is_created, :is_destroyed 
+    
+    include ActiveSupport::Callbacks
+    define_callbacks :before_save, :after_save, :before_destroy, :after_destroy, :before_validation, :before_create, :after_create
+    
+    before_create :set_id!
+
+    # Constructs a new YamlRecord instance based on specified attribute hash
+    #
+    # === Example:
+    #
+    #   class Post < YamlRecord::Base; properties :foo; end 
+    #
+    #   Post.new(:foo  => "bar")
+    #
+    def initialize(attr_hash={})
+      attr_hash.symbolize_keys!
+      attr_hash.reverse_merge!(self.class.properties.inject({}) { |result, key| result[key] = nil; result })
+
+      self.attributes ||= {}
+      self.is_created = attr_hash.delete(:persisted) || false
+      self.setup_properties!
+      attr_hash.each do |k,v|
+        self.send("#{k}=", v) # self.attributes[:media] = "foo"
+      end
+    end
+
+    # Accesses given attribute from YamlRecord instance
+    # 
+    # === Example:
+    #
+    #   @post[:foo] => "bar"
+    #
+    def [](attribute)
+      self.attributes[attribute]
+    end
+
+    # Assign given attribute from YamlRecord instance with specified value
+    # 
+    # === Example:
+    #
+    #   @post[:foo] = "baz"
+    #
+    def []=(attribute, value)
+      self.attributes[attribute] = value
+    end
+
+    # Saved YamlRecord instance to file
+    # Executes save and create callbacks
+    # Returns true if record saved; false otherwise
+    # 
+    # === Example:
+    #
+    #   @post.save => true
+    #
+    def save
+      run_callbacks(:before_save)
+      run_callbacks(:before_create) unless self.is_created
+
+      existing_items = self.class.all
+      if self.new_record?
+        existing_items << self 
+      else # update existing record
+        updated_item = existing_items.find { |item| item.id == self.id }
+        return false unless updated_item
+        updated_item.attributes = self.attributes
+      end
+
+      raw_data = existing_items ? existing_items.map { |item| item.persisted_attributes } : []
+      self.class.write_contents(raw_data) if self.valid? 
+
+      run_callbacks(:after_create) unless self.is_created
+      run_callbacks(:after_save)
+      true
+    rescue IOError
+      false
+    end
+    
+    # Update YamlRecord instance with specified attributes
+    # Returns true if record updated; false otherwise
+    # 
+    # === Example:
+    #
+    #   @post.update_attributes(:foo  => "baz", :miso => "awesome") => true
+    #
+    def update_attributes(updated_attrs={})
+      updated_attrs.each { |k,v| self.send("#{k}=", v) }
+      self.save
+    end
+    
+    # Returns array of instance attributes names; An attribute is a value stored for this record (persisted or not)
+    # 
+    # === Example:
+    #
+    #   @post.column_names => ["foo", "miso"]
+    #
+    def column_names
+      array = []
+      self.attributes.each_key { |k| array << k.to_s }
+      array
+    end
+    
+    # Returns hash of attributes to be persisted to file.
+    # A persisted attribute is a value stored in the file (specified with the properties declaration)
+    # 
+    # === Example:
+    #
+    #   class Post < YamlRecord::Base; properties :foo, :miso; end 
+    #   @post = Post.create(:foo => "bar", :miso => "great")
+    #   @post.persisted_attributes => { :id => "a1b2c3", :foo => "bar", :miso => "great" }
+    #
+    def persisted_attributes
+      self.attributes.slice(*self.class.properties).reject { |k, v| v.nil? }
+    end
+    
+    # Returns true if YamlRecord instance hasn't persisted; false otherwise
+    # 
+    # === Example:
+    #
+    #   @post = Post.new(:foo => "bar", :miso => "great")
+    #   @post.new_record?  =>  true
+    #   @post.save  => true
+    #   @post.new_record?  =>  false
+    #
+    def new_record?
+      !self.is_created
+    end
+
+    # Returns true if YamlRecord instance has been destroyed; false otherwise
+    # 
+    # === Example:
+    #
+    #   @post = Post.new(:foo => "bar", :miso => "great")
+    #   @post.destroyed?  =>  false
+    #   @post.save
+    #   @post.destroy  => true
+    #   @post.destroyed?  =>  true
+    #
+    def destroyed?
+      self.is_destroyed
+    end
+
+    # Remove a persisted YamlRecord object
+    # Returns true if destroyed; false otherwise
+    # 
+    # === Example:
+    #
+    #   @post = Post.create(:foo => "bar", :miso => "great")
+    #   Post.all.size => 1
+    #   @post.destroy  => true
+    #   Post.all.size => 0
+    #
+    def destroy
+      run_callbacks(:before_destroy)
+      new_data = self.class.all.reject { |item| item.persisted_attributes == self.persisted_attributes }.map { |item| item.persisted_attributes }
+      self.class.write_contents(new_data)
+      self.is_destroyed = true
+      run_callbacks(:after_destroy)
+      true
+    rescue IOError
+      false
+    end
+    
+    # Execute validations for instance
+    # Returns true if record is valid; false otherwise
+    # TODO Implement validation
+    # 
+    # === Example:
+    #
+    #   @post.valid? => true
+    #
+    def valid?
+      true
+    end
+    
+    # Returns errors messages if record isn't valid; empty array otherwise
+    # TODO Implement validation
+    # 
+    # === Example:
+    #
+    #   @post.errors => ["Foo can't be blank"]
+    #
+    def errors
+      []
+    end
+    
+    # Returns YamlRecord Instance
+    # Complies with ActiveModel api
+    # 
+    # === Example:
+    #
+    #   @post.to_model => @post
+    #
+    def to_model
+      self
+    end
+    
+    # Reload YamlRecord instance attributes from file
+    # 
+    # === Example:
+    #
+    #   @post = Post.create(:foo => "bar", :miso => "great")
+    #   @post.foo = "bazz"
+    #   @post.reload
+    #   @post.foo => "bar"
+    #
+    def reload
+      record = self.class.find(self.id)
+      self.attributes = record.attributes
+      record
+    end
+
+    # Find YamlRecord instance given attribute name and expected value
+    # Returns instance if found; false otherwise
+    # 
+    # === Example:
+    #
+    #   Post.find_by_attribute(:foo, "bar")  => @post
+    #
+    def self.find_by_attribute(attribute, expected_value)
+      self.all.find do |record|
+        value = record.send(attribute) if record.respond_to?(attribute)
+        value.is_a?(Array) ? 
+          value.include?(expected_value) :
+          value == expected_value
+      end
+    end
+    
+    class << self;
+      
+      # Find YamlRecord instance given id
+      # Returns instance if found; false otherwise
+      # 
+      # === Example:
+      #
+      #   Post.find_by_id("a1b2c3")  => @post
+      #
+      def find_by_id(value)
+        self.find_by_attribute(:id, value)
+      end
+      alias :find :find_by_id
+    end
+    
+    # Returns collection of all YamlRecord instances
+    # Caches results during request
+    # 
+    # === Example:
+    #
+    #   Post.all  => [@post1, @post2, ...]
+    #
+    def self.all
+      @records ||= begin
+        raw_items = YAML.load_file(source)
+        raw_items ? raw_items.map { |item| self.new(item.merge(:persisted => true)) } : []
+      end
+    end
+
+    # Find last YamlRecord instance given a limit
+    # Returns an array of instances if found; empty otherwise
+    # 
+    # === Example:
+    #
+    #   Post.last  => @post6
+    #   Post.last(3) => [@p4, @p5, @p6]
+    #
+    def self.last(limit=1)
+      limit == 1 ? self.all.last : self.all.last(limit)
+    end
+
+    # Find first YamlRecord instance given a limit
+    # Returns an array of instances if found; empty otherwise
+    # 
+    # === Example:
+    #
+    #   Post.first  => @post
+    #   Post.first(3) => [@p1, @p2, @p3]
+    #
+    def self.first(limit=1)
+      limit == 1 ? self.all.first : self.all.first(limit)
+    end
+    
+    # Initializes YamlRecord instance given an attribute hash and saves afterwards
+    # Returns instance if successfully saved; false otherwise
+    # 
+    # === Example:
+    #
+    #   Post.create(:foo => "bar", :miso => "great")  => @post
+    #
+    def self.create(attributes={})
+      @fs = self.new(attributes)
+      if @fs.save == true 
+        @fs.is_created = true;
+        @fs
+      else
+        false
+      end
+    end
+    
+    # Declares persisted attributes for YamlRecord class
+    # 
+    # === Example:
+    #
+    #   class Post < YamlRecord::Base; properties :foo, :miso; end
+    #   Post.create(:foo => "bar", :miso => "great")  => @post
+    #
+    def self.properties(*names)
+      names = names | [:id] if names.size > 0
+      names.size == 0 ? @_properties : @_properties = names
+    end
+    
+    # Declares source file for YamlRecord class
+    # 
+    # === Example:
+    #
+    #   class Post < YamlRecord::Base 
+    #     source "path/to/yaml/file"
+    #   end
+    #
+    def self.source(file=nil)
+      file ? @file = (file.to_s + ".yml") : @file
+    end
+    
+    protected
+    
+    # Validates each persisted attributes
+    # TODO Implement validation
+    #
+    def self.validates_each(*args, &block)
+      true
+    end
+    
+    # Write raw yaml data to file
+    # Protected method, not called during usage
+    # 
+    # === Example:
+    #
+    #   Post.write_content([{ :foo => "bar"}, { :foo => "baz"}, ...]) # writes to source file
+    #
+    def self.write_contents(raw_data)
+      File.open(self.source, 'w') {|f| f.write(raw_data.to_yaml) }
+      @records = nil
+    end
+    
+    # Creates reader and writer methods for each persisted attribute
+    # Protected method, not called during usage
+    # 
+    # === Example:
+    #
+    #   Post.setup_properties!
+    #   @post.foo = "baz"
+    #   @post.foo => "baz"
+    #
+    def setup_properties!
+     self.class.properties.each do |name|
+        self.class_eval do
+          define_method(name) { self[name.to_sym] }  # def media; self.attributes[:media]; end
+          define_method("#{name}=") { |val| self[name.to_sym] = val  }  # def media; self.attributes[:media]; end
+        end
+      end
+    end
+    
+    # Assign YamlRecord a unique id if not set
+    # Invoke before create of an instance
+    #
+    def set_id!
+      self.id = ActiveSupport::SecureRandom.hex(15)
+    end
+  end
+end

data/lib/yaml_record/version.rb

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

data/lib/yaml_record.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/kernel'
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/hash'
+require 'active_support/secure_random'
+require 'active_support/callbacks'
+require 'yaml'
+
+module YamlRecord
+  require File.dirname(__FILE__) + "/yaml_record/base"
+end

data/test/base_test.rb

@@ -0,0 +1,187 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class YamlObject < YamlRecord::Base
+  properties :title, :body, :child_ids
+  source File.dirname(__FILE__) + "/../tmp/yaml_object"
+end
+
+class BaseTest < Test::Unit::TestCase
+  
+  def setup 
+    @obj_title = "Simple Title"
+    @obj_id = "1234"
+    @obj2_id = "5678"
+    @obj2_title = "Simple Title 2"
+    
+    @attr = {
+      :child_ids  =>  [@obj_id],
+      :title =>  @obj_title,
+      :body => "Body!!"
+    }
+    
+    @attr2 = {
+      :child_ids  =>  [@obj2_id],
+      :title =>  @obj2_title,
+      :body => "Body!!"
+    }
+    
+    clean_yaml_record(YamlObject)
+    @fs = YamlObject.create(@attr)
+  end
+  
+  context "for instance methods" do
+    
+    context "for [] method" do
+      should("get  attribute with [attribute]"){ assert_equal @fs.title, @fs[:title] }
+    end
+    
+    context "for []= method" do
+      setup do
+        @fs[:title] = "Toto"
+      end
+      should("set attribute with [attribute]="){ assert_equal @fs[:title], "Toto" }
+    end
+  
+    context "for save method" do
+      setup do
+        @fs2 = YamlObject.new(@attr)
+        @fs2.save
+      end
+      
+      should("save on yaml file"){ assert_equal YamlObject.last.attributes.diff(@attr), {:id => @fs2.reload.id } }
+    end
+    
+    context "for update_attributes method" do
+      setup do 
+        @fs.update_attributes(:title => "Toto", :body  => "http://somewhereelse.com")
+        @fs.reload
+      end
+      should("update title") { assert_equal @fs.title, "Toto" }
+      should("update body") { assert_equal @fs.body, "http://somewhereelse.com"  }
+    end
+    
+    context "for column_names method" do
+      should("return an array with attributes names") { assert_equal @fs.column_names.sort!, YamlObject.properties.map { |p| p.to_s }.sort! }
+    end
+    
+    context "for persisted_attributes method" do
+      should("return persisted attributes") { assert_equal [:title, :body, :child_ids, :id ].sort_by {|sym| sym.to_s}, @fs.persisted_attributes.keys.sort_by {|sym| sym.to_s} }
+    end
+    
+    context "for new_record? method" do
+      setup do
+        @fs3 = YamlObject.new
+      end
+      should("be a new record") { assert @fs3.new_record? }
+      should("not be a new record") { assert_false @fs.new_record? }
+    end
+    
+    context "for destroyed? method" do
+      setup do
+        @fs4 = YamlObject.create(@attr)
+        @fs4.destroy
+      end
+      should("be a destoyed") { assert @fs4.destroyed? }
+      should("not be destroyed") { assert_false @fs.destroyed? }
+    end
+    
+    context "for destroy method" do
+      setup do 
+        @fs5 = YamlObject.create(@attr)
+        @fs5.destroy
+      end
+      should("not find @fs5"){ assert_nil YamlObject.find(@fs5.id) }
+    end
+    
+    context "for reload method" do
+      setup do
+        @fs.title = "Foo"
+      end
+      should("equal to Foo"){ assert_equal @fs.title, "Foo" }
+      should("equal to correct title"){ assert_equal @fs.reload.title, @obj_title }
+    end
+  end
+  
+  context "for class methods" do
+    context "for self.find_by_attribute method" do
+      setup do 
+        @fs_found = YamlObject.find_by_attribute(:title, @obj_title)
+      end
+      should("be same object as @fs"){ assert_equal @fs_found, YamlObject.find(@fs.id) }
+    end
+    
+    context "for self.find_by_id method" do
+      setup do
+        @fs_found = YamlObject.find_by_id(@fs.id)
+        @fs_found2 = YamlObject.find(@fs.id)
+      end
+      should("be same object as @fs"){ assert_equal @fs.attributes, @fs_found.attributes }
+      should("be same object as @fs bis"){ assert_equal @fs.attributes, @fs_found2.attributes }
+    end
+    
+    context "for self.all method" do
+      setup do 
+        clean_yaml_record(YamlObject)
+        @fs, @fs2 = YamlObject.create(@attr), YamlObject.create(@attr2)
+      end
+      should("retrieve 2 YamlObject obj"){ assert_equal YamlObject.all.size, 2 }
+      should("return as first item @fs"){ assert_equal YamlObject.all.first.attributes, @fs.attributes }
+      should("return as last item @fs2"){ assert_equal YamlObject.all.last.attributes, @fs2.attributes }
+    end
+    
+    context "for self.first method" do
+      setup do
+        clean_yaml_record(YamlObject)
+        @fs, @fs2 = YamlObject.create(@attr), YamlObject.create(@attr2)
+      end
+      
+      should("return @fs as the first item"){ assert_equal YamlObject.first.attributes, @fs.attributes }
+      should("return @fs"){ assert_equal YamlObject.first(2).first.attributes, @fs.attributes }
+      should("return @fs2"){ assert_equal YamlObject.first(2).last.attributes, @fs2.attributes }
+    end
+    
+    context "for self.last method" do
+      setup do
+        clean_yaml_record(YamlObject)
+        @fs, @fs2 = YamlObject.create(@attr), YamlObject.create(@attr2)
+      end
+      
+      should("return @fs as the first item"){ assert_equal YamlObject.last.attributes, @fs2.attributes }
+      should("return @fs"){ assert_equal YamlObject.last(2).first.attributes, @fs.attributes }
+      should("return @fs2"){ assert_equal YamlObject.last(2).last.attributes, @fs2.attributes }
+    end
+    
+    context "for self.write_contents method" do
+      setup do
+        clean_yaml_record(YamlObject)
+        @attributes = [ @attr, @attr2 ]
+        YamlObject.write_contents(@attributes)
+      end
+      should("write in yaml file"){ assert_equal YAML.load_file(YamlObject.source), [ @attr, @attr2 ] }
+    end
+    
+    context "for self.create method" do
+      setup do
+        clean_yaml_record(YamlObject)
+        @fs = YamlObject.create(@attr)
+        @fs_not_created = YamlObject.new(@attr)
+      end
+      should("create @fs"){ assert_equal YamlObject.last.attributes, @fs.attributes }
+      should("set its is_created to true"){ assert @fs.is_created }
+      should("set @fs_not_created is_created field  to false"){ assert_false @fs_not_created.is_created }
+    end
+    
+    context "for set_id!" do
+      setup do
+        @fs_no_id = YamlObject.new(@attr)
+        @fs_with_id = YamlObject.create(@attr)
+        @id = @fs_with_id.id
+        @fs_with_id.update_attributes(:title =>  "Gomiso")
+      end
+      should("not have any id"){ assert_nil @fs_no_id.id }
+      should("have a id"){ assert @fs_with_id.id }
+      should("keep the same id"){ assert_equal @fs_with_id.id, @id }
+    end
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require File.dirname(__FILE__) + "/../lib/yaml_record"
+
+class Test::Unit::TestCase
+  def clean_yaml_record(class_record)
+    File.open(class_record.source, 'w') {|f| f.write(nil) }
+  end
+  
+  # Asserts that the condition is not true
+  # assert_false @title == "hey"
+  def assert_false(condition, message=nil)
+    assert !condition, message
+  end
+end

data/yaml_record.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yaml_record/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yaml_record"
+  s.version     = YamlRecord::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nico Taing", "Nathan Esquenazi"]
+  s.email       = ["nico@gomiso.com"]
+  s.homepage    = "https://github.com/nico-taing/yaml_record"
+  s.summary     = %q{YAML file persistence engine}
+  s.description = %q{Use YAML for persisted data with ActiveModel interface}
+
+  s.rubyforge_project = "yaml_record"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency 'activesupport', '~> 2.3.11'
+  s.add_development_dependency 'rake', '~> 0.9.2'
+  s.add_development_dependency 'shoulda'
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification 
+name: yaml_record
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nico Taing
+- Nathan Esquenazi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-11 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 3
+        - 11
+        version: 2.3.11
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 9
+        - 2
+        version: 0.9.2
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Use YAML for persisted data with ActiveModel interface
+email: 
+- nico@gomiso.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/yaml_record.rb
+- lib/yaml_record/base.rb
+- lib/yaml_record/version.rb
+- test/base_test.rb
+- test/test_helper.rb
+- yaml_record.gemspec
+has_rdoc: true
+homepage: https://github.com/nico-taing/yaml_record
+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: yaml_record
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: YAML file persistence engine
+test_files: 
+- test/base_test.rb
+- test/test_helper.rb