yaml_record_rails_4 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7c8d16d47aacc32b9e9872265a47b59692127196
+  data.tar.gz: f5aa8767e80cf7b8d82a69e9dae554e6a3073c6a
+SHA512:
+  metadata.gz: 649b1d603d11fcbc1ca96795f97f8db64ddea172989d50bc3b0dc648b49f8240bf160916fb5dc93ce43ec57101ac16277cc7a015171eb85afb31b9bdd80ddf0b
+  data.tar.gz: 843b4a98521e65482e2dfaafcbb2843546b2b845d274d78a7fce68d433b224faaf8c37babdc41433130bcf98c1ff113c4c6ada2e79b5542d50e2fb83a2de1893

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,212 @@
+# 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:
+
+```bash
+gem install yaml_record
+```
+
+Or add gem to your Gemfile:
+
+```ruby
+# Gemfile
+gem 'yaml_record'
+# OR if you're using Rails 3.1
+gem 'yaml_record' :git => "git@github.com:Nico-Taing/yaml_record.git", :branch => "rails31"
+```
+
+## 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 your adapter (local by default)
+  adapter :local # or :redis
+  
+  # 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
+```
+
+## Storage Adapters ##
+
+YAMLRecord supports pluggable storage adapters that control the storage engine used for the YAML data. By default, the adapter used is the 
+`local` store which writes a file (specified by `source` path) to the local system. There are currently two available adapters: `Local` and `Redis`. 
+
+To configure the adapter, you can simply declare within the object:
+
+```ruby
+class Submission < YamlRecord::Base
+  adapter :redis, $redis # Second parameter is the redis client instance
+  source "contacts" # stores yaml namespaced as 'yaml_record:contacts' in redis
+end
+```
+
+Each storage adapter only defines a `read` and `write` interface and is easy to create. 
+Checkout the [redis adapter](https://github.com/Nico-Taing/yaml_record/blob/master/lib/yaml_record/adapters/redis_store.rb) for an example of how simple they are to define.
+Feel free to create additional adapters and send them to us via a pull request.
+
+## 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 your adapter (local by default)
+  adapter :local # or :redis
+  
+  # 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
+
+Special thanks to [Vaudoc](https://github.com/vaudoc)
+
+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/adapters/local_store.rb

@@ -0,0 +1,40 @@
+# YAML Adapter for using a local file store
+
+module YamlRecord
+  module Adapters
+    class LocalStore
+
+      # Returns YAML File as ruby collection
+      #
+      # === Example:
+      #
+      #   @adapter.read("foo") => [{...}, {...}]
+      #
+      def read(source, dynamic_source, source_file_name)
+        dir_path = source + dynamic_source
+        full_path = dir_path + source_file_name
+
+        Dir::mkdir(dir_path) unless File.directory?(dir_path)
+        File.open(full_path, 'w') unless File.exists?(full_path)
+
+        YAML.load_file(source + dynamic_source + source_file_name)
+      end
+
+      # Writes ruby collection as YAML File
+      #
+      # === Example:
+      #
+      #   @adapter.write("foo", [{...}, {...}]) => "<yaml data>"
+      #
+      def write(source, source_file_name, dynamic_source, collection)
+        dir_path = source + dynamic_source
+        full_path = dir_path + source_file_name
+
+        Dir::mkdir(dir_path) unless File.directory?(dir_path)
+        File.open(full_path, 'w') unless File.exists?(full_path)
+        
+        File.open(source + dynamic_source + source_file_name, 'w') {|f| f.write(collection.to_yaml) }
+      end
+    end
+  end
+end

data/lib/yaml_record/adapters/redis_store.rb

@@ -0,0 +1,42 @@
+# YAML Adapter for using a redis client store
+# YamlRecord::Adapters::RedisStore.new(@redis)
+
+module YamlRecord
+  module Adapters
+    class RedisStore
+      attr_reader :client
+
+      # client is an instantiated redis client (i.e Redis::Client.new(...))
+      def initialize(client)
+        raise "Please specify a Redis client" unless client
+        @client = client
+      end
+
+      # Returns Redis YML data as ruby collection
+      #
+      # === Example:
+      #
+      #   @adapter.read("foo") => [{...}, {...}]
+      #
+      def read(source)
+        YAML.load(@client.get(redis_key(source)).to_s)
+      end
+
+      # Writes ruby collection as Redis YML data
+      #
+      # === Example:
+      #
+      #   @adapter.write("foo", [{...}, {...}]) => "<yaml data>"
+      #
+      def write(source, collection)
+        @client.set(redis_key(source), collection.to_yaml)
+      end
+
+      private
+
+      def redis_key(source)
+        "yaml_record:" + source
+      end
+    end
+  end
+end

data/lib/yaml_record/base.rb

@@ -0,0 +1,425 @@
+require 'active_model'
+
+module YamlRecord
+  class Base
+    attr_accessor :attributes, :is_created, :is_destroyed
+
+    include ActiveModel::Conversion
+    include ActiveModel::Validations
+    include ActiveModel::Callbacks
+    include ActiveModel::Validations::Callbacks
+
+    define_model_callbacks :create, :save, :destroy, :update, :validation, :initialize
+
+    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
+      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(:save) { false }
+      run_callbacks(:create) { false } unless self.is_created
+
+      existing_items = self.class.all(dynamic_source)
+      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(dynamic_source, raw_data) if self.valid?
+
+      run_callbacks(:create) { true } unless self.is_created
+      run_callbacks(:save) { true }
+      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) { false }
+      new_data = self.class.all.reject { |item| item.persisted_attributes == self.persisted_attributes }.map { |item| item.persisted_attributes }
+      self.class.write_contents(dynamic_source, new_data)
+      self.is_destroyed = true
+      run_callbacks(:destroy) { true }
+      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
+
+    # 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(dynamic_source='default', attribute, expected_value)
+      self.all(dynamic_source).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(dynamic_source='default', value)
+        self.find_by_attribute(dynamic_source, :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(dynamic_source='default')
+      raw_items = self.adapter.read(self.source, dynamic_source, self.source_file_name) || []
+      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(dynamic_source='default', limit=1)
+      limit == 1 ? self.all(dynamic_source).last : self.all(dynamic_source).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(dynamic_source='default', limit=1)
+      limit == 1 ? self.all(dynamic_source).first : self.all(dynamic_source).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 or retrieves adapter for Yaml storage
+    # Returns an instance of an adapter
+    #
+    # === Example:
+    #
+    #   class Post < YamlRecord::Base
+    #     adapter :redis, @redis #  => YamlRecord::Adapters::RedisAdapter
+    #   end
+    #
+    def self.adapter(kind=nil, *options)
+      kind.nil? ? @_adapter_kind ||= :local : @_adapter_kind = kind
+      @_adapter ||= eval("YamlRecord::Adapters::#{@_adapter_kind.to_s.capitalize}Store").new(*options)
+    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
+    end
+
+    # Declares source_file_name for YamlRecord class
+    #
+    # === Example:
+    #
+    #   class Post < YamlRecord::Base
+    #     source_file_name "file_name"
+    #   end
+    #
+    def self.source_file_name(source_file_name=nil)
+      source_file_name ? @source_file_name = (source_file_name.to_s + ".yml") : @source_file_name
+    end
+
+    # Overrides equality to match if matching ids
+    #
+    def ==(comparison_record)
+      self.id == comparison_record.id
+    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(dynamic_source, raw_data)
+      self.adapter.write(self.source, self.source_file_name, dynamic_source, raw_data)
+      @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.1.0"
+end

data/lib/yaml_record_rails_4.rb

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

data/test/base_test.rb

@@ -0,0 +1,216 @@
+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 self.adapter method" do
+      should("return local adapter") do
+        class YamlOtherObject < YamlRecord::Base; end
+        assert_kind_of YamlRecord::Adapters::LocalStore, YamlOtherObject.adapter
+      end
+      should("support explicit local adapter") do
+        YamlObject.adapter(:local)
+        assert_kind_of YamlRecord::Adapters::LocalStore, YamlObject.adapter
+      end
+      should("support changing adapter") do
+        class YamlRedisObject < YamlRecord::Base; end
+        @object = Object.new
+        YamlRedisObject.adapter(:redis, @object)
+        assert_kind_of YamlRecord::Adapters::RedisStore, YamlRedisObject.adapter
+        assert_equal @object, YamlRedisObject.adapter.client
+        class YamlOtherObject < YamlRecord::Base; end
+        assert_kind_of YamlRecord::Adapters::LocalStore, YamlOtherObject.adapter
+      end
+      should("not support invalid adapter") do
+        assert_raise(NameError) { class YamlFakeObject < YamlRecord::Base; adapter(:fake); end }
+      end
+    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_rails_4"
+  s.version     = YamlRecord::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nico Taing", "Nathan Esquenazi", 'Ruslan Hamidullin', 'Eduard Gataullin']
+  s.email       = ["edikgat@gmail.com"]
+  s.homepage    = "https://github.com/edikgat/yaml_record/tree/rails4"
+  s.summary     = %q{This gem is a fork to gem yaml_record with rails 4 support}
+  s.description = %q{Use YAML for persisted data with ActiveModel interface}
+
+  s.rubyforge_project = "yaml_record_rails_4"
+
+  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.0.0'
+  s.add_development_dependency 'rake', '~> 1.5.2'
+  s.add_development_dependency 'shoulda'
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: yaml_record_rails_4
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nico Taing
+- Nathan Esquenazi
+- Ruslan Hamidullin
+- Eduard Gataullin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.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:
+- edikgat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/yaml_record/adapters/local_store.rb
+- lib/yaml_record/adapters/redis_store.rb
+- lib/yaml_record/base.rb
+- lib/yaml_record/version.rb
+- lib/yaml_record_rails_4.rb
+- test/base_test.rb
+- test/test_helper.rb
+- yaml_record.gemspec
+homepage: https://github.com/edikgat/yaml_record/tree/rails4
+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: yaml_record_rails_4
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: This gem is a fork to gem yaml_record with rails 4 support
+test_files: []