lolita 3.4.2 → 3.4.3

data/spec/adapter_helper.rb

@@ -1,43 +1,43 @@
-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.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.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,23 +1,23 @@
-require 'simple_spec_helper'
-
-describe Lolita::Configuration::Base do 
-  let(:klass){Lolita::Configuration::Base}
-  let(:dbp){Object.new}
-
-  it "should include Lolita::Builder" do 
-    klass.ancestors.should include(Lolita::Builder)
-  end
-
-  it "should respond to dbp" do 
-    klass.new(dbp).should respond_to(:dbp)
-  end
-
-  it "should respond to dbi" do 
-    klass.new(dbp).should respond_to(:dbi)
-  end
-
-  it "should call all args hash part keys as writer methods " do
-    klass.any_instance.should_receive(:my_method=).with(1)
-    klass.new(dbp, :my_method => 1)
-  end
+require 'simple_spec_helper'
+
+describe Lolita::Configuration::Base do 
+  let(:klass){Lolita::Configuration::Base}
+  let(:dbp){Object.new}
+
+  it "should include Lolita::Builder" do 
+    klass.ancestors.should include(Lolita::Builder)
+  end
+
+  it "should respond to dbp" do 
+    klass.new(dbp).should respond_to(:dbp)
+  end
+
+  it "should respond to dbi" do 
+    klass.new(dbp).should respond_to(:dbi)
+  end
+
+  it "should call all args hash part keys as writer methods " do
+    klass.any_instance.should_receive(:my_method=).with(1)
+    klass.new(dbp, :my_method => 1)
+  end
 end

data/spec/configuration/field_spec.rb

@@ -1,118 +1,118 @@
-require 'spec_helper'
-
-describe Lolita::Configuration::Field do
-  before(:each) do
-    @dbi=Lolita::DBI::Base.create(Post)
-    @dbi2=Lolita::DBI::Base.create(Comment)
-  end
-
-  let(:field_class){Lolita::Configuration::Field::Base}
-  let(:factory_class){Lolita::Configuration::Factory::Field}
-
-  it "should create new field" do
-    Lolita::Configuration::Field::Base.new(@dbi,:title,:string)
-  end
-
-  it "should create field when block given" do
-    field=field_class.new(@dbi,:title,:string) do
-  
-    end
-    field.name.should == :title
-  end
-
-  it "should raise error when no name specified" do
-    lambda{
-     field_class.new(@dbi,nil,nil)
-    }.should raise_error Lolita::FieldNameError
-  end
-
-  it "should raise error when class don't respond to field method when not value specified" do
-#    Lolita::Configuration::Field.new(@dbi,:title,:value=>"Field value")
-#    lambda{
-#      Lolita::Configuration::Field.new(@dbi,:noname)
-#    }.should raise_error Lolita::FieldNameError
-  end
-  
-  it "should always set field title if not specified" do
-    field=field_class.new(@dbi,:title)
-    field.title.size.should > 0
-  end
-
-  it "should raise error when field is nested in class that do not reference to field class" do
-    lambda{
-      field=field_class.new(@dbi,:title,:nested_in=>Lolita::DBI::Base.new(Address))
-    }.should raise_error Lolita::ReferenceError
-  end
-
-  it "should detect if field is nested in" do
-    field=field_class.new(@dbi2,:body,:nested_in=>@dbi)
-    field.nested?.should be_true
-  end
-
-  it "should detect if field is nested in given class" do
-    field=field_class.new(@dbi2,:body,:nested_in=>@dbi)
-    field.nested_in?(@dbi.klass).should be_true
-  end
-
-  it "should detect type and create field with specified type" do
-    require "rails_app/lib/lolita/configuration/field/my_custom_collection"
-    field=Lolita::Configuration::Factory::Field.add(@dbi,:comments, :my_custom_collection)
-    field.type.should == "my_custom_collection"
-  end
-
-  it "should fallback to string type if given type is not supported" do
-    field=Lolita::Configuration::Factory::Field.add(@dbi,:is_public)
-    field.type.should == "boolean"
-  end
-
-  it "should change field type for association columns if custom type is given" do
-    pending
-  end
-
-  it "should set field title when not specified" do
-    field=field_class.new(@dbi,:title)
-    field.title.should == "Title"
-  end
-
-  it "should allow set field that is referenced in (belongs_to) any class" do
-    field=Lolita::Configuration::Factory::Field.add(@dbi2,:post,:array)
-    field.type.should == "array"
-    field.association.macro.should == :one
-  end
-
-  it "should allow set field that references to (has_many or has_one) any class" do
-    field=Lolita::Configuration::Factory::Field.add(@dbi,:comments,:array)
-    field.type.to_s.should == "array"
-    field.association.macro.should == :many
-  end
-
-  it "should match state with given record state" do
-    field = factory_class.add(@dbi, :title, :string, :on => :create)
-    field2 = factory_class.add(@dbi, :title, :string, :on => [:update])
-    field3 = factory_class.add(@dbi, :title, :string)
-    field4 = factory_class.add(@dbi, :title, :string, :on => Proc.new{|rec| rec.title == "title"})
-    record = @dbi.klass.new
-    field.match_state_of?(record).should be_true
-    field2.match_state_of?(record).should_not be_true
-    field3.match_state_of?(record).should be_true
-    field4.match_state_of?(record).should_not be_true
-    record2 = @dbi.klass.create!(:title => "title")
-    field.match_state_of?(record2).should_not be_true
-    field2.match_state_of?(record2).should be_true
-    field3.match_state_of?(record2).should be_true
-    field4.match_state_of?(record2).should be_true
-  end
-
-  it "should match :read state for record" do
-    field = factory_class.add(@dbi,:title,:string, :on => :create)
-    field2 = factory_class.add(@dbi,:title,:string, :on => :read)
-    field3 = factory_class.add(@dbi,:title,:string)
-    record = @dbi.klass.new
-    @dbi.switch_record_state(record,:read)
-    field.match_state_of?(record).should_not be_true
-    field2.match_state_of?(record).should be_true
-    field3.match_state_of?(record).should be_true
-  end
-
-end
-
+require 'spec_helper'
+
+describe Lolita::Configuration::Field do
+  before(:each) do
+    @dbi=Lolita::DBI::Base.create(Post)
+    @dbi2=Lolita::DBI::Base.create(Comment)
+  end
+
+  let(:field_class){Lolita::Configuration::Field::Base}
+  let(:factory_class){Lolita::Configuration::Factory::Field}
+
+  it "should create new field" do
+    Lolita::Configuration::Field::Base.new(@dbi,:title,:string)
+  end
+
+  it "should create field when block given" do
+    field=field_class.new(@dbi,:title,:string) do
+  
+    end
+    field.name.should == :title
+  end
+
+  it "should raise error when no name specified" do
+    lambda{
+     field_class.new(@dbi,nil,nil)
+    }.should raise_error Lolita::FieldNameError
+  end
+
+  it "should raise error when class don't respond to field method when not value specified" do
+#    Lolita::Configuration::Field.new(@dbi,:title,:value=>"Field value")
+#    lambda{
+#      Lolita::Configuration::Field.new(@dbi,:noname)
+#    }.should raise_error Lolita::FieldNameError
+  end
+  
+  it "should always set field title if not specified" do
+    field=field_class.new(@dbi,:title)
+    field.title.size.should > 0
+  end
+
+  it "should raise error when field is nested in class that do not reference to field class" do
+    lambda{
+      field=field_class.new(@dbi,:title,:nested_in=>Lolita::DBI::Base.new(Address))
+    }.should raise_error Lolita::ReferenceError
+  end
+
+  it "should detect if field is nested in" do
+    field=field_class.new(@dbi2,:body,:nested_in=>@dbi)
+    field.nested?.should be_true
+  end
+
+  it "should detect if field is nested in given class" do
+    field=field_class.new(@dbi2,:body,:nested_in=>@dbi)
+    field.nested_in?(@dbi.klass).should be_true
+  end
+
+  it "should detect type and create field with specified type" do
+    require "rails_app/lib/lolita/configuration/field/my_custom_collection"
+    field=Lolita::Configuration::Factory::Field.add(@dbi,:comments, :my_custom_collection)
+    field.type.should == "my_custom_collection"
+  end
+
+  it "should fallback to string type if given type is not supported" do
+    field=Lolita::Configuration::Factory::Field.add(@dbi,:is_public)
+    field.type.should == "boolean"
+  end
+
+  it "should change field type for association columns if custom type is given" do
+    pending
+  end
+
+  it "should set field title when not specified" do
+    field=field_class.new(@dbi,:title)
+    field.title.should == "Title"
+  end
+
+  it "should allow set field that is referenced in (belongs_to) any class" do
+    field=Lolita::Configuration::Factory::Field.add(@dbi2,:post,:array)
+    field.type.should == "array"
+    field.association.macro.should == :one
+  end
+
+  it "should allow set field that references to (has_many or has_one) any class" do
+    field=Lolita::Configuration::Factory::Field.add(@dbi,:comments,:array)
+    field.type.to_s.should == "array"
+    field.association.macro.should == :many
+  end
+
+  it "should match state with given record state" do
+    field = factory_class.add(@dbi, :title, :string, :on => :create)
+    field2 = factory_class.add(@dbi, :title, :string, :on => [:update])
+    field3 = factory_class.add(@dbi, :title, :string)
+    field4 = factory_class.add(@dbi, :title, :string, :on => Proc.new{|rec| rec.title == "title"})
+    record = @dbi.klass.new
+    field.match_state_of?(record).should be_true
+    field2.match_state_of?(record).should_not be_true
+    field3.match_state_of?(record).should be_true
+    field4.match_state_of?(record).should_not be_true
+    record2 = @dbi.klass.create!(:title => "title")
+    field.match_state_of?(record2).should_not be_true
+    field2.match_state_of?(record2).should be_true
+    field3.match_state_of?(record2).should be_true
+    field4.match_state_of?(record2).should be_true
+  end
+
+  it "should match :read state for record" do
+    field = factory_class.add(@dbi,:title,:string, :on => :create)
+    field2 = factory_class.add(@dbi,:title,:string, :on => :read)
+    field3 = factory_class.add(@dbi,:title,:string)
+    record = @dbi.klass.new
+    @dbi.switch_record_state(record,:read)
+    field.match_state_of?(record).should_not be_true
+    field2.match_state_of?(record).should be_true
+    field3.match_state_of?(record).should be_true
+  end
+
+end
+