yaml_record4 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fbf3ac61a8c2cad6bc2bd097c5e08c0fd02c2f82
+  data.tar.gz: 4e4cea5900e52aa4885093b69bee89215322331a
+SHA512:
+  metadata.gz: 138dfcfb209574bef2735f56731eafdf24c9374135d067e50a3d5a928caeee25b20996ee538c89ba2f41f1ebaa5342693768544c581cdf0c85423349ed32ba27
+  data.tar.gz: 5ae126e0f749cb9825b077cf0545db92109f217e3d24db6f3321ad0e0b2f0ce26c0b2f4d50655cdd9f1305e8fd84fb512304026f180caf32dc7eb3713f9ea0a3

data/.gitignore

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

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use ruby-1.9.2-p180@sandbox #> /dev/null

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://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,180 @@
+# YAML RECORD #
+
+## Introduction ##
+
+YAML Record is a data persistence library that complies with the ActiveModel API. Using YAMLRecord should be familiar to anyone that has used ActiveRecord before to manage your database. Using this library, the data is persisted in a YAML backed file.
+
+## Rationale ##
+
+*Why a YAML-based persistence store?* In certain situations, there are collections of simple data in which there are very few records which are by nature infrequently accessed and that are ideally able to be scanned easily within a text file. These can include a simple contact form, landing page interest, feedback forms, surveys, team pages, etc where there is simply no need for the overhead of a fully persisted database solution.
+
+There are many cases where YAMLRecord is **not the correct** persistence strategy. Any collection that is going to have substantial number of records, will be frequently updated, or is accessible by a large volume of users should not be stored in a YAML text file for obvious reasons. However, for specific cases, the convenience of storing things in a simple text file becomes apparent. Being able to access the text file data as if the records were in a familiar database ORM has many conveniences and advantages such as keeping the controllers standard and leveraging existing ORM knowledge.
+
+## Installation ##
+
+Install using rubygems:
+
+    gem install yaml_record
+
+Or add gem to your Gemfile:
+
+    # Gemfile
+    gem 'yaml_record'
+
+## Usage ##
+
+### Declaration ###
+
+Create any ruby object and inherit from `YamlRecord:Base` to define a type:
+
+```ruby
+class Post < YamlRecord::Base
+  # Declare your properties
+  properties :title, :body, :user_id
+
+  # Declare source file path
+  source Rails.root.join("config/posts")
+end
+```
+
+Use this new object the same way as any ActiveRecord object.
+
+### Retrieval ###
+
+Retrieve the collection:
+
+    Post.all => [@p1, @p2]
+
+Retrieve item by id:
+
+    Post.find("a1b2") => @p1
+
+Retrieve by attribute:
+
+    Post.find_by_attribute(:title, "some title") => @p
+
+### Create ###
+
+Initialize post:
+
+    @p = Post.new(:title => "...", :body => "...", :user_id => 5)
+    @p.save
+
+Create post:
+
+    @p = Post.create(:title => "...", :body => "...", :user_id => 6)
+
+### Update ###
+
+Update attributes using the expected method:
+
+    @p.update_attributes(:title => "new title")
+
+### Destroy ###
+
+Destroy a given record:
+
+    @p.destroy
+
+### Access ###
+
+Access attributes:
+
+    @p = Post.find("a1b2")
+    @p.title => "..."
+
+Assign attributes:
+
+    @p.title = "new title"
+    @p.save
+
+### Callbacks ###
+
+Create callbacks:
+
+```ruby
+class Submission < YamlRecord::Base
+  # ...
+  before_create :do_something # or before_save, before_destroy, ...
+
+  def do_something
+    # something here
+  end
+end
+```
+
+## Example ##
+
+Imagine a simple contact form that accepts a name and email from a user along with a body:
+
+```ruby
+class Submission < YamlRecord::Base
+  # Declare your properties
+  properties :name, :email, :body
+
+  # Declare source file path (config/contact.yml)
+  source Rails.root.join("config/contact")
+end
+```
+
+Once we define the Contact model, we can setup a controller and form just the same as in ActiveRecord:
+
+```ruby
+class SubmissionsController < AC::Base
+  def create
+    @submission = Submission.create(params[:submission])
+  end
+
+  def index
+    @submissions = Submission.all
+  end
+
+  def show
+    @submission = Submission.find(params[:id])
+  end
+
+  def update
+    @submission = Submission.find(params[:id])
+    @submission.update_attributes(params[:submission])
+  end
+
+  def destroy
+    @submission = Submission.find(params[:id])
+    @submission.destroy
+  end
+end
+```
+
+As you can see the controller appears the same as any ActiveRecord controller would and this makes managing the YAML data easy and convenient. You can even define callbacks in your object as you would in ActiveRecord:
+
+```ruby
+class Submission < YamlRecord::Base
+  # ...
+  before_create :do_something # or before_save, before_destroy, ...
+
+  def do_something
+    # something here
+  end
+end
+```
+
+And that's all! Each record will be persisted to the source file for easy access.
+
+## Issues ##
+
+ * Validations should be supported `validates_presence_of :name`
+ * Property type declarations should be available `property :age, Integer`
+
+## Contributors ##
+
+Created at Miso by Nico Taing and Nathan Esquenazi
+
+Contributors and patches are welcome! Please send a pull request!
+
+## Notes ##
+
+There is already an excellent project for YAML persistence if you are using [Datamapper](https://github.com/datamapper/dm-yaml-adapter). In the situation in which we were using DM and [Padrino](http://padrinorb.com), this would surely be a better choice. But if you are using ActiveRecord and Rails, this library is a lightweight and standalone solution.
+
+## 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,388 @@
+# coding: utf-8
+
+require 'yaml'
+require 'securerandom'
+
+#require 'active_support'
+require 'active_support/core_ext/kernel'
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/hash'
+
+require 'active_model'
+
+module YamlRecord
+  class Base
+    include ActiveModel::Validations
+    extend ActiveModel::Naming # Required dependency for ActiveModel::Errors
+    extend ActiveModel::Callbacks
+
+    define_model_callbacks :save, :create, :destroy, :only => [:after, :before]
+
+    before_create :set_id!
+
+    attr_accessor :attributes, :is_created, :is_destroyed
+    attr_reader   :errors
+
+    # 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
+      attr_hash.each do |k,v|
+        self.send("#{k}=", v) # self.attributes[:media] = "foo"
+      end
+
+      @errors = ActiveModel::Errors.new(self)
+    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
+      block = lambda do
+        run_callbacks(:save) do
+          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?
+        end
+      end
+
+      self.is_created ? block.call : run_callbacks(:create) { block.call }
+      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(:destroy) do
+        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
+      end
+      true
+    rescue IOError
+      false
+    end
+
+    # Returns YamlRecord Instance
+    # Complies with ActiveModel api
+    #
+    # === Example:
+    #
+    #   @post.to_model => @post
+    #
+    def to_model
+      self
+    end
+
+    # Returns the instance of a record as a parameter
+    # By default return an id
+    #
+    # === Example:
+    #
+    #   @post.to_param => <id>
+    #
+    def to_param
+      self.id
+    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
+    # Supports checking inclusion for array based values
+    # Returns instance if found; false otherwise
+    #
+    # === Example:
+    #
+    #   Post.find_by_attribute(:foo, "bar")         => @post
+    #   Post.find_by_attribute(:some_list, "item")  => @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, ...]
+    #   Post.all(true) => (...force reload...)
+    #
+    def self.all
+      begin
+        raw_items = YAML.load_file(source)
+      rescue Errno::ENOENT
+      ensure
+        raw_items ||= []
+      end
+      raw_items.map { |item| self.new(item.merge(:persisted => true)) }
+    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)
+      @_properties ||= []
+      if names.size == 0 # getter
+        @_properties
+      elsif names.size > 0 # setter
+        names = names | [:id]
+        setup_properties!(*names)
+        @_properties += names
+      end
+    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 : File.join(YamlRecord.root_path, "#{model_name.name}.yml")
+    end
+
+    # Overrides equality to match if matching ids
+    #
+    def ==(comparison_record)
+      self.id == comparison_record.id
+    end
+
+    protected
+
+    # 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!(:foo)
+    #   @post.foo = "baz"
+    #   @post.foo => "baz"
+    #
+    def self.setup_properties!(*names)
+      names.each do |name|
+        define_method(name) { self[name.to_sym] }
+        define_method("#{name}=") { |val| self[name.to_sym] = val  }
+      end
+    end
+
+    # Assign YamlRecord a unique id if not set
+    # Invoke before create of an instance
+    # Protected method, not called during usage
+    #
+    def set_id!
+      self.id ||= SecureRandom.hex(15)
+    end
+  end
+end

data/lib/yaml_record/version.rb

@@ -0,0 +1,3 @@
+module YamlRecord
+  VERSION = '0.0.5'
+end

data/lib/yaml_record.rb

@@ -0,0 +1,9 @@
+require 'yaml_record/base'
+
+require 'active_support/core_ext/module/attribute_accessors'
+
+module YamlRecord
+  mattr_accessor :root_path do
+    Dir.tmpdir
+  end
+end

data/test/base_test.rb

@@ -0,0 +1,193 @@
+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
+
+    context "for to_param method" do
+      setup { @fs.id = "a1b2c3" }
+
+      should("return id of record") { assert_equal(@fs.to_param, @fs.id) }
+    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,17 @@
+require 'rubygems'
+require 'minitest/autorun'
+#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='')
+    assert !condition, message
+  end
+end

data/yaml_record.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yaml_record/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yaml_record4"
+  s.version     = YamlRecord::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nico Taing", "Nathan Esquenazi", "Thierry Zires"]
+  s.email       = ["zshuaibin@gmail.com"]
+  s.homepage    = "https://github.com/zires/yaml_record/tree/rails41"
+  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',       '~>4.1'
+  s.add_dependency 'activemodel',         '~>4.1'
+  s.add_development_dependency 'rake',    '~>0.9.2'
+  s.add_development_dependency 'shoulda'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: yaml_record4
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Nico Taing
+- Nathan Esquenazi
+- Thierry Zires
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use YAML for persisted data with ActiveModel interface
+email:
+- zshuaibin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- 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
+homepage: https://github.com/zires/yaml_record/tree/rails41
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: YAML file persistence engine
+test_files:
+- test/base_test.rb
+- test/test_helper.rb
+has_rdoc: