lore 0.4.8 → 0.9.2

data/spec/model_create.rb

@@ -0,0 +1,47 @@
+
+require 'spec_env'
+include Lore::Spec_Fixtures::Models
+
+describe(Lore::Table_Accessor) do
+  before do
+  end
+
+  it "does not create records for aggregated models on create procedures" do
+    motor   = Motor.create(:motor_name => 'Gaso-Suck 3000', :kw => 200)
+
+    vehicle = Motorized_Vehicle.create(:name => 'vehicle_name', 
+                                       :num_doors => 3, 
+                                       :num_seats => 5, 
+                                       :owner_id  => 0, 
+                                       :maxspeed  => 170,
+                                       :motor_id => motor.pkey)
+    
+    vehicle.name.should == 'vehicle_name'
+    vehicle.motor_name.should == 'Gaso-Suck 3000'
+    vehicle.kw.should == 200
+    vehicle.maxspeed.should == "170km/h"
+  end
+
+  it "automatically distributes attribute values on base tables on create procedures" do
+
+    motor   = Motor.create(:motor_name => 'Lawn Mower Ultra', :kw => 20)
+
+    car = Car.create(:name        => 'vehicle_name', 
+                     :num_doors   => 5, 
+                     :num_seats   => 4, 
+                     :owner_id    => 0, 
+                     :motor_id    => motor.pkey, 
+                     :car_type_id => Car_Type.create(:type_name => 'Roadkill X1000').car_type_id, 
+                     :maxspeed    => 180)
+    car.num_doors.should == 5
+    car.name.should == 'vehicle_name'
+    car.maxspeed.should == '180km/h'
+  end
+
+  it "provides a before_create hook" do
+  end
+
+  it "provides an after_create hook" do
+  end
+
+end

data/spec/model_definition.rb

@@ -0,0 +1,151 @@
+
+require 'spec_env'
+include Lore::Spec_Fixtures::Blank_Models
+
+describe(Lore::Table_Accessor) do
+  before do
+  # Lore::Spec_Fixtures::Models::Vehicle.delete_all
+  # Lore::Spec_Fixtures::Models::Car.delete_all
+  # Lore::Spec_Fixtures::Models::Motorbike.delete_all
+  # Lore::Spec_Fixtures::Models::Owner.delete_all
+  # Lore::Spec_Fixtures::Models::Vehicle_Owner.delete_all
+  # Lore::Spec_Fixtures::Models::Car_Type.delete_all
+  # Lore::Spec_Fixtures::Models::Garage.delete_all
+  # Lore::Spec_Fixtures::Models::Motor.delete_all
+  # Lore::Spec_Fixtures::Models::Motorized_Vehicle.delete_all
+  end
+
+  it "is assigned to a base table" do
+    Vehicle.table :vehicle, :public
+    Car.table :car, :public
+    Motorbike.table :motorbike, :public
+    Owner.table :owner, :public
+    Vehicle_Owner.table :vehicle_owner, :public
+    Car_Type.table :car_type, :public
+    Garage.table :garage, :public
+    Motor.table :motor, :public
+    Motorized_Vehicle.table :motorized, :public
+
+    Car.table_name.should == 'public.car'
+    Vehicle.table_name.should == 'public.vehicle'
+    Motorbike.table_name.should == 'public.motorbike'
+    Owner.table_name.should == 'public.owner'
+    Vehicle_Owner.table_name.should ==  'public.vehicle_owner'
+    Car_Type.table_name.should ==  'public.car_type'
+    Garage.table_name.should == 'public.garage'
+  end
+
+  it "loads attribute fields automatically as array of symbols" do
+    Vehicle.get_fields.should == { 'public.vehicle' => [ :id, :manuf_id, :num_seats, :maxspeed, :name, :owner_id ] }
+    Vehicle.get_fields_flat.should == [ :id, :manuf_id, :num_seats, :maxspeed, :name, :owner_id ] 
+  end
+
+  it "has one or more primary key attributes" do
+    Vehicle.primary_key :id, :vehicle_id_seq
+    Car.primary_key :id, :car_id_seq
+    Motorbike.primary_key :motorbike_id, :motorbike_id_seq
+    Owner.primary_key :owner_id, :owner_id_seq
+    Car_Type.primary_key :car_type_id, :car_type_id_seq
+    Garage.primary_key :garage_id, :garage_id_seq
+    Motor.primary_key :id, :motor_id_seq
+    Motorized_Vehicle.primary_key :id, :motorized_id_seq
+  end
+
+  it "may have required attributes" do
+    Car.expects :num_seats
+    # does the same
+    Car.validates :num_doors, :mandatory => true
+  end
+
+  it "allows adding other models as aggregates" do
+    Car.aggregates Car_Type, :car_type_id
+    Motorized_Vehicle.is_a Vehicle, :vehicle_id
+    Motorized_Vehicle.aggregates Motor, :motor_id
+    Motorized_Vehicle.__associations__.base_klasses.values.should == [ [ Vehicle, [ :vehicle_id ] ] ]
+    Motorized_Vehicle.__associations__.aggregate_klasses.values.should == [ [ Motor , [ :motor_id ] ] ]
+    Motorized_Vehicle.__associations__.joined_models.values.should == [ [ Vehicle, [ :vehicle_id ] ] , [ Motor, [ :motor_id ] ] ]
+  end
+
+  it "can be derived from one base model or more" do
+    Car.is_a Motorized_Vehicle, :motorized_id
+    Motorbike.is_a Vehicle, :vehicle_id
+
+    Car.is_a?(Motorized_Vehicle).should == true
+    Car.is_a?(Vehicle).should == true
+  end
+
+  it "inherits attribute fields from joined base models" do
+    expected_fields = { 
+      'public.vehicle'   => [ :id, :manuf_id, :num_seats, :maxspeed, :name, :owner_id ], 
+      'public.car_type'  => [ :car_type_id, :type_name ], 
+      'public.car'       => [ :id, :motorized_id, :car_type_id, :num_doors ], 
+      'public.motorized' => [ :vehicle_id, :motor_id, :id ], 
+      'public.motor'     => [ :id, :motor_name, :kw ]
+    }
+    Car.get_fields.should_be expected_fields
+  end
+
+  it "may have composed primary keys" do
+    Vehicle_Owner.primary_key :vehicle_id
+    Vehicle_Owner.primary_key :owner_id
+  end
+
+  it "may have non-sequential primary keys" do
+  end
+
+  it "allows arbitrary naming of keys" do
+    Vehicle.has_a Owner, :owner
+  end
+
+  it "provides input and output filters for attribute values" do
+  end
+
+  it "defines attributes that cannot be set manually as explicit" do
+    expected = { 
+      # has_a foreign keys :manuf_id and owner are explicit: 
+      'public.vehicle' => [ :manuf_id, :num_seats, :maxspeed, :name, :owner_id ], 
+      # Aggregate foreign key :motor_id is explicit: 
+      'public.motorized' => [ :motor_id ], 
+      # Aggregate foreign key :car_type_id is explicit: 
+      'public.car' => [ :car_type_id, :num_doors ] 
+
+      # Aggregated models do not extend implicit or explicit fields!
+      # 'public.motor' => [ :motor_name ],
+      # 'public.car_type' => [ :type_name ],
+    }
+    Car.__attributes__.explicit.should_be expected
+  end
+
+  it "defines all attributes that are not explicit as implicit" do
+    expected = { 
+      'public.vehicle' => [ :id ], 
+      'public.motorized' => [ :id, :vehicle_id ], 
+      'public.car' => [ :id, :motorized_id ] 
+
+      # Aggregated models do not extend implicit or explicit fields!
+      # 'public.motor' => [ :id ],
+      # 'public.car_type' => [ :car_type_id ],
+    }
+
+    Car.__attributes__.implicit.should_be expected
+  end
+
+  it "provides a before_select hook" do
+  end
+
+  it "provides validating presence of attribute values" do
+    Vehicle.validates :name, :mandatory => true
+    # .expects does the same
+    Car.expects :num_doors
+  end
+
+  it "provides validating attribute values by length" do
+    Vehicle.validates :name, :maxlength => 20
+  end
+
+  it "provides validating attribute values by format" do
+    Vehicle.validates :name, :format => NAME_FORMAT
+  end
+
+
+end

data/spec/model_delete.rb

@@ -0,0 +1,31 @@
+
+require 'spec_env'
+include Lore::Spec_Fixtures::Models
+
+include Spec_Model_Select_Helpers
+
+describe(Lore::Table_Accessor) do
+
+  it "does not delete records for aggregated models on delete procedures" do
+    manuf       = Manufacturer.create(:name => 'Major Motors')
+    vehicle     = Car.create(car_create_values(:name => 'wombat', :manuf_id => manuf.pkey))
+    manuf_id    = vehicle.manufacturer.manuf_id
+    motor_id    = vehicle.motor_id
+    manuf       = Manufacturer.get(manuf_id) 
+    vehicle.motor_name.should == 'Mock Motor'
+    vehicle.delete!
+    manuf       = Manufacturer.get(manuf_id) # Re-Select 
+    motor       = Motor.get(motor_id)        # Re-Select 
+    manuf.should_not == false
+    motor.should_not == false
+  end
+
+  it "deletes single Model instances on Model#delete" do
+    car = Car.create(car_create_values(:name => 'delete_me!'))
+    car_id = car.pkey
+    car.delete
+    Car.get(car_id).should == false
+  end
+
+end
+

data/spec/model_inheritance.rb

@@ -0,0 +1,50 @@
+
+require 'spec_env'
+include Lore::Spec_Fixtures::Models
+
+describe(Lore::Table_Accessor) do
+
+  before do
+    flush_test_data()
+  end
+
+  it "provides single inheritance" do
+    Motorized_Vehicle.is_a?(Vehicle).should == true
+    Car.is_a?(Vehicle).should == true
+    
+  end
+
+  it "provides multiple inheritance" do 
+    Autobot.is_a?(Car).should == true
+    Autobot.is_a?(Robot).should == true
+
+    motor = Motor.create(:motor_name => 'Autobot Car Motor', 
+                         :kw => 239)
+    car_type = Car_Type.create(:type_name => 'Autobot Car')
+    
+    t = Autobot.create(# Attributes for Vehicle
+                       :name => 'Autobot', 
+                       :num_seats => 4, 
+                       :maxspeed => 190, 
+                       :owner_id => 23, 
+                       :manuf_id => 42, 
+                       # Attributes for Motorized
+                       :motor_type => 'brushless', 
+                       :motor_id => motor.pkey, 
+                       # Attributes for Car
+                       :car_type_id => car_type.pkey, 
+                       :num_doors => 5, 
+                       # Attributes for Robot
+                       :robot_class => 'Exoskel X3000',
+                       :locomotion_type => 'bipedal')
+    
+    t.name.should == 'autobot'
+    t.num_seats.should == 4
+    t.manuf_id.should == 42
+    t.motor_type.should == 'brushless'
+    t.locomotion_type.should == 'bipedal'
+    
+    t.transform.should == 'Autobot transformed!'
+  end
+
+end

data/spec/model_polymorphic.rb

@@ -0,0 +1,85 @@
+
+require 'spec_env'
+include Lore::Spec_Fixtures::Polymorphic_Models
+
+describe(Lore::Table_Accessor) do
+  before do
+    flush_test_data()
+  end
+
+  it "implements the Liskov substitution principle" do
+  end
+
+  it "implements inverse polymorphism" do
+    
+    Asset.is_polymorphic?.should == true
+    Media_Asset.is_polymorphic?.should == false
+    Document_Asset.is_polymorphic?.should == false
+    
+    expected = { 'public.asset' => :model }
+    Media_Asset.__associations__.polymorphics.should_be expected
+
+    Asset.__associations__.concrete_models.length.should == 2
+
+    5.times { 
+      info = Media_Asset_Info.create(:description => 'a media file')
+      media = Media_Asset.create(:folder     => '/tmp/spec/media/', 
+                                 :filename   => 'music.ogg', 
+                                 :hits       => 123, 
+                                 :info_id    => info.pkey, 
+                                 :media_type => 'sound')
+      info = Document_Asset_Info.create(:relevance => 5)
+      docum = Document_Asset.create(:folder   => '/tmp/spec/docs/', 
+                                    :filename => 'sample.txt', 
+                                    :info_id    => info.pkey, 
+                                    :doctype  => 'plaintext')
+      
+    }
+    polymorphics = Asset.find(10).polymorphic.sort_by(Asset.asset_id, :desc).entities
+    polymorphics.length.should == 10
+    polymorphics.each_with_index { |a,idx|
+      expected = (idx % 2 == 1)? true : false
+      a.is_a?(Media_Asset).should == expected
+      a.is_a?(Document_Asset).should == !expected
+    }
+  end
+
+  it "Handles inherited fields like in regular selects" do
+
+    info = Media_Asset_Info.create(:description => 'a media file')
+    media = Media_Asset.create(:folder     => '/tmp/spec/media/', 
+                               :filename   => 'music.ogg', 
+                               :hits       => 123, 
+                               :info_id    => info.pkey, 
+                               :media_type => 'sound')
+    info = Document_Asset_Info.create(:relevance => 5)
+    docum = Document_Asset.create(:folder   => '/tmp/spec/docs/', 
+                                  :filename => 'sample.txt', 
+                                  :info_id    => info.pkey, 
+                                  :doctype  => 'plaintext')
+
+    media_polymorphic_id = media.asset_id
+    docum_polymorphic_id = docum.asset_id
+
+    # Select an Asset which is known to be a concrete 
+    # Media_Asset: 
+    asset = Asset.polymorphic_select { |a|
+      a.where(Asset.asset_id.is media_polymorphic_id)
+      a.limit(1)
+    }.first
+    asset.is_a?(Media_Asset).should == true
+    asset.is_a?(Asset).should == true
+    asset.media_type.should == 'sound'
+    
+    # Select an Asset which is known to be a concrete 
+    # Document_Asset: 
+    asset = Asset.polymorphic_select { |a|
+      a.where(Asset.asset_id.is docum_polymorphic_id)
+      a.limit(1)
+    }.first
+    asset.is_a?(Document_Asset).should == true
+    asset.is_a?(Asset).should == true
+    asset.doctype.should == 'plaintext'
+  end
+
+end

data/spec/model_select.rb

@@ -0,0 +1,101 @@
+
+require 'spec_env'
+include Lore::Spec_Fixtures::Models
+
+include Spec_Model_Select_Helpers
+
+describe(Lore::Table_Accessor) do
+  before do
+    flush_test_data()
+  end
+
+  it "should provide a DSL for selects" do 
+
+    for index in 0...3 do 
+      Car.create(car_create_values(:name => "Car #{index}" ))
+    end
+
+    expected = Car.select_value('count(*)') { |c| c.where(true) }
+    expected.to_i.should == 3
+
+    car = Car.select { |c|
+      c.where((c.name == "car1").or(c.name == "car2"))
+      c.limit(1)
+    }.first
+    car.name.should == "car1"
+
+    car = Car.select { |c|
+      c.where((c.name == "car1").or(c.name == "car2"))
+      c.limit(1, 1)
+    }.first
+    car.name.should == "car2"
+  end
+
+  it "provides convenience methods for selects" do
+    car_org = Car.create(car_create_values(:name => "The Car" ))
+    car_sel = Car.find(1).with(Car.name == "thecar").entity
+    car_org.name.should == "thecar"
+    car_sel.name.should == "thecar"
+    car_org.should == car_sel
+  end
+
+  it "allows arbitrary joins with other models" do
+    
+    cf = Car_Features.create(:car_id => Car.create(car_create_values(:name => 'fordmondeo')).pkey, 
+                             :color  => 'red')
+
+    res = Car.select { |c|
+      c.join(Car_Features).on(Car.id == Car_Features.car_id) { |cc|
+        cc.where(:name.ilike('ford%') & :color.is('red'))
+      }
+    }.first
+    res.color.should == 'red'
+    res.name.should == 'fordmondeo'
+
+  end
+
+  it "allows selecting skalar values, e.g. for aggregate functions" do
+    most_recent_car = false
+    3.times { 
+      most_recent_car = Car.create(car_create_values(:name => "The Car" ))
+    }
+    values = Car.select_values('count(*), max(car.id)') { |c|
+      c.where(true)
+    }.first
+
+    values[0].to_i.should == 3
+    values[1].to_i.should == most_recent_car.id
+  end
+
+  it "provides convenience methods for selecting skalar values" do
+    most_recent_car = false
+    id_sum = 0
+    3.times { 
+      most_recent_car = Car.create(car_create_values(:name => "The Car" ))
+      id_sum += most_recent_car.id
+    }
+    Car.value_of.max(Car.id).to_i.should == most_recent_car.id
+    Car.value_of.sum(Car.id).to_i.should == id_sum
+  end
+
+  it "does not trigger queries immediately, but provides proxy query objects" do
+    Lore::Connection.reset_query_count
+    query = Car.select { |c|
+      c.where(c.num_seats >= 100)
+      c.limit(10,5)
+    }
+    query.is_a?(Lore::Select_Query).should == true
+    query_string = query.sql
+    expected = "SELECT * FROM public.car
+                JOIN public.car_type ON (public.car_type.car_type_id = public.car.car_type_id)
+                JOIN public.motorized ON (public.motorized.id = public.car.motorized_id)
+                JOIN public.vehicle ON (public.vehicle.id = public.motorized.vehicle_id)
+                JOIN public.motor ON (public.motor.id = public.motorized.motor_id)
+                WHERE num_seats >= '100' LIMIT 10 OFFSET 5"
+    query.sql.gsub(/\s/,'').should == expected.gsub(/\s/,'')
+    Lore::Connection.query_count.should == 0
+  end
+
+end
+
+