lolita 3.0.7 → 3.1.0

data/spec/configuration/filter_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Lolita::Configuration::Filter do
+
+  before(:each) do
+    @dbi=Lolita::DBI::Base.new(Post)
+  end
+
+  it "should create new filter with block" do
+    Lolita::Configuration::Filter.new(@dbi) do
+
+    end
+  end
+
+  it "should create new filter without block" do
+    Lolita::Configuration::Filter.new(@dbi)
+  end
+
+  it "should give fields as arguments" do
+    list=Lolita::Configuration::List.new(@dbi)
+    list.filter :name, :is_public
+    list.filter.fields.size.should == 2
+  end
+  
+  it "should add default search field if none is given" do
+    filter=Lolita::Configuration::Filter.new(@dbi)
+    filter.fields.size.should == 1
+    filter=Lolita::Configuration::Filter.new(@dbi){}
+    filter.fields.size.should == 1
+  end
+
+  it "should add some fields" do
+    filter=Lolita::Configuration::Filter.new(@dbi) do
+      fields :name, :is_public, :not_public
+    end
+    filter.fields.size.should == 3
+  end
+
+  it "should add some field with block" do
+    filter=Lolita::Configuration::Filter.new(@dbi) do
+      field :name do
+        type :integer
+      end
+    end
+    filter.fields.first.type.should == "integer"
+  end
+
+  it "should add some fields with block" do
+    filter=Lolita::Configuration::Filter.new(@dbi) do
+      fields :name, :is_public do
+        type :integer
+      end
+      field :created_at, :time
+    end
+    filter.fields.size.should == 3
+    filter.fields[0].type.should == "integer"
+    filter.fields[1].type.should == "integer"
+    filter.fields[2].type.should == "time"
+  end
+end

data/spec/configuration/tab_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 # temp class for extending tabs
-class Lolita::Configuration::MyTab < Lolita::Configuration::Tab
+class Lolita::Configuration::Tab::My < Lolita::Configuration::Tab::Base
   def initialize(dbi,*args,&block)
     @type=:my
     super
@@ -15,15 +15,16 @@ describe Lolita::Configuration::Tab do
     @dbi=Lolita::DBI::Base.new(Post)
   end
 
+  let(:tab_class){Lolita::Configuration::Tab::Base}
   describe "create extended tabs" do
 
     context "tab class is child class of ::Tab class " do
       it "should create new" do
-        Lolita::Configuration::MyTab.new(@dbi).type.should == :my
+        Lolita::Configuration::Tab::My.new(@dbi).type.should == :my
       end
 
       it "should create new with block" do
-        Lolita::Configuration::MyTab.new(@dbi) do 
+        Lolita::Configuration::Tab::My.new(@dbi) do 
           title "My New tab"
         end.title.should == "My New tab"
       end
@@ -33,33 +34,33 @@ describe Lolita::Configuration::Tab do
 
   describe "add tab" do
     it "should recognize type of tab added and create it as a related class object" do
-      Lolita::Configuration::Tab.add(@dbi){ field(:email)}.class.to_s.should=="Lolita::Configuration::DefaultTab"
-      Lolita::Configuration::Tab.add(@dbi,:my).class.to_s.should == "Lolita::Configuration::MyTab"
+      Lolita::Configuration::Tab.add(@dbi){ field(:email)}.class.to_s.should=="Lolita::Configuration::Tab::Default"
+      Lolita::Configuration::Tab.add(@dbi,:my).class.to_s.should == "Lolita::Configuration::Tab::My"
       Lolita::Configuration::Tab.add(@dbi) {
         type :my
-      }.class.to_s.should == "Lolita::Configuration::MyTab"
+      }.class.to_s.should == "Lolita::Configuration::Tab::My"
     end
 
     it "should raise error when tab is not recognized" do
       lambda{
         Lolita::Configuration::Tab.add(@dbi,:yourtab)
-      }.should raise_error(Lolita::TabNotFoundError)
+      }.should raise_error(Lolita::ConfigurationClassNotFound)
     end
   end
 
   it "should create tab" do
-    Lolita::Configuration::Tab.new(@dbi,:content)
+    tab_class.new(@dbi,:content)
   end
 
   it "should allow to set title" do
-    tab=Lolita::Configuration::Tab.new(@dbi,:content) do
+    tab=tab_class.new(@dbi,:content) do
       title "My tab"
     end
     tab.title.should == "My tab"
   end
   
   it "should have default title that is humanized type" do
-    tab=Lolita::Configuration::Tab.new(@dbi,:content)
+    tab=tab_class.new(@dbi,:content)
     tab.title.should=="Content"
   end
   
@@ -70,19 +71,19 @@ describe Lolita::Configuration::Tab do
   end
 
   it "should create tab when attributes are given" do
-    tab=Lolita::Configuration::Tab.new(@dbi,:fields=>[{:name=>"field one"}])
+    tab=tab_class.new(@dbi,:fields=>[{:name=>"field one"}])
     tab.fields.size.should == 1
   end
 
   it "should create tab when block is given" do
-    tab=Lolita::Configuration::Tab.new(@dbi) do
+    tab=tab_class.new(@dbi) do
       field :name=>"field one"
     end
     tab.fields.size.should == 1
   end
 
   it "should allow add fieldset to tab" do
-    tab=Lolita::Configuration::Tab.new(@dbi) do
+    tab=tab_class.new(@dbi) do
       field_set("Person information") do
         field :name=>"field one"
       end
@@ -91,7 +92,7 @@ describe Lolita::Configuration::Tab do
   end
 
   it "should keep order for fields added in tab and in tab fieldsets" do
-    tab=Lolita::Configuration::Tab.new(@dbi) do
+    tab=tab_class.new(@dbi) do
       field :name=>"one"
       field_set("Fieldset") do
         field :name=>"two"
@@ -103,11 +104,11 @@ describe Lolita::Configuration::Tab do
       end
       field :name=>"six"
     end
-    tab.fields.collect{|f| f.name}.should == [:"one",:"two",:"three",:"four",:"five",:"six"]
+    tab.fields.collect{|f| f.name }.should == [:"one",:"two",:"three",:"four",:"five",:"six"]
   end
 
   it "should get fields from fieldset" do
-     tab=Lolita::Configuration::Tab.new(@dbi) do
+     tab=tab_class.new(@dbi) do
       field :name=>"one"
       field_set("Fieldset") do
         field :name=>"two"
@@ -118,14 +119,14 @@ describe Lolita::Configuration::Tab do
   end
 
   it "should add default fields for any tab when specified" do
-    tab=Lolita::Configuration::Tab.new(@dbi,:images) do
+    tab=tab_class.new(@dbi,:images) do
       default_fields
     end
     tab.fields.size.should > 0
   end
 
   it "should add nested fields" do
-    tab=Lolita::Configuration::Tab.new(@dbi) do
+    tab=tab_class.new(@dbi) do
       default_fields
       nested_fields_for("Comment") do
         default_fields
@@ -137,7 +138,7 @@ describe Lolita::Configuration::Tab do
   end
 
   it "should detect that field is nested" do
-    tab=Lolita::Configuration::Tab.new(@dbi) do
+    tab=tab_class.new(@dbi) do
       default_fields
       nested_fields_for("Comment") do
         default_fields
@@ -147,7 +148,7 @@ describe Lolita::Configuration::Tab do
   end
   
   it "should return nested fields for specified class" do
-    tab=Lolita::Configuration::Tab.new(@dbi) do
+    tab=tab_class.new(@dbi) do
       default_fields
       nested_fields_for("Comment") do
         default_fields
@@ -156,5 +157,12 @@ describe Lolita::Configuration::Tab do
     tab.nested_fields_of("Comment").size.should > 0
   end
 
+  it "should return field with given name" do
+    tab=tab_class.new(@dbi) do
+      default_fields
+    end
+    tab.fields.by_name(:title).name.should == :title
+  end
+
 end
 

data/spec/configuration/tabs_spec.rb

@@ -2,7 +2,11 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 module Lolita
   module Configuration
-    class ImagesTab < Lolita::Configuration::Tab
+    module Tab
+      class Images < Lolita::Configuration::Tab::Base
+      end
+      class Translation < Lolita::Configuration::Tab::Base
+      end
     end
   end
 end
@@ -30,7 +34,7 @@ describe Lolita::Configuration::Tabs do
   end
 
   it "should create tabs when specified as arguments" do
-    tabs=Lolita::Configuration::Tabs.new(@dbi,:tabs=>[Lolita::Configuration::Tab.new(@dbi,:content)])
+    tabs=Lolita::Configuration::Tabs.new(@dbi,:tabs=>[Lolita::Configuration::Tab::Base.new(@dbi,:content)])
     tabs.size.should == 1
   end
 
@@ -75,8 +79,8 @@ describe Lolita::Configuration::Tabs do
     tabs=Lolita::Configuration::Tabs.new(@dbi,:default=>:content)
     tabs<<:images
     tabs<<:translation
-    tabs[tabs.size-2].class.should == Lolita::Configuration::Tab
-    tabs[tabs.size-1].class.should == Lolita::Configuration::Tab
+    tabs[tabs.size-2].class.should == Lolita::Configuration::Tab::Images
+    tabs[tabs.size-1].class.should == Lolita::Configuration::Tab::Translation
   end
 
   it "should return all tab names" do

data/spec/controllers/lolita_rest_spec.rb

@@ -21,5 +21,20 @@ describe Lolita::RestController do
     get :new
     response.body.should =~/select|input/
   end
+
+  it "should change name of field's label to 'bar' if title 'bar' given in fields configuration" do
+    tab = Post.lolita.tabs.first
+    tab.type.should == :content
+    tab.fields.by_name(:title).title = "foobar"
+    get :new
+    response.body.should =~/foobar/
+  end
+
+  it "should display inline error messages if validations fail"
+
+  it "should display all error messages at top of from if a validations fail"
+
+  it "should use field.title instead of field.name when displaying all error messages at top of form"
+
 end
 

data/spec/hooks_spec.rb

@@ -0,0 +1,191 @@
+require File.expand_path(File.dirname(__FILE__) + '/simple_spec_helper')
+
+
+class MyClass
+  def self.value(value=nil)
+    @value=value if value
+    @value
+  end
+
+  attr_accessor :name
+  def initialize
+    self.fire(:after_init)
+  end
+
+  def save
+    self.fire(:before_save)
+  end
+end
+
+class Counter
+  def self.set(val)
+    @value=val
+  end
+
+  def self.get
+    @value
+  end
+end
+describe Lolita::Hooks do
+  after(:each) do
+    MyClass.clear_hooks if MyClass.respond_to?(:clear_hooks)
+    Counter.clear_hooks if Counter.respond_to?(:clear_hooks)
+    MyClass.value(0)
+  end
+
+  it "should be possible to define hooks for class" do
+    MyClass.send(:include, Lolita::Hooks)
+    MyClass.add_hook(:after_load)
+    MyClass.hooks.should have(1).item
+  end
+
+  it "should accept callback for class" do
+    MyClass.send(:include, Lolita::Hooks)
+    MyClass.add_hook(:after_load)
+    MyClass.after_load do
+      1+1
+    end
+    MyClass.callbacks[:after_load][:blocks].should have(1).item
+    MyClass.callbacks[:after_load][:methods].should have(0).items
+  end
+
+  it "should append methods and blocks to callbacks" do
+    MyClass.send(:include,Lolita::Hooks) 
+    MyClass.add_hook(:after_load)
+    MyClass.after_load {}
+    MyClass.after_load {}
+    MyClass.after_load :method
+    MyClass.after_load :other_method
+    MyClass.callbacks[:after_load][:blocks].should have(2).items
+    MyClass.callbacks[:after_load][:methods].should have(2).items
+  end
+    
+  context "Firing callbacks" do
+
+    before(:each) do
+      MyClass.send(:include, Lolita::Hooks)
+      MyClass.add_hook(:after_load)
+      MyClass.add_hook(:after_init)
+      MyClass.add_hook(:before_save)
+    end
+
+    it "should ran on instance when called on one" do
+      MyClass.value(0)
+      MyClass.after_init do 
+        self.name="name"
+      end
+      object=MyClass.new
+      object.name.should == "name"
+    end
+
+    it "should accept callbacks for any instance" do
+      object=MyClass.new
+      object.before_save do
+        self.name="new name"
+      end
+      object.save
+      object.name.should == "new name"
+    end
+
+    it "should detect hook by name" do
+      MyClass.after_load do
+        value(true)
+      end
+      MyClass.fire(:after_load)
+      MyClass.value.should be_true
+    end
+
+    it "should have named fire method" do
+      MyClass.after_load {
+        MyClass.value(MyClass.value()+1)
+      }
+      object=MyClass.new
+      MyClass.fire_after_load
+      object.fire_after_load
+      MyClass.value.should == 2
+    end
+
+    it "should execute callback each time" do
+      MyClass.value(0)
+      MyClass.after_load do
+        value(value()+1)
+      end
+      MyClass.fire(:after_load)
+      MyClass.fire(:after_load)
+      MyClass.value.should == 2
+    end
+
+
+    context "wrap around" do
+
+      it "should allow to wrap around when #fire receive block" do
+        MyClass.after_load do 
+          value("first")
+          let_content()
+          value("second")
+        end
+
+        MyClass.fire(:after_load) do
+          value().should=="first"
+        end
+        MyClass.value.should == "second"
+      end
+    end
+  end
+
+
+  describe "named callbacks" do
+    before(:each) do
+       Lolita::Hooks::NamedHook.add(:components) unless Lolita::Hooks::NamedHook.exist?(:component)
+    end
+
+    after(:each) do
+      Lolita::Hooks.components.clear_hooks
+    end
+
+    it "should add callbacks" do
+      Lolita::Hooks.components.add_hook(:before)
+      Lolita::Hooks.components.hooks.should have(1).hook
+    end
+
+    it "should filter by name" do
+      Lolita::Hooks.components.add_hook(:before)
+      Counter.set(0)
+      Lolita::Hooks.component(:"list").before do
+        Counter.set(Counter.get+1)
+      end
+
+      Lolita::Hooks.component(:"tab").before do
+        Counter.set(Counter.get+1)
+      end
+
+      Lolita::Hooks.component(:"list").fire(:before) 
+      Counter.get.should == 1
+    end
+
+    it "should run on each named object when defined for all collection" do
+      Lolita::Hooks.components.add_hook(:after)
+      Counter.set(0)
+      Lolita::Hooks.components.after do
+        Counter.set(Counter.get+1)
+      end
+      Lolita::Hooks.component(:"list").fire(:after)
+      Lolita::Hooks.component(:"tab").fire(:after)
+      Counter.get.should == 2
+    end
+
+    it "should run all named hook callbacks when fired on named collection" do
+      Lolita::Hooks.components.add_hook(:after)
+      Counter.set(0)
+      Lolita::Hooks.component(:"list").after do
+        Counter.set(Counter.get+1)
+      end
+      Lolita::Hooks.component(:"tab").after do
+        Counter.set(Counter.get+1)
+      end
+      Lolita::Hooks.components.fire(:after)
+      Counter.get.should == 2
+    end
+
+  end
+end