lore 0.4.8 → 0.9.2

data/lib/lore/{exception → exceptions}/ambiguous_attribute.rb

@@ -1,11 +1,11 @@
 
 module Lore
-module Exception
+module Exceptions
 
 	class Ambiguous_Attribute < ::Exception
 
 		def initialize(table_a, table_b, attribute)
-			@message = 'Ambiguous attribute: '+attribute+ ' exists in '+table_a+' and '+table_b+'. '
+			@message = "Ambiguous attribute: #{attribute.inspect} exists in #{table_a} and #{table_b}. "
 		end
 
 	end # class

data/lib/lore/{exception → exceptions}/cache_exception.rb

@@ -2,7 +2,7 @@
 require('lore/cache/bits')
 
 module Lore
-module Cache
+module Exceptions
 
   class Cache_Read_Exception < ::Exception
 

data/lib/lore/exceptions/database_exception.rb

@@ -0,0 +1,16 @@
+
+module Lore
+module Exceptions
+
+  class Database_Exception < ::Exception
+
+    attr_reader :message
+
+    def initialize(msg)
+      @message = msg
+    end
+
+  end
+
+end # module Exception
+end # module Lore

data/lib/lore/{exception/invalid_parameter.rb → exceptions/invalid_field.rb}

@@ -1,8 +1,8 @@
 
 module Lore
-module Exception
+module Exceptions
 
-  class Invalid_Parameters < ::Exception
+  class Invalid_Field < ::Exception
   
     attr_reader :invalid_params, :reason
 
@@ -19,17 +19,20 @@ module Exception
       }
       result
     end
+    def inspect
+      serialize.inspect
+    end
 
   end
 
-	class Invalid_Types < Invalid_Parameters
+	class Invalid_Types < Invalid_Field
     def initialize(invalid_params)
       super(invalid_params)
       @reason = :type
     end
 	end
 
-	class Unmet_Constraints < Invalid_Parameters
+	class Unmet_Constraints < Invalid_Field
     def initialize(invalid_params)
       super(invalid_params)
       @reason = :constraint

data/lib/lore/exceptions/unknown_type.rb

@@ -0,0 +1,18 @@
+
+module Lore
+module Exceptions
+  
+  class Unknown_Type < ::Exception
+    
+    attr_reader :code, :value
+    
+    def initialize(type_code, value)
+      @code  = type_code
+      @value = value
+      @message = "Unknown database type: #{type_code.to_s} for value #{value.inspect}"
+    end
+		
+  end
+
+end # module
+end # module

data/lib/lore/exceptions/validation_failure.rb

@@ -0,0 +1,71 @@
+
+require('lore/exceptions/invalid_field')
+
+module Lore
+module Exceptions
+
+  # A validation failure consists of one or more Invalid_Field 
+  # instances for every model field for which invalid values have 
+  # been passed, e.g. on Model.create or Model.update. 
+  #
+  # Usage: 
+  #
+  #   raise Validation_Failure.new(The_Model, { 
+  #       # Generic error. Example:  :user_id => Lore.integer
+  #         :table_foo  => Invalid_Field.new( :the_attribute => :error_type ) 
+  #       # Constraint error. Example:  :email => :format 
+  #         :table bar  => Unmet_Constraints.new( :the_attribute => :error_type )  
+  #       # Type error. Example:  :user_id => Lore.integer or :user_id => :missing
+  #         :table_batz => Invalid_Types.new( :the_attribute => :error_type ) 
+  #   })
+  #  
+	class Validation_Failure < ::Exception
+		
+    # Instances of Exception::Invalid_Field
+		attr_reader :invalid_fields
+    # Model klass that failed validation
+		attr_reader :invalid_klass
+		
+		def initialize(klass, invalid_params_hash)
+      # Instances of Exception::Invalid_Field
+			@invalid_fields = invalid_params_hash 
+			@invalid_klass  = klass
+      @message        = "#{self.class.to_s}: #{@invalid_fields.inspect}"
+      log()
+		end
+
+    def log()
+    # {{{ 
+      Lore.logger.error { "====== VALIDATION FAILURE ===========" }
+			Lore.logger.error { "Invalid field values for klass #{@invalid_klass}: " }
+			Lore.logger.error { 'Invalid field values are: ' }
+      @invalid_fields.each_pair { |table, ip|
+        Lore.logger.error { " |- Table: #{table}: #{ip.inspect}" }
+      }
+			Lore.logger.error { 'Required attributes are: ' } 
+      @invalid_klass.__attributes__.required.each_pair { |table, ip|
+        Lore.logger.error { " |- Table: #{table}: #{ip.inspect}" } 
+      }
+		end # }}}
+
+		def serialize() 
+    # {{{
+			serials = {}
+			@invalid_fields.each_pair { |table, invalid_param|
+				serials[table] = invalid_param.serialize
+			}
+			return serials
+		end # def }}}
+		
+		def inspect()
+			"Model(#{@invalid_klass}) => #{@invalid_fields.serialize} " << 
+			"Required: #{@invalid_klass.__attributes__.required.inspect}"
+		end
+    alias explain serialize
+		
+	end
+
+
+end # module
+end # module
+

data/lib/lore/gui/form_generator.rb

@@ -1,7 +1,8 @@
 
-require('aurita')
-Aurita.import_module :gui, :module
-Aurita.import_module :gui, :model_select_field
+require('rubygems')
+require('aurita-gui')
+require('lore')
+require('lore/gui/lore_model_select_field')
 
 module Lore
 module GUI
@@ -17,9 +18,10 @@ module GUI
   #   puts generator.form
   #
   class Form_Generator 
+    include Aurita::GUI
 
     attr_reader :form, :klass
-    attr_accessor :custom_elements, :labels, :params
+    attr_accessor :custom_elements, :labels, :params, :form_class
 
     def initialize(klass=nil)
       @klass           = klass
@@ -27,6 +29,7 @@ module GUI
       @params          = {}
       @custom_elements = {}
       @form            = false
+      @form_class      = Aurita::GUI::Form
     end
 
     def form
@@ -34,83 +37,129 @@ module GUI
       @form
     end
 
+    @@type_field_map = { 
+      :default                    => Proc.new { |l,f| Input_Field.new(:label => l, :name => f) }, 
+      Lore::PG_BOOL               => Proc.new { |l,f| Boolean_Field.new(:label => l, :name => f) }, 
+      Lore::PG_VARCHAR            => Proc.new { |l,f| Input_Field.new(:label => l, :name => f) }, 
+      Lore::PG_SMALLINT           => Proc.new { |l,f| Input_Field.new(:label => l, :name => f) }, 
+      Lore::PG_INT                => Proc.new { |l,f| Input_Field.new(:label => l, :name => f) }, 
+      Lore::PG_TEXT               => Proc.new { |l,f| Textarea_Field.new(:label => l, :name => f) }, 
+
+      Lore::PG_TIMESTAMP_TIMEZONE => Proc.new { |l,f| Datetime_Field.new(:label => l, :name => f, 
+                                                                         :date_format => 'dmy', 
+                                                                         :time_format => 'hms', 
+                                                                         :year_range => (2009..2020)) }, 
+
+      Lore::PG_TIMESTAMP          => Proc.new { |l,f| Datetime_Field.new(:label => l, :name => f, 
+                                                                         :date_format => 'dmy', 
+                                                                         :time_format => 'hms', 
+                                                                         :year_range => (2009..2020)) },
+
+      Lore::PG_DATE               => Proc.new { |l,f| Date_Field.new(:label => l, :name => f, 
+                                                                     :date_format => 'dmy', 
+                                                                     :year_range => (2009..2020)) },
+
+      Lore::PG_TIME               => Proc.new { |l,f| Time_Field.new(:label => l, :name => f, 
+                                                                     :time_format => 'hm') }
+    }
+
+  protected 
+
+    def field_for(type, params)
+      element   = @@type_field_map[type]
+      element ||= @@type_field_map[:default]
+      return element.call(params[:label], params[:name])
+    end
+
+  public
+
     def generate
-      @form = Aurita::GUI::Form.new(@params)
+      @form = @form_class.new(@params)
+      model_labels   = @klass.attribute_labels if @klass.respond_to?(:attribute_labels)
+      model_labels ||= {}
+
+      @klass.get_fields.each_pair { |table, attributes|
 
-      @klass.get_attributes.each_pair { |table, attributes|
         attributes.each { |attribute|
-          label_tag    = table.gsub('.','--') << '--' << attribute
+          label_tag    = "#{table.gsub('.','--')}--#{attribute}"
           label        = @labels[label_tag]
-          label      ||= label_tag
-          full_attrib  = table + '.' << attribute
-          field_name   = full_attrib.gsub('.','_')
+          label        = attribute.to_s.capitalize if label.to_s == ''
+
+          full_attrib  = "#{table}.#{attribute}"
+          field_name   = full_attrib
           form_element = false
+
+          attributes   = @klass.__attributes__
+          associations = @klass.__associations__
+
+          constraints  = attributes.constraints
+          constraints  = constraints[table] if constraints
+          constraints  = constraints[attribute] if constraints
+
+          aggregate_klasses = associations.aggregate_klasses
+          has_a_klasses     = associations.has_a
+          implicits         = attributes.implicit
+          ecplicits         = attributes.explicit
+          requireds         = attributes.required
+          primary_keys      = attributes.primary_keys
+          attribute_types   = attributes.types
           
-          # @custom_elements is a hash mapping attribute names to
-          # Custom_Element instances. 
+          # @custom_elements is a hash mapping attribute 
+          # names to Custom_Element instances. 
           if ((@custom_elements[table]) and
               (@custom_elements[table][attribute])) then
             
-            form_element = @custom_elements[table][attribute].new(table, attribute, label)
+            form_element = @custom_elements[table][attribute].new(:label => label, 
+                                                                  :id    => full_attrib, 
+                                                                  :name  => field_name)
             
-          elsif (@klass.get_primary_keys[table].nil? or                      # Ignore primary key attributes
-                 !@klass.get_primary_keys[table].include? attribute) and        
-                (@klass.get_implicit_attributes[table].nil? or               # Ignore implicit attributes
-                 !@klass.get_implicit_attributes[table].include? attribute) and 
-                (@klass.get_has_a_klasses.nil? or                            # Ignore attributes aggregated via has_a associations (added later)
-                 @klass.get_has_a_klasses[table+'.'+attribute].nil?) and        
-                (@klass.get_hidden_attributes[table].nil? or                 # Ignore otherwise hidden attributes
-                 !@klass.get_hidden_attributes[table].include? attribute)
+          elsif (primary_keys[table].nil? or                   # Ignore primary key attributes
+                 !primary_keys[table].include? attribute) and 
+                (implicits[table].nil? or                      # Ignore implicit attributes
+                 !implicits[table].include? attribute) and 
+                (has_a_klasses.nil? or                         # Ignore attributes aggregated via has_a associations (added later)
+                 has_a_klasses[full_attrib].nil?) 
+        #   and (hidden_attributes[table].nil? or              # Ignore otherwise hidden attributes
+        #       !hidden_attributes[table].include? attribute)
           then
-          # Attribute has to be added to form, according to data type
-            case @klass.get_attribute_types[table][attribute]
-            when Lore::PG_BOOL
-              form_element = Radio_Field.new(:label => label, 
-                                             :name  => field_name, 
-                                             :options => { 't' => 'yes', 'f' => 'no' } )
-              
-            when Lore::PG_SMALLINT || Lore::PG_INT
-              form_element = Input_Field.new(:label => label, :name => field_name)
-            when Lore::PG_VARCHAR
-              form_element = Input_Field.new(:label => label, :name => field_name)
-            when Lore::PG_TEXT
-              form_element = Textarea_Field.new(:label => label, :name => field_name)
-            when Lore::PG_TIMESTAMP_TIMEZONE
-              form_element = Datetime_Field.new(:label => label, :name => field_name, :date_format => 'dmy', :time_format => 'hms', :year_range => (2009..2020))
-            when Lore::PG_DATE
-              form_element = Date_Field.new(:label => label, :name => field_name, :date_format => 'dmy', :year_range => (2009..2020))
-            else
-              form_element = Input_Field.new(:label => label, :name => field_name)
-            end
-
-          elsif (!@klass.get_has_a_klasses.nil? and
-                 !@klass.get_has_a_klasses[full_attrib].nil?)
+            form_element = field_for(attribute_types[table][attribute], :name => field_name, :label => label)
+          elsif (!has_a_klasses.nil? and
+                 !has_a_klasses[full_attrib].nil?)
           then 
-            foreign_klass   = @klass.get_has_a_klasses[full_attrib]
-            form_element    = Model_Select_Field.new(foreign_klass, :label => label, :name => field_name)
+            foreign_klass   = has_a_klasses[full_attrib]
+            form_element    = Aurita::GUI::Lore_Model_Select_Field.new(foreign_klass, :label => label, :name => field_name)
 
-          elsif (!@klass.get_aggregate_klasses.nil? and
-                 !@klass.get_aggregate_klasses[full_attrib].nil?)
+          elsif (!aggregate_klasses.nil? and
+                 !aggregate_klasses[full_attrib].nil?)
           then 
-            foreign_klass   = @klass.get_aggregate_klasses[full_attrib]
-            form_element    = Model_Select_Field.new(foreign_klass, :label => label, :name => field_name)
+            foreign_klass   = aggregate_klasses[full_attrib]
+            form_element    = Aurita::GUI::Lore_Model_Select_Field.new(foreign_klass, :label => label, :name => field_name)
             
-            # Attribute is explixit (expected/required) but not 
-            # catched before -> Add attribute as hidden field: 
-          elsif (!@klass.get_explicit_attributes[table].nil? and 
-                 @klass.get_explicit_attributes[table].include? attribute)
-          then
-            form_element    = Hidden_Field.new(:name => field_name)
-
-          elsif (!@klass.get_implicit_attributes[table].nil? and 
-                 @klass.get_implicit_attributes[table].include? attribute)
+          elsif (!implicits[table].nil? and 
+                  implicits[table].include? attribute)
           then
             # Implicit field, ignored
           end
 
-          @form.add(form_element) if form_element
+          if form_element then
+            form_element.data_type = attribute_types[table][attribute] 
+            if(!requireds[table].nil? and 
+                requireds[table].include? attribute) then
+              form_element.required!
+            end
+            if constraints then
+              if constraints[:minlength] then
+              end
+              if constraints[:maxlength] then
+              end
+              if constraints[:format] then
+              end
+            end
+            @form.add(form_element) 
+          end
         }
       }
+      return @form
     end
     
   end # class

data/lib/lore/gui/lore_model_select_field.rb

@@ -10,6 +10,7 @@ module GUI
       @model        = model
       @filter       = params[:filter]
       @filter     ||= true
+      @data_type    = Lore::PG_INT
       if block_given? then
         @select_block = block
       else

data/lib/lore/migration.rb

@@ -1,45 +1,104 @@
 
+require('lore/types')
+require('lore/model/model_factory')
+
 module Lore
 
 
   # Usage: 
   # 
-  # Using auto-bootstrap of models: 
+  #  class User_Profile_Migration < Lore::Migration
   #
-  #   class My_Model < Lore::Model
-  #   extend Lore::Migration
-  # 
-  #     table :my_model, :public
-  #     primary_key :key_a, :key_a_seq
-  #     primary_key :key_b
+  #    def up
+  #      create_table(:user_profile) { 
+  #        schema :public
+  #        primary_key :user_profile_id, :user_profile_id_seq
+  #        index :user_name
+  #
+  #        user_name Lore::Type.varchar(50), :null => false, :unique => true
+  #        is_admin Lore::Type.boolean, :null => false, :default => false
+  #        registered Lore::Type.timestamp, :null => false, :default => 'now()'
+  #      }
+  #    end
   #
-  #     has_attributes { 
-  #       :foo, Lore::Type.integer, { :unique => true, :default => 1 } 
-  #       :bar, Lore::Type.integer, { :not_null => true, :check => 'bar < 1000' }
-  #     }
+  #    def down
+  #      drop_table(:user_profile)
+  #      drop_sequence(:user_profile_id_seq)
+  #    end
   #
-  #     def self.up
-  #       bootstrap()
-  #       My_Model.create(:foo => 23, :bar => 123)
-  #     end
+  #  end
   #
-  #   end
   #
-  module Migration
+  class Migration
 
-    def has_attributes(attrib_hash)
-      @model_schema = attrib_hash
+    attr_reader :primary_keys, :schema, :table, :fields, :field_params, :indices, :drop_tables
+
+    def initialize()
+      @primary_keys   = []
+      @sequences      = {}
+      @fields         = []
+      @field_params   = {}
+      @indices        = []
+      @drop_tables    = []
+      @drop_sequences = []
+      @constraints    = []
     end
 
-    def update_schema
-      @factory = Model_Factory.new(self.class.to_s)
-      @model_schema.each_pair { |attrib_name, attrib_props|
-        @factory.add_attribute(attrib_name.to_s, attrib_props)
+    def create_table(table_name, schema=:public, &block)
+      instance_eval(&block)
+      @table = table_name
+      factory = Model_Factory.new(table_name)
+      @primary_keys.each { |p|
+        factory.add_attribute(p, :null => false, :type => Lore::Type.integer)
+        factory.add_primary_key(:attribute => p, 
+                                :key_name => "#{table_name}_pkey", 
+                                :sequence => @sequences[p] )
+      }
+      @fields.each { |f|
+        factory.add_attribute(f, @field_params[f])
       }
+      factory.build_table
+    end
+
+    def drop_table(table_name)
+      @drop_tables << table_name
+    end
+    def drop_sequence(sequence_name)
+      @drop_sequences << sequence_name
+    end
+
+    def up()
+    end
+
+    def down()
+    end
+      
+    def primary_key(key_name, sequence_name=nil)
+      key_name = key_name.to_sym
+      @primary_keys << key_name
+      @sequences[key_name] = sequence_name.to_sym if sequence_name
+    end
+
+    def schema(schema_name)
+      @schema = schema_name
+    end
+
+    def add_field(field_name, type, params={})
+      @fields << field_name
+      @field_params[field_name] = params
+      @field_params[field_name][:type] = type
+    end
+
+    def add_constraint(constraint)
+      @constraints << constraint
+    end
+
+    def index(field_name)
+      @indices << field_name
     end
 
-    def bootstrap
-      @factory.build_table
+    def method_missing(field_name, type, params={})
+      add_field(field_name, type, params)
     end
 
   end