plain_record 0.1.0 → 0.2

data/lib/plain_record/callbacks.rb

@@ -0,0 +1,146 @@
+=begin
+Module to add before/after hooks.
+
+Copyright (C) 2009 Andrey “A.I.” Sitnik <andrey@sitnik.ru>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+module PlainRecord
+  # Callbacks are hooks that allow you to define methods to run before and
+  # after some method, to change it logic.
+  module Callbacks
+    # Hash of class callbacks with property.
+    attr_accessor :callbacks
+
+    # Set block as callback before +events+. Callback with less +priority+ will
+    # start earlier.
+    #
+    #   class File
+    #     include PlainRecord::Callbacks
+    #
+    #     attr_accessor :name
+    #     attr_accessor :content
+    #
+    #     def save
+    #       use_callbacks(:save, self) do
+    #         File.open(@name, 'w') { |io| io.puts @content }
+    #       end
+    #     end
+    #   end
+    #
+    #   class NewFile < File
+    #     before :save do |file|
+    #       while File.exists? file.name
+    #         file.name = 'another ' + file.name
+    #       end
+    #     end
+    #
+    #     before, :save do
+    #       raise ArgumentError if 255 < @name.length
+    #     end
+    #   end
+    def before(events, priority = 1, &block)
+      Array(events).each do |event|
+        add_callback(:before, event, priority, block)
+      end
+    end
+
+    # Set block as callback after +events+. Callback with less +priority+ will
+    # start earlier.
+    #
+    # After callbacks may change method return, which will be pass as first
+    # argument for first callback. It return will be pass for next callback and
+    # so on.
+    #
+    #   class Person
+    #     include PlainRecord::Callbacks
+    #
+    #     def name
+    #       use_callbacks(:name) do
+    #         'John'
+    #       end
+    #     end
+    #   end
+    #
+    #   class GreatPerson < Person
+    #     after :name, 2 do |name|
+    #       'Great ' + name
+    #     end
+    #
+    #     after :name do |name|
+    #       'The ' + name
+    #     end
+    #   end
+    #
+    #   GreatPerson.new.name #=> "The Great John"
+    def after(events, priority = 1, &block)
+      Array(events).each do |event|
+        add_callback(:after, event, priority, block)
+      end
+    end
+
+    # Call +before+ callbacks for +event+ with +params+. In your
+    # code use more pretty +use_callbacks+ method.
+    def call_before_callbacks(event, params)
+      init_callbacks(event)
+      @callbacks[:before][event].each do |before, priority|
+        before.call(*params)
+      end
+    end
+
+    # Call +before+ callbacks for +event+ with +params+. Callbacks can change 
+    # +result+. In your code use more pretty +use_callbacks+ method.
+    def call_after_callbacks(event, result, params)
+      init_callbacks(event)
+      @callbacks[:after][event].each do |after, priority|
+        result = after.call(result, *params)
+      end
+      result
+    end
+
+    # Call before callback for +event+, run block and give it result to
+    # after callbacks.
+    #
+    #   def my_save_method(entry)
+    #     use_callbacks(:save, enrty) do
+    #       entry.file.write
+    #     end
+    #   end
+    def use_callbacks(event, *params, &block)
+      call_before_callbacks(event, params)
+      result = yield
+      call_after_callbacks(event, result, params)
+    end
+
+    private
+
+    # Backend for +before+ and +after+ method to add callback.
+    def add_callback(type, event, priority, block)
+      init_callbacks(event)
+
+      @callbacks[type][event] << [block, priority]
+      @callbacks[type][event].sort! { |a, b| a[1] <=> b[1] }
+    end
+
+    # Check and create Hash into +callbacks+ for +event+ if necessary.
+    def init_callbacks(event)
+      unless @callbacks
+        @callbacks = { :before => { }, :after => { } }
+      end
+      @callbacks[:before][event] = [] unless @callbacks[:before][event]
+      @callbacks[:after][event]  = [] unless @callbacks[:after][event]
+    end
+  end
+end

data/lib/plain_record/filepath.rb

@@ -0,0 +1,141 @@
+=begin
+Extention to get property from entry file path.
+
+Copyright (C) 2009 Andrey “A.I.” Sitnik <andrey@sitnik.ru>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end
+
+module PlainRecord
+  # Extention to get properties from enrty file path. For example, your blog
+  # post may stored in <tt>_name_/post.md</tt>, and post model will have +name+
+  # property. Also if you set name property to Model#first or Model#all method,
+  # they will load entry directly only by it file.
+  #
+  # To define filepath property:
+  # 1. Use <tt>*</tt> or <tt>**</tt> pattern in model path in +enrty_in+ or
+  #    +list_in+.
+  # 2. In +virtual+ method use <tt>in_filepath(i)</tt> definer after name with
+  #    <tt>*</tt> or <tt>**</tt> number (start from 1).
+  #
+  # Define filepath property only after +entry_in+ or +list_in+ call.
+  #
+  #   class Post
+  #     include PlainRecord::Resource
+  #
+  #     entry_in '*/*/post.md'
+  #
+  #     virtual :category, in_filepath(1)
+  #     virtual :name,     in_filepath(1)
+  #     …
+  #   end
+  #
+  #   superpost = Post.new
+  #   superpost.name = 'superpost'
+  #   superpost.category = 'best/'
+  #   superpost.save               # Save to best/superpost/post.md
+  #
+  #   bests = Post.all(category: 'best') # Look up only in best/ dir
+  module Filepath
+    attr_accessor :filepath_properties
+    attr_accessor :filepath_regexp
+
+    private
+
+    # Return definer for filepath property for +number+ <tt>*</tt> or
+    # <tt>**</tt> pattern in path.
+    def in_filepath(number)
+      proc do |property, caller|
+        if :virtual != caller
+          raise ArgumentError, "You must create filepath property #{property}" +
+                               ' virtual creator'
+        end
+        Filepath.define_property(self, property, number)
+        nil
+      end
+    end
+
+    class << self
+      # Define class variables and events in +klass+. It should be call once on
+      # same class after +entry_in+ or +list_in+ call.
+      def install(klass)
+        klass.filepath_properties = { }
+
+        path = Regexp.escape(klass.path).gsub(/\\\*\\\*(\/|$)/, '(.*)').
+                                         gsub('\\*', '([^/]+)')
+        klass.filepath_regexp = Regexp.new(path)
+
+        klass.class_eval do
+          attr_accessor :filepath_data
+        end
+
+        klass.after :load do |result, entry|
+          if entry.path
+            data = klass.filepath_regexp.match(entry.path)
+            entry.filepath_data = { }
+            klass.filepath_properties.each_pair do |number, name|
+              entry.filepath_data[name] = data[number]
+            end
+          else
+            entry.filepath_data = { }
+            klass.filepath_properties.each_value do |name|
+              entry.filepath_data[name] = entry.data[name]
+              entry.data.delete(name)
+            end
+          end
+          result
+        end
+
+        klass.after :path do |path, matchers|
+          i = 0
+          path.gsub /(\*\*(\/|$)|\*)/ do |pattern|
+            i += 1
+            property = klass.filepath_properties[i]
+            unless matchers[property].is_a? Regexp or matchers[property].nil?
+              matchers[property]
+            else
+              pattern
+            end
+          end
+        end
+
+        klass.before :save do |entry|
+          unless entry.file
+            path = klass.path(entry.filepath_data)
+            entry.file = path unless path =~ /[\*\[\?\{]/
+          end
+        end
+      end
+
+      # Define in +klass+ filepath property with +name+ for +number+ <tt>*</tt>
+      # or <tt>**</tt> pattern in path.
+      def define_property(klass, name, number)
+        unless klass.filepath_properties
+          install(klass)
+        end
+
+        klass.filepath_properties[number] = name
+
+        klass.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            @filepath_data[:#{name}]
+          end
+          def #{name}=(value)
+            @filepath_data[:#{name}] = value
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/plain_record/model.rb

@@ -26,31 +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(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 each_entry; end
-      
+    def move_entry(entry, from, to); end
+
     # Write all loaded entries to +file+.
     def save_file(file)
       if @loaded.has_key? file
@@ -59,7 +83,7 @@ module PlainRecord
         end
       end
     end
-    
+
     # Return all entries, which is match for +matchers+ and return true on
     # +block+.
     #
@@ -69,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+.
     #
@@ -85,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
@@ -97,24 +123,45 @@ 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
+        path.rmdir
+        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|
@@ -127,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+.
@@ -152,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}
@@ -190,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>).
     #
@@ -205,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
@@ -227,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}
@@ -249,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
@@ -264,7 +337,7 @@ module PlainRecord
           accessors[:writer] = false
         end
       end
-      
+
       accessors
     end
   end