lore 0.4.2

data/LICENSE

@@ -0,0 +1,19 @@
+
+Copyright (c) 2005-2008 Tobias Fuchs (fuchs@wortundform.de)
+Lore has evolved from Cuba::DB, Copyright (c) 2004 Tobias Fuchs (fuchs@wortundform.de)
+
+(MIT Licence)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated 
+documentation files (the "Software"), to deal in the Software without restriction, including without limitation 
+the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and 
+to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of 
+the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
+THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF 
+CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,74 @@
+
+Q: Are there adapters for other DBMS than PostgreSQL?
+A: PostgreSQL is - to me and everyone using Lore i know of - 
+   the best (free) choice for sophisticated database-driven 
+   apps, so frankly said: Implementing adapters is not on my
+   top priority list. Adapters also come with some cost in 
+   performance, by introducing an additional level of 
+   abstraction. 
+   So far, Lore supports PostgreSQL (7.4 to 8.3 tested). 
+   Adapters are planned for oracle mysql and sqlite though. 
+   Lore is SQL 92 compatible and not using any exotic 
+   Postgres features, so it *might* work fine on e.g. mysql 
+   and sqlite with just minor modifications. It is caring 
+   about cascading dependencies etc, so you don't even need 
+   foreign keys or table inheritance. 
+   You will have to change the code establishing DB 
+   connections (see connection.rb), but as those are 
+   abstracted, just a couple of lines of code in connection.rb
+   had to be changed. 
+
+Q: How do i establish a DB connection at all? 
+A: In /lore.rb, edit the Hash instance @logins. Lore is caring 
+   about connections itself. 
+   You have to enter a so-called context (database, that is), 
+   though: 
+
+     Lore::Context.enter :my_dbname
+
+Q: What about connection pooling? 
+A: Use PGPool for that, it's way better than any 
+   implementation of connection pooling in ruby. 
+   Install PGPool and tell lore to connect to PGPool's port 
+   instead of PostgreSQL's one. 
+   Example: 
+
+      Lore.server = 'localhost:9999'
+
+   That's it! 
+
+Q: Which solution do you recommend for query result caching? 
+A: There are many possibilities: Tempfiles, MMap and Memcached
+   are the most widespread solutions known to me. 
+   Many will agree that MMap is the best solution in matters 
+   of performance on a single server, and memcached as soon as
+   more than one server is involved in your application. 
+
+Q: There are failing unit tests!!
+A: I know. Those document missing features i'm implementing 
+   at the very moment :)  Be sure to update once in a while! 
+
+Q: After creating a model via Model_Factory: How do i change 
+   it? 
+A: At the moment, this is not implemented, but tracked as 
+   'missing feature'. This will be possible in version 1.0 at 
+   the latest. 
+
+Q: There's so much documentation missing, the API isn't really 
+   helpful. Where can i get more info and examples? 
+A: Have a look at the wiki. I'm updating it quite often, and 
+   new features are explained in the wiki first: 
+   http://infranode.com/wiki/
+
+Q: I found a bug!! What now?
+A: In case you're registered at rubyforge, visit 
+   http://lore.rubyforge.org and submit a bug report. 
+   Otherwise, just send me a mail (fuchs@atomnode.net). 
+   If you're using Lore and are your progress is blocked by a 
+   bug, i'll fix it almost instantly. I'm checking my mails 
+   more often than the tickets at rubyforge, though. 
+
+Q: I want to join the dev team. 
+A: Great! Just send a mail to fuchs@wortundform.de, i will add 
+   you on Rubyforge if you got some code to share. 
+   

data/aspect.rb

@@ -0,0 +1,80 @@
+
+
+module Lore
+
+  # Steps taken in .create are: 
+  # 
+  # * .before_create(attribs)
+  # * applying input filters
+  # * .before_create_after_filters(attribs)
+  # * distributing attributes to tables: 
+  #    { :attrib => 'value' } -> { 'public.my_table' => { :attrib => 'value'} }
+  # * .before_create_and_validation(table_attribs)
+  # * validation
+  # * .before_insert(table_attribs)
+  # * insert operation
+  # * .before_load(attribs)
+  # * load new instance from DB (thus getting final table values)
+  # * .after_create(created_instance)
+
+  module Aspect
+
+  private
+
+    def before_delete(args)
+    end
+
+    def after_delete(args)
+    end
+
+    # Expects arguments (value hash) passed
+    # to Table_Accessor.create
+    def before_create(args)
+    end
+
+    # Expects arguments (value hash) passed
+    # to Table_Accessor.create
+    def after_filters(filtered_args)
+    end
+
+    # Expects arguments (value hash) passed
+    # to Table_Accessor.create and distributed 
+    # to table names
+    def before_validation(distributed_args)
+    end
+
+    # Expects arguments (value hash) passed
+    # to Table_Accessor.create and distributed 
+    # to table names
+    def before_insert(validated_args)
+    end
+
+    def before_load(completed_args)
+    end
+
+    # Expects object that has been created. 
+    def after_create(obj)
+    end
+
+  public
+    
+    # Expects model instance to be deleted. 
+    def before_instance_delete(model_instance)
+    end
+    # Expects model instance table rows have been 
+    # deleted of
+    def after_instance_delete(model_instance)
+    end
+
+    # Expects arguments (value hash) passed
+    # to Table_Accessor.create and object 
+    # to be updated. 
+    def before_commit(obj)
+    end
+    # Expects updated object. 
+    def after_commit(obj)
+    end
+
+  end
+
+end

data/behaviours/lockable.rb

@@ -0,0 +1,41 @@
+
+module Lore
+module Behaviours
+
+  module Lockable
+
+    # Defines which attribute to use for locking. 
+    # Default is 'lock'.
+    # Usage: 
+    #
+    # If a block is given, a lock is only set when it 
+    # evaluates to true: 
+    #
+    #   lock_by(:lock) { |me|
+    #     me.user_id != $user.user_id
+    #   }
+    #
+    def lock_by(attrib, &block)
+      @lock_proc = block
+      @lock_attr = attrib
+      @lock_attr_name = attrib.to_s.split('.')[-1].intern
+    end
+    
+    def lock!(inst)
+      inst[@lock_attr] = true
+      commit
+    end # def
+
+    def release!(inst)
+      inst[@lock_attr] = false
+      commit
+    end # def
+    
+    def locked?(inst)
+      (inst[@lock_attr] == true) || (inst[@lock_attr] == 't')
+    end # def
+
+  end # module
+
+end # module
+end # module

data/behaviours/movable.rb

@@ -0,0 +1,54 @@
+
+module Lore
+module Behaviours
+
+  module Movable
+
+    def ordered_by(attr)
+      @order_attr = attr
+      @order_attr_name = attr.to_s.split('.')[-1].intern
+    end
+    
+    def move(inst, sortpos, criteria)
+
+      sortpos = sortpos.to_i
+      return if sortpos < 1
+      
+      sortpos_old = inst.attr[@order_attr_name].to_i
+
+      # move down: 
+      if sortpos.to_i > sortpos_old then
+        
+        self.update { |na|
+          na.set({@order_attr_name => @order_attr-1}).where(
+            (criteria) &
+            (@order_attr <= sortpos) &
+            (@order_attr > sortpos_old)
+          )
+        }
+
+      elsif sortpos.to_i < sortpos_old then
+        
+        self.update { |na|
+          na.set({@order_attr_name => @order_attr+1}).where(
+            (criteria) &
+            (@order_attr >= sortpos) &
+            (@order_attr < sortpos_old)
+          )
+        }
+        
+      end
+
+      if sortpos != sortpos_old then
+        
+        inst.set_attribute_value(@order_attr_name, sortpos)
+        inst.commit()
+
+      end
+
+    end # def
+    
+  end # module
+
+end # module
+end # module

data/behaviours/versioned.rb

@@ -0,0 +1,24 @@
+
+module Lore
+module Behaviours
+
+  module Versioned
+  
+    # Defines attribute the version number is stored in. 
+    # Default is 'version'. 
+    def version_by(attrib)
+      @version_attr = attrib
+      @version_attr_name = attrib.to_s.split('.')[-1].intern
+    end
+    
+    # Overloads commit so it increments the version attribute 
+    # before saving instance to database. 
+    def commit()
+      set_attribute_value(@version_attr, self.attr[@version_attr].to_i + 1)
+      super()
+    end
+
+  end # module
+
+end # module
+end # module

data/benchmark.rb

@@ -0,0 +1,193 @@
+
+require('lore/model')
+require('lore/cache/mmap_entity_cache')
+
+Lore::Model.use_entity_cache Lore::Cache::MMap_Entity_Cache
+# Aurita.load_project :default
+# Aurita.import_plugin_model :wiki, :article
+
+# include Aurita::Plugins::Wiki
+
+require('benchmark')
+include Benchmark
+# require('profile')
+Lore.logfile = './benchmark_query.log'
+
+require('rubygems')
+require('activerecord')
+
+ActiveRecord::Base.establish_connection(
+  :adapter => 'postgresql', 
+  :host => 'localhost', 
+  :username => 'cuba', 
+  :password => 'cuba23', 
+  :database => 'artest'
+)
+
+Lore.add_login_data('artest' => ['cuba', 'cuba23'])
+Lore::Context.enter :artest
+
+module AR
+  class Content < ActiveRecord::Base
+  end
+
+  class Article < Content
+  end
+end
+
+module Lore
+  class Content < Lore::Model
+    table :contents, :public
+    primary_key :id, :content_id_seq
+  end
+
+  class Article < Content
+    table :articles, :public
+    primary_key :id, :article_id_seq
+    is_a Content, :content_id
+  end
+end
+
+num_loops = 10000
+
+  class Result_Parser
+  require 'inline'
+
+    def initialize(result) # expects PGresult
+      
+      @result = result
+      @field_types      = nil
+      @result_rows      = Array.new
+      @num_fields       = @result.num_fields
+      @field_name_split = Array.new
+      @field_name       = String.new
+      @table_name       = String.new
+      @field_counter    = 0
+      
+    end # def initialize
+
+=begin
+    inline { |builder|
+      builder.c <<-EOC
+        VALUE get_row_c(VALUE result, int row_num) { 
+          unsigned int field_counter; 
+          VALUE row_result, field_name, table_name, field_name_split; 
+          VALUE value_set = rb_hash_new(); 
+          field_name = rb_string_new(); 
+          table_name = rb_string_new(); 
+          row_result = rb_hash_new(); 
+          for(field_counter = 0; field_counter < num_fields; field_counter++) { 
+             value_set = result->getvalue(row_num, UINT2NUM(field_counter)); 
+          // if(row_result[@table_name].nil?) then
+             if(rb_hash_aref(row_result, table_name) == QNil) { 
+            // row_result[@table_name] = Hash.new()
+               rb_hash_aset(row_result, table_name, value_set)
+             }
+             rb_hash_aset(rb_hash_aref)row_result, table_name), value_set); 
+          }
+          return row_result; 
+        }
+      EOC
+    }
+=end
+
+    def get_row(row_num=0)
+      
+      return if @result.num_tuples == 0
+
+      row_result        = Hash.new
+      
+      @field_name_split = Array.new
+      @field_name       = String.new
+      @table_name       = String.new
+      @field_counter = 0
+      for @field_counter in 0...@num_fields do
+        # admin.rd__content.name -> [admin, rd__content, name]
+        @field_name = @result.fieldname(@field_counter)
+
+        row_result[@field_name] = @result.getvalue(row_num,@field_counter)
+      end
+      
+      @result_rows[row_num] = row_result
+      
+    end
+    
+    def get_rows()
+      if !@result_rows.first then
+        for tuple_counter in 0...@result.num_tuples do
+          get_row(tuple_counter)
+        end
+      end
+      @result_rows
+    end
+
+  end
+
+db_name    = 'artest'
+connection = PGconn.connect(Lore.pg_server, Lore.pg_port, '', '', db_name.to_s, Lore.user_for(db_name), Lore.pass_for(db_name.to_s))
+
+sql = 'SELECT * 
+        FROM public.articles
+        JOIN public.contents on (public.contents.id = public.articles.content_id)
+        WHERE public.articles.id BETWEEN 1100 AND 1200 LIMIT 100 OFFSET 0'
+
+bmbm(12) { |test|
+  test.report("rows_raw") { 
+    num_loops.times { 
+      result = connection.exec(sql)
+      for row in 0...result.num_tuples do
+        for field_index in 0...result.num_fields do
+          result.getvalue(row,field_index)
+        end
+      end
+    }
+  }
+  test.report("rows_raw_parsed") { 
+    num_loops.times { 
+      result = connection.exec(sql)
+      p = Result_Parser.new(result)
+#     puts p.get_row_c(result, 0)
+      p.get_rows
+    }
+  }
+  test.report("rows_lore") { 
+    num_loops.times { 
+      result = connection.exec(sql)
+      lore_result = Lore::Result.new('',result)
+      lore_result.get_rows.each { |row|
+        # noop
+      }
+    }
+  }
+  test.report("ac_instances") { 
+    num_loops.times { 
+      result = connection.exec(sql)
+      lore_result = Lore::Result.new('',result)
+      model_instances = []
+      lore_result.get_rows.each { |row|
+         i = Lore::Article.new(Lore::Article,row)
+         model_instances.push(i)
+      }
+    }
+  }
+  test.report("full_auto") { 
+    Lore.disable_cache
+    num_loops.times { 
+      Lore::Article.find(100).with(Lore::Article.id.in(1100..1200)).entities
+    }
+  }
+  test.report("ar") { 
+    num_loops.times { 
+      AR::Article.find(:all, :conditions => "id > 1100 AND id < 1200").each { |a|
+      }
+    }
+  }
+  test.report('using cache') { 
+    Lore.enable_cache
+    num_loops.times { 
+      Lore::Article.find(100).with(Lore::Article.id.in(1100..1200)).entities
+    }
+  }
+}
+
+

data/bits.rb

@@ -0,0 +1,52 @@
+
+module Lore
+
+  def self.resolve_passed_value(values, table_name, attrib_name)
+    return { :value => values[attrib_name].to_s, :field => attrib_name }
+    idx = attrib_name.to_s.length
+    value = nil
+    while value.nil? && idx > 1 do 
+      name_part = attrib_name.to_s[0..idx]
+      value = values[name_part]
+      if value == '' then 
+        name_part = table_name + '.' << name_part
+        value = values[name_part]
+      end
+
+      idx -= 1
+    end
+    { :value => value, :field => name_part }
+  end
+
+end
+
+class Hash
+
+  def deep_merge!(second)
+    merger = proc { |key,v1,v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge!(second, &merger)
+  end
+  
+  def nested_hash(array)
+    node = self
+    array.each do |i|
+       node[i]=Hash.new if node[i].nil?
+       node = node[i]
+    end 
+    self
+  end
+  
+  def merge_nested_hash!(nested_hash)
+    deep_merge!(nested_hash)
+  end
+  
+  def keys_flat(keys_result=[])
+    keys.each { |k|
+     keys_result << k
+     child = self[k]
+     child.keys_flat(keys_result) if (child && child.kind_of?(Hash))
+    } 
+    return keys_result
+  end
+
+end

data/cache/abstract_entity_cache.rb

@@ -0,0 +1,82 @@
+
+require('logger')
+require('pstore')
+require('digest/md5')
+
+module Lore
+module Cache
+
+  # When implementing your own entity cache, derive from and implement 
+  # Abstract_Entity_Cache. 
+  # Expected class methods are: 
+  #  - flush
+  #  - read(query_string)
+  #  - create(model_klass, query_string, result)
+  #  - include?(query_string)
+  #  - delete(cache_index)
+  #    cache_index being an MD5 sum of the query_string that 
+  #    generated the cache entry. 
+  #    In case you want cache indices other than MD5 sums, 
+  #    define class method 
+  #    index_for(query_string)
+  #
+  # Every model may use a different caching implementation. 
+  # To enable a specific caching implenentation for a model, use:
+  #
+  #    class Your_Model < Lore::Model
+  #      ...
+  #      use_cache_impl The_Cache_Implementation_Klass
+  #      ...
+  #    end 
+  #
+  class Abstract_Entity_Cache
+
+    # Delete all cache entries for this model
+    def self.flush
+      raise ::Exception.new('Not implemented')
+    end
+
+    # Read cached result for a specific query string. 
+    # Returns array of model instances.  
+    def self.read(accessor, query_string)
+      raise ::Exception.new('Not implemented')
+    end
+
+    # 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)
+      raise ::Exception.new('Not implemented')
+    end
+
+    # Whether there is a cache entry for a query or not. 
+    def self.include?(accessor, query_string)
+      raise ::Exception.new('Not implemented')
+    end
+
+    # Delete a specific cache entry, parameter index being 
+    # primary key (e.g. a hash value) in cache generated from 
+    # a query. 
+    def self.delete(index)
+      raise ::Exception.new('Not implemented')
+    end
+
+  end
+
+  module Cache_Helpers
+    def index_for(query)
+      Digest::MD5.hexdigest(query)
+    end
+
+    def storefile_of(model_name, query)
+      '/tmp/lore_cache__' << model_name + '_' << Digest::MD5.hexdigest(query)
+    end
+
+    def create_store(storefile_name)
+      store = PStore.new(storefile_name) unless storefile_name.nil?
+      return store
+    end
+  end
+
+end
+end

data/cache/bits.rb

@@ -0,0 +1,22 @@
+
+module Lore
+module Cache
+
+    @@ignore_params = [ 'cb__model', 'cb__controller', 'cb__mode' ]
+  
+    def self.store_name(klass_name, controller, mode, keys)
+      key_string = ''
+      keys.each_pair { |name, value|
+        key_string += '@@@'+name+'==' << value.to_s unless @@ignore_params.include? name
+      }
+      controller = '*' if controller == :all
+      mode = '*'       if mode == :all
+      
+      store_name  = '/tmp/cb__cache__' << klass_name.to_s << '@@@' << controller.to_s << '@@@' << mode.to_s
+      store_name += key_string unless key_string == ''
+
+      return store_name
+    end
+
+end # module
+end # module