lore 0.4.8 → 0.9.2

data/lib/lore/strategies/table_update.rb

@@ -0,0 +1,155 @@
+
+require('lore/bits')
+
+module Lore
+
+  class Table_Update
+
+    @logger = Logger.new(Lore.logfile)
+
+    public
+
+    def initialize(accessor)
+      @accessor = accessor
+      @base_table = accessor.table_name
+    end
+
+    private
+
+    def atomic_update_query(accessor, 
+                            primary_key_values, 
+                            value_keys)
+    # {{{
+
+      return unless value_keys && value_keys.length > 0
+
+      table      = accessor.table_name
+    # attributes = accessor.get_fields_flat
+      attributes = accessor.get_fields[table]
+      required   = accessor.__attributes__.required[table]
+      required ||= {}
+
+      Lore.logger.debug { 'atomic update query' }
+      Lore.logger.debug { '----- ' << table.to_s + ' ------' }
+      Lore.logger.debug { 'Values: ' << value_keys.inspect }
+      Lore.logger.debug { 'Fields: ' << attributes.inspect }
+      Lore.logger.debug { 'Required: ' << required.inspect }
+
+      query_string = "UPDATE #{table} SET "
+      set_string   = String.new
+      key_counter  = 0
+      value_keys.each_pair { |attribute_name, value|
+
+        internal_attribute_name = attribute_name.to_s[0..24].to_sym
+        if value.empty? then 
+          value = value_keys["#{table}.#{internal_attribute_name}"].to_s
+        end
+
+        # Disallow setting an empty value for required fields
+        if !(required[attribute_name] && value.empty?) && !(value.nil?) then
+          if key_counter > 0 then
+            set_string += ', '
+          end 
+          set_string << "#{attribute_name} = '#{value}'"
+          key_counter = 1
+        end 
+      }
+      query_string << set_string
+
+      query_string << ' WHERE '
+
+      field_counter=0
+      primary_key_values.each_pair { |field, value|
+        query_string << "#{field} = '#{value}'"
+        if field_counter < primary_key_values.keys.length-1
+          query_string << ' AND '
+        end
+        field_counter += 1
+      }
+      query_string << "; "
+        
+      return query_string
+    end # }}}
+
+    public
+
+    def block_update(&block)
+    # {{{
+      query_string = "UPDATE #{@base_table} "
+
+      if block_given? then
+        yield_obj = Lore::Clause_Parser.new(@accessor)
+        clause = yield *yield_obj
+      end
+
+      query_string += clause.set_part
+      query_string += clause.where_part
+      
+      Lore::Context.enter(@accessor.get_context) if @accessor.get_context
+      begin
+        Lore::Connection.perform(query_string)
+      ensure
+        Lore::Context.leave if @accessor.get_context
+      end
+
+    end # }}}
+
+    def update_query(accessor, 
+                     primary_key_values,
+                     value_keys,
+                     query_string='')
+    # {{{
+      Lore.logger.debug { 'Update query: ' }
+      Lore.logger.debug { value_keys.inspect }
+      Lore.logger.debug { primary_key_values.inspect }
+      
+      associations   = accessor.__associations__
+      is_a_hierarchy = associations.base_klasses_tree()
+      joined_models  = associations.base_klasses()
+      is_a_hierarchy.each_pair { |table, base_tables| 
+        
+        # pass base tables first, recursively, as IS_A-based creation has
+        # to be done bottom-up:
+        Lore.logger.debug { 'For ' << table.to_s } 
+        Lore.logger.debug { joined_models.inspect }
+        query_string << update_query(joined_models[table].first, 
+                                     primary_key_values, 
+                                     value_keys
+                                    ).to_s
+      }
+      # finally, add query string for this table: 
+      table_name = accessor.table_name
+      query_string << atomic_update_query(accessor, 
+                                          primary_key_values[table_name], 
+                                          value_keys[table_name]
+                                         ).to_s
+        
+      query_string
+
+    end # }}}
+
+    public
+
+    def perform_update(accessor_instance)
+    # {{{
+      query_string = update_query(@accessor, 
+                                  accessor_instance.update_pkey_values, 
+                               #  accessor_instance.get_attribute_value_map)
+                                  accessor_instance.update_values)
+      
+      Lore::Context.enter(@accessor.get_context) if @accessor.get_context
+      begin
+        Lore::Connection.perform("BEGIN;\n#{query_string}\nCOMMIT;")
+      rescue ::Exception => excep
+        Lore::Connection.perform("ROLLBACK;")
+        raise excep
+      ensure
+        Lore::Context.leave if @accessor.get_context
+      end
+      @accessor.flush_entity_cache()
+
+    end # }}}
+    
+  end # class
+
+end # module

data/lib/lore/validation/parameter_validator.rb

@@ -1,11 +1,12 @@
 
 require('lore/validation/type_validator')
-require('lore/exception/invalid_parameter')
+require('lore/exceptions/invalid_field')
+require('lore/exceptions/validation_failure')
 
 module Lore
 module Validation
   
-  class Parameter_Validator # :nodoc:
+  class Parameter_Validator 
 
     PG_BOOL                 = 16
     PG_SMALLINT             = 21
@@ -22,56 +23,109 @@ module Validation
     # or e.g. in a dispatcher with
     # Validator.invalid_params(Some_Klass, parameter_hash)
     # 
-    def self.invalid_params(klass, value_hash)
+    def self.validate(klass, value_hash)
     
-      invalid_params = Hash.new
-      explicit_attributes = klass.get_explicit_attributes
-      constraints = klass.get_constraints
+      Lore.logger.debug { "Validating attributes for #{klass.to_s}: " }
+      Lore.logger.debug { "#{value_hash.inspect}" }
+      invalid_params     = Hash.new
+      attribute_settings = klass.__attributes__
+      constraints        = attribute_settings.constraints
+      required           = attribute_settings.required
 
-      klass.get_attribute_types.each_pair { |table, fields|
+      attribute_settings.types.each_pair { |table, fields|
         begin
-          validate_types(fields, value_hash[table], explicit_attributes[table]) 
-        rescue Exception::Invalid_Types => ip
+          validate_types(fields, value_hash[table], required[table])
+        rescue Lore::Exceptions::Invalid_Types => ip
           invalid_params[table] = ip
         end
       }
       
-      klass.get_constraints.each_pair { |table, fields|
+      attribute_settings.constraints.each_pair { |table, fields|
         begin
           validate_constraints(fields, value_hash[table])
-        rescue Exception::Unmet_Constraints => ip
+        rescue Lore::Exceptions::Unmet_Constraints => ip
           invalid_params[table] = ip
         end
       }
       if invalid_params.length == 0 then return true end
         
-      raise Lore::Exception::Invalid_Klass_Parameters.new(klass, invalid_params)
+      raise Lore::Exceptions::Validation_Failure.new(klass, invalid_params)
 
     end
 
-    def self.validate_types(type_codes, table_value_hash, table_explicit_attributes)
-      invalid_types = {} 
-      value = false
-      type_validator = Type_Validator.new()
-      type_codes.each_pair { |field, type|
+    def self.validate_update(klass, value_hash)
+      Lore.logger.debug { "Validating attributes for updating #{klass.to_s}: " }
+      Lore.logger.debug { "#{value_hash.inspect}" }
+      invalid_params     = Hash.new
+      attribute_settings = klass.__attributes__
+      constraints        = attribute_settings.constraints
+      required           = attribute_settings.required
+
+      value_hash.each_pair { |table, attributes|
+        types = attribute_settings.types[table] 
+        if !types then 
+          raise ::Exception.new("No types given for #{klass.to_s} (#{table})")
+        end
+        types.delete_if { |attribute,value| !attributes[attribute] }
+        begin
+          validate_types(types, attributes, required[table])
+        rescue Lore::Exceptions::Invalid_Types => ip
+          invalid_params[table] = ip
+        end
+      }
+      
+      value_hash.each_pair { |table, attributes|
+        constraints = attribute_settings.constraints[table]
+        if constraints then 
+          constraints.delete_if { |attribute,constraint| !attributes[attribute] }
+          begin
+            validate_constraints(constraints, attributes)
+          rescue Lore::Exceptions::Unmet_Constraints => ip
+            invalid_params[table] = ip
+          end
+        else 
+          Lore.logger.info { "No constraints for #{klass.to_s}?" }
+        end
+      }
+      if invalid_params.length == 0 then return true end
         
-        nil_allowed = table_explicit_attributes.nil? ||
-                      !table_explicit_attributes.include?(field)
+      raise Lore::Exceptions::Validation_Failure.new(klass, invalid_params)
+
+    end
 
-        value = table_value_hash[field]
+    def self.validate_types(type_codes, table_value_hash, required)
+      invalid_types  = {} 
+      value          = false
+      type_validator = Type_Validator.new()
+
+      # DERRN-DERRN-DERRN!! What if there is no value hash? 
+      type_codes.each_pair { |field,type|
+        field = field.to_sym
+        is_required = (required && required[field]) || false
+
+        value = table_value_hash[field] if table_value_hash
         # Replace whitespaces and array delimiters to check for real value length
         value_nil = (value.nil? || value.to_s.gsub(/\s/,'').gsub(/[{}]/,'').length == 0)
+        Lore.logger.debug { 
+          "Validate #{field}, required? #{is_required}, " << 
+          "value: #{value.inspect}, value nil? #{value_nil}" 
+        }
         # Is value missing? 
-        if (!nil_allowed && value_nil) then 
+        if (is_required && value_nil) then 
           invalid_types[field] = :missing
-        # If so: Is value of valid type? 
-        elsif !type_validator.typecheck(type, value, nil_allowed) then
+          Lore.logger.debug { "Field #{field} is :missing" }
+        # Otherwise: Is value of valid type? 
+        elsif !value_nil && !type_validator.typecheck(type, value, is_required) then
           invalid_types[field] = type
+          Lore.logger.debug { 
+            "Field #{field} has invalid type: " << 
+            "expected: #{type}, value: #{value}" 
+          }
         end
         
       }
       if invalid_types.keys.length > 0 then
-          raise Lore::Exception::Invalid_Types.new(invalid_types)
+        raise Lore::Exceptions::Invalid_Types.new(invalid_types)
       end
       return true
     end
@@ -79,21 +133,26 @@ module Validation
     def self.validate_constraints(table_constraints, table_value_hash)
       unmet_constraints = {}
       table_constraints.each_pair { |attrib, rules|
-        value = table_value_hash[attrib.to_s]
+        value = table_value_hash[attrib.to_s] if table_value_hash
         rules.each_pair { |rule, rule_value|
+          Lore.logger.debug { "Found constraint for #{attrib}: #{rule.inspect} " }
+          Lore.logger.debug { "Rule is: #{rule_value.inspect} " }
           if rule == :minlength && value.to_s.length < rule_value then
             unmet_constraints[attrib] = :minlength
+            Lore.logger.debug { "Field #{attrib} failed :minlength" }
           end
           if rule == :maxlength && value.to_s.length > rule_value then
             unmet_constraints[attrib] = :maxlength
+            Lore.logger.debug { "Field #{attrib} failed :maxlength" }
           end
           if rule == :format && rule_value.match(value).nil? then
             unmet_constraints[attrib] = :format
+            Lore.logger.debug { "Field #{attrib} failed :format" }
           end
         }
       }
       if unmet_constraints.length > 0 then
-        raise Lore::Exception::Unmet_Constraints.new(unmet_constraints)
+        raise Lore::Exceptions::Unmet_Constraints.new(unmet_constraints)
       end
       return true
     end

data/lib/lore/validation/type_validator.rb

@@ -1,88 +1,44 @@
 
-require('lore/exception/invalid_parameter')
-require('lore/exception/unknown_typecode')
-require('lore/types')
+require('lore/exceptions/invalid_field')
+require('lore/exceptions/unknown_type')
+require('lore/adapters/postgres')
 
 module Lore
 module Validation
 
 	class Type_Validator # :nodoc:
 
-		def typecheck(code, value, nil_allowed=true)
-
-			case code
-
-			# bool
-			when Lore::PG_BOOL
-				if value == 't' || value == 'f' || 
-				   value == '' && nil_allowed || value.nil? && nil_allowed
-				then true else false end
-			# bytea
-			when Lore::PG_BYTEA
-        true
-			# int
-			when Lore::PG_INT 
-				if value.kind_of?(Integer) or 
-					value.to_i.to_s == value or 
-					value.nil? && nil_allowed or
-					value == '' && nil_allowed
-				then true else false end
-			# smallint
-			when Lore::PG_SMALLINT 
-				if ((value.kind_of?(Integer) or value.to_i.to_s == value or 
-					value.nil? && nil_allowed || value == '' && nil_allowed)) and
-					value.to_i < 1024 and value.to_i > -1024
-				then true else false end
-			# decimal
-			when Lore::PG_DECIMAL
-				if ((value.kind_of?(Integer) or value.to_f.to_s == value or 
-					value.nil? && nil_allowed || value == '' && nil_allowed)) 
-				then true else false end
-			# text
-			when Lore::PG_TEXT 
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-			# varchar
-			when Lore::PG_CHAR 
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-			# varchar
-			when Lore::PG_CHARACTER
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-			# varchar
-			when Lore::PG_VARCHAR 
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-			# timestamp
-			when Lore::PG_TIME
-				# TODO
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-			# timestamp with timezone
-			when Lore::PG_TIMESTAMP
-				# TODO
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-			# timestamp with timezone
-			when Lore::PG_TIMESTAMP_TIMEZONE 
-				# TODO
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-			# date
-			when Lore::PG_DATE
-				# TODO
-				if nil_allowed || !nil_allowed && !value.nil? && value != '' 
-				then true else false end
-
-      # character varying[]
-      when Lore::PG_VCHAR_LIST
-        true
-		
-			else 
-        raise ::Exception.new('Unknown type code (' << code.inspect + ') for value ' << value.inspect + '. See README on how to add new types. ')
-			end
-			
+    @@type_validation_rules = {
+      Lore::PG_BOOL               => Proc.new { |value, required| 
+                                       (value == 't' || value == 'f' || value.empty? && !required)
+                                     }, 
+      Lore::PG_BYTEA              => Proc.new { |value, required| true }, 
+      Lore::PG_INT                => Proc.new { |value, required|
+                                       value && ((value.kind_of?(Integer) || value.to_i.to_s == value)) || 
+                                       !required && (value.empty?)
+                                     }, 
+      Lore::PG_SMALLINT           => Proc.new { |value, required|
+                                       value && ((value.kind_of?(Integer) || value.to_i.to_s == value) && 
+                                        (value.to_i < 1024 && value.to_i > -1024)) || 
+                                       !required && (value.empty?)
+                                     }, 
+      Lore::PG_DECIMAL            => Proc.new { |value, required| 
+                                       value && (value.kind_of?(Integer) || value.to_f.to_s == value) ||
+                                       !required && (value.empty?)
+                                     }, 
+      Lore::PG_TEXT               => Proc.new { |value, required| !required || !value.empty? }, 
+      Lore::PG_VARCHAR            => Proc.new { |value, required| !required || !value.empty? }, 
+      Lore::PG_TIME               => Proc.new { |value, required| !required || !value.empty? },  # TODO
+      Lore::PG_DATE               => Proc.new { |value, required| !required || !value.empty? },  # TODO
+      Lore::PG_TIMESTAMP          => Proc.new { |value, required| !required || !value.empty? },  # TODO
+      Lore::PG_VCHAR_LIST         => Proc.new { |value, required| !required || !value.empty? },  # TODO
+      Lore::PG_TIMESTAMP_TIMEZONE => Proc.new { |value, required| !required || !value.empty? }   # TODO
+    }
+
+		def typecheck(code, value, is_required)
+      validation = @@type_validation_rules[code]
+      return validation.call(value, is_required) if validation
+			raise Lore::Exceptions::Unkown_Type.new(code, value)
 		end
 
 	end