plain_record 0.1 → 0.2

data/spec/callbacks_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe PlainRecord::Callbacks do
+  before :all do
+    module ::Fullname
+      include PlainRecord::Callbacks
+
+      def fullname(first, second)
+        use_callbacks(:fullname, first, second) do
+          first + ' ' + second
+        end
+      end
+    end
+  end
+
+  it "should use methods without callbacks" do
+    Class.new {
+      extend ::Fullname
+    }.fullname('John', 'Smith').should == 'John Smith'
+  end
+
+  it "should use before callbacks by priority" do
+    checker = mock()
+    checker.should_receive(:check_first).with('John', 'Smith').once.ordered
+    checker.should_receive(:check_last).with('John', 'Smith').once.ordered
+
+    Class.new {
+      extend ::Fullname
+
+      before :fullname, 2, &checker.method(:check_last)
+      before :fullname, 1, &checker.method(:check_first)
+    }.fullname('John', 'Smith').should == 'John Smith'
+  end
+
+  it "should use after callbacks by priority" do
+    adder = Class.new do
+      def self.add_first(full, first, last); full + ' ' + first.downcase end
+      def self.add_last(full, first, last);  full + ' ' + last.downcase  end
+    end
+
+    Class.new {
+      extend ::Fullname
+
+      after :fullname, 2, &adder.method(:add_last)
+      after :fullname, 1, &adder.method(:add_first)
+    }.fullname('John', 'Smith').should == 'John Smith john smith'
+  end
+
+  it "should set one callback for many events" do
+    klass = Class.new {
+      extend ::Fullname
+      before [:one, :two] do; end
+      before [:one, :two] do; end
+    }
+    klass.callbacks[:before].length.should == 2
+    klass.callbacks[:after].length.should == 2
+  end
+
+end

data/spec/data/1/comments.yml

@@ -0,0 +1,5 @@
+- author_name: super1997
+  text: Cool!
+  answers:
+  - author_name: john
+    text: Thanks

data/spec/data/2/{post.m → post.md}

@@ -1,3 +1,3 @@
 unknow_property: 1
---- 
+---
  only one

data/spec/data/3/post.md

@@ -0,0 +1,4 @@
+title: Third
+rate:
+  text: 2
+  subject: 5

data/spec/data/authors/extern.yml

@@ -1,3 +1,3 @@
 - name:  Anonymous
-- login: super1997
-  name:  SuperHacker
+- name:  SuperHacker
+  login: super1997

data/spec/data/authors/intern.yml

@@ -1,4 +1,4 @@
-- login: john
-  name:  John Smith
-- login: ivan
-  name:  Ivan Ivanov
+- name:  John Smith
+  login: john
+- name:  Ivan Ivanov
+  login: ivan

data/spec/data/best/4/post.md

@@ -0,0 +1 @@
+title: Best

data/spec/filepath_spec.rb

@@ -0,0 +1,53 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe PlainRecord::Filepath do
+
+  it "shouldn't create non-virtual filepath property" do
+    lambda {
+      Class.new do
+        include PlainRecord::Resource
+        entry_in 'data/*/post.md'
+        property :category, in_filepath(1)
+      end
+    }.should raise_error(ArgumentError, /virtual creator/)
+  end
+
+  it "should load filepath property" do
+    best = FilepathPost.first(:title => 'Best')
+    best.category.should == 'best/'
+    best.name.should == '4'
+  end
+
+  it "should load filepath property as nil when ** pattern is empty" do
+    FilepathPost.first(:title => 'First').category.should be_empty
+  end
+
+  it "should return more accurate path by filepath properties" do
+    FilepathPost.path(:name => 2).should == 'data/**/2/post.md'
+  end
+
+  it "should use filepath properties in search" do
+    FilepathPost.loaded = { }
+    FilepathPost.all(:category => 'best/')
+    FilepathPost.loaded.should have(1).keys
+  end
+
+  it "should load properties from model constructor" do
+    post = FilepathPost.new(:name => 5)
+    post.name.should == 5
+    post.category.should be_nil
+  end
+
+  it "should get entry path by filepath properties" do
+    path = File.join(File.dirname(__FILE__), 'data/5/post.md')
+    post = FilepathPost.new(:name => 5, :category => '')
+    FilepathPost.should_receive(:move_entry).with(post, nil, path)
+    post.save
+  end
+
+  it "should raise error, when can't get entry path by filepath properties" do
+    post = FilepathPost.new
+    lambda { post.save }.should raise_error(ArgumentError, /isn't file to save/)
+  end
+
+end

data/spec/model_spec.rb

@@ -1,33 +1,56 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe PlainRecord::Model do
-  
+
+  after :each do
+    Post.loaded   = { }
+    Author.loaded = { }
+  end
+
+  it "should define virtual property" do
+    klass = Class.new do
+      include PlainRecord::Resource
+      virtual :one, Definers.none
+    end
+
+    klass.virtuals.should == [:one]
+  end
+
+  it "shouldn't define virtual property without accessor from definers" do
+    lambda {
+      Class.new do
+        include PlainRecord::Resource
+        virtual :one, Definers.reader
+      end
+    }.should raise_error(ArgumentError, /own accessors/)
+  end
+
   it "should define property" do
     klass = Class.new do
       include PlainRecord::Resource
       property :one
     end
-    
+
     klass.properties.should == [:one]
-    object = klass.new(nil, {'one' => 1})
+    object = klass.new(nil, { 'one' => 1 })
     object.one.should == 1
     object.one = 2
     object.one.should == 2
   end
-  
+
   it "should define text" do
     klass = Class.new do
       include PlainRecord::Resource
       text :content
     end
-    
+
     klass.texts.should == [:content]
-    object = klass.new(nil, {}, ['text'])
+    object = klass.new(nil, { }, ['text'])
     object.content.should == 'text'
     object.content = 'another'
     object.content.should == 'another'
   end
-  
+
   it "should call definer" do
     klass = Class.new do
       include PlainRecord::Resource
@@ -38,7 +61,7 @@ describe PlainRecord::Model do
     end
     klass.should has_methods(:one, :'one=', :'three=', :two)
   end
-  
+
   it "should use accessors from definers" do
     klass = Class.new do
       include PlainRecord::Resource
@@ -47,25 +70,29 @@ describe PlainRecord::Model do
     end
     klass.should has_methods(:two)
   end
-  
-  it "should send property name to definer" do
+
+  it "should send property name and caller type to definer" do
     definer = mock
-    definer.stub!(:accessor).with(:one)
+    definer.stub!(:virtual).with(:one, :virtual)
+    definer.stub!(:property).with(:two, :property)
+    definer.stub!(:text).with(:three, :text)
     klass = Class.new do
       include PlainRecord::Resource
-      property :one, definer.method(:accessor)
+      virtual  :one,   definer.method(:virtual)
+      property :two,   definer.method(:property)
+      text     :three, definer.method(:text)
     end
   end
-  
+
   it "should find all enrty files by glob pattern" do
     klass = Class.new do
       include PlainRecord::Resource
-      entry_in 'data/*/post.m'
+      entry_in 'data/*/post.md'
     end
     klass.storage.should == :entry
     klass.files.sort.should == [FIRST, SECOND, THIRD]
   end
-  
+
   it "should find all list files by glob pattern" do
     klass = Class.new do
       include PlainRecord::Resource
@@ -74,40 +101,40 @@ describe PlainRecord::Model do
     klass.storage.should == :list
     klass.files.sort.should == [EXTERN, INTERN]
   end
-  
+
   it "should load YAML data from entry file" do
     obj = Post.load_file(FIRST)
     obj.should be_a(Post)
     obj.title.should == 'First'
-    
+
     obj = Post.load_file(SECOND)
     obj.should be_a(Post)
     obj.title.should be_nil
   end
-  
+
   it "should load text data from entry file" do
     post = Post.load_file(FIRST)
     post.summary.should == 'first --- content'
     post.content.rstrip.should == "big\n---\ncontent"
-    
+
     post = Post.load_file(SECOND)
     post.summary.rstrip.should == " only one"
     post.content.should be_nil
   end
-  
+
   it "should load data from list file" do
     authors = Author.load_file(EXTERN)
     authors.length.should == 2
-    
+
     authors[0].should be_a(Author)
     authors[0].login.should be_nil
     authors[0].name.should == 'Anonymous'
-    
+
     authors[1].should be_a(Author)
     authors[1].login.should == 'super1997'
     authors[1].name.should == 'SuperHacker'
   end
-  
+
   it "shouldn't define text data in model with list storage" do
     lambda {
       klass = Class.new do
@@ -117,58 +144,79 @@ describe PlainRecord::Model do
       end
     }.should raise_error /entry_in/
   end
-  
+
   it "should load all entries" do
-    Post.all.should == [SECOND_POST, THIRD_POST, FIRST_POST]
+    Post.all.should =~ [SECOND_POST, THIRD_POST, FIRST_POST]
   end
-  
+
   it "should return entries by string matcher" do
     Post.all(:title => 'First').should == [FIRST_POST]
   end
-  
+
   it "should return entries by regexp matcher" do
     Post.all(:title => /First/, :title => /Second/).should be_empty
   end
-  
+
   it "should return entries by search proc" do
-    Post.all { |i| not i.title.nil? }.should == [THIRD_POST, FIRST_POST]
+    Post.all { |i| not i.title.nil? }.should =~ [THIRD_POST, FIRST_POST]
   end
-  
+
   it "should return all list entries" do
-    Author.all.map { |i| i.login }.should == [nil, 'super1997', 'john', 'ivan']
+    Author.all.map { |i| i.login }.should =~ [nil, 'super1997', 'john', 'ivan']
   end
-  
+
   it "should return first entry" do
     Post.first.should be_a(Post)
   end
-  
+
   it "should return entry by string matcher" do
     Post.first(:title => 'Third').should == THIRD_POST
   end
-  
+
   it "should return entry by regexp matcher" do
-    Post.first(:title => /First|Third/).should == THIRD_POST
+    Post.first(:title => /First/).should == FIRST_POST
   end
-  
+
   it "should return entry by search proc" do
     Post.first { |i| false }.should be_nil
   end
-  
+
   it "should return first list entry" do
-    Author.first { |i| not i.login.nil? }.name.should == 'SuperHacker'
+    Author.first { |i| not i.login.nil? and i.type == 'extern' }.
+      name.should == 'SuperHacker'
   end
-  
+
   it "should delete file, cache and empty dirs" do
     File.should_receive(:delete).with(FIRST)
-    
+
     first_dir = File.dirname(FIRST)
     Dir.should_receive(:entries).with(first_dir).and_return(['.', '..'])
     Dir.should_receive(:rmdir).with(first_dir)
     Dir.should_receive(:entries).with(File.dirname(first_dir)).and_return(
         ['.', '..', '2', '3'])
-    
+
     Post.instance_eval { delete_file(FIRST) }
     Post.loaded.should_not have_key(FIRST)
   end
-  
+
+  it "should move entry from one file to another" do
+    first = Post.first(:title => 'First')
+    Post.should_receive(:delete_file).with(FIRST)
+    Post.should_receive(:save_file).with(PlainRecord.root('file'))
+    first.file = 'file'
+    first.save
+  end
+
+  it "should move list entry from one file to another" do
+    Author.should_receive(:save_file).with(INTERN).once
+    Author.should_receive(:save_file).with(PlainRecord.root('file')).twice
+    Author.should_receive(:delete_file).with(INTERN).once
+
+    authors = Author.all(:login => /john|ivan/)
+    authors.each do |author|
+      author.file = 'file'
+      author.save
+    end
+  end
+
 end

data/spec/resource_spec.rb

@@ -1,27 +1,33 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe PlainRecord::Resource do
-  
+
+  after :each do
+    Post.loaded   = { }
+    Author.loaded = { }
+  end
+
   it "should compare two object" do
-    first = Post.load_file(FIRST)
-    another_first = Post.load_file(FIRST)
-    second = Post.load_file(SECOND)
-    
-    first.should == another_first
+    first   = Post.load_file(FIRST)
+    another = Post.load_file(FIRST)
+    second  = Post.load_file(SECOND)
+
+    first.should == another
     first.should_not == second
   end
-  
+
   it "should remeber it file" do
     Post.load_file(FIRST).file.should == FIRST
+    Post.load_file(FIRST).path.should == 'data/1/post.md'
   end
-  
+
   it "should save entry" do
     file = StringIO.new
     File.should_receive(:open).with(FIRST, 'w').and_yield(file)
-    
+
     first = Post.first(:title => 'First')
     first.save
-    
+
     file.rewind
     file.read.should == "title: First\n" +
                         "---\n" +
@@ -31,39 +37,76 @@ describe PlainRecord::Resource do
                         "---\n" +
                         "content\n"
   end
-  
+
   it "should save list entry" do
     file = StringIO.new
+    Author.all
     File.should_receive(:open).with(INTERN, 'w').and_yield(file)
-    
+
     john = Author.first(:login => 'john')
     john.save
-    
-    file.rewind
-    file.read.should == "- login: john\n" +
-                        "  name: John Smith\n" +
-                        "- login: ivan\n" +
-                        "  name: Ivan Ivanov\n"
+
+    file.should has_yaml([
+      { 'name' => 'John Smith',  'login' => 'john' },
+      { 'name' => 'Ivan Ivanov', 'login' => 'ivan' }
+    ])
   end
-  
+
   it "should delete entry" do
     Post.should_receive(:delete_file).with(FIRST)
     Post.first(:title => 'First').destroy
   end
-  
+
+  it "should save entry without file if model use only one file" do
+    class Model
+      include PlainRecord::Resource
+      list_in 'file.yml'
+    end
+
+    path = PlainRecord.root('file.yml')
+    File.should_receive(:open).with(path, 'w').and_yield(StringIO.new)
+    Model.new.save
+  end
+
   it "should delete list entry" do
     file = StringIO.new
+    Author.all
     File.should_receive(:open).with(INTERN, 'w').and_yield(file)
-    
+
     Author.first(:login => 'john').destroy
-    
+
     Author.first(:login => 'john').should be_nil
-    file.rewind
-    file.read.should == "- login: ivan\n" +
-                        "  name: Ivan Ivanov\n"
-    
+
+    file.should has_yaml([{ 'name' => 'Ivan Ivanov', 'login' => 'ivan' }])
+
     Author.should_receive(:delete_file).with(INTERN)
     Author.first(:login => 'ivan').destroy
   end
-  
+
+  it "should call callbacks" do
+    class Callbacked
+      include PlainRecord::Resource
+      entry_in 'data/*/post.md'
+      property :title
+      text :summary
+      text :content
+    end
+
+    callbacks  = mock()
+    callbacks.should_receive(:path).
+      with(Callbacked.path, { :title => 'First' }).and_return('data/1/post.md')
+    callbacks.should_receive(:load).with(an_instance_of Callbacked)
+    callbacks.should_receive(:save).with(an_instance_of Callbacked).and_raise
+    callbacks.should_receive(:destroy).with(an_instance_of Callbacked).and_raise
+
+    Callbacked.after  :path,    &callbacks.method(:path)
+    Callbacked.before :load,    &callbacks.method(:load)
+    Callbacked.before :save,    &callbacks.method(:save)
+    Callbacked.before :destroy, &callbacks.method(:destroy)
+
+    first = Callbacked.first({ :title => 'First' })
+    lambda { first.save }.should raise_error
+    lambda { first.destroy }.should raise_error
+  end
+
 end

data/spec/spec_helper.rb

@@ -2,43 +2,62 @@ require File.join(File.dirname(__FILE__), '../lib/plain_record')
 
 class Post
   include PlainRecord::Resource
-  
-  entry_in 'data/*/post.m'
-  
+
+  entry_in 'data/*/post.md'
+
   property :title
   text :summary
   text :content
 end
 
+class FilepathPost
+  include PlainRecord::Resource
+
+  entry_in 'data/**/*/post.md'
+
+  virtual :category, in_filepath(1)
+  virtual :name,     in_filepath(2)
+
+  property :title
+end
+
 class Author
   include PlainRecord::Resource
-  
+
   list_in 'data/authors/*.yml'
-  
+
+  virtual  :type, in_filepath(1)
   property :login
   property :name
 end
 
 PlainRecord.root = File.dirname(__FILE__)
 
-FIRST  = File.join(File.dirname(__FILE__), 'data/1/post.m')
-SECOND = File.join(File.dirname(__FILE__), 'data/2/post.m')
-THIRD  = File.join(File.dirname(__FILE__), 'data/3/post.m')
-FIRST_POST = Post.load_file(FIRST)
+FIRST  = File.join(File.dirname(__FILE__), 'data/1/post.md')
+SECOND = File.join(File.dirname(__FILE__), 'data/2/post.md')
+THIRD  = File.join(File.dirname(__FILE__), 'data/3/post.md')
+FIRST_POST  = Post.load_file(FIRST)
 SECOND_POST = Post.load_file(SECOND)
-THIRD_POST = Post.load_file(THIRD)
+THIRD_POST  = Post.load_file(THIRD)
 
 INTERN = File.join(File.dirname(__FILE__), 'data/authors/intern.yml')
 EXTERN = File.join(File.dirname(__FILE__), 'data/authors/extern.yml')
 
 def model_methods(model)
-    model.instance_methods - Object.instance_methods -
-        PlainRecord::Resource.instance_methods
+    (model.instance_methods - Object.instance_methods -
+        PlainRecord::Resource.instance_methods).map { |i| i.to_s }
 end
 
-Spec::Matchers.define :has_methods do |*methods|
+RSpec::Matchers.define :has_methods do |*methods|
   match do |model|
-    model_methods(model).sort == methods.sort
+    model_methods(model).sort == methods.map! { |i| i.to_s }.sort
+  end
+end
+
+RSpec::Matchers.define :has_yaml do |data|
+  match do |file|
+    file.rewind
+    YAML.load(file.read).should == data
   end
 end