lolita 3.1.10 → 3.1.11

data/spec/adapter_helper.rb

@@ -1,44 +1,44 @@
-if ADAPTER=='mongoid'
-  require 'mongoid'
-  Mongoid.configure do |config|
-    name = "lolita3_test"
-    host = "localhost"
-    config.master = Mongo::Connection.new.db(name)
-    config.slaves = [
-      Mongo::Connection.new(host, 27017, :slave_ok => true).db(name)
-    ]
-    #config.use_object_ids = true
-    config.persist_in_safe_mode = false
-  end
-else
-  require 'active_record'
-  ActiveRecord::Base.establish_connection({ :database => ":memory:", :adapter => 'sqlite3', :timeout => 500 })
-  ActiveRecord::Schema.define do
-    create_table :posts, :force => true do |t|
-      t.string :field_one
-    end
-    create_table :test_class2, :force => true do |t|
-      t.string :field_one
-    end
-    create_table :pages,:force=>true do |t|
-      t.string :name
-    end
-  end
-  
-  class Comment < ActiveRecord::Base
-    belongs_to :test_class1, :class_name=>"Post"
-  end
-
-  class Post < ActiveRecord::Base
-    has_many :pages
-    include Lolita::Configuration
-    lolita 
-  end
-
-  class Profile < ActiveRecord::Base
-    include Lolita::Configuration
-    lolita do
-      
-    end
-  end
+if ADAPTER=='mongoid'
+  require 'mongoid'
+  Mongoid.configure do |config|
+    name = "lolita3_test"
+    host = "localhost"
+    config.master = Mongo::Connection.new.db(name)
+    config.slaves = [
+      Mongo::Connection.new(host, 27017, :slave_ok => true).db(name)
+    ]
+    #config.use_object_ids = true
+    config.persist_in_safe_mode = false
+  end
+else
+  require 'active_record'
+  ActiveRecord::Base.establish_connection({ :database => ":memory:", :adapter => 'sqlite3', :timeout => 500 })
+  ActiveRecord::Schema.define do
+    create_table :posts, :force => true do |t|
+      t.string :field_one
+    end
+    create_table :test_class2, :force => true do |t|
+      t.string :field_one
+    end
+    create_table :pages,:force=>true do |t|
+      t.string :name
+    end
+  end
+  
+  class Comment < ActiveRecord::Base
+    belongs_to :test_class1, :class_name=>"Post"
+  end
+
+  class Post < ActiveRecord::Base
+    has_many :pages
+    include Lolita::Configuration
+    lolita 
+  end
+
+  class Profile < ActiveRecord::Base
+    include Lolita::Configuration
+    lolita do
+      
+    end
+  end
 end

data/spec/builder_spec.rb

@@ -1,121 +1,121 @@
-require File.expand_path(File.dirname(__FILE__) + '/simple_spec_helper')
-
-class SimpleObject 
-  include Lolita::Builder
-end
-
-describe Lolita::Builder::Custom do
-  let(:object){SimpleObject.new}
-  let(:builder){Lolita::Builder::Custom.new(object,{})}
-  let(:klass){Lolita::Builder::Custom}
-
-  it "should create new Custom builder" do
-    builder = Lolita::Builder::Custom.new(object,{})
-  end
-
-  it "should set name and state" do
-    builder = Lolita::Builder::Custom.new(object,{:name => "name", :state=>"state"})
-    builder.instance_variable_get(:"@name").should == "name"
-    builder.instance_variable_get(:"@state").should == "state"
-  end
-
-  it "should set default attributes" do
-    builder = Lolita::Builder::Custom.new(object,{:name => "name"})
-    builder.instance_variable_get(:"@state").should == :display
-  end
-
-  describe "build attributes" do
-    it "should set through #with" do
-      builder.with("name","state").build_attributes.should == {:name => "name", :state => "state"}
-      builder.with({:name=>"name",:state=>"state"}).build_attributes.should == {:name => "name", :state=>"state"}
-      builder.with("name",:state=>"state").build_attributes.should == {:name=>"name",:state=>"state"}
-    end
-  end
-
-  it "should return default state when no build attributes given" do
-    builder.state.should == :display
-  end
-
-  it "should return build attributes state when given" do
-    builder.with(:state=>"state").state.should == :"state"
-  end
-
-  it "should return default name when no build name given" do
-    builder.name.should == :"/simple_object"
-  end
-
-  it "should return build name when given" do
-    builder.with(:name => "name").name.should == :"/simple_object/name"
-    builder.with(:name => "/name").name.should == :"/name"
-  end
-
-  describe "#build" do
-    it "should return array with name,state and options" do
-      builder.build.should == [:"/simple_object",:"display",{}]
-      builder.with({:display_value => 1}).build.should == [:"/simple_object",:display,{:display_value=>1}]
-    end
-  end
-
-  describe "conditions" do
-    it "should use given over default when there's no conditions" do
-      builder = klass.new(object,:name => "/custom", :state => "special")
-      builder.build.should == [:"/custom",:"special",{}]
-    end
-
-    it "should use given over default when conditions met" do
-      builder = klass.new(object, :name => "/custom", :state=>"special", :unless=>{:state=>"display"})
-      builder.build.should == [:"/simple_object",:"display",{}]
-      builder.class_eval do
-        def default_state
-          :other
-        end
-      end
-      builder.build.should == [:"/custom",:special,{}]
-    end
-
-    it "should use given over build given when conditions met" do
-      builder = klass.new(object,:name => "/custom", :"state" => "special", :if=>{:state=>"default"})
-      builder.with(:state => "other").build.should == [:"/simple_object",:other,{}]
-      builder.with(:state => :default).build.should == [:"/custom",:special,{}]
-    end
-  end
-end
-
-describe Lolita::Builder do
-
-  let(:object){SimpleObject.new}
-
-  describe "#build" do
-
-    describe "default path" do
-
-      it "should be /:class_name/display" do
-        info=object.build
-        info.first.should == :"/simple_object"
-        info[1].should == :display
-      end
-
-      it "should use given name when it starts with /" do
-        object.builder = {:name =>"/custom"}
-        info = object.build
-        info.first.should == :"/custom"
-        info[1].should == :display
-      end
-
-      it "should make name /:class_name/:custom_name when it doesn't start with /" do
-        object.builder = {:name => "custom"}
-        info = object.build
-        info.first.should == :"/simple_object/custom"
-        info[1].should == :display
-      end
-    
-    end
-
-    it "should use received name" do
-      object.builder = {:name=>"/custom"}
-      info = object.build("/other_custom")
-      info.first.should == :"/other_custom"
-    end
-
-  end
+require File.expand_path(File.dirname(__FILE__) + '/simple_spec_helper')
+
+class SimpleObject 
+  include Lolita::Builder
+end
+
+describe Lolita::Builder::Custom do
+  let(:object){SimpleObject.new}
+  let(:builder){Lolita::Builder::Custom.new(object,{})}
+  let(:klass){Lolita::Builder::Custom}
+
+  it "should create new Custom builder" do
+    builder = Lolita::Builder::Custom.new(object,{})
+  end
+
+  it "should set name and state" do
+    builder = Lolita::Builder::Custom.new(object,{:name => "name", :state=>"state"})
+    builder.instance_variable_get(:"@name").should == "name"
+    builder.instance_variable_get(:"@state").should == "state"
+  end
+
+  it "should set default attributes" do
+    builder = Lolita::Builder::Custom.new(object,{:name => "name"})
+    builder.instance_variable_get(:"@state").should == :display
+  end
+
+  describe "build attributes" do
+    it "should set through #with" do
+      builder.with("name","state").build_attributes.should == {:name => "name", :state => "state"}
+      builder.with({:name=>"name",:state=>"state"}).build_attributes.should == {:name => "name", :state=>"state"}
+      builder.with("name",:state=>"state").build_attributes.should == {:name=>"name",:state=>"state"}
+    end
+  end
+
+  it "should return default state when no build attributes given" do
+    builder.state.should == :display
+  end
+
+  it "should return build attributes state when given" do
+    builder.with(:state=>"state").state.should == :"state"
+  end
+
+  it "should return default name when no build name given" do
+    builder.name.should == :"/simple_object"
+  end
+
+  it "should return build name when given" do
+    builder.with(:name => "name").name.should == :"/simple_object/name"
+    builder.with(:name => "/name").name.should == :"/name"
+  end
+
+  describe "#build" do
+    it "should return array with name,state and options" do
+      builder.build.should == [:"/simple_object",:"display",{}]
+      builder.with({:display_value => 1}).build.should == [:"/simple_object",:display,{:display_value=>1}]
+    end
+  end
+
+  describe "conditions" do
+    it "should use given over default when there's no conditions" do
+      builder = klass.new(object,:name => "/custom", :state => "special")
+      builder.build.should == [:"/custom",:"special",{}]
+    end
+
+    it "should use given over default when conditions met" do
+      builder = klass.new(object, :name => "/custom", :state=>"special", :unless=>{:state=>"display"})
+      builder.build.should == [:"/simple_object",:"display",{}]
+      builder.class_eval do
+        def default_state
+          :other
+        end
+      end
+      builder.build.should == [:"/custom",:special,{}]
+    end
+
+    it "should use given over build given when conditions met" do
+      builder = klass.new(object,:name => "/custom", :"state" => "special", :if=>{:state=>"default"})
+      builder.with(:state => "other").build.should == [:"/simple_object",:other,{}]
+      builder.with(:state => :default).build.should == [:"/custom",:special,{}]
+    end
+  end
+end
+
+describe Lolita::Builder do
+
+  let(:object){SimpleObject.new}
+
+  describe "#build" do
+
+    describe "default path" do
+
+      it "should be /:class_name/display" do
+        info=object.build
+        info.first.should == :"/simple_object"
+        info[1].should == :display
+      end
+
+      it "should use given name when it starts with /" do
+        object.builder = {:name =>"/custom"}
+        info = object.build
+        info.first.should == :"/custom"
+        info[1].should == :display
+      end
+
+      it "should make name /:class_name/:custom_name when it doesn't start with /" do
+        object.builder = {:name => "custom"}
+        info = object.build
+        info.first.should == :"/simple_object/custom"
+        info[1].should == :display
+      end
+    
+    end
+
+    it "should use received name" do
+      object.builder = {:name=>"/custom"}
+      info = object.build("/other_custom")
+      info.first.should == :"/other_custom"
+    end
+
+  end
 end

data/spec/configuration/base_spec.rb

@@ -1,44 +1,44 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Lolita::Configuration::Base do
-#    before(:each) do
-#      @base = Lolita::Configuration::Base.new
-#    end
-
-  it "should define configuration without block" do
-    Post.lolita.should_not be_nil
-  end
-
-  it "should define configuration with block" do
-    Profile.lolita.should_not be_nil
-  end
-
-  it "should not initialize instance methods for configuration without calling them" do
-    Profile.lolita.list.to_s.should match(/Lolita::LazyLoader/)
-    Post.lolita.list.to_s.should match(/Lolita::LazyLoader/)
-  end
-
-  it "should return real object when calling it" do
-    define_config do
-      list
-    end
-    Post.lolita.list.class.to_s.should == "Lolita::Configuration::List"
-  end
-
-  it "should return tabs" do
-    define_config
-    Post.lolita.tabs.class.should == Lolita::Configuration::Tabs
-  end
-
-  it "should allow add tabs" do
-    define_config do
-      tab(:content)
-    end
-    Post.lolita.tabs.size.should == 1
-  end
-  
-  def define_config &block
-    Post.lolita=Lolita::Configuration::Base.new(Post,&block)
-  end
-end
-
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Lolita::Configuration::Base do
+#    before(:each) do
+#      @base = Lolita::Configuration::Base.new
+#    end
+
+  it "should define configuration without block" do
+    Post.lolita.should_not be_nil
+  end
+
+  it "should define configuration with block" do
+    Profile.lolita.should_not be_nil
+  end
+
+  it "should not initialize instance methods for configuration without calling them" do
+    Profile.lolita.list.to_s.should match(/Lolita::LazyLoader/)
+    Post.lolita.list.to_s.should match(/Lolita::LazyLoader/)
+  end
+
+  it "should return real object when calling it" do
+    define_config do
+      list
+    end
+    Post.lolita.list.class.to_s.should == "Lolita::Configuration::List"
+  end
+
+  it "should return tabs" do
+    define_config
+    Post.lolita.tabs.class.should == Lolita::Configuration::Tabs
+  end
+
+  it "should allow add tabs" do
+    define_config do
+      tab(:content)
+    end
+    Post.lolita.tabs.size.should == 1
+  end
+  
+  def define_config &block
+    Post.lolita=Lolita::Configuration::Base.new(Post,&block)
+  end
+end
+

data/spec/configuration/column_spec.rb

@@ -1,89 +1,89 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Lolita::Configuration::Column do
-  let(:dbi){Lolita::DBI::Base.new(Post)}
-  let(:column){Lolita::Configuration::Column.new(dbi,:col1)}
-  
-  
-  it "should create new column with Hash attributes" do
-    column=Lolita::Configuration::Column.new(dbi,:name=>"col1",:title=>"Col1",:type=>String)
-    column.name.should == "col1"
-  end
-
-  it "should create new column with Proc as block given" do
-    p=Proc.new{
-      name "col1"
-      title "Col one"
-      type String
-    }
-    column=Lolita::Configuration::Column.new dbi,&p
-    column.type.should == String
-  end
-
-  it "should create new column with block given" do
-    column=Lolita::Configuration::Column.new(dbi) do
-      name "col1"
-      title "Col one"
-      type String
-    end
-    column.title.size.should > 0
-  end
-
-  it "should create new column when String or Symbol is given" do
-    column=Lolita::Configuration::Column.new(dbi,:col1)
-    column.name.should == "col1"
-    column=Lolita::Configuration::Column.new(dbi,"col2")
-    column.name.should == "col2"
-  end
-  
-  it "should raise error when no name is provided for column" do
-    lambda{
-      Lolita::Configuration::Column.new(dbi) do
-        title "Col one"
-      end
-    }.should raise_error(ArgumentError, "Column must have name.")
-  end
-
-  it "should allow to add formatter with block" do
-    column.formatter do|value|
-      "value #{value}"
-    end
-    column.formatter.with("1").should == "value 1"
-  end
-
-  it "should allow to add formatter as attribute" do
-    column.type :float
-    column.formatter = "%.3f"
-    column.formatter.with(44.88).should == "44.880"
-  end
-
-  it "should allow to add formatter as attribute with Lolita::Support instance" do
-    column.formatter = Lolita::Support::Formatter.new("%s")
-    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_false
-    column.formatter = "%s"
-    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_true
-  end
-
-  it "should allow to add formatter as block with Lolita::Support instance" do
-    column=Lolita::Configuration::Column.new(dbi) do
-      name "col1"
-      title "Col one"
-      type String
-      formatter Lolita::Support::Formatter.new("%s")
-    end
-    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_false
-    column=Lolita::Configuration::Column.new(dbi) do
-      name "col1"
-      title "Col one"
-      type String
-      formatter "%s"
-    end    
-    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_true
-  end
-
-  it "should make default formater not defined" do
-    column.formatter.with(1).should == 1
-  end
-
-end
-
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Lolita::Configuration::Column do
+  let(:dbi){Lolita::DBI::Base.new(Post)}
+  let(:column){Lolita::Configuration::Column.new(dbi,:col1)}
+  
+  
+  it "should create new column with Hash attributes" do
+    column=Lolita::Configuration::Column.new(dbi,:name=>"col1",:title=>"Col1",:type=>String)
+    column.name.should == "col1"
+  end
+
+  it "should create new column with Proc as block given" do
+    p=Proc.new{
+      name "col1"
+      title "Col one"
+      type String
+    }
+    column=Lolita::Configuration::Column.new dbi,&p
+    column.type.should == String
+  end
+
+  it "should create new column with block given" do
+    column=Lolita::Configuration::Column.new(dbi) do
+      name "col1"
+      title "Col one"
+      type String
+    end
+    column.title.size.should > 0
+  end
+
+  it "should create new column when String or Symbol is given" do
+    column=Lolita::Configuration::Column.new(dbi,:col1)
+    column.name.should == "col1"
+    column=Lolita::Configuration::Column.new(dbi,"col2")
+    column.name.should == "col2"
+  end
+  
+  it "should raise error when no name is provided for column" do
+    lambda{
+      Lolita::Configuration::Column.new(dbi) do
+        title "Col one"
+      end
+    }.should raise_error(ArgumentError, "Column must have name.")
+  end
+
+  it "should allow to add formatter with block" do
+    column.formatter do|value|
+      "value #{value}"
+    end
+    column.formatter.with("1").should == "value 1"
+  end
+
+  it "should allow to add formatter as attribute" do
+    column.type :float
+    column.formatter = "%.3f"
+    column.formatter.with(44.88).should == "44.880"
+  end
+
+  it "should allow to add formatter as attribute with Lolita::Support instance" do
+    column.formatter = Lolita::Support::Formatter.new("%s")
+    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_false
+    column.formatter = "%s"
+    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_true
+  end
+
+  it "should allow to add formatter as block with Lolita::Support instance" do
+    column=Lolita::Configuration::Column.new(dbi) do
+      name "col1"
+      title "Col one"
+      type String
+      formatter Lolita::Support::Formatter.new("%s")
+    end
+    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_false
+    column=Lolita::Configuration::Column.new(dbi) do
+      name "col1"
+      title "Col one"
+      type String
+      formatter "%s"
+    end    
+    column.formatter.is_a?(Lolita::Support::Formatter::Rails).should be_true
+  end
+
+  it "should make default formater not defined" do
+    column.formatter.with(1).should == 1
+  end
+
+end
+