lore 0.4.2

data/test/test_db.sql

@@ -0,0 +1,400 @@
+--
+-- PostgreSQL database dump
+--
+
+SET client_encoding = 'SQL_ASCII';
+SET standard_conforming_strings = off;
+SET check_function_bodies = false;
+SET client_min_messages = warning;
+SET escape_string_warning = off;
+
+--
+-- Name: SCHEMA public; Type: COMMENT; Schema: -; Owner: postgres
+--
+
+COMMENT ON SCHEMA public IS 'Standard public schema';
+
+
+SET search_path = public, pg_catalog;
+
+SET default_tablespace = '';
+
+SET default_with_oids = false;
+
+--
+-- Name: bike; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE bike (
+    bike_id integer NOT NULL,
+    vehicle_id integer NOT NULL,
+    is_chopper boolean NOT NULL
+);
+
+
+ALTER TABLE public.bike OWNER TO lore;
+
+--
+-- Name: bike_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE bike_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.bike_id_seq OWNER TO lore;
+
+--
+-- Name: car; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE car (
+    id integer NOT NULL,
+    vehicle_id integer NOT NULL,
+    car_type_id integer NOT NULL,
+    num_doors smallint NOT NULL
+);
+
+
+ALTER TABLE public.car OWNER TO lore;
+
+--
+-- Name: car_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE car_id_seq
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.car_id_seq OWNER TO lore;
+
+--
+-- Name: car_type; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE car_type (
+    car_type_id integer NOT NULL,
+    name character varying(100) NOT NULL
+);
+
+
+ALTER TABLE public.car_type OWNER TO lore;
+
+--
+-- Name: car_type_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE car_type_id_seq
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.car_type_id_seq OWNER TO lore;
+
+--
+-- Name: garage; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE garage (
+    garage_id integer NOT NULL,
+    vehicle_id integer NOT NULL
+);
+
+
+ALTER TABLE public.garage OWNER TO lore;
+
+--
+-- Name: garage_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE garage_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.garage_id_seq OWNER TO lore;
+
+--
+-- Name: manuf_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE manuf_id_seq
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.manuf_id_seq OWNER TO lore;
+
+--
+-- Name: manufacturer; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE manufacturer (
+    manuf_id integer NOT NULL,
+    name character varying(100) NOT NULL
+);
+
+
+ALTER TABLE public.manufacturer OWNER TO lore;
+
+--
+-- Name: owner; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE "owner" (
+    owner_id integer NOT NULL,
+    name character varying(200) NOT NULL
+);
+
+
+ALTER TABLE public."owner" OWNER TO lore;
+
+--
+-- Name: owner_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE owner_id_seq
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.owner_id_seq OWNER TO lore;
+
+--
+-- Name: trailer; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE trailer (
+    trailer_id integer NOT NULL,
+    car_id integer NOT NULL,
+    maxweight integer NOT NULL
+);
+
+
+ALTER TABLE public.trailer OWNER TO lore;
+
+--
+-- Name: trailer_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE trailer_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.trailer_id_seq OWNER TO lore;
+
+--
+-- Name: vehicle; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE vehicle (
+    id integer NOT NULL,
+    manuf_id integer NOT NULL,
+    num_seats smallint NOT NULL,
+    maxspeed integer NOT NULL,
+    name character varying(100) NOT NULL,
+    owner_id integer
+);
+
+
+ALTER TABLE public.vehicle OWNER TO lore;
+
+--
+-- Name: vehicle_id_seq; Type: SEQUENCE; Schema: public; Owner: lore
+--
+
+CREATE SEQUENCE vehicle_id_seq
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.vehicle_id_seq OWNER TO lore;
+
+--
+-- Name: vehicle_owner; Type: TABLE; Schema: public; Owner: lore; Tablespace: 
+--
+
+CREATE TABLE vehicle_owner (
+    owner_id integer NOT NULL,
+    vehicle_id integer NOT NULL
+);
+
+
+ALTER TABLE public.vehicle_owner OWNER TO lore;
+
+--
+-- Name: public; Type: ACL; Schema: -; Owner: postgres
+--
+
+REVOKE ALL ON SCHEMA public FROM PUBLIC;
+REVOKE ALL ON SCHEMA public FROM postgres;
+GRANT ALL ON SCHEMA public TO postgres;
+GRANT ALL ON SCHEMA public TO PUBLIC;
+
+
+--
+-- Name: bike; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON TABLE bike FROM PUBLIC;
+REVOKE ALL ON TABLE bike FROM lore;
+GRANT ALL ON TABLE bike TO lore;
+GRANT ALL ON TABLE bike TO "lore";
+
+
+--
+-- Name: bike_id_seq; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON SEQUENCE bike_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE bike_id_seq FROM lore;
+GRANT ALL ON SEQUENCE bike_id_seq TO lore;
+GRANT ALL ON SEQUENCE bike_id_seq TO "lore";
+
+
+--
+-- Name: car; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON TABLE car FROM PUBLIC;
+REVOKE ALL ON TABLE car FROM lore;
+GRANT ALL ON TABLE car TO lore;
+GRANT ALL ON TABLE car TO "lore";
+
+
+--
+-- Name: car_id_seq; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON SEQUENCE car_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE car_id_seq FROM lore;
+GRANT ALL ON SEQUENCE car_id_seq TO lore;
+GRANT ALL ON SEQUENCE car_id_seq TO "lore";
+
+
+--
+-- Name: car_type; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON TABLE car_type FROM PUBLIC;
+REVOKE ALL ON TABLE car_type FROM lore;
+GRANT ALL ON TABLE car_type TO lore;
+GRANT ALL ON TABLE car_type TO "lore";
+
+
+--
+-- Name: car_type_id_seq; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON SEQUENCE car_type_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE car_type_id_seq FROM lore;
+GRANT ALL ON SEQUENCE car_type_id_seq TO lore;
+GRANT ALL ON SEQUENCE car_type_id_seq TO "lore";
+
+
+--
+-- Name: garage; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON TABLE garage FROM PUBLIC;
+REVOKE ALL ON TABLE garage FROM lore;
+GRANT ALL ON TABLE garage TO lore;
+GRANT ALL ON TABLE garage TO "lore";
+
+
+--
+-- Name: garage_id_seq; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON SEQUENCE garage_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE garage_id_seq FROM lore;
+GRANT ALL ON SEQUENCE garage_id_seq TO lore;
+GRANT ALL ON SEQUENCE garage_id_seq TO "lore";
+
+
+--
+-- Name: manuf_id_seq; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON SEQUENCE manuf_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE manuf_id_seq FROM lore;
+GRANT ALL ON SEQUENCE manuf_id_seq TO lore;
+GRANT ALL ON SEQUENCE manuf_id_seq TO "lore";
+
+
+--
+-- Name: manufacturer; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON TABLE manufacturer FROM PUBLIC;
+REVOKE ALL ON TABLE manufacturer FROM lore;
+GRANT ALL ON TABLE manufacturer TO lore;
+GRANT ALL ON TABLE manufacturer TO "lore";
+
+
+--
+-- Name: trailer; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON TABLE trailer FROM PUBLIC;
+REVOKE ALL ON TABLE trailer FROM lore;
+GRANT ALL ON TABLE trailer TO lore;
+GRANT ALL ON TABLE trailer TO lore;
+
+
+--
+-- Name: trailer_id_seq; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON SEQUENCE trailer_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE trailer_id_seq FROM lore;
+GRANT ALL ON SEQUENCE trailer_id_seq TO lore;
+GRANT ALL ON SEQUENCE trailer_id_seq TO lore;
+
+
+--
+-- Name: vehicle; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON TABLE vehicle FROM PUBLIC;
+REVOKE ALL ON TABLE vehicle FROM lore;
+GRANT ALL ON TABLE vehicle TO lore;
+GRANT ALL ON TABLE vehicle TO "lore";
+
+
+--
+-- Name: vehicle_id_seq; Type: ACL; Schema: public; Owner: lore
+--
+
+REVOKE ALL ON SEQUENCE vehicle_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE vehicle_id_seq FROM lore;
+GRANT ALL ON SEQUENCE vehicle_id_seq TO lore;
+GRANT ALL ON SEQUENCE vehicle_id_seq TO "lore";
+
+
+--
+-- PostgreSQL database dump complete
+--
+

data/test/ts_lore.rb

@@ -0,0 +1,49 @@
+
+require 'test/unit/testsuite'
+
+require('lore')
+Lore.logfile = './lore_test.log'
+require('rubygems')
+require('lore/test/model')
+require('lore/connection')
+require('lore/cache/mmap_entity_cache')
+
+require('lore/test/tc_table_accessor')
+require('lore/test/tc_clause')
+require('lore/test/tc_model')
+require('lore/test/tc_form')
+require('lore/test/tc_cache')
+require('lore/test/tc_factory')
+require('lore/test/tc_refined_query')
+require('lore/test/tc_filter')
+require('lore/test/tc_deep_inheritance')
+require('lore/test/tc_prepare')
+
+module Lore
+
+class Table_Accessor
+#  @@cache_impl = Lore::Cache::MMap_Entity_Cache
+end
+
+module Unit
+
+  class TS_Lore
+
+    def self.suite
+      suite = Test::Unit::TestSuite.new()
+      suite << TC_Model.suite
+      suite << TC_Refined_Query.suite
+      suite << TC_Clause.suite
+      suite << TC_Table_Accessor.suite
+      suite << TC_Form.suite
+      suite << TC_Cache.suite
+      suite << TC_Factory.suite
+      suite << TC_Aspect.suite
+      suite << TC_Filter.suite
+      suite << TC_Prepare.suite
+    end
+
+  end
+
+end
+end

data/types.rb

@@ -0,0 +1,55 @@
+
+module Lore
+
+  PG_BOOL                = 16
+  PG_BYTEA               = 17
+  PG_SMALLINT            = 21
+  PG_CHAR                = 18
+  PG_INT                 = 23
+  PG_TEXT                = 25
+  PG_CHARACTER           = 1042
+  PG_VARCHAR             = 1043
+  PG_TIME                = 1083
+  PG_TIMESTAMP_TIMEZONE  = 1184
+  PG_TIMESTAMP           = 1114
+  PG_DATE                = 1082
+  PG_VCHAR_LIST          = 1015
+  PG_DECIMAL             = 1700
+
+  TYPE_NAMES = { 
+    PG_BYTEA               => 'bytea',
+    PG_BOOL                => 'boolean',
+    PG_SMALLINT            => 'small int',
+    PG_CHAR                => 'char',
+    PG_INT                 => 'integer',
+    PG_TEXT                => 'text',
+    PG_CHARACTER           => 'character',
+    PG_VARCHAR             => 'character varying(1000)',
+    PG_TIME                => 'time',
+    PG_TIMESTAMP_TIMEZONE  => 'timestamp with timezone',
+    PG_TIMESTAMP           => 'timestamp',
+    PG_DATE                => 'data',
+    PG_VCHAR_LIST          => 'character varying[]', 
+    PG_DECIMAL             => 'decimal'
+  }
+
+  class Type
+
+    def self.integer; 'integer'; end
+    def self.boolean; 'boolean'; end
+    def self.bytea; 'bytea'; end
+    def self.char; 'char'; end
+    def self.varchar(length=255); 'character varying(' << length.to_s + ')'; end
+    def self.time; 'time'; end
+    def self.timestamp; 'timestamp'; end
+    def self.date; 'date'; end
+    def self.text; 'text'; end
+    def self.decimal; 'decimal'; end
+
+    def self.type_name(int)
+      TYPE_NAMES[int]
+    end
+
+  end
+
+end # module

data/validation/message.rb

@@ -0,0 +1,60 @@
+
+module Lore
+module Validation
+
+	class Message
+
+		def [](serial_string) # {{{
+
+			if $cb__message_strings[$lang].include?(serial_string) then
+				return nil
+			else 
+				return $cb__message_strings[$lang][serial_string]
+			end	
+
+		end # def }}}
+
+	end # class
+
+	class Error_Message < Message
+
+		@logger = Lore.logger
+
+		def [](serial_string) # {{{
+		
+			if $cb__message_strings[$lang].include?(serial_string) then
+				compose_error_message(serial_string)
+			else 
+				return $cb__error_strings[$lang][serial_string]
+			end	
+			
+		end # def }}}
+
+		def self.compose_error_message(serial_array) # {{{
+			
+			message = []
+			serial_array.uniq!
+			serial_array.each { |serial_code|
+			# klass--name--given--typecode (from Invalid_Klass_Parameters) 
+			# to [klass,name,given,typecode]
+#				@logger.log('serial code: '+serial_code.to_s)
+				invalid_parameter = serial_code.split('--')
+
+				# try to resolve a human readable name for this parameter: 
+				if !Lang[invalid_parameter[1]].nil? then inv_param_name = Lang[invalid_parameter[1]] 
+				else inv_param_name = invalid_parameter[1] end
+				
+				if invalid_parameter[2] == '' then 
+					message << Lang[:error__specify_value].gsub('{1}', inv_param_name)
+				else
+					message << Lang[:error__invalid_value].gsub('{1}', inv_param_name)
+				end
+			}
+			return message
+			
+		end # def }}}
+
+	end # class
+
+end # module
+end # module

data/validation/parameter_validator.rb

@@ -0,0 +1,104 @@
+
+require('lore/validation/type_validator')
+require('lore/exception/invalid_parameter')
+
+module Lore
+module Validation
+  
+  class Parameter_Validator # :nodoc:
+
+    PG_BOOL                 = 16
+    PG_SMALLINT             = 21
+    PG_INT                  = 23
+    PG_TEXT                 = 25
+    PG_VARCHAR              = 1043
+    PG_TIMESTAMP_TIMEZONE   = 1184
+
+    @logger = Lore.logger
+    
+    #############################################################
+    # To be used inside Table_Accessor with
+    # Validator.invalid_params(this, @attribute_values)
+    # or e.g. in a dispatcher with
+    # Validator.invalid_params(Some_Klass, parameter_hash)
+    # 
+    def self.invalid_params(klass, value_hash)
+    
+      invalid_params = Hash.new
+      explicit_attributes = klass.get_explicit_attributes
+      constraints = klass.get_constraints
+
+      klass.get_attribute_types.each_pair { |table, fields|
+        begin
+          validate_types(fields, value_hash[table], explicit_attributes[table]) 
+        rescue Exception::Invalid_Types => ip
+          invalid_params[table] = ip
+        end
+      }
+      
+      klass.get_constraints.each_pair { |table, fields|
+        begin
+          validate_constraints(fields, value_hash[table])
+        rescue Exception::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)
+
+    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|
+        
+        nil_allowed = table_explicit_attributes.nil? ||
+                      !table_explicit_attributes.include?(field)
+
+        value = table_value_hash[field]
+        # Replace whitespaces and array delimiters to check for real value length
+        value_nil = (value.nil? || value.to_s.gsub(/\s/,'').gsub(/[{}]/,'').length == 0)
+        # Is value missing? 
+        if (!nil_allowed && value_nil) then 
+          invalid_types[field] = :missing
+        # If so: Is value of valid type? 
+        elsif !type_validator.typecheck(type, value, nil_allowed) then
+          invalid_types[field] = type
+        end
+        
+      }
+      if invalid_types.keys.length > 0 then
+          raise Lore::Exception::Invalid_Types.new(invalid_types)
+      end
+      return true
+    end
+
+    def self.validate_constraints(table_constraints, table_value_hash)
+      unmet_constraints = {}
+      table_constraints.each_pair { |attrib, rules|
+        value = table_value_hash[attrib.to_s]
+        rules.each_pair { |rule, rule_value|
+          if rule == :minlength && value.to_s.length < rule_value then
+            unmet_constraints[attrib] = :minlength
+          end
+          if rule == :maxlength && value.to_s.length > rule_value then
+            unmet_constraints[attrib] = :maxlength
+          end
+          if rule == :format && rule_value.match(value).nil? then
+            unmet_constraints[attrib] = :format
+          end
+        }
+      }
+      if unmet_constraints.length > 0 then
+        raise Lore::Exception::Unmet_Constraints.new(unmet_constraints)
+      end
+      return true
+    end
+
+  end
+
+end # module
+end # module

data/validation/reason.rb

@@ -0,0 +1,54 @@
+
+require('lore/validation/message')
+require('htmlentities')
+
+module Lore
+module Validation
+
+  class Reason # :nodoc:
+
+    @logger = Lore.logger
+
+    attr_reader :options
+
+    def message()
+      # polish message for html output: 
+      return @message.map { |m| HTMLEntities.new.decode(m) }
+    end 
+    
+    def initialize(message, options) # {{{
+      @message = message
+      @options = options
+    end # def }}}
+    
+    # Parameter validation failed: 
+    def self.of_invalid_parameters(ikp) # {{{
+
+      message = Lore::Validation::Error_Message.compose_error_message(ikp.serialize())
+      @logger.debug('Reason message: '+message.inspect)
+      return self.new(message, @options)
+      
+    end # def }}}
+
+    # System exception:
+    def self.of_user_runtime_error(excep) # {{{
+
+      options = [:choice_critical, :choice_recommended] 
+      message = Lang[excep.message]
+      return self.new(message, options)
+      
+    end # def }}}
+    
+    # System exception:
+    def self.of_exception(excep) # {{{
+
+      options = [:choice_critical, :choice_recommended] 
+      message = excep.message + ': ' + excep.backtrace.join('<br />')
+      return self.new(message, options)
+      
+    end # def }}}
+    
+  end # class
+
+end # module
+end # module