plain_record 0.1 → 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/entry.rb

@@ -30,23 +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,15 +29,15 @@ 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)
@@ -46,13 +46,26 @@ module PlainRecord
           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