plain_record 0.1.0 → 0.2

data/lib/plain_record/model/entry.rb

@@ -30,19 +30,31 @@ module PlainRecord
         end
         @loaded[file]
       end
-      
-      def each_entry
-        files.each do |file|
+
+      def each_entry(matcher = { })
+        files(matcher).each do |file|
           yield load_file(file)
         end
       end
-      
+
+      def delete_entry(file, entry = nil)
+        delete_file(file)
+      end
+
+      def move_entry(entry, from, to)
+        if from
+          @loaded.delete(from)
+          delete_file(from)
+        end
+        @loaded[to] = entry
+      end
+
       private
-      
-      def all_entries
-        files.map { |file| load_file(file) }
+
+      def all_entries(matcher = { })
+        files(matcher).map { |file| load_file(file) }
       end
-      
+
       def entries_string(entry)
         entry.to_yaml + entry.texts.map{ |i| "---\n" + i }.join("\n")
       end

data/lib/plain_record/model/list.rb

@@ -29,21 +29,43 @@ module PlainRecord
         end
         @loaded[file]
       end
-      
-      def each_entry
-        files.each do |file|
+
+      def each_entry(matcher = { })
+        files(matcher).each do |file|
           load_file(file).each do |entry|
             yield entry
           end
         end
       end
-      
+
+      def delete_entry(file, entry = nil)
+        if entry.nil? or 1 == @loaded[file].length
+          delete_file(file)
+        else
+          @loaded[file].delete(entry)
+          save_file(file)
+        end
+      end
+
+      def move_entry(entry, from, to)
+        if from
+          @loaded[from].delete(entry)
+          if @loaded[from].empty?
+            delete_file(from)
+          else
+            save_file(from)
+          end
+        end
+        @loaded[to] = [] unless @loaded.has_key? to
+        @loaded[to] << entry
+      end
+
       private
-      
-      def all_entries
-        files.map { |file| load_file(file) }.flatten
+
+      def all_entries(matcher = { })
+        files(matcher).map { |file| load_file(file) }.flatten
       end
-      
+
       def entries_string(entries)
         entries.to_yaml
       end

data/lib/plain_record/resource.rb

@@ -21,11 +21,27 @@ module PlainRecord
   # Module to be included into model class. Contain instance methods. See
   # Model for class methods.
   #
+  # You can set your callbacks before and after some methods/events:
+  # * <tt>path(matchers)</tt> – return file names for model which is match for
+  #   matchers;
+  # * <tt>load(enrty)</tt> – load or create new entry;
+  # * <tt>destroy(entry)</tt> – delete entry;
+  # * <tt>save(entry)</tt> – write entry to file.
+  # See PlainRecord::Callbacks for details.
+  #
+  # You can define properties  from entry file path, by +in_filepath+ definer.
+  # See PlainRecord::Filepath for details.
+  #
   #   class Post
   #     include PlainRecord::Resource
-  #     
-  #     entry_in '/content/*/post.m'
-  #     
+  #
+  #     entry_in 'content/*/post.md'
+  #
+  #     before :save do |enrty|
+  #       entry.title = Time.now.to.s unless entry.title
+  #     end
+  #
+  #     virtual :name, in_filepath(1)
   #     property :title
   #     text :summary
   #     text :content
@@ -36,38 +52,80 @@ module PlainRecord
         base.send :extend, Model
       end
     end
-    
+
     # Properties values.
     attr_reader :data
-    
+
     # Texts values.
     attr_reader :texts
-    
+
     # File, where this object is stored.
-    attr_reader :file
-    
+    attr_accessor :file
+
     # Create new model instance with YAML +data+ and +texts+ from +file+.
-    def initialize(file, data, texts = [])
-      @file = file
-      @data = data
-      @texts = texts
+    def initialize(file = nil, data = { }, texts = [])
+      self.class.use_callbacks(:load, self) do
+        texts, data = data, nil if data.is_a? Array
+        data,  file = file, nil if file.is_a? Hash
+
+        @file  = file
+        @data  = data
+        @texts = texts
+      end
+    end
+
+    # Set path to entry storage. File should be in <tt>PlainRecord.root</tt> and
+    # can be relative.
+    def file=(value)
+      if PlainRecord.root != value.slice(0...PlainRecord.root.length)
+        value = PlainRecord.root(value)
+      end
+
+      if @file != value
+        self.class.move_entry(self, @file, value)
+        @file = value
+      end
     end
-    
+
+    # Return relative path to +file+ from <tt>PlainRecord.root</tt>.
+    def path
+      return nil unless @file
+      @file.slice(PlainRecord.root.length..-1)
+    end
+
     # Save entry to file. Note, that for in_list models it also save all other
     # entries in file.
     def save
-      self.class.save_file(@file)
+      self.class.use_callbacks(:save, self) do
+        unless @file
+          unless self.class.path =~ /[\*\[\?\{]/
+            self.file = self.class.path
+          else
+            raise ArgumentError, "There isn't file to save entry. " +
+                                 "Set filepath properties or file."
+          end
+        end
+
+        self.class.save_file(@file)
+      end
+    end
+
+    # Delete current entry and it file if there isn’t has any other entries.
+    def destroy
+      self.class.use_callbacks(:destroy, self) do
+        self.class.delete_entry(@file, self)
+      end
     end
-    
+
     # Return string of YAML representation of entry +data+.
-    def to_yaml(opts = {})
+    def to_yaml(opts = { })
       @data.to_yaml(opts)
     end
-    
+
     # Compare if its properties and texts are equal.
     def eql?(other)
       return false unless other.kind_of?(self.class)
-      @data == other.data and @texts == @texts
+      @file == other.file and @data == other.data and @texts == @texts
     end
     alias == eql?
   end

data/lib/plain_record/version.rb

@@ -0,0 +1,3 @@
+module PlainRecord
+  VERSION = '0.2' unless defined? PlainRecord::VERSION
+end

data/plain_record.gemspec

@@ -0,0 +1,30 @@
+require './lib/plain_record/version'
+
+Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.name     = 'plain_record'
+  s.version  = PlainRecord::VERSION
+  s.date     = Time.now.strftime('%Y-%m-%d')
+  s.summary  = 'Data persistence, which use human editable and ' +
+               'readable plain text files.'
+  s.description = <<-EOF
+    Plain Record is a data persistence, which use human editable and
+    readable plain text files. It’s ideal for static generated sites,
+    like blog or homepage.
+  EOF
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {spec}/*`.split("\n")
+  s.extra_rdoc_files = ['README.md', 'LICENSE', 'ChangeLog']
+  s.require_path     = 'lib'
+
+  s.author   = 'Andrey "A.I." Sitnik'
+  s.email    = 'andrey@sitnik.ru'
+  s.homepage = 'https://github.com/ai/plain_record'
+
+  s.add_development_dependency "bundler",   [">= 1.0.10"]
+  s.add_development_dependency "yard",      [">= 0"]
+  s.add_development_dependency "rake",      [">= 0"]
+  s.add_development_dependency "rspec",     [">= 0"]
+  s.add_development_dependency "redcarpet", [">= 0"]
+end

data/spec/associations_spec.rb

@@ -0,0 +1,142 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe PlainRecord::Associations do
+
+  before :all do
+    class ::Rate
+      include PlainRecord::Resource
+    end
+
+    class ::RatedPost
+      include PlainRecord::Resource
+      entry_in 'data/3/post.md'
+      property :rate, one(::Rate)
+    end
+
+    class ::Comment
+      include PlainRecord::Resource
+
+      list_in 'data/*/comments.yml'
+
+      virtual :commented_post_name, in_filepath(1)
+      virtual :commented_post,      one(::FilepathPost)
+
+      property :author_name
+      property :text
+      property :answers, many(::Comment)
+    end
+
+    class ::CommentedPost
+      include PlainRecord::Resource
+      entry_in 'data/*/post.md'
+      virtual :name,     in_filepath(1)
+      virtual :comments, many(::Comment)
+    end
+  end
+
+  it "shouldn't create association for text" do
+    lambda {
+      Class.new do
+        include PlainRecord::Resource
+        text :one, one(Post)
+      end
+    }.should raise_error(ArgumentError, /text creator/)
+
+    lambda {
+      Class.new do
+        include PlainRecord::Resource
+        text :many, many(Post)
+      end
+    }.should raise_error(ArgumentError, /text creator/)
+  end
+
+  it "should load one-to-one real association" do
+    rate = ::RatedPost.first().rate
+    rate.should be_instance_of(::Rate)
+    rate.path.should == 'data/3/post.md'
+    rate.data.should == { 'subject' => 5, 'text' => 2 }
+  end
+
+  it "should save one-to-one real association" do
+    file = StringIO.new
+    File.should_receive(:open).with(anything(), 'w').and_yield(file)
+
+    ::RatedPost.first().save()
+
+    file.should has_yaml({ 'title' => 'Third',
+                           'rate'  => { 'text' => 2, 'subject' => 5 } })
+  end
+
+  it "should load one-to-many real association" do
+    root = ::Comment.first()
+    root.should have(1).answers
+    root.answers[0].should be_instance_of(::Comment)
+    root.answers[0].path.should == 'data/1/comments.yml'
+    root.answers[0].data.should == { 'author_name' => 'john',
+                                     'text'        => 'Thanks',
+                                     'answers'     => [] }
+  end
+
+  it "should save one-to-many real association" do
+    file = StringIO.new
+    File.should_receive(:open).with(anything(), 'w').and_yield(file)
+
+    ::Comment.first().save()
+
+    file.should has_yaml([
+      {
+        'author_name' => 'super1997',
+        'text'        => 'Cool!',
+        'answers'     => [{ 'author_name' => 'john', 'text' => 'Thanks' }]
+      }
+    ])
+  end
+
+  it "should find map for virtual association" do
+    PlainRecord::Associations.map(
+        ::Comment, ::CommentedPost, 'commented_post_').should == { 
+            :commented_post_name => :name }
+  end
+
+  it "should load one-to-one virtual association" do
+    post = ::FilepathPost.first(:name => '1')
+    comment = ::Comment.first(:author_name => 'super1997')
+    comment.commented_post.should == post
+  end
+
+  it "should change one-to-one virtual association" do
+    post = ::FilepathPost.first(:name => '2')
+    comment = ::Comment.first(:author_name => 'super1997')
+    comment.commented_post = post
+
+    post.name.should == '1'
+    comment.commented_post.should == post
+  end
+
+  it "should load one-to-many virtual association" do
+    post = ::CommentedPost.first(:name => '1')
+    post.should have(1).comments
+    post.comments.first.should == ::Comment.first(:author_name => 'super1997')
+  end
+
+  it "should add new item to one-to-many virtual association" do
+    post = ::CommentedPost.first(:name => '1')
+    comment = ::Comment.new
+    post.comments << comment
+
+    post.should have(2).comments
+    post.comments[1].should == comment
+    comment.commented_post_name.should == post.name
+  end
+
+  it "should create new one-to-many association" do
+    post = ::CommentedPost.new(:name => 'new')
+    comment = ::Comment.new
+    post.comments = [comment]
+
+    post.should have(1).comments
+    post.comments.first.should == comment
+    comment.commented_post_name.should == post.name
+  end
+
+end

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