lore 0.4.2

data/exception/cache_exception.rb

@@ -0,0 +1,30 @@
+
+require('lore/cache/bits')
+
+module Lore
+module Cache
+
+  class Cache_Read_Exception < ::Exception
+
+    def initialize(klass_name, controller, mode, keys)
+
+      @message = 'PStore file does not exist: [' << Lore::Cache.store_name(klass_name, controller, mode, keys) << ']'
+      
+    end # def
+
+  end # class
+  
+  class Cache_Write_Exception < ::Exception
+
+    def initialize(klass_name, controller, mode, keys)
+
+      @message  = 'Error when trying to cache [' << Lore::Cache.store_name(klass_name, controller, mode, keys) << ']'
+      @message += '(is caching enabled for this controller?)'
+      
+    end # def
+
+  end # class
+
+
+end # module
+end # module

data/exception/invalid_klass_parameters.rb

@@ -0,0 +1,63 @@
+
+module Lore
+module Exception
+
+  # Usage: 
+  #
+  #   raise Lore::Exception::Invalid_Klass_Parameters.new(The_Model, { 
+  #       # Generic error. Example:  :user_id => Lore.integer
+  #           :table_foo  => Invalid_Parameters.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 Invalid_Klass_Parameters < ::Exception
+		
+		attr_reader :invalid_parameters
+		attr_reader :invalid_klass
+		
+		def initialize(klass, invalid_params_hash)
+
+			@logger             = Lore.logger
+      # Instances of Exception::Invalid_Parameters
+			@invalid_parameters = invalid_params_hash 
+			@invalid_klass 		  = klass
+			
+		end
+
+		def log()
+
+			@logger.error('Invalid parameters for klass '+@invalid_klass.to_s+': ')
+			@logger.error('Invalid parameters: ')
+			@logger.error(@invalid_parameters.inspect)
+			@logger.error('Explicit attributes: ')
+			@logger.error(@invalid_klass.get_explicit_attributes.inspect)
+			
+		end
+
+		def serialize() # {{{
+
+			serials = {}
+			@invalid_parameters.each_pair { |table, invalid_param|
+				serials[table] = invalid_param.serialize
+			}
+			return serials
+			
+		end # def }}}
+		
+		def inspect()
+			'Model('+@invalid_klass.to_s+') => '+
+			@invalid_parameters.inspect+ 
+			' Explicit: '+ 
+			@invalid_klass.get_explicit_attributes.inspect
+		end
+    alias explain serialize
+		
+	end
+
+
+end # module
+end # module
+

data/exception/invalid_parameter.rb

@@ -0,0 +1,42 @@
+
+module Lore
+module Exception
+
+  class Invalid_Parameters < ::Exception
+  
+    attr_reader :invalid_params, :reason
+
+    def initialize(invalid_params) 
+      @invalid_params = invalid_params
+      @reason = :invalid
+    end
+    alias fields invalid_params
+
+    def serialize
+      result = {}
+      @invalid_params.each_pair { |field, type| 
+        result[field] = type 
+      }
+      result
+    end
+    alias serialize inspect
+
+  end
+
+	class Invalid_Types < Invalid_Parameters
+    def initialize(invalid_params)
+      super(invalid_params)
+      @reason = :type
+    end
+	end
+
+	class Unmet_Constraints < Invalid_Parameters
+    def initialize(invalid_params)
+      super(invalid_params)
+      @reason = :constraint
+    end
+	end
+	
+	
+end # module
+end # module

data/exception/unknown_typecode.rb

@@ -0,0 +1,19 @@
+
+module Lore
+module Exception
+  
+  class Unknown_Typecode < ::Exception
+    
+    attr_reader :code
+    
+    def initialize(_code)
+      
+      @code = _code
+      @message = 'Unknown PGSQL type: ' + _code.to_s
+      
+    end
+		
+  end
+
+end # module
+end # module

data/file_index.sql

@@ -0,0 +1,56 @@
+
+CREATE TABLE file_index (
+    file_index_id integer NOT NULL,
+    model character varying(100),
+    file character varying(255)
+);
+
+
+ALTER TABLE public.file_index OWNER TO fuchsto;
+
+CREATE SEQUENCE file_index_id_seq
+    START WITH 1
+    INCREMENT BY 1
+    NO MAXVALUE
+    NO MINVALUE
+    CACHE 1;
+
+
+ALTER TABLE public.file_index_id_seq OWNER TO fuchsto;
+
+--
+-- 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: file_index; Type: ACL; Schema: public; Owner: fuchsto
+--
+
+REVOKE ALL ON TABLE file_index FROM PUBLIC;
+REVOKE ALL ON TABLE file_index FROM fuchsto;
+GRANT ALL ON TABLE file_index TO fuchsto;
+GRANT ALL ON TABLE file_index TO cuba;
+GRANT ALL ON TABLE file_index TO lore;
+
+
+--
+-- Name: file_index_id_seq; Type: ACL; Schema: public; Owner: fuchsto
+--
+
+REVOKE ALL ON SEQUENCE file_index_id_seq FROM PUBLIC;
+REVOKE ALL ON SEQUENCE file_index_id_seq FROM fuchsto;
+GRANT ALL ON SEQUENCE file_index_id_seq TO fuchsto;
+GRANT ALL ON SEQUENCE file_index_id_seq TO lore;
+GRANT ALL ON SEQUENCE file_index_id_seq TO cuba;
+
+
+--
+-- PostgreSQL database dump complete
+--
+

data/gui/erb_template.rb

@@ -0,0 +1,79 @@
+
+require('lore/lore')
+require('logger')
+require('erb')
+
+module Lore
+module GUI
+
+  class ERB_Binding_Params
+    
+    def initialize(param_hash)
+      @params = Hash.new
+      param_hash.each_pair { |key,value|
+        @params[key.to_s.intern] = value 
+      }
+    end
+
+    def get(param)
+      @params[param]
+    end
+
+    def param(param)
+      @params[param]
+    end
+      
+    def method_missing(method)
+      @params[method]
+    end
+    
+  end
+
+  class ERB_Template
+
+  public
+
+    def initialize(template_path, param_hash={}, from=:backend)
+
+      @logger = Lore.logger
+      
+      @template = ''      
+      IO.foreach(Lore.path + 'gui/erb_template_helpers.rhtml') { |line|
+        @template << line
+      }
+      template_path = template_path.to_s << '.rhtml' if template_path.instance_of? Symbol
+      IO.foreach(Lore.path + 'gui/templates/' << template_path) { |line|
+        @template << line
+      }
+      
+      @logger.debug('Template: ' << template_path)
+      
+      @erb = ERB.new(@template)
+
+      @binding = binding_for(ERB_Binding_Params.new(param_hash))
+      
+    end
+
+    def set_data(param_hash)
+      @binding = binding_for(ERB_Binding_Params.new(param_hash))
+    end
+
+    def string
+      @erb.result(@binding)
+    end
+
+    def print
+      puts @erb.result(@binding)
+    end
+
+  protected
+
+    def binding_for(params)
+      binding
+    end
+      
+    
+  end # class
+
+end # module
+end # module

data/gui/erb_template_helpers.rhtml

@@ -0,0 +1,19 @@
+<%
+
+  def tag_attributes(attrib_hash)
+    return '' if attrib_hash.nil?
+    string = ''
+    attrib_hash.each_pair { |name, value| 
+      string << name.to_s 
+      string << '="' << value.to_s 
+      string << '" '
+    }
+    string
+  end
+
+  @params = params
+  def method_missing(method)
+    @params.get(method)
+  end
+
+%>

data/gui/form.rb

@@ -0,0 +1,314 @@
+
+require('lore/clause')
+require 'lore/gui/form_element'
+
+module Lore
+module GUI
+
+  # Form class returned by Cuba::GUI::Form_Generator. 
+  # Usage: 
+  # 
+  #   generator = Form_Generator.new(Table_Accessor, Lang, :readonly | :mutable)
+  #   form =  generator.generate
+  #
+  # Setting templates is optional (uses System_Templates 'form/element.amr.html' 
+  # and 'form/table.arm.html' by default): 
+  #
+  #   form.element_template Some_Template.new('template/element.amr.html') 
+  #   form.form_template Some_Template.new('template/table.amr.html') 
+  #
+  # Set a form title (optional): 
+  #
+  #   form.set_title('An example form')
+  #
+  # Fill form values if present: 
+  # 
+  #   values = [Some Cuba::Attributes hash like $cb__libparams]
+  #   form.set_values(values)
+  #
+  # Add additional hidden fields Form_Generator can't resolve itself: 
+  #
+  #   form.add_hidden(Table_Accessor.table_name, :attribute_name, value)
+  # 
+  # Add buttons: 
+  # 
+  #   form.add_button(:submit, 'click here to submit data')
+  #   form.add_button(:clear, 'click here to clear form')
+  #
+  # Configure attribute order and grouping (optional). See method 
+  # documentation for #set_groups for details: 
+  # 
+  #   form.set_groups(attribute_array)
+  #   
+  #   form.print # alias for puts form.string
+  #
+  class Form
+
+    attr_accessor :element_template, :form_template, :form_values
+
+    @@logger = Lore.logger
+
+    def initialize # {{{
+
+      @elements           = Array.new
+      @buttons            = Array.new
+      @indexed_elements   = Hash.new
+      @element_template   = ERB_Template.new('form_element.rhtml')
+      @form_template      = ERB_Template.new('form_table.rhtml')
+      @form_values        = Hash.new
+      @element_groups     = nil
+      @hidden_fields      = Array.new
+      @title              = nil
+
+    end # }}}
+
+    # adders and setters # {{{
+    def add(form_element)
+      if form_element.instance_of? Hidden then
+        @hidden_fields.push(form_element)
+      else
+        if form_element.attribute_table then
+          index = form_element.attribute_table+'.'+form_element.attribute_name
+        else
+          index = form_element.attribute_name
+        end
+        # If there is an element for this attribute present already, delete 
+        # it and use the new one only: 
+        if !@indexed_elements[index].nil? then
+          @elements.delete_if { |e| e.attribute_table == form_element.attribute_table && 
+                                    e.attribute_name == form_element.attribute_name }
+        end
+        @indexed_elements[index] = form_element
+        @elements.push(form_element)
+      end
+    end
+
+    def add_duplicate(form_element)
+      if form_element.instance_of? Hidden then
+        @hidden_fields.push(form_element)
+      else
+        index = form_element.attribute_table+'.'+form_element.attribute_name
+        # If there is an element for this attribute present already, delete 
+        # it and use the new one only: 
+        @indexed_elements[index] = form_element
+        @elements.push(form_element)
+      end
+    end
+
+    def set_readonly(*attributes)
+      attributes.each { |a| 
+        @indexed_elements[a.to_s].set_mode(:readonly)
+      }
+    end
+
+    # Add additional hidden fields Form_Generator can't resolve itself: 
+    #
+    #   form.add_hidden(Table_Accessor.table_name, :attribute_name, value)
+    # 
+    def add_hidden(name, value=nil)
+      if name.instance_of? Lore::Clause then
+        value = value.to_s
+        name_parts = name.to_s.split('.')
+        table = name_parts[0..1].join('.')
+        name = name_parts[2]
+      else
+        table = nil
+        name = name.to_s
+      end
+      hidden = Hidden.new(table, name.to_s)
+      if !value.nil? then
+        hidden.set_attribute_value(value.to_s)
+      end
+      @hidden_fields.push(hidden)
+    end
+
+    def add_hidden_fields(params={})
+      params.each_pair { |k,v|
+        add_hidden(k, v)
+      }
+    end
+
+    def drop_hidden_fields
+      @hidden_fields = []
+    end
+    
+    # Add buttons: 
+    # 
+    #   form.add_button(:submit, 'click here to submit data')
+    #   form.add_button(:clear, 'click here to clear form')
+    #
+    def add_button(type, label)
+      button = Button.new(type, label)
+      @buttons.push(button)
+    end
+
+    # Fill form values if present: 
+    # 
+    #   values = [Some Cuba::Attributes hash like $cb__libparams]
+    #   form.set_values(values)
+    #
+    def set_values(values)
+      @form_values = values
+    end 
+
+    def [](key)
+      @form_values[key.to_s]
+    end
+
+    def []=(key, value)
+      @form_values[key.to_s] = value
+    end
+
+    def values
+      @form_values
+    end
+
+    def keys
+      @form_values.keys
+    end
+
+    # Configure attribute order and grouping (optional). 
+    # Array argument is a one- or two-dimensional array of
+    # full attribute names this form should print. This way, 
+    # order of input fields can be specified, and attributes 
+    # can be filtered. Two-dimensional arrays provide grouping
+    # of form elements. Example: 
+    #
+    #   qttribute_array = 
+    #   [
+    #     [ Klass_A.foo, Klass_A.bar ], 
+    #     [ Klass_B.wombat, Klass_C.bla ]
+    #   ]
+    #
+    #   form.set_groups(attribute_array)
+    #
+    # Add filtered attribute as hidden field: 
+    #
+    #   form.add_hidden(Klass_A.table_name, :wombat)
+    # 
+    def set_groups(groups)
+      if(groups.nil? || groups.at(0).nil?) then
+        @@logger.warn('Form groups are nil or empty') 
+        return
+      end
+      groups.map! { |entry|
+        if entry.instance_of? Array then
+          entry.map! { |field| field.to_s }
+        else 
+          entry.to_s
+        end
+      }
+      @@logger.debug('Form groups set: '+groups.inspect)
+      @element_groups = groups
+    end
+
+    # Set a form title (optional): 
+    #
+    #   form.set_title('An example form')
+    #
+    def set_title(title)
+      @title = title
+    end 
+
+    # end adders / setters }}}
+
+    # Return form as XHTML string based on current configuration
+    #
+    def string # {{{
+
+      elements = ''
+
+      if !@title.nil? then
+        title_string = '<div class="form_header">'+@title.to_s+'</div>' 
+      else 
+        title_string = ''
+      end
+      
+      if @element_groups.nil? then
+        @elements.each { |element|
+          elements += process_element(element)
+        }
+      else
+        @element_groups.each { |attribs|
+          group = ''
+          attribs.each { |attrib|
+          attrib = attrib.to_s
+          if !@indexed_elements[attrib].nil? then
+            element = @indexed_elements[attrib]
+            group += process_element(element)
+          end
+          }
+          if attribs.instance_of? Array then
+            elements += '<div class="form_delimiter"></div>'+group
+          else 
+            elements += group
+          end
+        }
+        # Check for explicit (expected/required) attributes 
+        # group configuration doesn't contain. Add those as 
+        # hidden field: 
+        # TODO: Cannot be realized in current solution! 
+        
+      end
+      @form_template.set_data({
+        :form => elements
+      })
+
+      buttons = ''
+      @buttons.each { |button|
+        data = {
+          :label => '', 
+          :element => button.string
+        }
+        @element_template.set_data(data)
+        buttons += @element_template.string
+      }
+      
+      hidden_fields_string = ''
+      @hidden_fields.each { |element|
+        set_element_value(element)
+        hidden_fields_string += element.string
+      }
+      
+      result = title_string + hidden_fields_string + @form_template.string + buttons
+
+      return result
+
+    end # }}}
+
+    # Alias for puts form.string
+    def print
+      puts string()
+    end
+    
+  private
+
+    def set_element_value(element) # {{{
+      if !@form_values[element.attribute_name].nil? then 
+        value = @form_values[element.attribute_name]
+        element.set_attribute_value(value)
+      elsif !@form_values[element.attribute_table.to_s+'.'+element.attribute_name].nil? then 
+        value = @form_values[element.attribute_table+'.'+element.attribute_name] 
+        element.set_attribute_value(value)
+      end
+    end # }}}
+
+    def process_element(element) # {{{
+      
+      set_element_value(element)
+      
+      data = {
+        :label => "<label id=\"#{element.attribute_id}_label\" for=\"#{element.attribute_id}\">#{element.label}</label>", 
+        :element => element.string, 
+        :element_obj => element
+      }
+      @element_template.set_data(data)
+      
+      return @element_template.string
+      
+    end # }}}
+    
+  end # class
+  
+end # module 
+end # module