plain_record 0.2 → 0.3

data/lib/plain_record/type.rb

@@ -0,0 +1,86 @@
+=begin
+Extention to convert fields to special type.
+
+Copyright (C) 2012 Andrey “A.I.” Sitnik <andrey@sitnik.ru>,
+sponsored by Evil Martians.
+
+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
+
+require 'time'
+require 'date'
+
+module PlainRecord
+  # Extention to set field type and convert value to it.
+  #
+  #   class Post
+  #     include PlainRecord::Resource
+  #
+  #     entry_in '*/*/post.md'
+  #
+  #     field :title,   type(String)
+  #     field :visits,  type(Integer)
+  #     field :rating,  type(Float)
+  #     field :created, type(Date)
+  #     field :updated, type(Time)
+  #   end
+  #
+  # You can add support for your classes. Just set parse and stringify
+  # code to <tt>PlainRecord::Type</tt>:
+  #
+  #   PlainRecord::Type.parsers[Car]     = 'Car.parse(super)'
+  #   PlainRecord::Type.stringifies[Car] = 'v.to_s'
+  module Type
+
+    private
+
+    # Filter to convert field values to some type.
+    def type(klass)
+      proc do |model, field, type|
+        model.add_accessors <<-EOS, __FILE__, __LINE__
+          def #{field}
+            v = super
+            #{Type.parsers[klass]}
+          end
+          def #{field}=(v)
+            super(#{Type.stringifies[klass]})
+          end
+        EOS
+      end
+    end
+
+    class << self
+      # Hash of class to string of parse code.
+      attr_accessor :parsers
+
+      # Hash of class to string of stringify code.
+      attr_accessor :stringifies
+    end
+
+    Type.parsers = {
+      String  => 'v ? v.to_s : v',
+      Integer => 'v ? v.to_i : v',
+      Float   => 'v ? v.to_f : v',
+      Time    => 'v.is_a?(String) ? Time.parse(v) : v',
+      Date    => 'v.is_a?(String) ? Date.parse(v) : v'
+    }
+    Type.stringifies = {
+      String  => 'v ? v.to_s : v',
+      Integer => 'v ? v.to_i : v',
+      Float   => 'v ? v.to_f : v',
+      Time    => 'v ? v.strftime("%Y-%m-%d %H:%M:%S %Z") : v',
+      Date    => 'v'
+    }
+  end
+end

data/lib/plain_record/version.rb

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

data/lib/plain_record.rb

@@ -1,7 +1,8 @@
 =begin
 Main file to load all neccessary classes for Plain Record.
 
-Copyright (C) 2009 Andrey “A.I.” Sitnik <andrey@sitnik.ru>
+Copyright (C) 2009 Andrey “A.I.” Sitnik <andrey@sitnik.ru>,
+sponsored by Evil Martians.
 
 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
@@ -25,21 +26,29 @@ YAML::ENGINE.yamler = 'syck' if defined? YAML::ENGINE
 dir = Pathname(__FILE__).dirname.expand_path + 'plain_record'
 require dir + 'version'
 require dir + 'callbacks'
+require dir + 'default'
 require dir + 'filepath'
 require dir + 'association_proxy'
 require dir + 'associations'
+require dir + 'type'
 require dir + 'model'
 require dir + 'resource'
 
 module PlainRecord
+  module Extra
+    autoload :Git,  'plain_record/extra/git'
+    autoload :I18n, 'plain_record/extra/i18n'
+  end
+
   class << self
     # 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  = value.to_s
       value += File::SEPARATOR if File::SEPARATOR != value[-1..-1]
-      @root = value
+      @root  = value
     end
 
     # Return root for Model#entry_in or Model#list_in.
@@ -50,3 +59,9 @@ module PlainRecord
     end
   end
 end
+
+if defined? Rails
+  ActiveSupport.on_load(:after_initialize) do
+    PlainRecord.root = Rails.root.join('data')
+  end
+end

data/plain_record.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |s|
                '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,
+    readable plain text files. It's ideal for static generated sites,
     like blog or homepage.
   EOF
 
@@ -27,4 +27,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake",      [">= 0"]
   s.add_development_dependency "rspec",     [">= 0"]
   s.add_development_dependency "redcarpet", [">= 0"]
+  s.add_development_dependency "r18n-core", [">= 0"]
+  s.add_development_dependency "i18n",      [">= 0"]
 end

data/spec/associations_spec.rb

@@ -10,7 +10,7 @@ describe PlainRecord::Associations do
     class ::RatedPost
       include PlainRecord::Resource
       entry_in 'data/3/post.md'
-      property :rate, one(::Rate)
+      field :rate, one(::Rate)
     end
 
     class ::Comment
@@ -21,9 +21,9 @@ describe PlainRecord::Associations do
       virtual :commented_post_name, in_filepath(1)
       virtual :commented_post,      one(::FilepathPost)
 
-      property :author_name
-      property :text
-      property :answers, many(::Comment)
+      field :author_name
+      field :text
+      field :answers, many(::Comment)
     end
 
     class ::CommentedPost
@@ -68,7 +68,7 @@ describe PlainRecord::Associations do
   end
 
   it "should load one-to-many real association" do
-    root = ::Comment.first()
+    root = ::Comment.first(:commented_post_name => '1')
     root.should have(1).answers
     root.answers[0].should be_instance_of(::Comment)
     root.answers[0].path.should == 'data/1/comments.yml'
@@ -78,10 +78,11 @@ describe PlainRecord::Associations do
   end
 
   it "should save one-to-many real association" do
+    comment = ::Comment.first(:commented_post_name => '1')
+
     file = StringIO.new
     File.should_receive(:open).with(anything(), 'w').and_yield(file)
-
-    ::Comment.first().save()
+    comment.save()
 
     file.should has_yaml([
       {
@@ -94,7 +95,7 @@ describe PlainRecord::Associations do
 
   it "should find map for virtual association" do
     PlainRecord::Associations.map(
-        ::Comment, ::CommentedPost, 'commented_post_').should == { 
+        ::Comment, ::CommentedPost, 'commented_post_').should == {
             :commented_post_name => :name }
   end
 
@@ -102,6 +103,9 @@ describe PlainRecord::Associations do
     post = ::FilepathPost.first(:name => '1')
     comment = ::Comment.first(:author_name => 'super1997')
     comment.commented_post.should == post
+
+    another = ::Comment.first(:commented_post_name => '2')
+    another.commented_post.should_not == post
   end
 
   it "should change one-to-one virtual association" do

data/spec/data/2/comments.yml

@@ -0,0 +1,2 @@
+- author_name: john
+  text: Fix

data/spec/data/2/post.md

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

data/spec/default_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe PlainRecord::Default do
+
+  it "should set default value for field" do
+    klass = Class.new do
+      include PlainRecord::Resource
+      field :category, default('uncategorized')
+    end
+    post = klass.new
+
+    post.category.should == 'uncategorized'
+    post.category = 'a'
+    post.category.should == 'a'
+  end
+
+end

data/spec/filepath_spec.rb

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

data/spec/git_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe PlainRecord::Extra::Git do
+
+  before :all do
+    class TimedPost
+      include PlainRecord::Resource
+      include PlainRecord::Extra::Git
+
+      entry_in 'data/*/post.md'
+
+      virtual :name,    in_filepath(1)
+      field   :created, git_created_time
+      field   :updated, git_modified_time
+    end
+  end
+
+  before do
+    @post = TimedPost.first(:name => '2')
+
+    @now = Time.at(256)
+    Time.stub!(:now).and_return(@now)
+  end
+
+  it "should take file create time from git" do
+    @post.created.utc.should == Time.parse('2012-05-17 22:23:47 UTC')
+  end
+
+  it "should take file updated time from git" do
+    @post.updated.utc.should == Time.parse('2012-05-18 07:41:52 UTC')
+  end
+
+  it "should overrided git time" do
+    post = TimedPost.new
+
+    post.created = Time.at(0)
+    post.created.should == Time.at(0)
+
+    post.updated = Time.at(1)
+    post.updated.should == Time.at(1)
+  end
+
+  it "should return now for new model" do
+    post = TimedPost.new
+    post.created.should == @now
+    post.updated.should == @now
+  end
+
+  it "shoult return now if file has uncommitted changes" do
+    @post.stub!(:git_uncommitted?).and_return(true)
+    @post.created.utc.should == Time.parse('2012-05-17 22:23:47 UTC')
+    @post.updated.should == @now
+  end
+
+end

data/spec/i18n_spec.rb

@@ -0,0 +1,167 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe PlainRecord::Extra::I18n do
+
+  before :all do
+    class I18nPost
+      include PlainRecord::Resource
+      include PlainRecord::Extra::I18n
+      field :one, i18n
+    end
+
+    class PlainI18nPost < I18nPost
+      attr_accessor :locale
+    end
+  end
+
+  it "should raise error on i18n filter on text" do
+    lambda {
+      klass = Class.new do
+        include PlainRecord::Resource
+        include PlainRecord::Extra::I18n
+        text :one, i18n
+      end
+    }.should raise_error(ArgumentError, /text/)
+  end
+
+  it "should save translations with locale" do
+    post = PlainI18nPost.new
+
+    post.locale = 'en'
+    post.one = 1
+    post.data['one'].should == { 'en' => 1 }
+
+    post.locale = 'ru'
+    post.one = 2
+    post.data['one'].should == { 'en' => 1, 'ru' => 2 }
+  end
+
+  it "should return untraslated field" do
+    post = PlainI18nPost.new
+
+    post.locale = 'en'
+    post.one = 1
+    post.untraslated_one.should == { 'en' => 1 }
+
+    post.untraslated_one = { 'ru' => 2 }
+    post.data['one'] == { 'ru' => 2 }
+  end
+
+  it "should return original field if it is not hash" do
+    post = PlainI18nPost.new
+    post.one.should be_nil
+    post.data['one'] = 1
+    post.one.should == 1
+  end
+
+  context 'plain' do
+
+    it "should raise error when locale method is not redefined" do
+      klass = Class.new do
+        include PlainRecord::Resource
+        include PlainRecord::Extra::I18n
+        field :one, i18n
+      end
+      post = klass.new
+      lambda { post.locale }.should raise_error(/Redefine/)
+    end
+
+    it "should translate method" do
+      post = PlainI18nPost.new
+      post.data['one'] = { 'en' => 1, 'ru' => 2 }
+
+      post.locale = 'en'
+      post.one.should == 1
+
+      post.locale = 'ru'
+      post.one.should == 2
+    end
+  end
+
+  context 'i18n' do
+    before :all do
+      require 'i18n'
+    end
+
+    it "should git locale from I18n" do
+      post = I18nPost.new
+      post.data['one'] = { 'en' => 1, 'ru' => 2 }
+
+      I18n.locale = :en
+      post.one == 1
+
+      I18n.locale = :ru
+      post.one == 2
+
+      post.one = 3
+      post.data['one'].should == { 'en' => 1, 'ru' => 3 }
+    end
+  end
+
+  context 'r18n' do
+    before :all do
+      require 'r18n-core'
+    end
+
+    before do
+      @post = I18nPost.new
+    end
+
+    it "should get I18n object from R18n" do
+      @post.data['one'] = { 'en' => 1, 'ru' => 2 }
+
+      R18n.set('en')
+      @post.one == 1
+
+      R18n.set('ru')
+      @post.one == 2
+
+      @post.one = 3
+      @post.data['one'].should == { 'en' => 1, 'ru' => 3 }
+    end
+
+    it "should return translated string" do
+      @post.data['one'] = { 'en' => '1' }
+      R18n.set('en')
+
+      @post.one.should be_translated
+      @post.one.locale.code.should == 'en'
+      @post.one.path.should == 'I18nPost#one'
+    end
+
+    it "should find translation in user locales" do
+      @post.data['one'] = { 'fr' => '1' }
+
+      R18n.set(['ru', 'fr'])
+      @post.one.should == '1'
+    end
+
+    it "should return untraslated" do
+      @post.data['one'] = { 'fr' => '1' }
+      R18n.set('ru')
+
+      @post.one.should_not be_translated
+      @post.one.translated_path.should   == 'I18nPost#'
+      @post.one.untranslated_path.should == 'one'
+    end
+
+    it "should translate non-strings" do
+      @post.data['one'] = { 'ru' => { :a => 1 } }
+      R18n.set('ru')
+
+      @post.one.should == { :a => 1 }
+    end
+
+    it "should use filters for custom type" do
+      klass = Class.new do
+        include PlainRecord::Resource
+        include PlainRecord::Extra::I18n
+        field :one, i18n('pl')
+      end
+      post = klass.new
+      post.data['one'] = { 'en' => { '1' => '%1 one', 'n' => '%1 ones' } }
+      post.one(5).should == '5 ones'
+    end
+  end
+
+end

data/spec/model_spec.rb

@@ -7,31 +7,33 @@ describe PlainRecord::Model do
     Author.loaded = { }
   end
 
-  it "should define virtual property" do
+  it "should define virtual field" do
     klass = Class.new do
       include PlainRecord::Resource
-      virtual :one, Definers.none
+      virtual :one, proc { }
     end
 
     klass.virtuals.should == [:one]
   end
 
-  it "shouldn't define virtual property without accessor from definers" do
+  it "shouldn't define virtual field without accessor from filters" do
     lambda {
       Class.new do
         include PlainRecord::Resource
-        virtual :one, Definers.reader
+        virtual :one
       end
     }.should raise_error(ArgumentError, /own accessors/)
   end
 
-  it "should define property" do
+  it "should define field" do
     klass = Class.new do
       include PlainRecord::Resource
-      property :one
+      field :one
     end
 
-    klass.properties.should == [:one]
+    klass.fields.should == [:one]
+    klass.accessors_modules[:main].should has_methods(:one, :one=)
+
     object = klass.new(nil, { 'one' => 1 })
     object.one.should == 1
     object.one = 2
@@ -45,43 +47,43 @@ describe PlainRecord::Model do
     end
 
     klass.texts.should == [:content]
+    klass.accessors_modules[:main].should has_methods(:content, :content=)
+
     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
+  it "should send field name and type type to filter" do
+    klass   = Class.new
+    filter = mock
+    filter.stub!(:virtual).with(klass, :one, :virtual)
+    filter.stub!(:field).with(klass, :two,  :field)
+    filter.stub!(:text).with(klass, :three, :text)
+    klass.class_eval do
       include PlainRecord::Resource
-      property :one, Definers.accessor
-      property :two, Definers.reader
-      text :three, Definers.writer
-      text :four, Definers.none
+      virtual :one,   filter.method(:virtual)
+      field   :two,   filter.method(:field)
+      text    :three, filter.method(:text)
     end
-    klass.should has_methods(:one, :'one=', :'three=', :two)
   end
 
-  it "should use accessors from definers" do
-    klass = Class.new do
-      include PlainRecord::Resource
-      property :one, Definers.writer, Definers.reader, Definers.accessor
-      text :two, Definers.reader
+  it "should override sustem accessors by filter" do
+    filter = proc do |model, name, type|
+      model.add_accessors <<-EOS, __FILE__, __LINE__
+        def #{name}
+          super + 1
+        end
+      EOS
     end
-    klass.should has_methods(:two)
-  end
-
-  it "should send property name and caller type to definer" do
-    definer = mock
-    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
-      virtual  :one,   definer.method(:virtual)
-      property :two,   definer.method(:property)
-      text     :three, definer.method(:text)
+      field :one, filter
     end
+    a = klass.new
+    a.one = 1
+    a.one.should == 2
   end
 
   it "should find all enrty files by glob pattern" do
@@ -219,4 +221,43 @@ describe PlainRecord::Model do
     end
   end
 
+  it "should add modules for accessors" do
+    klass = Class.new do
+      include PlainRecord::Resource
+    end
+
+    klass.accessors_modules.should be_empty
+
+    main = klass.add_accessors(:main)
+    klass.add_accessors(:main).should == main
+    klass.accessors_modules.should have(1).keys
+
+    mod = klass.add_accessors
+    mod.should_not == main
+    klass.add_accessors.should_not == mod
+    klass.accessors_modules.should have(1).keys
+  end
+
+  it "should define accessors" do
+    klass = Class.new do
+      include PlainRecord::Resource
+    end
+    klass.add_accessors :one, "def one; 1; end"
+    klass.add_accessors       "def two; 2; end"
+    klass.add_accessors <<-EOS, __FILE__, __LINE__
+       def three; 3; end
+    EOS
+
+    klass.should has_methods(:one, :two, :three)
+  end
+
+  it "should allow to define filters as Hash" do
+    klass = Class.new do
+      include PlainRecord::Resource
+      field :one, :default => 1
+    end
+    a = klass.new
+    a.one.should == 1
+  end
+
 end