lore 0.4.2

data/test/model.rb

@@ -0,0 +1,142 @@
+
+require 'rubygems'
+require('lore/test/env')
+require('lore/model')
+
+Lore::Context.enter :test
+
+module Lore
+module Unit
+
+  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
+
+    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
+  end
+
+  class Vehicle < Lore::Model
+    table :vehicle, :public
+    primary_key :id, :vehicle_id_seq
+
+    has_a Manufacturer, :manuf_id
+    has_n Owner, :vehicle_id
+
+    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_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
+    table :vehicle_owner, :public
+    primary_key :vehicle_id
+    primary_key :owner_id
+    #    aggregates Vehicle, :vehicle_id
+    #    aggregates Owner, :owner_id
+    # maps Vehicle, Owner
+    
+    def get_owner()
+      Owner.find(1).with(Owner.owner_id == owner_id).entity
+    end
+  end
+
+  class Car_Type < Lore::Model
+    table :car_type, :public
+    primary_key :car_type_id, :car_type_id_seq
+
+    validates :name, NAME_FORMAT
+
+    use_label :name
+
+    cache_entities
+  end
+
+  class Car < Vehicle
+    table :car, :public
+    primary_key :id, :car_id_seq
+    
+    is_a Vehicle, :vehicle_id 
+    aggregates Car_Type, :car_type_id
+
+    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
+  end
+
+  class Convertible < Car
+    table :convertible, :public
+    primary_key :id, :convertible_id_seq
+    is_a Car, :car_id
+  end
+
+  class Trailer < Lore::Model
+    table :trailer, :public
+    primary_key :trailer_id, :trailer_id_seq
+
+    aggregates Car, :car_id
+  end
+
+  class Bike < Vehicle
+    table :bike, :public
+    primary_key :bike_id, :bike_id_seq
+    
+    is_a Vehicle, :vehicle_id
+
+    cache_entities
+  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
+
+    cache_entities
+  end
+
+end
+end
+
+

data/test/prepare.rb

@@ -0,0 +1,37 @@
+
+require 'rubygems'
+require 'cuba'
+require 'lore'
+require 'lore/connection'
+
+Lore::Context.enter :aurita
+
+Cuba.import_imp_model :wiki, :article
+
+include Cuba::Wiki
+
+STDERR.puts '----------------------------------------'
+
+Article.all.entities
+
+Article.select { |art| 
+  art.join(User_Group).using(:user_group_id) { |a|
+    a.where((Article.content_id > '100') & (Article.title == 'foo') | 
+            (Article.content_id < '200') & (Article.title <=> 'bar') & (Article.published == 't'))
+  a.limit(10)
+    a.order_by(Article.article_id, :desc)
+  }
+}
+
+STDERR.puts '----------------------------------------'
+
+=begin
+Article.prepare(:by_id, Lore::Type.integer) { |a|
+  a.where(Article.article_id == Lore::Clause.new('$1'))
+}
+2.times do
+ p Article.find(1).with(Article.article_id == '1001').entity.article_id
+# Article.by_id(1001).first.article_id
+end
+=end
+

data/test/tc_aspect.rb

@@ -0,0 +1,58 @@
+
+require 'test/unit'
+require('lore/test/model')
+
+
+module Lore
+module Unit
+
+  # Extend Car by hooks: 
+  class Car 
+    def self.pre_create(attrib_hash)
+      attrib_hash[:aspect_pre_value] = 'ChangedPre'
+    end
+    def self.post_create(obj)
+      obj[:aspect_post_value] = 'ChangedPost'
+    end
+    def self.pre_commit(obj)
+      obj[:maxspeed] = 120
+    end
+    def self.post_commit(obj)
+      obj[:num_seats] = 5
+    end
+    def self.pre_delete(obj)
+    end
+    def self.post_delete()
+    end
+  end
+
+  class TC_Aspect < Test::Unit::TestCase
+
+    def setup
+      @@ct = Car_Type.create(:name => 'Pickup')
+      @@ac = Car.create(:name => 'Foo', 
+                        :aspect_pre_value => 'WillChange', 
+                        :aspect_post_value => 'WillChange', 
+                        :maxspeed => 100, 
+                        :num_doors => 5, 
+                        :manuf_id => 1, 
+                        :num_seats => 4, 
+                        :car_type_id => @@ct.car_type_id)
+    end
+
+    def test_create
+      assert_equal(@@ac.aspect_pre_value, 'ChangedPre')
+      assert_equal(@@ac.aspect_post_value, 'ChangedPost')
+    end
+
+    def test_update
+      @@ac[:name] = 'RedPickup'
+      @@ac.commit
+      assert_equal(@@ac.num_seats.to_s, '5')
+      assert_equal(@@ac.maxspeed.to_s, '120')
+    end
+
+  end
+
+end
+end

data/test/tc_cache.rb

@@ -0,0 +1,80 @@
+
+require 'test/unit'
+
+require('lore/test/model')
+require('lore/test/ts_lore')
+
+module Lore
+module Unit
+
+  class TC_Cache < Test::Unit::TestCase
+
+    def setup
+      m1 = Manufacturer.create( :name => 'BMW' )
+      m2 = Manufacturer.create( :name => 'Mercedes' )
+      m3 = Manufacturer.create( :name => 'Audi' )
+    
+      ct1 = Car_Type.create( :name => 'Limousine' )
+      ct2 = Car_Type.create( :name => 'SUV' )
+      ct3 = Car_Type.create( :name => 'Cabrio' )
+      ct4 = Car_Type.create( :name => 'Boxter' )
+      
+      c1 = Car.create(
+        :manuf_id => m2.manuf_id,
+        :name => 'SLK', 
+        :num_seats => 2, 
+        :maxspeed => 180, 
+        :num_doors => 3, 
+        :car_type_id => ct3.car_type_id
+      )
+    end
+
+    def teardown
+      Manufacturer.delete_all
+      Vehicle.delete_all
+      Car_Type.delete_all
+      Car.delete_all
+      Bike.delete_all
+      Owner.delete_all
+      Garage.delete_all
+    end
+
+    def test_basic
+      passed = true
+      org_name = Car.all.entity.name
+      20.times { 
+        cached_inst = Car.all.entity
+        cached_name = cached_inst.name
+        passed = passed && (org_name == cached_name)
+        assert_equal(org_name, cached_name)
+        passed = passed && (!Lore.cache_enabled? || cached_inst.is_cached_entity?)
+      }
+      assert(passed, 'Cached value and original value differ (This will fail if caching is not configured, doing no harm)') 
+
+      20.times { 
+        cached_inst = Car.all.entity
+        cached_name = cached_inst.name
+        passed = passed && (org_name == cached_name)
+        assert_equal(org_name, cached_name)
+        cached_inst[:name] = 'Changed'
+        passed = passed && (cached_inst.name == 'Changed')
+        assert_equal(cached_inst.name, 'Changed')
+        cached_inst.commit
+        passed = passed && (!Lore.cache_enabled? || !cached_inst.is_cached_entity?)
+      }
+      assert(passed, 'Cached value and original value differ') 
+    end
+
+    def test_random_select
+      # Random selects must not be cached under any circumstances. 
+      random_car = Car.select('*, random() as rand') { |rcar|
+        rcar.where(true)
+        rcar.order_by(:rand, :desc)
+        rcar.limit(1)
+      }.first
+      assert(!random_car.loaded_from_cache)
+    end
+
+  end
+end
+end

data/test/tc_clause.rb

@@ -0,0 +1,104 @@
+
+require 'test/unit'
+require('lore/test/model')
+require('lore/clause')
+
+module Lore
+module Unit
+
+
+  class TC_Clause < Test::Unit::TestCase
+
+  private
+
+    def clean(query)
+      return query.gsub("\n",'').gsub("\t",' ').gsub(/(\s+)/,' ')
+    end
+
+  public
+
+    def setup
+    end
+
+    def teardown
+    end
+
+    def test_models
+      assert(Car.table_name == 'public.car')
+      assert(Vehicle.table_name == 'public.vehicle')
+    end
+
+    def test_attribte_clauses
+      assert(Car.vehicle_id.to_s == 'public.car.vehicle_id', 'clause failed: ' << Car.vehicle_id.to_s)
+    end
+
+    def test_inherited_attributes
+      # Attribute only in derived model: 
+      assert_equal('public.car.vehicle_id', Car.vehicle_id.to_s) 
+      # Attribute in both base and derived model (default to derived model): 
+      assert_equal('public.car.id', Car.id.to_s)
+      # Attribute only in base model (redirect to base model attribute); 
+      assert_equal('public.vehicle.name', Car.name.to_s)
+    end
+
+    def test_logic
+
+      (Car.name == 'foo') & (Car.vehicle_id == '23')
+
+    end
+
+    def test_operators
+      s1 = Car.name == Vehicle.name
+      s1_sql = 'public.vehicle.name = public.vehicle.name'
+      assert(clean(s1.to_s) == s1_sql, s1.to_s + ' != ' << s1_sql)
+
+      s2 = Car.name.not_in( 
+          Vehicle.select(Vehicle.name) { |v| v.where(v.id == 1) } 
+      )
+      s2_sql = "public.vehicle.name NOT IN (SELECT public.vehicle.name FROM public.vehicle WHERE public.vehicle.id = '1' ) "
+      assert_equal(clean(s2.to_s), s2_sql)
+
+    end
+
+    def test_select_value
+      ct = Car_Type.create( :name => 'Pickup' )
+      Car.create(
+        :manuf_id => 1,
+        :name => 'SLK', 
+        :num_seats => 2, 
+        :maxspeed => 180, 
+        :num_doors => 3, 
+        :car_type_id => ct.car_type_id
+      )
+      latest_car = Car.create(
+        :manuf_id => 1,
+        :name => 'SLK2', 
+        :num_seats => 2, 
+        :maxspeed => 180, 
+        :num_doors => 3, 
+        :car_type_id => ct.car_type_id
+      )
+      all_car_names = Car.all(Car.name).entities
+      assert(all_car_names.include?('slk'))
+      assert(all_car_names.include?('slk2'))
+      assert_equal Car.value_of.max(Car.vehicle_id).to_i, latest_car.vehicle_id.to_i
+      assert_equal Car.value_of.max(Car.vehicle_id).to_i, Car.value_of.max('public.vehicle.id').to_i
+
+    end
+
+    def test_ranges
+      Car.select { |c| 
+        c.where(c.id.in([1,2,3,4]))
+      }
+      Car.select { |c| 
+        c.where(c.id.in(1..4))
+      }
+    end
+
+    def test_having
+    end
+
+  end
+
+end
+end

data/test/tc_deep_inheritance.rb

@@ -0,0 +1,49 @@
+
+require 'test/unit'
+require 'lore/test/model'
+require 'lore/symbol'
+
+module Lore
+module Unit
+
+  class TC_Deep_Inheritancei < Test::Unit::TestCase
+
+    def test_create
+
+      Manufacturer.delete_all
+      Vehicle.delete_all
+      Car.delete_all
+      Car_Type.delete_all
+
+      m = Manufacturer.create(:name => 'temp')
+      o = Owner.create(:name => 'temp')
+      ct = Car_Type.create(:name => 'temp')
+
+      # Make sure vehicle and car ids differ by at 
+      # least 1: 
+      v = Vehicle.create(:manuf_id => m.id, 
+                         :owner_id => o.id, 
+                         :name => 'temp', 
+                         :num_seats => 2, 
+                         :num_doors => 5, 
+                         :maxspeed => 190)
+
+      v.delete
+      c = Convertible.create(:color => 'red', 
+                             :manuf_id => m.id, 
+                             :owner_id => o.id, 
+                             :name => 'convertible1', 
+                             :num_seats => 2, 
+                             :num_doors => 5, 
+                             :maxspeed => 190, 
+                             :car_type_id => ct.id)
+      c.delete
+      m.delete
+      o.delete
+      ct.delete
+    end
+
+  end
+
+end
+end

data/test/tc_factory.rb

@@ -0,0 +1,57 @@
+
+require 'test/unit'
+require 'lore/test/model'
+require 'lore/model_factory'
+require 'lore/gui/form_generator'
+
+module Lore
+module Unit
+  
+  class TC_Factory < Test::Unit::TestCase
+    
+    public
+    
+    def setup
+      begin
+        Model_Factory.drop_model(Some::App::New_Model)
+        Model_Factory.drop_model(Some::App::Other_Model)
+      rescue ::Exception => excep
+        # ignore
+      end
+    end
+    
+    def teardown
+      Model_Factory.drop_model(Some::App::New_Model)
+      Model_Factory.drop_model(Some::App::Other_Model)
+    end
+    
+    def test_simple
+      builder = Model_Factory.new('Some::App::New_Model')
+      builder.set_attributes(:model_id => { :type => Type.integer, :not_null => true }, 
+                             :name     => { :type => Type.integer, :not_null => true, :check => "name <> ''", :unique => true }, 
+                             :created  => { :type => Type.timestamp, :not_null => true, :default => 'now()' })
+      builder.add_primary_key(:key_name => 'model_pkey', :attribute => 'model_id')
+      builder.output_file = 'custom_models.rb'
+      builder.build_model_klass()
+      
+      form_string = GUI::Form_Generator.new(Some::App::New_Model).generate.string
+      
+      assert_equal(Some::App::New_Model.to_s, 'Some::App::New_Model') 
+      
+      builder = Model_Factory.new('Some::App::Other_Model')
+      builder.add_attribute('other_id_1', :type => Type.integer, :not_null => true)
+      builder.add_attribute('other_id_2', :type => Type.integer, :not_null => true)
+      builder.add_attribute('name', :type => Type.integer, :not_null => true, :check => "name <> ''", :unique => true)
+      builder.add_attribute('created', :type => Type.timestamp, :not_null => true, :default => 'now()')
+      builder.add_primary_key(:attribute => 'other_id_1', :key_name => 'id1') 
+      builder.add_primary_key(:attribute => 'other_id_2', :key_name => 'id2') 
+      builder.output_file = 'custom_models.rb'
+      builder.build_model_klass()
+
+      assert_equal(Some::App::Other_Model.to_s, 'Some::App::Other_Model') 
+    end
+    
+  end
+  
+end # module
+end # module

data/test/tc_filter.rb

@@ -0,0 +1,37 @@
+
+require 'test/unit'
+require 'lore/test/model'
+
+module Lore
+module Unit
+
+  class TC_Filter < Test::Unit::TestCase
+    
+    public
+
+    def setup
+    end
+    
+    def teardown
+    end
+
+    def test_simple
+   
+      m1 = Manufacturer.create( :name => 'Dodge' )
+      ct1 = Car_Type.create( :name => 'VPenis' )
+      
+      c1 = Car.create(
+                      :manuf_id => m1.manuf_id,
+                      :name => 'Viper', 
+                      :num_seats => 2, 
+                      :maxspeed => 230, 
+                      :num_doors => 3, 
+                      :car_type_id => ct1.car_type_id
+                     )
+                      
+    end
+
+  end
+  
+end # module
+end # module

data/test/tc_form.rb

@@ -0,0 +1,32 @@
+
+require 'test/unit'
+require 'lore/gui/form_generator'
+require 'lore/test/model'
+
+module Lore
+module Unit
+
+  class TC_Form < Test::Unit::TestCase
+    
+  public
+
+    def setup
+      for count in (1..5) do
+        Manufacturer.create( :name => 'manufacturer_' << count.to_s)
+        Car_Type.create( :name => 'car_type_' << count.to_s)
+      end
+    end
+    
+    def teardown
+      Manufacturer.delete_all
+      Car_Type.delete_all
+    end
+
+    def test_simple
+      form = GUI::Form_Generator.new(Car).generate
+    end
+
+  end
+  
+end # module
+end # module

data/test/tc_model.rb

@@ -0,0 +1,86 @@
+
+require 'test/unit'
+require 'lore/test/model'
+require 'lore/symbol'
+
+module Lore
+module Unit
+
+
+  class TC_Model < Test::Unit::TestCase
+
+    def setup
+    end
+
+    def teardown
+    end
+
+    def test_basic_attribs
+
+      assert(Car.table_name == 'public.car', 'Table name incorrect')
+      assert(Vehicle.table_name == 'public.vehicle', 'Table name incorrect')
+
+      assert(Car.get_is_a.has_key?(Vehicle.table_name))
+      assert(!(Car.get_is_a.has_key?(Car_Type.table_name)))
+      assert(Car.get_joins.has_key?(Car_Type.table_name))
+
+      assert(Car.get_has_a_klasses['public.vehicle.manuf_id'] == Manufacturer)
+
+      attribs = Car.get_attributes
+      types = Car.get_attribute_types
+      assert(attribs.has_key?('public.vehicle'))
+      assert(attribs.has_key?('public.car'))
+      assert(types.has_key?('public.vehicle'))
+      assert(types.has_key?('public.car'))
+    end
+
+    def test_aggregates
+      is_a_hierarchy = Car.get_is_a
+      # Car_Type is an aggregate, it must not be listed 
+      # as base table: 
+      assert(!is_a_hierarchy.keys_flat.include?('public.car_type'))
+    end
+    
+    def test_create
+      v = Vehicle.create(:name => 'Async', :maxspeed => 100, 
+                     :owner_id => 0, :num_seats => 2, 
+                     :manuf_id => 0)
+
+      car_type = Car_Type.create(:name => 'Basic_Type')
+      assert_equal(car_type.name, 'Basic_Type')
+      v.delete
+      car_type.commit
+      ct = Car_Type.load(:car_type_id => car_type.car_type_id)
+      assert_equal(ct.name, 'Basic_Type')
+      ct.delete
+    end
+
+    def test_create_with_inheritance
+      car_type = Car_Type.create(:name => 'Temp')
+      inst_attribs =  { 
+        :num_seats => 5, :num_doors => 5, 
+        :maxspeed => 180, :name => 'Basic', 
+        :owner_id => 0, :manuf_id => 0, 
+        :car_type_id => car_type.car_type_id
+      }
+      car = Car.create(inst_attribs)
+
+      car.name = 'Changed Name'
+      assert_equal(car.name, 'Changed Name')
+      # As Car is not derived from Car_Type but aggregating 
+      # it only, Car.name and Car_Type.name are not conflicting! 
+      # Updating a Car instance must not affect its aggregated 
+      # instances. 
+      assert_equal(car_type.name, 'Temp')
+      assert(car.touched?)
+      car.commit
+      assert(!car.touched?)
+
+      car.delete
+      car_type.delete
+    end
+
+  end
+
+end
+end