orientdb-ar 0.0.4-jruby → 0.0.5-jruby

data/lib/orientdb-ar/relations.rb

@@ -1,65 +1,31 @@
 module OrientDB::AR
   module Relations
 
-    def embedds_one(klass, options = {})
-      klass = klass_for klass
-      name = options[:name].to_s || field_name_for(klass, true)
-
-      field name, [OrientDB::FIELD_TYPES[:embedded], klass.oclass]
-
-      class_eval <<-eorb, __FILE__, __LINE__ + 1
-        def #{name}                                                          # def address
-          self[:#{name}]                                                     #   self[:address]
-        end                                                                  # end
-      eorb
-
-      class_eval <<-eorb, __FILE__, __LINE__ + 1
-        def #{name}=(value)                                                  # def address=(value)
-          self[:#{name}] = value                                             #   self[:address] = value.odocument
-          #{name}                                                            #   address
-        end                                                                  # end
-      eorb
-    end
-
-    def embedds_many(klass, options = {})
-      klass = klass_for klass
-      name = options[:name].to_s || field_name_for(klass, false)
-
-      field name, [OrientDB::FIELD_TYPES[:embedded_list], klass.oclass]
-
-      class_eval <<-eorb, __FILE__, __LINE__ + 1
-        def #{name}                                         # def addresses
-          self[:#{name}]                                    #   self[:addresses]
-        end                                                 # end
-      eorb
-
-      class_eval <<-eorb, __FILE__, __LINE__ + 1
-        def #{name}=(value)                                 # def addresses=(value)
-          self[:#{name}]                                    #   self[:addresses]
-        end                                                 # end
-      eorb
+    private
 
-      class_eval <<-eorb, __FILE__, __LINE__ + 1
-        def add_#{name.singularize}(value)                  # def add_address(value)
-          self[:#{name}] ||= []                             #   self[:addresses] ||= []
-          self[:#{name}] << value                           #   self[:addresses] << value
-          #{name}                                           #   addresses
-        end                                                 # end
-      eorb
+    def check_rel_options(klass_name, options, plurality, default = nil)
+      klass_name          = klass_name_for klass_name
+      options[:plurality] ||= plurality
+      options[:name]      ||= field_name_for klass_name, plurality
+      options[:name]      = options[:name].to_s
+      options[:default]   ||= default
+      [klass_name, options]
     end
 
-    private
-
-    def klass_for(klass)
-      return klass if klass.class.name == 'Class'
-      klass.to_s.singularize.camelize.constantize
-    rescue
-      raise "Problem getting klass for [#{klass}]"
+    def klass_name_for(klass_name)
+      return klass_name.name if klass_name.class.name == 'Class'
+      klass_name.to_s
     end
 
-    def field_name_for(klass, singular)
-      klass.to_s.underscore.send(singular ? :singularize : :pluralize).gsub('/', '__')
+    def field_name_for(klass, plurality)
+      plurality_meth = plurality.to_s + 'ize'
+      klass.to_s.underscore.send(plurality_meth).gsub('/', '__')
     end
 
   end
-end
+end
+
+require 'orientdb-ar/relations/embedds_one'
+require 'orientdb-ar/relations/embedds_many'
+require 'orientdb-ar/relations/links_one'
+require 'orientdb-ar/relations/links_many'

data/lib/orientdb-ar/relations/embedds_many.rb

@@ -0,0 +1,40 @@
+module OrientDB::AR
+  module Relations
+
+    def embedds_many(klass_name, options = { })
+      klass_name, options = check_rel_options klass_name, options, :plural, []
+      name = options[:name]
+
+      relationships[name] = options.merge :type => :embedds_many, :class_name => klass_name
+
+      field name, [OrientDB::FIELD_TYPES[:embedded_list], OrientDB::AR::Base.oclass_name_for(klass_name)]
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}                                         # def address
+          self[:#{name}] || #{options[:default].inspect}    #   self[:address] || nil
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}=(value)                                 # def addresses=(value)
+          self[:#{name}] = value                            #   self[:addresses] = value
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def add_#{name.singularize}(value)                  # def add_address(value)
+          self[:#{name}] ||= #{options[:default].inspect}   #   self[:addresses] ||= []
+          self[:#{name}] << self.class.to_orientdb(value)   #   self[:addresses] << self.class.to_orientdb(value)
+          #{name}                                           #   addresses
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def build_#{name}(fields = {})                      # def build_address(fields = {})
+          add_#{name} #{klass_name}.new fields              #   self[:addresses] = Address.new fields
+        end                                                 # end
+      eorb
+    end
+
+  end
+end

data/lib/orientdb-ar/relations/embedds_one.rb

@@ -0,0 +1,33 @@
+module OrientDB::AR
+  module Relations
+
+    def embedds_one(klass_name, options = { })
+      klass_name, options = check_rel_options klass_name, options, :singular
+      name = options[:name]
+
+      relationships[name] = options.merge :type => :embedds_one, :class_name => klass_name
+
+      field name, [OrientDB::FIELD_TYPES[:embedded], OrientDB::AR::Base.oclass_name_for(klass_name)]
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}                                         # def address
+          self[:#{name}] || #{options[:default].inspect}    #   self[:address] || nil
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}=(value)                                 # def addresses=(value)
+          self[:#{name}] = value                            #   self[:addresses] = value
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def build_#{name}(fields = {})                      # def build_address(fields = {})
+          self[:#{name}] = #{klass_name}.new fields         #   self[:addresses] = Address.new fields
+          #{name}                                           #   address
+        end                                                 # end
+      eorb
+    end
+
+  end
+end

data/lib/orientdb-ar/relations/links_many.rb

@@ -0,0 +1,46 @@
+module OrientDB::AR
+  module Relations
+
+    def links_many(klass_name, options = { })
+      klass_name, options = check_rel_options klass_name, options, :plural, []
+      name = options[:name]
+
+      relationships[name] = options.merge :type => :links_many, :class_name => klass_name
+
+      field name, [OrientDB::FIELD_TYPES[:link_list], OrientDB::AR::Base.oclass_name_for(klass_name)]
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}                                         # def address
+          self[:#{name}] || #{options[:default].inspect}    #   self[:address] || nil
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}=(value)                                 # def addresses=(value)
+          self[:#{name}] = value                            #   self[:addresses] = value
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def add_#{name.singularize}(value)                  # def add_address(value)
+          self[:#{name}] ||= #{options[:default].inspect}   #   self[:addresses] ||= []
+          self[:#{name}] << self.class.to_orientdb(value)   #   self[:addresses] << self.class.to_orientdb(value)
+          #{name}                                           #   addresses
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def build_#{name}(fields = {})                      # def build_address(fields = {})
+          add_#{name} #{klass_name}.new fields              #   self[:addresses] = Address.new fields
+        end                                                 # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def create_#{name}(fields = {})                     # def create_address(fields = {})
+          add_#{name} #{klass_name}.create fields           #   self[:addresses] = Address.create fields
+        end                                                 # end
+      eorb
+    end
+
+  end
+end

data/lib/orientdb-ar/relations/links_one.rb

@@ -0,0 +1,41 @@
+module OrientDB::AR
+  module Relations
+
+    def links_one(klass_name, options = { })
+      klass_name, options = check_rel_options klass_name, options, :singular
+      puts "links_one : #{klass_name} : #{options.inspect}"
+      name = options[:name]
+
+      relationships[name] = options.merge :type => :links_one, :class_name => klass_name
+
+      field name, [OrientDB::FIELD_TYPES[:link], OrientDB::AR::Base.oclass_name_for(klass_name)]
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}                                          # def address
+          self[:#{name}] || #{options[:default].inspect}     #   self[:address] || nil
+        end                                                  # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def #{name}=(value)                                  # def addresses=(value)
+          self[:#{name}] = value                             #   self[:addresses] = value
+        end                                                  # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def build_#{name}(fields = {})                       # def build_address(fields = {})
+          self[:#{name}] = #{klass_name}.new fields          #   self[:addresses] = Address.create fields
+          #{name}                                            #   address
+        end                                                  # end
+      eorb
+
+      class_eval <<-eorb, __FILE__, __LINE__ + 1
+        def create_#{name}(fields = {})                      # def create_address(fields = {})
+          self[:#{name}] = #{klass_name}.create fields       #   self[:addresses] = Address.create fields
+          #{name}                                            #   address
+        end                                                  # end
+      eorb
+    end
+
+  end
+end

data/lib/orientdb-ar/sql/query.rb

@@ -2,6 +2,12 @@ class OrientDB::AR::Query
 
   attr_accessor :model, :query
 
+  def self.for_oclass(name, query = OrientDB::SQL::Query.new)
+    obj = new OrientDB::AR::Base, query
+    obj.from OrientDB::AR::Base.oclass_name_for name
+    obj
+  end
+
   def initialize(model, query = OrientDB::SQL::Query.new)
     @model, @query = model, query
     @query.from model.oclass_name

data/orientdb-ar.gemspec

@@ -5,16 +5,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{orientdb-ar}
-  s.version = "0.0.4"
+  s.version = "0.0.5"
   s.platform = %q{jruby}
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Adrian Madrid"]
-  s.date = %q{2011-01-26}
-  s.default_executable = %q{orientdbar_console}
+  s.authors = [%q{Adrian Madrid}]
+  s.date = %q{2012-01-12}
   s.description = %q{Active Model wrappers to persist Ruby objects under OrientDB in JRuby.}
-  s.email = ["aemadrid@gmail.com"]
-  s.executables = ["orientdbar_console"]
+  s.email = [%q{aemadrid@gmail.com}]
+  s.executables = [%q{orientdbar_console}]
   s.extra_rdoc_files = [
     "LICENSE",
     "README.rdoc"
@@ -36,12 +35,15 @@ Gem::Specification.new do |s|
     "lib/orientdb-ar/embedded.rb",
     "lib/orientdb-ar/ext.rb",
     "lib/orientdb-ar/relations.rb",
+    "lib/orientdb-ar/relations/embedds_many.rb",
+    "lib/orientdb-ar/relations/embedds_one.rb",
+    "lib/orientdb-ar/relations/links_many.rb",
+    "lib/orientdb-ar/relations/links_one.rb",
     "lib/orientdb-ar/sql.rb",
     "lib/orientdb-ar/sql/delete.rb",
     "lib/orientdb-ar/sql/insert.rb",
     "lib/orientdb-ar/sql/query.rb",
     "lib/orientdb-ar/sql/update.rb",
-    "lib/orientdb-ar/validations.rb",
     "orientdb-ar.gemspec",
     "spec/base_spec.rb",
     "spec/dirty_spec.rb",
@@ -51,36 +53,42 @@ Gem::Specification.new do |s|
     "spec/models/address.rb",
     "spec/models/customer.rb",
     "spec/models/flo_admin.rb",
+    "spec/models/invoice.rb",
+    "spec/models/invoice_line.rb",
     "spec/models/person.rb",
     "spec/models/phone_number.rb",
+    "spec/models/product.rb",
     "spec/models/simple_person.rb",
     "spec/serialization_spec.rb",
     "spec/spec.opts",
     "spec/spec_helper.rb"
   ]
   s.homepage = %q{http://rubygems.org/gems/orientdb}
-  s.require_paths = ["lib"]
+  s.require_paths = [%q{lib}]
   s.rubyforge_project = %q{orientdb-ar}
-  s.rubygems_version = %q{1.4.2}
+  s.rubygems_version = %q{1.8.9}
   s.summary = %q{ActiveRecord-like persistency through OrientDB in JRuby}
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<orientdb>, ["= 0.0.15"])
+      s.add_runtime_dependency(%q<orientdb>, [">= 0.0.20"])
       s.add_runtime_dependency(%q<activemodel>, [">= 3.0.3"])
+      s.add_runtime_dependency(%q<jnunemaker-validatable>, ["= 1.8.4"])
       s.add_development_dependency(%q<awesome_print>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 2.4"])
     else
-      s.add_dependency(%q<orientdb>, ["= 0.0.15"])
+      s.add_dependency(%q<orientdb>, [">= 0.0.20"])
       s.add_dependency(%q<activemodel>, [">= 3.0.3"])
+      s.add_dependency(%q<jnunemaker-validatable>, ["= 1.8.4"])
       s.add_dependency(%q<awesome_print>, [">= 0"])
       s.add_dependency(%q<rspec>, [">= 2.4"])
     end
   else
-    s.add_dependency(%q<orientdb>, ["= 0.0.15"])
+    s.add_dependency(%q<orientdb>, [">= 0.0.20"])
     s.add_dependency(%q<activemodel>, [">= 3.0.3"])
+    s.add_dependency(%q<jnunemaker-validatable>, ["= 1.8.4"])
     s.add_dependency(%q<awesome_print>, [">= 0"])
     s.add_dependency(%q<rspec>, [">= 2.4"])
   end

data/spec/dirty_spec.rb

@@ -1,33 +1,30 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "ActiveModel" do
-
-  describe "Dirty" do
-
-    it "should comply" do
-      @person = Person.create :name => "Uncle Bob", :age => 45
-      @person.changed?.should == false
-
-      @person.name = 'Bob'
-      @person.changed?.should == true
-      @person.name_changed?.should == true
-      @person.name_was.should == 'Uncle Bob'
-      @person.name_change.should == ['Uncle Bob', 'Bob']
-      @person.name = 'Bill'
-      @person.name_change.should == ['Uncle Bob', 'Bill']
-
-      @person.save
-      @person.changed?.should == false
-      @person.name_changed?.should == false
-
-      @person.name = 'Bill'
-      @person.name_changed?.should == false
-      @person.name_change.should == nil
-
-      @person.name = 'Bob'
-      @person.changed.should == ['name']
-      @person.changes.should == {'name' => ['Bill', 'Bob']}
-    end
+describe "ActiveModel::Dirty" do
+
+  it "should comply" do
+    @person = Person.create :name => "Uncle Bob", :age => 45
+    @person.changed?.should == false
+
+    @person.name = 'Bob'
+    @person.changed?.should == true
+    @person.name_changed?.should == true
+    @person.name_was.should == 'Uncle Bob'
+    @person.name_change.should == ['Uncle Bob', 'Bob']
+    @person.name = 'Bill'
+    @person.name_change.should == ['Uncle Bob', 'Bill']
+
+    @person.save
+    @person.changed?.should == false
+    @person.name_changed?.should == false
+
+    @person.name = 'Bill'
+    @person.name_changed?.should == false
+    @person.name_change.should == nil
+
+    @person.name = 'Bob'
+    @person.changed.should == ['name']
+    @person.changes.should == { 'name' => ['Bill', 'Bob'] }
   end
 
 end

data/spec/lint_behavior.rb

@@ -17,10 +17,10 @@ module RspecRailsMatchers
         it { should respond_to(:to_param) }
 
         it { should respond_to(:valid?) }
-        its(:valid?) { should be_a_boolean }
+        #its(:valid?) { should be_a_boolean }
 
         it { should respond_to(:persisted?) }
-        its(:persisted?) { should be_a_boolean }
+        #its(:persisted?) { should be_a_boolean }
 
         its(:class) { should respond_to(:model_name) }
 

data/spec/lint_spec.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "ActiveModel" do
+describe "ActiveModel::Lint" do
+  include RspecRailsMatchers::Behavior::Lint
 
   describe Person do
     it_should_behave_like AnActiveModel
@@ -41,7 +42,7 @@ describe "ActiveModel" do
       @person.serializable_hash.should == {"name" => nil}
       @person.as_json.should == {"name" => nil}
       @person.to_json.should == %{{"name":null}}
-      @person.to_xml.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<simple-person>\n  <name type=\"yaml\" nil=\"true\"></name>\n</simple-person>\n"
+      @person.to_xml.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<simple-person>\n  <name nil=\"true\"></name>\n</simple-person>\n"
 
       @person.name = "Bob"
       @person.serializable_hash.should == {"name" => "Bob"}

data/spec/model_spec.rb

@@ -2,100 +2,230 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "Model" do
 
-  it "should have a valid connection" do
-    Person.connection.should be_a_kind_of OrientDB::DocumentDatabase
+  describe :connection do
+    it "should have a valid connection" do
+      Person.connection.should be_a_kind_of OrientDB::DocumentDatabase
+    end
   end
 
-  it "should have the right schema" do
-    Person.new.should be_a_kind_of Person
-    Person.oclass_name.should == 'Person'
-    Person.fields.keys.should == [:name, :age, :tags]
-    Person.fields[:name].should == { :type => :string, :not_null => true }
-    Person.fields[:age].should == { :type => :int }
-    Person.fields[:tags].should == { :type => [:list, :string] }
+  describe :schema do
+    it "should have the right schema" do
+      Person.new.should be_a_kind_of Person
+      Person.oclass_name.should == 'Person'
+      Person.fields.keys.should == [:name, :age, :tags]
+      Person.fields[:name].should == { :type => :string, :not_null => true }
+      Person.fields[:age].should == { :type => :int }
+      Person.fields[:tags].should == { :type => [:list, :string] }
+    end
   end
 
-  it "should create working models" do
-    p = Person.create :name => "Tester Testing", :age => 45, :tags => %w{ tech_support rocks }
+  describe :attributes do
+    it "should create working models" do
+      p = Person.create :name => "Tester Testing", :age => 45, :tags => %w{ tech_support rocks }
 
-    p.name.should == "Tester Testing"
-    p.age.should == 45
-    p.tags.should == %w{ tech_support rocks }
+      p.name.should == "Tester Testing"
+      p.age.should == 45
+      p.tags.should == %w{ tech_support rocks }
 
-    p2 = Person.first :name => "Tester Testing"
-    p2.name.should == p.name
-    p2.age.should == p.age
-    p2.tags.map.should == p.tags
+      p2 = Person.first :name => "Tester Testing"
+      p2.name.should == p.name
+      p2.age.should == p.age
+      p2.tags.map.should == p.tags
+    end
   end
 
-  it "should handle embedded models as relations" do
-    Customer.clear
-
-    a  = Address.new :street => "123 S Main", :city => "Salt Lake", :state => "UT", :country => "USA"
-    p1 = PhoneNumber.new :number => "123456789"
-    p2 = PhoneNumber.new :number => "987654321"
-    c1 = Customer.create :name => "Albert Einstein", :number => 1, :address => a, :phones => [p1, p2]
-
-    c2 = Customer.first
-    c1.should == c2
+  describe :embedded do
+    it "should handle embedds_one models as relations" do
+      Customer.clear
+      Customer.count.should <= 0
+
+      a  = Address.new :street => "123 S Main", :city => "Salt Lake", :state => "UT", :country => "USA"
+      c1 = Customer.create :name => "Albert Einstein", :number => 1, :address => a, :age => 35
+      c1.saved?.should == true
+      c1.address.should == a
+      c1.phones.should == []
+
+      c2 = Customer.first
+      c1.should == c2
+      c2.address.should == a
+      c2.phones.should == []
+    end
+
+    it "should handle embedds_many models as relations" do
+      Customer.clear
+      Customer.count.should <= 0
+
+      p1 = PhoneNumber.new :number => "123456789"
+      p2 = PhoneNumber.new :number => "987654321"
+      c1 = Customer.create :name => "Albert Einstein", :number => 1, :phones => [p1, p2], :age => 35
+      c1.saved?.should == true
+      c1.address.should == nil
+      c1.phones.should == [p1, p2]
+
+      c2 = Customer.first
+      c1.should == c2
+      c2.address.should == nil
+      c2.phones.should == [p1, p2]
+    end
+
+    it "should handle mixed embedded models as relations" do
+      Customer.clear
+      Customer.count.should <= 0
+
+      a  = Address.new :street => "123 S Main", :city => "Salt Lake", :state => "UT", :country => "USA"
+      p1 = PhoneNumber.new :number => "123456789"
+      p2 = PhoneNumber.new :number => "987654321"
+      c1 = Customer.create :name => "Albert Einstein", :number => 1, :address => a, :phones => [p1, p2], :age => 35
+      c1.saved?.should == true
+      c1.address.should == a
+      c1.phones.should == [p1, p2]
+
+      c2 = Customer.first
+      c1.should == c2
+      c2.address.should == a
+      c2.phones.should == [p1, p2]
+    end
   end
 
-  it "should find models" do
-    OrientDB::SQL.monkey_patch! Symbol
-    Person.clear
-
-    p1 = Person.create :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
-    p2 = Person.create :name => "Yoda", :age => 387, :tags => %w{ genius jedi }
-    p3 = Person.create :name => "Luke Skywalker", :age => 28, :tags => %w{ jedi fighter pilot }
-    p4 = Person.create :name => "Princess Leia", :age => 28, :tags => %w{ fighter royalty }
-    p5 = Person.create :name => "Chewbaca", :age => 53, :tags => %w{ fighter brave hairy }
-
-    Person.where(:name.like('%w%')).all.should == [p3, p5]
-    Person.where(:age.gt(28), :age.lt(75)).all.should == [p1, p5]
-    Person.where("'jedi' IN tags").all.should == [p2, p3]
-    Person.where("'fighter' IN tags", :age.lte(28)).order(:name.desc).all.first.should == p4
+  describe :linked do
+    it "should handle mixed linked models as relations" do
+      Invoice.clear; InvoiceLine.clear; Product.clear; Customer.clear
+
+      c1    = Customer.create :name => "Generous Buyer", :age => 38, :number => 1001
+      p1    = Product.create :sku => "h1", :title => "Hammer", :price => 7.25
+      p2    = Product.create :sku => "n2", :title => "9in Nail", :price => 0.12
+      l1    = InvoiceLine.create :product => p1, :quantity => 1, :price => p1.price
+      l2    = InvoiceLine.create :product => p2, :quantity => 10, :price => p2.price
+      total = l1.quantity * l1.price + l2.quantity * l2.price
+      i1    = Invoice.create :number => 417, :customer => c1, :sold_on => Date.today, :total => total, :lines => [l1, l2]
+      l3    = InvoiceLine.create :product => p1, :quantity => 2, :price => p1.price
+      i3    = Invoice.create :number => 418, :customer => c1, :sold_on => Date.today, :lines => [l3]
+      l4    = InvoiceLine.create :product => p2, :quantity => 3, :price => p2.price
+      i4    = Invoice.create :number => 419, :customer => c1, :sold_on => Date.today, :lines => [l4]
+      i1.saved?.should == true
+      i1.customer.should == c1
+      i1.lines.should == [l1, l2]
+      i1.lines[0].product.should == p1
+      i1.lines[1].product.should == p2
+
+      i2 = Invoice.first
+      i2.customer.should == c1
+      i2.lines.map { |x| x.rid }.should == [l1.rid, l2.rid]
+      i2.lines[0].product.rid.should == p1.rid
+      i2.lines[1].product.rid.should == p2.rid
+      i2.rid.should == i1.rid
+    end
   end
 
-  it "should update models" do
-    Person.clear
-
-    p1 = Person.create :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
-    p2 = Person.create :name => "Yoda", :age => 387, :tags => %w{ genius jedi }
-    p3 = Person.create :name => "Luke Skywalker", :age => 28, :tags => %w{ jedi fighter pilot }
-
-    Person.where(:name => "Hans Solo").update(:name => "Hans Meister")
-    Person.where(:name => "Hans Meister").all.map { |x| x.rid }.should == [p1.rid]
-    p1.reload
-    Person.where(:name => "Hans Meister").all.should == [p1]
-
-
-    Person.update(:age => 45)
-    Person.where(:age => 45).all.map { |x| x.name }.should == [p1.name, p2.name, p3.name]
+  describe "SQL" do
+    describe "query" do
+      it "should find models" do
+        OrientDB::SQL.monkey_patch! Symbol
+        Person.clear
+        Person.count.should == 0
+
+        p1 = Person.create :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
+        p2 = Person.create :name => "Yoda", :age => 387, :tags => %w{ genius jedi }
+        p3 = Person.create :name => "Luke Skywalker", :age => 28, :tags => %w{ jedi fighter pilot }
+        p4 = Person.create :name => "Princess Leia", :age => 28, :tags => %w{ fighter royalty }
+        p5 = Person.create :name => "Chewbaca", :age => 53, :tags => %w{ fighter brave hairy }
+
+        Person.where(:name.like('%w%')).all.should == [p3, p5]
+        Person.where(:age.gt(28), :age.lt(75)).all.should == [p1, p5]
+        Person.where("'jedi' IN tags").all.should == [p2, p3]
+        Person.where("'fighter' IN tags", :age.lte(28)).order(:name.desc).all.first.should == p4
+      end
+    end
+
+    describe "update" do
+      it "should update models" do
+        Person.clear
+        Person.count.should == 0
+
+        p1 = Person.create :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
+        p2 = Person.create :name => "Yoda", :age => 387, :tags => %w{ genius jedi }
+        p3 = Person.create :name => "Luke Skywalker", :age => 28, :tags => %w{ jedi fighter pilot }
+
+        Person.where(:name => "Hans Solo").update(:name => "Hans Meister")
+        Person.where(:name => "Hans Meister").all.map { |x| x.rid }.should == [p1.rid]
+        p1.reload
+        Person.where(:name => "Hans Meister").all.should == [p1]
+
+
+        Person.update(:age => 45)
+        Person.where(:age => 45).all.map { |x| x.name }.should == [p1.name, p2.name, p3.name]
+      end
+    end
+
+    describe "delete" do
+      it "should delete models" do
+        Person.delete
+        Person.count.should == 0
+
+        Person.create :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
+        Person.create :name => "Yoda", :age => 387, :tags => %w{ genius jedi }
+        Person.create :name => "Luke Skywalker", :age => 28, :tags => %w{ jedi fighter pilot }
+
+        Person.count.should == 3
+
+        Person.where(:name => "Hans Solo").delete
+        Person.count.should == 2
+
+        Person.delete
+        Person.count.should == 0
+      end
+    end
+
+    describe "insert" do
+      it "should insert models" do
+        Person.delete
+        Person.count.should == 0
+
+        p1 = Person.insert :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
+        Person.count.should == 1
+
+        p2 = Person.first
+        p1.should == p2
+      end
+    end
   end
 
-  it "should delete models" do
-    Person.clear
-
-    Person.create :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
-    Person.create :name => "Yoda", :age => 387, :tags => %w{ genius jedi }
-    Person.create :name => "Luke Skywalker", :age => 28, :tags => %w{ jedi fighter pilot }
-
-    Person.count.should == 3
-
-    Person.where(:name => "Hans Solo").delete
-    Person.count.should == 2
-
-    Person.delete
-    Person.count.should == 0
+  describe :validations do
+    it "should validate models correctly" do
+      Person.delete
+      Person.count.should == 0
+
+      p1 = Person.new
+      p1.save.should == false
+      p1.errors.size.should == 2
+      p1.errors.keys.should == [:name, :age]
+      p1.errors[:name].should == ["can't be empty"]
+      p1.errors[:age].should == ["can't be empty"]
+
+      p1.name = "Tester"
+      p1.valid?.should == false
+      p1.errors.size.should == 1
+      p1.errors[:age].should == ["can't be empty"]
+
+      p1.age = 25
+      p1.valid?.should == true
+      p1.errors.size.should == 0
+
+      p1.save.should == true
+    end
   end
 
-  it "should insert models" do
-    Person.clear
+  describe :validate_embedded do
+    it "should validate properly with embedded documents" do
+      Customer.clear
 
-    p1 = Person.insert :name => "Hans Solo", :age => 38, :tags => %w{ fighter pilot }
-    Person.count.should == 1
+      c1 = Customer.new :name => "Tester", :age => 37
+      c1.valid?.should == true
 
-    p2 = Person.first
-    p1.should == p2
+      c1.build_address :street => "4647 Pagentry", :city => "Sandy"
+      c1.valid?.should == false
+      c1.errors.size.should == 1
+      c1.errors[:address].should == ["#-1:-1 State can't be empty"]
+    end
   end
 end