lore 0.4.3 → 0.4.5

data/custom_models.rb

@@ -0,0 +1,93 @@
+
+require('lore/model') 
+
+module Some
+module App
+
+  class New_Model < Lore::Model 
+    table :new_model, :public
+    primary_key :model_id, :model_id_seq
+    has_attribute :name, Lore::Type.integer
+    has_attribute :created, Lore::Type.timestamp
+    has_attribute :model_id, Lore::Type.integer
+
+
+  end
+end
+end
+
+module Some
+module App
+
+  class New_Model < Lore::Model 
+    table :new_model, :public
+    primary_key :model_id, :model_id_seq
+    has_attribute :name, Lore::Type.integer
+    has_attribute :created, Lore::Type.timestamp
+    has_attribute :model_id, Lore::Type.integer
+
+
+  end
+end
+end
+
+module Some
+module App
+
+  class New_Model < Lore::Model 
+    table :new_model, :public
+    primary_key :model_id, :model_id_seq
+    has_attribute :name, Lore::Type.integer
+    has_attribute :created, Lore::Type.timestamp
+    has_attribute :model_id, Lore::Type.integer
+
+
+  end
+end
+end
+
+module Some
+module App
+
+  class New_Model < Lore::Model 
+    table :new_model, :public
+    primary_key :model_id, :model_id_seq
+    has_attribute :name, Lore::Type.integer
+    has_attribute :created, Lore::Type.timestamp
+    has_attribute :model_id, Lore::Type.integer
+
+
+  end
+end
+end
+
+module Some
+module App
+
+  class New_Model < Lore::Model 
+    table :new_model, :public
+    primary_key :model_id, :model_id_seq
+    has_attribute :name, Lore::Type.integer
+    has_attribute :created, Lore::Type.timestamp
+    has_attribute :model_id, Lore::Type.integer
+
+
+  end
+end
+end
+
+module Some
+module App
+
+  class New_Model < Lore::Model 
+    table :new_model, :public
+    primary_key :model_id, :model_id_seq
+    has_attribute :name, Lore::Type.integer
+    has_attribute :created, Lore::Type.timestamp
+    has_attribute :model_id, Lore::Type.integer
+
+
+  end
+end
+end
+

data/lib/lore/README.txt

@@ -26,9 +26,9 @@ A: First provide login data for a database (aka Context):
 
      Lore::Context.enter :dbname
      # Operate in database dbname
-     Lore::Context.enter :other_dbname
-     # Operate in database other_dbname
-     Lore::Context.leave
+       Lore::Context.enter :other_dbname
+       # Operate in database other_dbname
+       Lore::Context.leave
      # Operate in database dbname
      Lore::Context.enter :other_dbname
 

data/lib/lore/cache/abstract_entity_cache.rb

@@ -45,7 +45,7 @@ module Cache
     # Create cache entry for a specific query_string on a model. 
     # Expects result from given query string as it has to be 
     # returned when calling Cache_Implementation.read(query_string) 
-    def self.create(accessor, query_string, result)
+    def self.create(accessor, query_object, result)
       raise ::Exception.new('Not implemented')
     end
 

data/lib/lore/cache/mmap_entity_cache.rb

@@ -33,20 +33,20 @@ module Cache
       }
     end
 
-    def self.read(accessor, query_string)
-      @@logger.debug('Loading from cache: ' << index_for(query_string))
-      store = Mmap.new(storefile_of(accessor.table_name, query_string))
+    def self.read(accessor, query_obj)
+      @@logger.debug('Loading from cache: ' << index_for(query_obj[:query]))
+      store = Mmap.new(storefile_of(accessor.table_name, query_obj[:query]))
       @@logger.debug('STORE: ' << store.inspect)
       return [] unless store
       result = Marshal::load(store)
       return result['dump']
     end
 
-    def self.create(accessor, query_string, result)
-      storefile = create_mmap(accessor, query_string, result)
+    def self.create(accessor, query_object, result)
+      storefile = create_mmap(accessor, query_object, result)
     end
-    def self.create_mmap(accessor, query_string, result)
-      storefile = storefile_of(accessor.table_name, query_string)
+    def self.create_mmap(accessor, query_object, result)
+      storefile = storefile_of(accessor.table_name, query_object[:query])
       store = create_store(storefile)
       store.transaction do
         store['dump'] = result
@@ -56,8 +56,8 @@ module Cache
       return storefile
     end
 
-    def self.include?(accessor, query_string)
-      FileTest.exist?(storefile_of(accessor.table_name, query_string))
+    def self.include?(accessor, query_obj)
+      FileTest.exist?(storefile_of(accessor.table_name, query_obj[:query]))
     end
 
     def self.delete(index)

data/lib/lore/clause.rb

@@ -35,23 +35,24 @@ module Lore
   class Join # :nodoc:
   # {{{
 
-    def initialize(clause, join_klass, type=:natural)
+    def initialize(clause, base_klass, join_klass, type=:natural)
       @type = type
       @clause_parser = clause
+      @base_klass = base_klass
       @join_klass = join_klass
       @string = ''
       # By joining with another klass, new attributes are added 
       # we have to include in the AS part of the query: 
       new_attributes = ''
-      join_klass.get_attributes.each { |attr_set|
-        table = attr_set[0]
-        attr_set[1].each { |attrib_name|
-          new_attributes += ', ' << "\n"
-          new_attributes += table + '.' << attrib_name 
-          new_attributes += ' AS '
-          new_attributes += '"' << table << '.' << attrib_name << '" ' 
-        }
-      }
+   #  join_klass.get_attributes.each { |attr_set|
+   #    table = attr_set[0]
+   #    attr_set[1].each { |attrib_name|
+   #      new_attributes += ', ' << "\n"
+   #      new_attributes += table + '.' << attrib_name 
+   #      new_attributes += ' AS '
+   #      new_attributes += '"' << table << '.' << attrib_name << '" ' 
+   #    }
+   #  }
       implicit_joins = ''
       @clause_parser.add_as(new_attributes)
 
@@ -72,12 +73,16 @@ module Lore
       @string
     end
 
+    # Will transform into ON clause, as USING drops duplicate fields
     def using(key, &block)
       if @type == :natural then cmd = 'JOIN '
       elsif @type == :left then cmd = 'LEFT JOIN '
       elsif @type == :right then cmd = 'RIGHT JOIN '
       end
-      @string = "\n" << cmd << @join_klass.table_name << ' USING (' << key.to_s << ') '
+      key = key.to_s
+      using_string =  "#{@base_klass.table_name}.#{key} = "
+      using_string << "#{@join_klass.table_name}.#{key}"
+      @string = "\n" << cmd << @join_klass.table_name << ' ON (' << using_string << ') '
       @clause_parser.append_join(self)
       yield @clause_parser # use extended clause parser for inner block argument
     end
@@ -99,14 +104,14 @@ module Lore
 
     attr_reader :field_name, :value_string, :left_side, :plan
     
-    def initialize(field_name, left_side='', value_string='', plan={})
+    def initialize(field_name='', left_side='', value_string='', plan={})
       @value_string  = value_string
       @left_side     = left_side
       @field_name    = field_name
     end
 
     def self.for(accessor)
-      Clause_Parser.new(accessor.table_name, accessor.get_attributes)
+      Clause_Parser.new(accessor)
     end
 
     def not_in(nested_query_string)
@@ -296,10 +301,6 @@ module Lore
     def to_sql
       @left_side + @value_string
     end
-
-    def plan_name
-
-    end
     
   end # class }}}
   
@@ -308,7 +309,7 @@ module Lore
   class Clause_Parser # :nodoc
   # {{{
 
-    def initialize(base_table, *table_fields)
+    def initialize(base_accessor)
 
       @clause            = Hash.new
       @clause[:limit]    = ''
@@ -320,12 +321,13 @@ module Lore
       @clause[:set]      = ''
       @clause[:filter]   = ''
       @clause[:where]    = 't'
-      @base_table = base_table
+      @clause[:joined]   = []
+      @base_accessor = base_accessor
 
     end # def
 
     def self.for(accessor)
-      Clause_Parser.new(accessor.table_name, accessor.get_attributes)
+      Clause_Parser.new(accessor)
     end
 
     def parts
@@ -433,19 +435,20 @@ module Lore
     def join(join_klass)
       # this Join instance also will update this Clause_Parser's 
       # as_part (so passing self is crucial): 
-      j = Join.new(self, join_klass)
+      @clause[:joined] << join_klass
+      j = Join.new(self, @base_accessor, join_klass)
       return j
     end
     def left_join(join_klass)
       # this Join instance also will update this Clause_Parser's 
       # as_part (so passing self is crucial): 
-      j = Join.new(self, join_klass, :left)
+      j = Join.new(self, @base_accessor, join_klass, :left)
       return j
     end
     def right_join(join_klass)
       # this Join instance also will update this Clause_Parser's 
       # as_part (so passing self is crucial): 
-      j = Join.new(self, join_klass, :right)
+      j = Join.new(self, @base_accessor, join_klass, :right)
       return j
     end
 
@@ -511,11 +514,12 @@ module Lore
         field_name = absolute_field_name.to_s
       end
       
-      return Clause.new("#{@base_table}.#{field_name}")
+    # return Clause.new("#{@base_table}.#{field_name}")
+      return Clause.new(field_name)
     end
 
     def id()
-      return Clause.new("#{@base_table}.id")
+      return Clause.new("#{@base_accessor.table_name}.id")
     end
 
     def perform

data/lib/lore/gui/erb_template.rb

@@ -1,5 +1,5 @@
 
-require('lore/lore')
+require('lore')
 require('logger')
 require('erb')
 
@@ -38,11 +38,11 @@ module GUI
       @logger = Lore.logger
       
       @template = ''      
-      IO.foreach(Lore.path + 'gui/erb_template_helpers.rhtml') { |line|
+      IO.foreach(Lore.path + 'lore/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|
+      IO.foreach(Lore.path + 'lore/gui/templates/' << template_path) { |line|
         @template << line
       }
       

data/lib/lore/gui/form_element.rb

@@ -658,8 +658,8 @@ module GUI
   class Hidden < Form_Element 
   # {{{
   
-    def initialize(_table, _attrib_name)
-      setup(_table, _attrib_name, '', nil, nil)
+    def initialize(_table, _attrib_name, value=nil)
+      setup(_table, _attrib_name, '', nil, value)
     end
 
     def string()

data/lib/lore/result.rb

@@ -72,6 +72,25 @@ class Result
     @result_rows[row_num] = row_result
     return row_result
     
+  end
+  def get_row_with_field_names(row_num=0)
+
+    return @result_rows.at(row_num) if @result_rows.at(row_num)   
+    return if @result.num_tuples == 0
+
+    row_result        = Array.new
+    
+    @field_counter = 0
+    for @field_counter in 0...@num_fields do
+      row_result << @result.getvalue(row_num, @field_counter)
+    end
+    @result_rows[row_num] = row_result
+    @fieldnames = []
+    for @field_counter in 0...@num_fields do
+      @fieldnames << @result.fieldname(@field_counter)
+    end
+    return { :values => row_result, :fields => @fieldnames }
+    
   end
   
   def get_rows()