plain_record 0.1 → 0.2

data/lib/plain_record/model.rb

@@ -26,36 +26,55 @@ module PlainRecord
     dir = Pathname(__FILE__).dirname.expand_path + 'model'
     autoload :Entry, (dir + 'entry').to_s
     autoload :List,  (dir + 'list').to_s
-    
-    # Properties names.
-    attr_reader :properties
-    
+
+    include PlainRecord::Callbacks
+    include PlainRecord::Filepath
+    include PlainRecord::Associations
+
+    # YAML properties names.
+    attr_accessor :properties
+
     # Name of special properties with big text.
-    attr_reader :texts
-    
+    attr_accessor :texts
+
+    # Properties names with dynamic value.
+    attr_accessor :virtuals
+
     # Storage type: +:entry+ or +:list+.
     attr_reader :storage
-    
+
     # Content of already loaded files.
-    attr_reader :loaded
-    
+    attr_accessor :loaded
+
+    def self.extended(base) #:nodoc:
+      base.properties = []
+      base.virtuals   = []
+      base.texts      = []
+      base.loaded     = { }
+    end
+
     # Load and return all entries in +file+.
     #
     # See method code in <tt>Model::Entry</tt> or <tt>Model::List</tt>.
     def load_file(file); end
-    
-    # Call block on all entry. Unlike <tt>all.each</tt> it use lazy file
-    # loading, so it is useful if you planing to break this loop somewhere in
-    # the middle (for example, like +first+).
+
+    # Call block on all entry, which is may be match for +matchers+. Unlike
+    # <tt>all.each</tt> it use lazy file loading, so it is useful if you planing
+    # to break this loop somewhere in the middle (for example, like +first+).
     #
     # See method code in <tt>Model::Entry</tt> or <tt>Model::List</tt>.
-    def each_entry; end
-    
+    def each_entry(matchers = { }); end
+
     # Delete +entry+ from +file+.
     #
     # See method code in <tt>Model::Entry</tt> or <tt>Model::List</tt>.
     def delete_entry(file, entry = nil); end
-      
+
+    # Move +entry+ from one file to another.
+    #
+    # See method code in <tt>Model::Entry</tt> or <tt>Model::List</tt>.
+    def move_entry(entry, from, to); end
+
     # Write all loaded entries to +file+.
     def save_file(file)
       if @loaded.has_key? file
@@ -64,7 +83,7 @@ module PlainRecord
         end
       end
     end
-    
+
     # Return all entries, which is match for +matchers+ and return true on
     # +block+.
     #
@@ -74,13 +93,13 @@ module PlainRecord
     #   Post.all(title: 'Post title')
     #   Post.all(title: /^Post/, summary: /cool/)
     #   Post.all { |post| 20 < Post.content.length }
-    def all(matchers = {}, &block)
-      entries = all_entries
+    def all(matchers = { }, &block)
+      entries = all_entries(matchers)
       entries.delete_if { |i| not match(i, matchers) } if matchers
-      entries.delete_if { |i| not block.call(i) } if block_given?
+      entries.delete_if { |i| not block.call(i) }      if block_given?
       entries
     end
-    
+
     # Return first entry, which is match for +matchers+ and return true on
     # +block+.
     #
@@ -90,11 +109,13 @@ module PlainRecord
     #   Post.first(title: 'Post title')
     #   Post.first(title: /^Post/, summary: /cool/)
     #   Post.first { |post| 2 < Post.title.length }
-    def first(matchers = {}, &block)
+    def first(matchers = { }, &block)
       if matchers and block_given?
-        each_entry { |i| return i if match(i, matchers) and block.call(i) }
+        each_entry(matchers) do |i|
+          return i if match(i, matchers) and block.call(i)
+        end
       elsif matchers
-        each_entry { |i| return i if match(i, matchers) }
+        each_entry(matchers) { |i| return i if match(i, matchers) }
       elsif block_given?
         each_entry { |i| return i if block.call(i) }
       else
@@ -102,29 +123,37 @@ module PlainRecord
       end
       nil
     end
-    
-    # Return all model files.
-    def files
-      Dir.glob(File.join(PlainRecord.root, @path))
+
+    # Return all file list for models, which match for +matchers+.
+    def files(matchers = { })
+      Dir.glob(PlainRecord.root(path(matchers)))
+    end
+
+    # Return glob pattern to for files with entris, which is may be match for
+    # +matchers+.
+    def path(matchers = { })
+      use_callbacks(:path, matchers) do
+        @path
+      end
     end
-    
+
     private
-    
-    # Return all model entries.
+
+    # Return all model entries, which is may be match for +matchers+.
     #
     # See method code in <tt>Model::Entry</tt> or <tt>Model::List</tt>.
-    def all_entries; end
-    
+    def all_entries(matchers); end
+
     # Return string representation of +entries+ to write it to file.
     #
     # See method code in <tt>Model::Entry</tt> or <tt>Model::List</tt>.
     def entries_string(entries); end
-    
+
     # Delete file, cache and empty dirs in path.
     def delete_file(file)
       File.delete(file)
       @loaded.delete(file)
-      
+
       path = Pathname(file).dirname
       root = Pathname(PlainRecord.root)
       until 2 != path.entries.length or path == root
@@ -132,7 +161,7 @@ module PlainRecord
         path = path.parent
       end
     end
-    
+
     # Match +object+ by +matchers+ to use in +all+ and +first+ methods.
     def match(object, matchers)
       matchers.each_pair do |key, matcher|
@@ -145,20 +174,19 @@ module PlainRecord
       end
       true
     end
-    
+
     # Set glob +pattern+ for files with entry. Each file must contain one entry.
     # To set root for this path use +PlainRecord.root+.
     #
     # Also add methods from <tt>Model::Entry</tt>.
     #
-    #   entry_in 'content/*/post.m'
+    #   entry_in 'content/*/post.md'
     def entry_in(path)
       @storage = :entry
       @path = path
       self.extend PlainRecord::Model::Entry
-      @loaded = {}
     end
-    
+
     # Set glob +pattern+ for files with list of entries. Each file may contain
     # several entries, but you may have several files. All data will storage
     # in YAML, so you can’t define +text+.
@@ -170,29 +198,55 @@ module PlainRecord
       @storage = :list
       @path = path
       self.extend PlainRecord::Model::List
-      @loaded = {}
     end
-    
-    # Add property to model with some +name+. It will be stored as YAML.
+
+    # Add virtual property with some +name+ to model. It value willn’t be in
+    # file and will be calculated dynamically.
+    #
+    # You _must_ provide your own define logic by +definers+. Definer Proc
+    # will be call with property name in first argument and may return
+    # +:accessor+, +:writer+ or +:reader+ this method create standard methods
+    # to access to property.
+    #
+    #   class Post
+    #     include PlainRecord::Resource
+    #
+    #     entry_in 'posts/*/post.md'
+    #
+    #     virtual :name, in_filepath(1)
+    #   end
+    def virtual(name, *definers)
+      @virtuals ||= []
+      @virtuals << name
+
+      accessors = call_definers(definers, name, :virtual)
+
+      if accessors[:reader] or accessors[:writer]
+        raise ArgumentError, 'You must provide you own accessors for virtual ' +
+                             "property #{name}"
+      end
+    end
+
+    # Add property with some +name+ to model. It will be stored as YAML.
     #
     # You can provide your own define logic by +definers+. Definer Proc
     # will be call with property name in first argument and may return
     # +:accessor+, +:writer+ or +:reader+ this method create standard methods
     # to access to property.
-    # 
+    #
     #   class Post
     #     include PlainRecord::Resource
     #
-    #     entry_in 'posts/*/post.m'
+    #     entry_in 'posts/*/post.md'
     #
     #     property :title
     #   end
     def property(name, *definers)
       @properties ||= []
       @properties << name
-      
-      accessors = call_definers(definers, name)
-      
+
+      accessors = call_definers(definers, name, :property)
+
       if accessors[:reader]
         class_eval <<-EOS, __FILE__, __LINE__
           def #{name}
@@ -208,7 +262,7 @@ module PlainRecord
         EOS
       end
     end
-    
+
     # Add special property with big text (for example, blog entry content). It
     # will stored after 3 dashes (<tt>---</tt>).
     #
@@ -223,19 +277,19 @@ module PlainRecord
     # == Example
     #
     # Model:
-    # 
+    #
     #   class Post
     #     include PlainRecord::Resource
     #
-    #     entry_in 'posts/*/post.m'
+    #     entry_in 'posts/*/post.md'
     #
     #     property :title
     #     text :summary
     #     text :content
     #   end
-    # 
+    #
     # File:
-    # 
+    #
     #   title: Post title
     #   ---
     #   Post summary
@@ -245,13 +299,13 @@ module PlainRecord
       if :list == @storage
         raise ArgumentError, 'Text is supported by only entry_in models'
       end
-      
+
       @texts ||= []
       @texts << name
       number = @texts.length - 1
-      
-      accessors = call_definers(definers, name)
-      
+
+      accessors = call_definers(definers, name, :text)
+
       if accessors[:reader]
         class_eval <<-EOS, __FILE__, __LINE__
           def #{name}
@@ -267,14 +321,15 @@ module PlainRecord
         EOS
       end
     end
-    
-    # Call +definers+ for property with +name+ and return accessors, which will
+
+    # Call +definers+ from +caller+ (<tt>:virtual</tt>, <tt>:property</tt> or
+    # <tt>:text</tt>) for property with +name+ and return accessors, which will
     # be created as standart by +property+ or +text+ method.
-    def call_definers(definers, name)
-      accessors = {:reader => true, :writer => true}
-      
+    def call_definers(definers, name, caller)
+      accessors = { :reader => true, :writer => true }
+
       definers.each do |definer|
-        access = definer.call(name)
+        access = definer.call(name, caller)
         if :writer == access or access.nil?
           accessors[:reader] = false
         end
@@ -282,7 +337,7 @@ module PlainRecord
           accessors[:writer] = false
         end
       end
-      
+
       accessors
     end
   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,39 +52,76 @@ 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.delete_entry(@file, self)
+      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/lib/plain_record/version.rb

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

data/lib/plain_record.rb

@@ -20,14 +20,33 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 require 'pathname'
 require 'yaml'
 
+YAML::ENGINE.yamler = 'syck' if defined? YAML::ENGINE
+
 dir = Pathname(__FILE__).dirname.expand_path + 'plain_record'
 require dir + 'version'
+require dir + 'callbacks'
+require dir + 'filepath'
+require dir + 'association_proxy'
+require dir + 'associations'
 require dir + 'model'
 require dir + 'resource'
 
 module PlainRecord
   class << self
-    # Root of all file path in Model#entry_in.
-    attr_accessor :root
+    # Set new root for Model#entry_in or Model#list_in.
+    #
+    # Note, that it add last slash to root path (<tt>/content</tt> will be saved
+    # as <tt>/content/</tt>).
+    def root=(value)
+      value += File::SEPARATOR if File::SEPARATOR != value[-1..-1]
+      @root = value
+    end
+
+    # Return root for Model#entry_in or Model#list_in.
+    #
+    # If you set +path+ it will be added to root path.
+    def root(path = '')
+      File.join(@root, path)
+    end
   end
 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