lore 0.4.8 → 0.9.2

data/lib/lore/model.rb

@@ -1,20 +1,8 @@
 
 require('logger')
 
-require('lore/aspect');
-require('lore/table_selector');
-require('lore/table_inserter');
-require('lore/table_updater');
-require('lore/table_deleter');
-require('lore/table_instance');
-require('lore/query_shortcuts');
-require('lore/validation');
-require('lore/migration');
-require('lore/validation/parameter_validator');
-require('lore/exception/invalid_parameter');
-require('lore/exception/invalid_klass_parameters');
-require('lore/cache/cacheable');
-require('lore/table_accessor.rb')
+require('lore/model/aspect');
+require('lore/model/table_accessor');
 
 module Lore
 
@@ -77,7 +65,6 @@ module Lore
   # Lore::Model extends 
   # * Lore::Cache::Cacheable
   # * Lore::Query_Shortcuts
-  # * Lore::Validation
   # * Lore::Aspect
   # 
   # Each of them is optional. If you want, for example, a minimalistic 
@@ -101,7 +88,6 @@ module Lore
   #   class User < Lore::Table_Accessor
   #   extend Lore::Query_Shortcuts
   #   extend Lore::Aspect
-  #   extend Lore::Validation
   #     
   #     table :user, :public
   #     primary_key :user_id
@@ -127,9 +113,8 @@ module Lore
   class Model < Table_Accessor
     extend Lore::Cache::Cacheable
     extend Lore::Query_Shortcuts
-    extend Lore::Validation
     extend Lore::Aspect
-    extend Lore::Migration
+  # extend Lore::Migration
 
     def by_id(pkey_id)
       _by_id(pkey_id).first # Auto-defined in Lore::Table_Accessor.primary_key

data/lib/lore/model/associations.rb

@@ -0,0 +1,225 @@
+
+module Lore
+
+  class Associations
+
+    attr_reader :foreign_keys
+    attr_reader :primary_keys 
+    attr_reader :base_klasses 
+    attr_reader :has_a 
+    attr_reader :has_n 
+    attr_reader :belongs_to 
+    attr_reader :aggregate_klasses
+    attr_reader :aggregates 
+    attr_reader :base_klasses_tree
+    attr_reader :aggregates_tree
+    # Returns mapping rules from own foreign key values to 
+    # foreign primary key values. Supports composed foreign keys. 
+    # Example: 
+    #   { 
+    #     'public.vehicle'   => [ :vehicle_id ], 
+    #     'public.motorizes' => [ :motorized_id ] 
+    #   }
+    #   -->
+    #   # Mapping is:  [ <table>, <own key names>, <foreign pkey name> ]
+    #   [ 
+    #     'public.vehicle',   [ :vehicle_id ], [ :id ], 
+    #     'public.motorized', [ :motorizes_id ], [ :id ], 
+    #   ]
+    # Note that this is an array, not a Hash, and entries are 
+    # ordered by join order. 
+    # (Which is important as arrays are ordered, opposed to Hashes 
+    # in Ruby 1.8)
+    #
+    # For in-depth understanding, see 
+    # Model_Instance#get_primary_key_value_map
+    attr_reader :pkey_value_lookup
+
+    # Returns polymorphic base classes as map 
+    #   { table => polymorphic_attribute }
+    # Example: 
+    #  
+    #  { 'public.asset' => :concrete_asset_model }
+    #
+    attr_reader :polymorphics
+
+    attr_reader :concrete_models
+
+    def initialize(accessor)
+      @accessor = accessor
+      @foreign_keys = {}
+      @primary_keys = {}
+      
+      @has_a = {}
+      @has_n = {}
+      @belongs_to = {}
+      
+      @base_klasses = {}
+      @base_klasses_tree = {}
+      @aggregate_klasses = {}
+      @aggregates_tree = {}
+
+      @pkey_value_lookup = []
+
+      @polymorphics = {}
+      @concrete_models = []
+
+      @joins = false
+    end
+
+    private
+
+    # Add foreign keys to another model. 
+    # Assumes foreign keys are stored in the models own table. 
+    def add_foreign_key_to(model, *keys)
+    # {{{
+      keys.flatten! 
+      mapping = [ keys, model.__associations__.primary_keys[model.table_name] ]
+      @foreign_keys[@accessor.table_name] = {} unless @foreign_keys[@accessor.table_name]
+      @foreign_keys[@accessor.table_name][model.table_name] = mapping 
+      # Inherit foreign keys: 
+      @foreign_keys.update(model.__associations__.foreign_keys)
+    end # }}}
+
+    public
+
+    def add_primary_key(attribute, sequence_name=nil)
+      @primary_keys[@accessor.table_name] = [] unless @primary_keys[@accessor.table_name]
+      @primary_keys[@accessor.table_name] << attribute
+    end
+
+    # Add another model as base model. 
+    # Leads to inheritance of fields, primary keys, 
+    # joins etc. 
+    #
+    # Used by Model.is_a? Other_Model
+    #
+    def add_base_model(model, *keys)
+    # {{{
+      add_foreign_key_to(model, *keys)
+      @base_klasses[model.table_name]      = [ model, *keys ]
+      @base_klasses_tree[model.table_name] = model.__associations__.base_klasses_tree
+      @aggregates_tree[model.table_name]   = model.__associations__.aggregates_tree
+      keys.flatten.each { |attribute|
+        @accessor.__attributes__.set_implicit(@accessor.table_name, attribute)
+      }
+      @primary_keys.update(model.__associations__.primary_keys)
+      @pkey_value_lookup += model.__associations__.pkey_value_lookup
+      @pkey_value_lookup << [ model.table_name, 
+                              keys.flatten, 
+                              model.__associations__.primary_keys[model.table_name] ]
+      if model.is_polymorphic? then
+        @polymorphics[model.table_name] = model.polymorphic_attribute
+        model.__associations__.add_concrete_model(@accessor)
+      end
+      inherit(model)
+    end # }}}
+
+    # For polymorphic models only. 
+    # Adds a concrete model class for a polymorphic 
+    # model. 
+    def add_concrete_model(model)
+      @concrete_models << model
+    end
+
+    # Add another model as aggregate model. 
+    # Leads to inheritance of fields, primary keys, 
+    # joins etc. 
+    #
+    # Used by Model.aggregates Other_Model
+    #
+    def add_aggregate_model(model, *keys)
+    # {{{
+      add_foreign_key_to(model, *keys)
+      @aggregate_klasses[model.table_name] = [ model, *keys ]
+      @aggregates_tree[model.table_name]   = model.__associations__.aggregates_tree
+      # Required attributes of aggregated models are not 
+      # required in this model, as aggregated models are 
+      # referenced by their pkey only and have to exist 
+      # in DB already. 
+      # Thus, the foreign key to an aggregated model is
+      # required only: 
+      keys.flatten.each { |attribute|
+        @accessor.__attributes__.set_required(attribute)
+      }
+      inherit(model)
+    end # }}}
+
+    def joined_models()
+      @joined_models || @joined_models = @aggregate_klasses.dup.update(@base_klasses)
+    end
+    alias joined_klasses joined_models
+
+    # Recursively checks if another model is aggregated 
+    # by this model, either directly (foreign key is in 
+    # own table) or via inheritance (foreign key is in 
+    # joined table). 
+    def has_aggregate_model?(model)
+    # {{{
+      @aggregate_klasses.each_pair { |table,map|
+        aggr_model = map.first
+        if aggr_model == model || 
+           aggr_model.__associations__.has_aggregate_model?(model) then
+          return true 
+        end
+      }
+      return false
+    end # }}}
+
+    # Recursively checks if another model is a base model  
+    # of this model, either directly (foreign key is in 
+    # own table) or via inheritance (foreign key is in 
+    # joined table). 
+    def has_base_model?(model)
+    # {{{
+      @base_klasses.each_pair { |table,map|
+        aggr_model = map.first
+        if aggr_model == model || 
+           aggr_model.__associations__.has_base_model?(model) then
+          return true 
+        end
+      }
+      return false
+    end # }}}
+
+    # Recursively checks if another model is joined  
+    # by this model (aggregated or as base model), either 
+    # directly (foreign key is in own table) or via 
+    # inheritance (foreign key is in joined table). 
+    def has_joined_model?(model)
+      has_base_model?(model) || has_aggregated_model?(model)
+    end
+
+
+    def joins()
+      @joins || @joins = @aggregates_tree.dup.update(@base_klasses_tree)
+    end
+
+    # For cat.get_wheel()
+    def add_has_a(model, *keys)
+      add_foreign_key_to(model, *keys)
+      @has_a[@accessor.table_name] = model
+    end
+
+    # For cat.get_wheel_set()
+    def add_has_n(model, *keys)
+      add_foreign_key_to(model, *keys)
+      @has_n[@accessor.table_name] = model
+    end
+
+    # For wheel.get_car()
+    def add_belongs_to(model, *keys)
+      add_foreign_key_to(model, *keys)
+      @belongs_to[@accessor.table_name] = model
+    end
+
+    def inherit(base_model)
+      parent_associations = base_model.__associations__
+      @has_a.update(parent_associations.has_a)
+      @has_n.update(parent_associations.has_n)
+      @belongs_to.update(parent_associations.belongs_to)
+    end
+
+  end
+
+end

data/lib/lore/model/attribute_settings.rb

@@ -0,0 +1,233 @@
+
+module Lore
+
+  # There are several categories of attributes: 
+  #
+  # [required] - A value for this attribute has to be set in any case 
+  #              (field is NOT NULL)
+  # [implicit] - Value for this attribute will be set by database. 
+  #              (field is set via sequence, trigger, etc.)
+  #              Any given value will be ignored. 
+  #
+  # If none of the above, field will be treaded as NULL field. 
+  #
+  class Attribute_Settings
+
+    attr_accessor :fields, :fields_flat, :required, :implicit, :types, :constraints, :sequences, :primary_keys
+    
+    def initialize(accessor, fields, types)
+      fields.map! { |a| a.to_sym }
+      @accessor           = accessor
+      fields.map! { |f| f.to_sym } 
+      @fields             = { accessor.table_name => fields }
+    # @fields_flat        = fields
+      @required           = {}
+      @implicit           = {}
+      @types              = {}
+      @constraints        = {}
+      @hidden             = {}
+      @sequences          = {}
+      @primary_keys       = {}
+      sym_types = {}
+      types.each_pair { |attrib, type|
+        sym_types[attrib.to_sym] = type
+      }
+      @types[accessor.table_name] = sym_types
+    end
+
+    def [](table_name)
+      @fields[table_name]
+    end
+
+    def num_fields
+      fields_flat.length
+    end
+    def num_own_fields
+      fields[@accessor.table_name].length
+    end
+
+    def required?(attribute)
+      # Inherited primary keys are marked as required, 
+      # but they aren't in this model, where they are 
+      # also marked as implicit. 
+      @required[attribute] && !@implicit[attribute] || false
+    end
+    def implicit?(attribute)
+      @implicit[attribute] 
+    end
+
+    def set_required(*args)
+      table = @accessor.table_name
+      if args.length == 1 then
+        attribute = args.at(0)
+      else 
+        table     = args.at(0)
+        attribute = args.at(1)
+      end
+      @required[table] = {} unless @required[table]
+      @required[table][attribute.to_sym] = true
+    end
+
+    # Implicit attributes are set by the DBMS, via sequences, 
+    # triggers, or may not be set manually for some reason. 
+    # Manually set values for implicit attributes are ignored 
+    # on INSERT and UPDATE commands, but may be used in e.g. 
+    # WHERE part of a query. 
+    #
+    # Usage: 
+    #  
+    #   set_implicit(table, :attrib_a)
+    # Or 
+    #   set_implicit(:attrib_a)  # table defaults to own table
+    #
+    def set_implicit(*args)
+      table     = nil
+      attribute = nil
+      if args.length > 1 then 
+        table     = args.at(0)
+        attribute = args.at(1).to_sym
+      else
+        table     = @accessor.table_name
+        attribute = args.at(0).to_sym
+      end
+      @implicit[table] = [] unless @implicit[table]
+      @implicit[table] << attribute
+    end
+
+    def add_primary_key(attribute, sequence_name=nil)
+      @primary_keys[@accessor.table_name] = [] unless @primary_keys[@accessor.table_name]
+      @primary_keys[@accessor.table_name] << attribute
+      if sequence_name then
+        set_sequence(attribute, sequence_name) if sequence_name
+      else
+        set_required(attribute)
+      end
+    end
+
+    def set_sequence(attribute, sequence_name)
+      set_implicit(attribute)
+      if @sequences[@accessor.table_name] then
+        @sequences[@accessor.table_name][attribute] = sequence_name
+      else
+        @sequences[@accessor.table_name] = { attribute => sequence_name } 
+      end
+    end
+
+    # All attributes that aren't implicit and thus 
+    # can be set manually. 
+    def explicit
+      return @explicit if @explicit
+      @explicit = {}
+      @fields.each_pair { |table, attrib_list| 
+        @explicit[table] = attrib_list.reject { |a| 
+          # @fields includes all inherited fields. 
+          # We do not want to aggregated models to 
+          # extend @expected and @implicit, as they 
+          # can only be referenced by their primary 
+          # keys, but never assigned values in e.g. 
+          # Model.create. 
+          !@implicit[table] || @implicit[table].include?(a.to_sym)
+        }
+      }
+      @explicit.delete_if { |table, fields| fields.length == 0 }
+      @explicit
+    end
+
+    def add_hidden(attribute)
+      @hidden[@accessor.table_name] = attribute
+    end
+
+    def add_base_model(model)
+      inherit(model)
+      @sequences.update(model.__attributes__.sequences)
+      @implicit.update(model.__attributes__.implicit)
+      @required.update(model.__attributes__.required)
+      @fields_flat = false # Invalidate cached values
+    end
+
+    def add_aggregate_model(model)
+      inherit(model)
+      # Include indirect implicit fields, but do not 
+      # set aggregated primary keys as implicit, as it 
+      # will be set manually: 
+      aggregated_implicit = model.__attributes__.implicit.dup
+    # model.get_primary_keys.each { |pkey_field|
+    #   aggregated_implicit[model.table_name].delete(pkey_field)
+    # }
+    # @implicit.update(aggregated_implicit)
+      @fields_flat = false # Invalidate cached values
+    end
+
+    def fields_flat
+      return @fields_flat if @fields_flat
+      fields = @fields[@accessor.table_name]
+      fields += fields_flat_rec
+      # Shadowing attribute fields whose name is already 
+      # present in more specific table. Remove uniq! to 
+      # allow multiple appearance of attribute names in 
+      # flat field list. 
+      # TODO: CHECK THIS!!
+      # fields.uniq!
+      @fields_flat = fields
+      return @fields_flat
+    end
+
+    def fields_flat_rec(model=nil)
+      fields = []
+      model ||= @accessor
+      joined_models = model.__associations__.joined_models
+      model.__associations__.joins.each_pair { |table,base_tables|
+        fields += @fields[table]
+        fields += fields_flat_rec(joined_models[table].first)
+      }
+      fields
+    end
+    
+    def inherit(base_model)
+      parent_attributes = base_model.__attributes__
+      @constraints.update(parent_attributes.constraints)
+      @types.update(parent_attributes.types)
+      @fields.update(parent_attributes.fields)
+    # @fields_flat += parent_attributes.fields_flat
+      @primary_keys.update(parent_attributes.primary_keys)
+    end
+
+    def add_constraints(attrib, constraints={})
+      if attrib.kind_of? Clause then
+        attrib_split = attrib.to_s.split('.')
+        table        = attrib_split[0..-2]
+        attrib       = attrib_split[-1]
+      else
+        table = @accessor.table_name
+      end
+      attrib = attrib.to_sym unless attrib.is_a? Symbol
+
+      @constraints[table]         = Hash.new unless @constraints[table]
+      @constraints[table][attrib] = Hash.new unless @constraints[table][attrib]
+
+      if constraints[:mandatory] then
+        set_required(table, attrib.to_s)
+      end
+      if constraints[:format] then
+        @constraints[table][attrib][:format] = constraints[:format]
+      end
+      if constraints[:length] then
+        if constraints[:length].kind_of? Range then
+          @constraints[table][attrib][:minlength] = constraints[:length].first
+          @constraints[table][attrib][:maxlength] = constraints[:length].last
+        else 
+          @constraints[table][attrib][:minlength] = constraints[:length]
+          @constraints[table][attrib][:maxlength] = constraints[:length]
+        end
+      end
+      if constraints[:minlength] then
+        @constraints[table][attrib][:minlength] = constraints[:minlength]
+      end
+      if constraints[:maxlength] then
+        @constraints[table][attrib][:maxlength] = constraints[:maxlength]
+      end
+    end
+    
+  end
+
+end