lore 0.4.2

data/model_factory.rb

@@ -0,0 +1,202 @@
+
+def global_eval(string)
+  eval(string)
+end
+
+module Lore
+
+  class Model_Factory
+
+    attr_accessor :output_folder, :output_file
+    attr_reader :model_name, :fields, :primary_keys, :aggregates, :types, :labels
+
+    # Usage: 
+    #   builder = Model_Builder.new('new_model')
+    #   builder.add_attribute('model_id', :type => Type.integer, :not_null => true)
+    #   builder.add_attribute('name', :type => Type.integer, :not_null => true, :check => "name <> ''", :unique => true)
+    #   builder.add_attribute('created', :type => Type.timestamp, :not_null => true, :default => 'now()')
+    #   builder.add_primary_key(:key_name => 'model_pkey', :attribute => 'model_id')
+    #   builder.set_table_space('diskvol1')
+    #   builder.build()
+    def initialize(model_name, connection=nil)
+      name_parts       = model_name.split('::')
+      @model_name      = name_parts[-1]
+      @namespaces      = name_parts[0..-2]
+
+      @table_name      = @model_name.downcase
+
+      @output_folder   = './'
+      @output_file     = @table_name + '.rb'
+
+      @connection      = connection
+      @connection      = Lore::Connection unless @connection
+      @table_space     = ''
+
+      @fields          = Array.new
+      @types           = Array.new
+      @labels          = Array.new
+      @aggregates      = Array.new
+      @attributes      = Array.new
+      @constraints     = Array.new
+      @schema_name     = :public
+      @primary_keys    = Array.new
+      @attribute_types = Hash.new
+      
+      @base_model_klass = 'Lore::Model'
+      @base_model_klass_file = 'lore/model'
+    end
+
+    def self.drop_model(model)
+      query =  'DROP TABLE ' << model.table_name + ';'
+      model.get_sequences()[model.table_name].each { |key, seq|
+        query << 'DROP SEQUENCE ' << seq.to_s + ";\n" 
+      }
+      Lore::Connection.perform(query)
+    end
+    
+    def use_model(model_klass_string, model_klass_file)
+      @base_model_klass = model_klass_string
+    end
+
+  public
+
+    # Usage: 
+    # 
+    #  add_attribute('primary_id', 
+    #                :type => integer, 
+    #                :not_null => true, 
+    #                :default => '0', 
+    #                :length => 20, 
+    #                :check => '...')
+    #
+    def add_attribute(attrib_name, attrib_hash)
+
+      @fields << { :name => attrib_name, :type => attrib_hash[:type] }
+
+      attribute_part = ''
+      attribute_part << attrib_name + "\t " << attrib_hash[:type].to_s
+      if attrib_hash[:length].instance_of? Integer then
+        attribute_part << '(' << attrib_hash[:length].to_s + ')'
+      end
+      attribute_part << ' UNIQUE ' if attrib_hash[:unique]
+      attribute_part << ' NOT NULL ' if attrib_hash[:not_null]
+      
+      @attributes << attribute_part
+      @attribute_types[attrib_name] = attrib_hash[:type]
+    end
+    def set_attributes(attrib_hash)
+      attrib_hash.each_pair { |attrib_name, attrib_props|
+        add_attribute(attrib_name.to_s, attrib_props)
+      }
+    end
+    
+    def set_table_space(table_space)
+      @table_space = table_space
+    end
+
+    def add_has_a(model, attribute_name)
+      @aggregates << [:has_a, model, attribute_name]
+    end
+
+    def add_is_a(model, attribute_name)
+      @aggregates << [:is_a, model, attribute]
+    end
+
+    def add_label(label)
+      @labels << label.downcase
+    end
+
+    def set_labels(labels)
+      @labels = labels
+    end
+
+    # Usage: 
+    #  add_primary_key(:attribute => 'my_id', :key_name => 'my_model_pkey')
+    # or: 
+    #  add_primary_key(:attributes => ['id_1', 'id_2'], :key_name => 'my_model_pkey')
+    def add_primary_key(key_hash)
+      key_hash[:attribute] = key_hash[:attribute].to_s
+      key_hash[:key_name] = key_hash[:key_name].to_s
+      @primary_keys << [ key_hash[:attribute], key_hash[:attribute]+'_seq', key_hash[:key_name] ]
+    end
+
+  public
+
+    # Finally installs model table
+    def build_table
+
+      query = ''
+      pkey_constraint = "CONSTRAINT #{@table_name}_pkey PRIMARY KEY (#{@primary_keys.collect { |pk| pk[0] }.join(',')})\n"
+      @primary_keys.each { |pk|
+        query << 'CREATE SEQUENCE ' << pk[1] + ';' << "\n"
+      }
+
+      query << 'CREATE TABLE ' << @table_name + " ( \n" 
+      query << @attributes.join(", \n")
+      query << ', ' << "\n"
+      query << pkey_constraint
+      query << "\n" << ') ' << @table_space + ';'
+      
+      @connection.perform(query)
+    end
+    
+    def build_model_klass
+      build_table
+      model_klass_string = build_model_klass_string
+      if @output_file then
+        out = @output_folder + @output_file
+        prepend_header = !File.exists?(out)
+        File.open(out, 'a+') { |f|
+          f << "\nrequire('" << @base_model_klass_file + "') \n\n" if prepend_header
+          prepend_header = false
+          f << model_klass_string
+          f << "\n\n"
+        }
+      end
+      global_eval(model_klass_string)
+    end
+
+    def build_model_klass_string
+
+      requires = ''
+      @aggregates.each { |type, model_name, attribute|
+        requires << "require('aurita/main/model/" << model_name.downcase + "')"
+        requires << "\n"
+      }
+      requires << "\n"
+
+      model = requires
+
+      model << '  class ' << @model_name.to_s + ' < ' << @base_model_klass + " \n"
+      model << '    table :' << @table_name.to_s
+      model << ', :' << @schema_name.to_s
+      model << "\n"
+      @primary_keys.each { |key|
+        model << '    primary_key :' << key[0]
+        model << ', :' << key[1] if key[1]
+        model << "\n"
+      }
+      @attribute_types.each_pair { |attr, type|
+        model << '    has_attribute :' << attr + ', Lore::Type.' << type
+        model << "\n"
+      }
+      
+      model << '    use_label :' << @labels.join(', :') if @labels.first
+      model << "\n"
+
+      @aggregates.each { |type, model_name, attribute_name|
+        model << '    has_a ' << model_name + ', :' << attribute_name.downcase if type==:has_a
+        model << '    is_a ' << model_name + ', :' << attribute_name.downcase if type==:is_a
+        model << "\n"
+      }
+      model << "\n" << '  end'
+      @namespaces.reverse.each { |ns|
+        model = 'module ' << ns + "\n" << model << "\n" << 'end'
+        
+      }
+      return model
+    end
+
+  end # class
+
+end # module

data/model_shortcuts.rb

@@ -0,0 +1,16 @@
+
+module Lore
+
+  module Model_Shortcuts
+
+    def html_escape_values_of(*attributes)
+      attributes.each { |attrib|
+        add_input_filter(attrib) { |a|
+          a.gsub("'",''')
+        }
+      }
+    end
+
+  end
+
+end

data/query_shortcuts.rb

@@ -0,0 +1,367 @@
+
+module Lore
+
+  class Refined_Query
+
+    def initialize(accessor, statements={})
+      @accessor  = accessor
+      @condition = statements[:condition]
+      @what      = statements[:what]
+      @limit     = statements[:limit]
+      @offset    = statements[:offset]
+      @order_by  = statements[:order_by]
+      @order_by  = Array.new unless @order_by
+      @group_by  = statements[:group_by]
+      @having    = statements[:having]
+      @condition = true unless @condition
+#     @what = @what.to_s unless @what.nil?
+    end
+
+    # Example: 
+    # Adds where-condition to query. Multiple calls stack using AND. Examples; 
+    # 
+    #   Type.find(1).with(Type.name == 'foo' & Type.position > 2).having(<...>).ordered_by(:name).result 
+    #   # ... is same as ...
+    #   Type.find(1).with(Type.name == 'foo').with(Type.position > 2).having(<...>).ordered_by(:name).result 
+    #
+    #   User.all.with(User.user_id.in( Admin.all(:user_id) ))
+    #
+    def with(condition)
+      if((@condition.instance_of? TrueClass) || @condition.nil?) then 
+        @condition = condition 
+      else
+        @condition = (@condition & condition)
+      end
+      return self
+    end
+    alias where with
+
+    # Adds HAVING statement to query. Examples: 
+    # 
+    #   User.all.having(User.user_id.in( Admin.all(:user_id) ))
+    # 
+    def having(having_clause)
+      @having = having_clause
+      return self
+    end
+
+    # To be overloaded by derived classes
+    def perform
+    end
+
+    # Provides wrapper for simple SQL attribute operation keywords. 
+    # Examples: 
+    #
+    #   Car.value_of.sum(Car.car_id).to_i   
+    #   -> SELECT sum(public.car.car_id) ...
+    #   -> Amount of all cars as integer, e.g. 2342
+    #   Car.value_of.max(Car.car_id).to_i   
+    #   -> SELECT max(public.car.car_id) ...
+    #   -> Highest car_id as integer, e.g. 14223
+    #
+    def method_missing(method, attribute_name)
+      @what = method.to_s << '(' << attribute_name.to_s << ') AS "value"'
+      return self
+    end
+
+  end # class
+  
+  class Refined_Select < Refined_Query
+
+    def initialize(accessor, statements={})
+      super(accessor, statements)
+    end
+
+    # Examples: 
+    # 
+    # Initiates request for single attribute values instead 
+    # model instances. Returns value as string, array or two-dimensional 
+    # array, depending from parameters passed: 
+    # 
+    #   Car.find(2).values_of(Car.name, Car.id).ordered_by(Car.name, :asc).entities 
+    #   -> [ ['BMW318i', '3'], ['BMW Mini', '5'] ]
+    #   Car.find(2).values_of(Car.name).ordered_by(Car.name, :asc).entities   
+    #   -> [ 'BMW318i', 'BMW Mini']
+    #   Car.find(1).value_of(Car.name, Car.type).with(Car.name.ilike '%BMW%').entity 
+    #   -> ['BMW318i', 'Convertible']
+    #   Car.find(1).value_of(Car.name).with(Car.name.ilike '%BMW%').entity 
+    #   -> 'BMW318i'
+    #
+    def values_of(*what)
+      @what = what
+      return self
+    end
+    alias value_of values_of
+
+    # Same as #entities.first. Useful when requesting one row or a single 
+    # attribute only. 
+    def entity
+      entities.first
+    end
+    
+    def first
+      entities.first
+    end
+
+    # When requesting a single value, #to_i can be used to 
+    # retreive the result as string instead of calling #entity:
+    # 
+    #   s1 = User.all(User.name).with(User.name.like '%Christina%').to_s
+    #   s2 = User.all(User.name).with(User.name.like '%Christina%').entity
+    #   assert_equal s1, s2
+    #
+    def to_s
+      entities.first.to_s
+    end
+    # When requesting a single value, #to_i can be used to 
+    # retreive the result as integer instead of calling #entity: 
+    # 
+    #   i1 = User.all(User.id).with(User.name.like '%Christina%').to_i
+    #   i2 = User.all(User.id).with(User.name.like '%Christina%').entity.to_i
+    #   assert_equal i1, i2
+    #
+    def to_i
+      entities.first.to_i
+    end
+
+    # Adds order statement to query. Direction is either :desc or :asc. 
+    # Example: 
+    # 
+    #   User.find(0..10).ordered_by(:surname, :asc)
+    #   User.find(20).ordered_by([:surname, :forename], :desc)
+    # 
+    # Aliases are #order_by and #sort_by. 
+    # 
+    def ordered_by(attrib, dir=:asc)
+      @order_by << [attrib, dir]
+      return self
+    end
+    alias order_by ordered_by
+    alias sort_by ordered_by
+
+    # Offset part of a query. 
+    #
+    #   Something.find(10).with(Something.name == 'foo').offset(123).entities
+    # Results in 
+    #   SELECT * FROM something WHERE something.name = 'foo' LIMIT 10,123
+    #
+    def offset(off)
+      @offset = off
+      return self
+    end
+
+    # Limit part of a query. 
+    #
+    #   Something.all_with(Something.name == 'foo').limit(10,123).entities
+    # Is same as 
+    #   Something.find(10).with(Something.name == 'foo').offset(123).entities
+    # Is same as 
+    #   Something.find(10,123).with(Something.name == 'foo').entities
+    #
+    # And results in 
+    #   SELECT * FROM something WHERE something.name = 'foo' LIMIT 10,123
+    #
+    def limit(lim, off=0)
+      @limit = lim
+      @offset = off
+      return self
+    end
+
+    # Handy wrapper for 
+    #   <request>.entities.each { |e| ... }
+    def each(&block)
+      entities.each &block
+    end
+
+    # Returns Clause instance containing this select statement. 
+    # This is needed for all Clause methods expecting an inner select. 
+    # Example: 
+    #
+    #   inner = Car.all(Car.car_id).with(Car.seats > 2)
+    #   Car.all.where(Car.car_id).in(inner)  # method 'in' calls inner.to_select
+    #
+    # Full example: 
+    #
+    #   Car.all.where(Car.car_id).in( 
+    #     Manufacturer_Car.values_of(Manufacturer_Car.car_id).limit(10).sort_by(Manufacturer_Car.name)
+    #   )
+    #
+    def to_select
+      @accessor.select(@what) { |entity|
+        entity.where(@condition)
+        entity.limit(@limit, @offset) unless @limit.nil?
+        @order_by.each { |o|  
+          entity.order_by(o[0], o[1]) 
+        }
+        entity.group_by(@group_by) unless @group_by.nil?
+        entity.having(@having) unless @having.nil?
+        entity
+      }
+    end
+
+    # Sends request defined by previous method calls to self. Examples: 
+    # 
+    #   Car.find(10).with(Car.name.like '%BMW%').entities  # -> Array of 10 instances of model klass 'Car'
+    # 
+    # Before calling #entities, the request isn't sent, but defined only. 
+    # Therefore you safely can pass a query (Clause) object to other methods, 
+    # like in this example: 
+    # 
+    #   def filter_cars(clause)
+    #     query.with((Car.name != '') & clause).limit(10).entities
+    #   end
+    #
+    #   filder = Car.find(10).with(Car.name.like '%Audi%').limit(20) # Request is not sent yet
+    #   filter_cars(filter) # Request will be sent here
+    #   # -> Car.find(10).with(Car.name.like '%Audi%').with(Car.name != '').limit(10).entities
+    #   # -> Car.find(10).with((Car.name.like '%Audi%') & (Car.name != '')).limit(10).entities
+    # 
+    # There are other methods not defining but executing a request: 
+    # #entity, #each, #to_i, #to_s
+    #
+    def entities
+      if @what.nil? then
+        result = @accessor.select { |entity|
+          entity.where(@condition)
+          entity.limit(@limit, @offset) unless @limit.nil?
+          @order_by.each { |o|  
+            entity.order_by(o[0], o[1]) 
+          }
+          entity.group_by(@group_by) unless @group_by.nil?
+          entity.having(@having) unless @having.nil?
+          entity
+        }
+      else
+        result = Array.new
+        @accessor.select_values(@what) { |entity|
+          entity.where(@condition)
+          entity.limit(@limit, @offset) unless @limit.nil?
+          @order_by.each { |o|  
+            entity.order_by(o[0], o[1]) 
+          }
+          entity.group_by(@group_by) unless @group_by.nil?
+          entity.having(@having) unless @having.nil?
+          entity
+        }.each { |row|
+          if row.kind_of? Hash then
+            result << row.values['value'] 
+          elsif row.kind_of? String then
+            result << row
+          end
+        }
+      end
+
+      return result
+    end
+    alias perform entities
+
+  end # class
+
+  class Refined_Delete < Refined_Query
+
+    def perform
+      @accessor.delete { |entity|
+        entity.where(@condition)
+        entity.limit(@limit, @offset) unless @limit.nil?
+        entity.having(@having) unless @having.nil?
+        entity
+      }
+    end
+
+  end # class
+
+  class Refined_Update < Refined_Query
+    
+    def initialize(accessor, statements={})
+      @update_values = statements[:update_values]
+      super(accessor, statements)
+    end
+
+    def perform
+      @accessor.update { |entity|
+        entity.set(@update_values)
+        entity.where(@condition)
+        entity
+      }
+    end
+
+  end
+
+
+  module Query_Shortcuts
+
+    # Example: 
+    #
+    #  Users.value_of.sum(:user_id)
+    #
+    def value_of(what=nil)
+      Refined_Select.new(self, :condition => true, :what => what)
+    end
+
+    def all(what=nil)
+      Refined_Select.new(self, :condition => true, :what => what)
+    end
+
+    # Wrapper for 
+    #
+    #   Accessor.all.entities.each { |e| ... }
+    #
+    def each(&block)
+      all.entities.each(&block)
+    end
+
+    # Returns Refined_Select instance with limit set to amount. 
+    # Example: 
+    #   
+    #   Car.find(10).with(...) ...
+    #
+    def find(amount, offset=0)
+      if amount == :all then
+        all()
+      else
+        Refined_Select.new(self, :limit => amount, :offset => offset)
+      end
+    end
+
+    # Returns Refined_Select instance with WHERE statement set 
+    # to condition. 
+    # Same as 
+    #
+    #   Accessor.find(:all).with(condition)
+    # or
+    #   Accessor.all.with(condition)
+    #
+    def all_with(condition)
+      Refined_Select.new(self, :condition => condition)
+    end
+    
+    # Example:
+    #
+    #   Accessor.set(:attribute => 'value').where(...).perform
+    #
+    def set(values)
+      Refined_Update.new(self, :update_values => values)
+    end
+
+    # Example:
+    #
+    #   Accessor.delete.where(...).perform
+    #
+    def delete
+      Refined_Delete.new(self)
+    end
+    
+    # Deletes all entities of model class, i.e. empties its tables (!). 
+    # Example: 
+    #
+    #   Car.delete_all
+    #
+    def delete_all
+      delete { |entity|
+        entity.where(true)
+      }
+    end
+
+  end # module
+
+end # module

data/reserved_methods.txt

@@ -0,0 +1,3 @@
+
+Model#touched
+Whether attribute values have changed since loading of instance. 

data/result.rb

@@ -0,0 +1,100 @@
+
+require('postgres')
+require('digest/md5')
+
+module Lore
+  
+  # :nodoc
+class Result
+
+  attr_reader :query_hashval
+
+  def initialize(query, result) # expects PGresult
+    
+    @result = result
+    @field_types      = nil
+    @result_rows      = Array.new
+  # @query_hashval    = Digest::MD5.hexdigest(query)
+    @num_fields       = @result.num_fields
+    @field_counter    = 0
+    
+  end # def initialize
+  
+  def get_field_value(row_index, field_name)
+    
+    field_index = @result.fieldnum(field_name)
+    return @result.getvalue(row_index, field_index)
+    
+  end # def get_field_value
+  
+  def get_field_names()
+    return @result.fields
+  end
+  
+  def get_field_types()
+    
+    return @field_types unless @field_types.nil?
+    
+    @field_types = Hash.new
+    for field_index in 0...get_field_num()
+      @field_types[@result.fields[field_index]] = @result.type(field_index)
+    end
+    
+    return @field_types
+  end
+  
+  def get_field_num()
+    return @result.num_fields
+  end
+  
+  def get_tuple_num()
+    return @result.num_tuples
+  end
+  
+  def get_row(row_num=0)
+
+    return @result_rows.at(row_num) if @result_rows.at(row_num)   
+    return if @result.num_tuples == 0
+
+    # We cannot use a hash here, as there might be 
+    # duplicate attribute names due to joins: 
+    #
+    # { 
+    #   :fields => [ 'id', 'foo', 'foreign_id, 'id', 'bar' ]
+    #   :values => [ '1', 'wombat', '5', '5', 'cthulluh' ]
+    # }
+    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
+    return 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
+      @fieldnames = []
+      for @field_counter in 0...@num_fields do
+        @fieldnames << @result.fieldname(@field_counter)
+      end
+    end
+
+    result = { :values => @result_rows, :fields => @fieldnames }
+    return result
+  end
+  
+  def fieldname(index)
+    
+    return @result.fieldname(index)
+    
+  end
+  
+end # class Result
+
+end # module Lore