lore 0.4.8 → 0.9.2

data/lore.gemspec

@@ -9,37 +9,46 @@ spec = Gem::Specification.new { |s|
   s.description = <<-EOF
     Lore is an object-relational mapping (ORM) implementation 
     providing many features like prepared statements, 
-    (multiple) inheritance, a comfortable query syntax, 
-    highly customizable automated form generation, 
-    and result caching using memory mapping (MMap). 
+    (multiple) inheritance, true polymorphism, a comfortable 
+    query syntax, highly customizable automated form generation, 
+    and result caching. 
     It aims at performance, usability and - unlike most ORMs - 
-    high coverage of native SQL functions and features. 
+    high coverage of object oriented paradigms. 
     Lore is currently using PostgreSQL as database backend. 
   EOF
-  s.version = '0.4.8'
-  s.author = 'Tobias Fuchs'
-  s.email = 'fuchs@atomnode.net'
-  s.date = Time.now
-  s.files = '*.rb'
-  s.add_dependency('postgres', '>= 0.1')
-  s.add_dependency('aurita-gui', '>= 0.1')
+  s.version = '0.9.2'
+  s.author  = 'Tobias Fuchs'
+  s.email   = 'twh.fuchs@gmail.com'
+  s.date    = Time.now
+  s.files   = '*.rb'
+
+  s.requirements  = "A ruby binding for PostgreSQL, such as postgres or postgres-pr. "
+# Remove dependency as postgres-pr would be ok, too
+# s.add_dependency('postgres', '>= 0.1')
+  s.add_dependency('aurita-gui', '>= 0.2')
   s.files = FileList['*', 
+                     'benchmark/*', 
+                     'spec/*', 
+                     'spec/fixtures/*', 
                      'lib/*', 
                      'lib/lore/*', 
-                     'lib/lore/behaviours/*', 
+                     'lib/lore/adapters/*', 
+                     'lib/lore/adapters/postgres/*', 
+                     'lib/lore/adapters/postgres-pr/*', 
                      'lib/lore/cache/*', 
-                     'lib/lore/validation/*', 
+                     'lib/lore/exceptions/*', 
                      'lib/lore/gui/*', 
                      'lib/lore/gui/templates/*', 
-                     'lib/lore/exception/*', 
-                     'bin/*', 
-                     'test/*'].to_a
+                     'lib/lore/model/*', 
+                     'lib/lore/strategies/*', 
+                     'lib/lore/validation/*', 
+                     'bin/*'].to_a
 
   s.has_rdoc = true
   s.rdoc_options << '--title' << 'Lore ORM' <<
                     '--main' << 'Lore::Model' <<
                     '--line-numbers'
 
-  s.homepage = 'http://lore.rubyforge.org'
+  s.homepage = 'http://github.com/fuchsto/lore/'
 
 }

data/spec/clause.rb

@@ -0,0 +1,37 @@
+
+require 'spec_env'
+
+include Lore::Spec_Fixtures::Models
+
+describe(Lore::Clause) do
+
+  it "is assigned to a concrete table field" do
+    Car.maxspeed.to_s.should  == 'public.vehicle.maxspeed'
+    Car.num_seats.to_s.should == 'public.vehicle.num_seats'
+    Car.num_doors.to_s.should == 'public.car.num_doors'
+    Car.name.to_s.should      == 'public.vehicle.name'
+  # should agggregates be included? 
+  # Car.type_name.to_s.should == 'public.car_type.type_name 
+  end
+
+  it "has comparison operators like >, <, <=>, <=, >= and some aliases" do
+    (Car.maxspeed > 100).to_s.should == "public.vehicle.maxspeed > '100'"
+    (Car.num_doors == 4).to_s.should == "public.car.num_doors = '4'"
+    (Car.num_seats <= 5).to_s.should == "public.vehicle.num_seats <= '5'"
+  end
+
+  it "has special SQL comparison operators such as between, like, ilike" do
+    Car.name.like('%wombat').to_s.should == "public.vehicle.name LIKE '%wombat'"
+  end
+
+  it "has logical operators like & and |" do
+    clause = Car.name.ilike('%knurt%').and(Car.num_doors.is(3))
+    clause.to_sql.should == "(public.vehicle.name ILIKE '%knurt%' AND public.car.num_doors = '3')"
+
+    or_clause = (Vehicle.num_seats.in(1..5))
+    or_clause.to_sql.should == "public.vehicle.num_seats BETWEEN 1 AND 5 "
+
+    (clause | or_clause).to_sql.should == "((public.vehicle.name ILIKE '%knurt%' AND public.car.num_doors = '3') OR public.vehicle.num_seats BETWEEN 1 AND 5 )"
+  end
+
+end

data/spec/fixtures/blank_models.rb

@@ -0,0 +1,37 @@
+
+module Lore
+module Spec_Fixtures
+module Blank_Models
+
+  NAME_FORMAT = { :format => /^([a-zA-Z_0-9 ])+$/, :length => 3..100, :mandatory => true }
+
+  class Vehicle < Lore::Model
+  end
+
+  class Motor < Lore::Model
+  end
+
+  class Motorized_Vehicle < Lore::Model
+  end
+
+  class Car < Vehicle
+  end
+
+  class Motorbike < Vehicle
+  end
+
+  class Owner < Lore::Model
+  end
+
+  class Vehicle_Owner < Lore::Model
+  end
+
+  class Car_Type < Lore::Model
+  end
+
+  class Garage < Lore::Model
+  end
+
+end
+end
+end

data/{test/model.rb → spec/fixtures/models.rb}

@@ -1,33 +1,28 @@
 
 require 'rubygems'
-require('./test/env')
+require('lore')
 require('lore/model')
 
-Lore::Context.enter :test
-
 module Lore
-module Unit
+module Spec_Fixtures
+module Models
 
-  NAME_FORMAT = { :format => /^([a-zA-Z_0-9])+$/, :length => 3..100, :mandatory => true }
+  NAME_FORMAT = { :format => /^([a-zA-Z_0-9 ])+$/, :length => 3..100, :mandatory => true }
 
   class Manufacturer < Lore::Model
     table :manufacturer, :public
     primary_key :manuf_id, :manuf_id_seq
 
-    validates :name, NAME_FORMAT
+  # validates :name, NAME_FORMAT
 
     use_label :name
-    
-    cache_entities
   end
 
   class Owner < Lore::Model
     table :owner, :public
     primary_key :owner_id, :owner_id_seq
 
-    validates :name, NAME_FORMAT
-
-    cache_entities
+  # validates :name, NAME_FORMAT
   end
 
   class Vehicle < Lore::Model
@@ -37,21 +32,17 @@ module Unit
     has_a Manufacturer, :manuf_id
     has_n Owner, :vehicle_id
 
-    validates :name, NAME_FORMAT
+  # validates :name, NAME_FORMAT
     validates :maxspeed, :mandatory => true
     validates :num_seats, :mandatory => true
 
     add_input_filter(:name) { |name|
       name.gsub(/[^a-zA-Z_0-9]/,'').downcase
     }
-    add_input_filter(:maxspeed) { |m| m.to_s.gsub('km/h','') }
+    add_input_filter(:maxspeed) { |m| m.to_s.sub('km/h','') }
     add_output_filter(:maxspeed) { |m| m << 'km/h' }
 
-    explicit :optional, :owner_id
-
   # add_select_filter { |clause| clause & (Vehicle.deleted == 't') }
-
-    cache_entities
   end
 
   class Vehicle_Owner < Lore::Model
@@ -71,27 +62,55 @@ module Unit
     table :car_type, :public
     primary_key :car_type_id, :car_type_id_seq
 
-    validates :name, NAME_FORMAT
+  # validates :type_name, NAME_FORMAT
 
-    use_label :name
+    use_label :type_name
+  end
 
-    cache_entities
+  class Motor < Lore::Model
+    table :motor, :public
+    primary_key :id, :motor_id_seq
+    
+    expects :kw
+  end
+
+  class Motorized_Vehicle < Vehicle
+    table :motorized, :public
+    primary_key :id, :motorized_id_seq
+
+    is_a Vehicle, :vehicle_id
+    aggregates Motor, :motor_id
   end
 
-  class Car < Vehicle
+  class Car < Motorized_Vehicle
     table :car, :public
     primary_key :id, :car_id_seq
     
-    is_a Vehicle, :vehicle_id 
+    # This is not a typo: As vehicle_id is a unique, 
+    # inherited primary key in Motorized_Vehicle, it 
+    # must be allowed for referencing a Motorized_Vehicle. 
+    # is_a Motorized_Vehicle, :vehicle_id 
+    is_a Motorized_Vehicle, :motorized_id 
     aggregates Car_Type, :car_type_id
 
-    validates :num_seats, :mandatory => true
+  # validates :num_seats, :mandatory => true
     validates :num_doors, :mandatory => true
 
     add_input_filter(:maxspeed) { |m| m.to_s.gsub('km/h','') }
     add_output_filter(:maxspeed) { |m| m << 'km/h' }
 
-    cache_entities
+    def drive
+      "driving with #{maxspeed}!"
+    end
+  end
+
+  class Car_Features < Lore::Model
+    table :car_features, :public
+    primary_key :id, :car_features_id_seq
+
+    has_a Car, :car_id
+
+    expects :color
   end
 
   class Convertible < Car
@@ -107,36 +126,40 @@ module Unit
     aggregates Car, :car_id
   end
 
-  class Bike < Vehicle
-    table :bike, :public
-    primary_key :bike_id, :bike_id_seq
+  class Motorbike < Motorized_Vehicle
+    table :motorbike, :public
+    primary_key :id, :bike_id_seq
     
-    is_a Vehicle, :vehicle_id
-
-    cache_entities
+    is_a Motorized_Vehicle, :vehicle_id
   end
-=begin
-  class Trike < Vehicle
-    table :trike, :public
-    primary_key :trike_id, :trike_id_seq
-
-    is_a Car, :car_id
-    is_a Bike, :bike_id
 
-    cache_entities
-  end
-=end
   class Garage < Lore::Model
     table :garage, :public
     primary_key :garage_id, :garage_id_seq
     primary_key :vehicle_id
 
     has_n Vehicle, :vehicle_id
+  end
+
+  class Robot < Lore::Model
+    table :robot, :public
+    primary_key :id, :robot_id_seq
+
+    def transform
+      'Autobot transformed!'
+    end
+  end
+
+  class Autobot < Robot
+    table :autobot, :public
+    primary_key :id, :autobot_id_seq
 
-    cache_entities
+    is_a Robot, :robot_id
+    is_a Car, :car_id
   end
 
 end
 end
+end
 
 

data/spec/fixtures/polymorphic_models.rb

@@ -0,0 +1,68 @@
+
+require 'lore/model'
+
+module Lore
+module Spec_Fixtures
+module Polymorphic_Models
+
+  class Asset < Lore::Model
+
+    table :asset, :public
+    primary_key :asset_id, :asset_id_seq
+
+    expects :folder, :filename
+
+    is_polymorphic :model
+
+    def path
+      folder + '/' + filename
+    end
+  end
+
+  class Media_Asset_Info < Lore::Model
+    table :media_asset_info, :public
+    primary_key :id, :media_asset_id_seq
+    expects :media_asset_id
+  end
+
+  class Document_Asset_Info < Lore::Model
+    table :document_asset_info, :public
+    primary_key :id, :document_asset_id_seq
+    expects :document_asset_id
+  end
+
+  class Media_Asset < Asset
+    table :media_asset, :public
+    primary_key :id, :media_asset_id_seq
+
+    is_a Asset, :asset_id
+
+    expects :media_type
+    aggregates Media_Asset_Info, :info_id
+  end
+
+# class Movie_Asset < Media_Asset
+#   table :movie_asset, :public
+#   primary_key :id, :movie_asset_id_seq
+#
+#   is_a Media_Asset, :media_asset_id
+#
+#   def self.before_create(args)
+#     args[:media_type] = 'movie'
+#   end
+# end
+
+  class Document_Asset < Asset
+    table :document_asset, :public
+    primary_key :id, :document_asset_id_seq
+
+    is_a Asset, :asset_id
+
+    expects :doctype
+    aggregates Document_Asset_Info, :info_id
+  end
+
+end
+end
+end
+

data/spec/model_associations.rb

@@ -0,0 +1,86 @@
+
+require 'spec_env'
+include Lore::Spec_Fixtures::Models
+
+describe(Lore::Table_Accessor) do
+  before do
+    flush_test_data()
+  end
+
+  it "is assigned to a base table" do
+    Car.table_name.should == 'public.car'
+    Vehicle.table_name.should == 'public.vehicle'
+  end
+
+  it "loads attribute fields automatically as array of symbols" do
+    owner = Owner.create(:name => 'Filou')
+    manuf_org = Manufacturer.create(:name => 'Ford')
+    manuf_new = Manufacturer.create(:name => 'Ford')
+    v = Vehicle.create(:name => 'Ford Mondeo', 
+                       :num_seats => 100, 
+                       :maxspeed => 180, 
+                       :manuf_id => manuf_org.pkey, 
+                       :owner_id => owner.pkey)
+    v.manufacturer.should == manuf_org
+  end
+
+  it "allows setting entities for 1:1 relations" do
+    owner     = Owner.create(:name => 'Filou')
+    manuf_org = Manufacturer.create(:name => 'Ford')
+    manuf_new = Manufacturer.create(:name => 'Ford')
+    motor     = Motor.create(:motor_name => 'Ford V8', :kw => 120)
+    type      = Car_Type.create(:type_name => 'Limousine')
+    v = Car.create(:name => 'Ford Mondeo', 
+                   :motor_id => motor.pkey,
+                   :num_doors => 3, 
+                   :num_seats => 100, 
+                   :maxspeed => 180, 
+                   :car_type_id => type.pkey, 
+                   :manuf_id => manuf_org.pkey, 
+                   :owner_id => owner.pkey)
+    v.manufacturer.should == manuf_org
+    v.manufacturer = manuf_new
+    
+    expected = { 'public.vehicle'   => { :id => v.vehicle_id }, 
+                 'public.car'       => { :id => v.id }, 
+                 'public.motorized' => { :id => v.motorized_id } } 
+  
+    v.get_primary_key_value_map.should_be expected
+    v.commit
+    v.manufacturer.should == manuf_new
+    
+    v.set_manufacturer!(manuf_org)
+    v.manufacturer.should == manuf_org
+  end
+
+  it "provides 1:n associations" do
+# TODO: Implement this
+# 
+#   garage = Garage.create()
+#   vehicle_1 = Vehicle.create()
+#   vehicle_2 = Vehicle.create()
+#   car_1 = Car.create()
+#   car_2 = Car.create()
+#
+#   garage.add_vehicle(vehicle_1)
+#   garage.add_vehicle(car_1)
+#   garage.save
+#   expected = [ vehicle_1, car_1 ]
+#   garage.vehicle_set.should_be expected
+#
+#   garage.vehicle_set = [ vehicle_2, car_2 ]
+#   garage.save
+#   expected = [ vehicle_2, car_2 ]
+#   garage.vehicle_set.should_be expected
+#
+#   garage.vehicle_set.delete(car2)
+#   garage.save
+#   expected = [ vehicle_2 ]
+#   garage.vehicle_set.should_be expected
+  end
+
+  it "provides n:n associations" do
+    
+  end
+
+end