class JunglePath::DBModel::Table

Public Class Methods

alternate_key_columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 45
def self.alternate_key_columns
        @alternate_key_columns
end
columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 25
def self.columns
        @columns
end
columns_alphabetical_order() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 29
def self.columns_alphabetical_order
        @columns.values.clone.sort { |a,b| a.name <=> b.name }
end
columns_sequence_order() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 33
def self.columns_sequence_order
        @columns.values.clone.sort { |a,b| a.sequence <=> b.sequence }
end
define(*column_defs) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 200
def self.define(*column_defs)
        set_columns

        column_defs.each do |column_def|
                # one column_def may produce multiple actual columns:
                columns = Column.get_column_def_columns(column_def, @sequence)
                columns.each do |column|
                        @sequence = column.sequence + 1
                        self.columns[column.name] = column
                        self.primary_key_columns[column.name] = column if column.primary_key?
                        self.alternate_key_columns[column.name] = column if column.alternate_key?
                        self.foreign_key_columns[column.name] = column if column.foreign_key?

                        if column.foreign_key?
                                hash = self.foreign_key_columns_by_table_name
                                sub_hash = hash[column.foreign_key_table_name]
                                sub_hash = {} unless sub_hash
                                sub_hash[column.name] = column
                                hash[column.foreign_key_table_name] = sub_hash
                        end

                        if column.tags
                                column.tags.each do |tag|
                                        tagged_columns = @tagged_columns[tag] || Set.new
                                        tagged_columns.add(column)
                                        @tagged_columns[tag] = tagged_columns
                                end
                        end

                        self.references << column.foreign_key_table_name if column.foreign_key? and column.foreign_key_table_name != self.table_name
                        self.secure_columns[column.name] = column if column.secure?
                        self.non_audit_columns[column.name] = column unless column.is_audit_column?
                        #attr_accessor column.name
                        define_method(column.name) do
                                @values[column.name]
                        end
                        define_method("#{column.name}=") do |value|
                                if value != @values[column.name]
                                        @values[column.name] = value
                                        @modified.add(column.name)
                                end
                        end
                end
                self.primary_key_columns.values[0].calculated = true if self.primary_key_columns.length == 1
        end

        define_method("_values") do
                @values
        end

        define_method("_modified") do
                @modified
        end

        define_method("_modified_hash") do
                hash = {}
                @modified.each do |key|
                        hash[key] = @values[key]
                end
                hash
        end

        define_method("_has_value_hash") do
                hash = {}
                @values.each do |key, value|
                        hash[key] = value unless value == nil
                end
                hash
        end

        define_method("_primary_key") do
                primary_key = {}
                _primary_key_columns.keys.each do |key|
                        primary_key[key] = @values[key]
                end
                primary_key
        end

        define_method("_alternate_key") do
                alternate_key = {}
                _alternate_key_columns.keys.each do |key|
                        alternate_key[key] = @values[key]
                end
                alternate_key
        end

        define_method("_consume_hash") do |hash, mark_as_modified_if_changed=true|
                @values.each do |key, value|
                        if hash.has_key?(key) and @values[key] != hash[key]
                                @values[key] = hash[key]
                                @modified.add(key) if mark_as_modified_if_changed
                        end
                end
        end

        define_method("_columns") do
                self.class.columns
        end

        define_method("_primary_key_columns") do
                self.class.primary_key_columns
        end

        define_method("_alternate_key_columns") do
                self.class.alternate_key_columns
        end

        define_method("_foreign_key_columns") do
                self.class.foreign_key_columns
        end

        define_method("_secure_columns") do
                self.class.secure_columns
        end

        define_method("_tagged_columns") do
                self.class.tagged_columns
        end

        define_method("_table_name") do
                self.class.table_name
        end

        define_method("_secure?") do
                @secure
        end

        define_method("_secure=") do |value|
                @secure = value
        end

        define_method("to_hash") do
                #puts "#{_table_name} to_hash."
                return @values.clone if _secure_columns.length == 0 or !_secure?
                hash = {}
                puts "stripping secure columns!"
                @values.each do |key, value|
                        hash[key] = value unless _secure_columns.has_key?(key)
                end
                hash
        end

        define_method("to_h") do
                # ruby way :)
                to_hash
        end

        define_method("to_json") do |arg=nil|
                #puts "#{_table_name} to_json."
                #puts "to_json - arg: #{arg.class}" if arg
                json = JunglePath::Json.dump self
                #puts json
                json
        end
end
description() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 105
def self.description
        @description
end
description=(value) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 109
def self.description=(value)
        @description = value
end
foreign_key_columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 49
def self.foreign_key_columns
        @foreign_key_columns
end
foreign_key_columns_by_table_name() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 53
def self.foreign_key_columns_by_table_name
        @foreign_key_columns_by_table_name
end
has_no_references?() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 74
def self.has_no_references?
        !self.has_references?
end
has_no_view_references?() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 153
def self.has_no_view_references?
  !self.has_view_references?
end
has_reference_to?(table) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 66
def self.has_reference_to?(table)
        @references.member?(table.table_name)
end
has_references?() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 70
def self.has_references?
        !@references.empty?
end
has_view_reference_to?(table) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 137
def self.has_view_reference_to?(table)
  if @view
    @view.has_reference_to?(table.table_name)
  else
    has_reference_to?(table)
  end
end
has_view_references?() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 145
def self.has_view_references?
  if @view
    !@view.references.empty?
  else
    has_references?
  end
end
inherited(sub_class) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 157
                def self.inherited(sub_class)
                        sub_class.set_columns #setup subclass with particular class instance vars.
@models = {} unless @models
                        @models[sub_class.table_name] = sub_class #keep a list of all subclasses.
                end
is_view?() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 113
def self.is_view?
        if @view
          true
        else
          false
        end
      end
model_sort(list, result=Set.new, level=0) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 177
def self.model_sort(list, result=Set.new, level=0)
        # return array of table names sorted in dependency order (not alphabetical order).
        #puts "level: #{level}."
        remaining = []
        list.each do |value|
          #puts "\tvalue: #{value.table_name}. references: #{value.references.to_a}."
          if value.has_no_view_references?
            #puts "\tadding: #{value.table_name}."
            result << value.table_name
          elsif value.view_references.subset? result
            #puts "\tadding: #{value.table_name}."
            result << value.table_name
          else
            remaining << value
          end
        end
        #puts "\tresult: #{result.length}: #{result.to_a}."
        #puts "\tremaining: #{remaining.length}: #{remaining}."
        return [] if level > 10 #something is wrong!!!
        result = self.model_sort(remaining, result, level + 1) if remaining.length > 0
        result
      end
models() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 163
def self.models
        @models
end
models_alphabetical_order() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 167
def self.models_alphabetical_order
        @models.values.clone.sort { |a,b| a.table_name <=> b.table_name }
end
models_dependent_order() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 171
def self.models_dependent_order
        result = self.model_sort(@models.values.clone)
        # map array of table names into an array of table (model) classes.
        result.map {|key| @models[key]}
end
new(hash=nil, mark_as_modified_if_changed=true, transform_params=false) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 356
def initialize(hash=nil, mark_as_modified_if_changed=true, transform_params=false)
        @values = {}
        @secure = true
        _columns.keys.each do |key| @values[key] = nil end
        @modified = Set.new # holds hash keys of modified values.
        hash = DBModel::Params.transform(hash, _columns) if transform_params
        _consume_hash(hash, mark_as_modified_if_changed) if hash
end
non_audit_columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 37
def self.non_audit_columns
        @non_audit_columns
end
original_table_name() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 87
def self.original_table_name
  @table_name
end
override_table_name() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 91
def self.override_table_name
  @override_table_name
end
override_table_name=(value) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 95
def self.override_table_name=(value)
  tmp = nil
  tmp = value.to_sym if value
  @override_table_name = tmp
end
plural_table_name() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 101
def self.plural_table_name
        "#{@table_name}s"
end
primary_key_columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 41
def self.primary_key_columns
        @primary_key_columns
end
references() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 62
def self.references
        @references
end
secure_columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 78
def self.secure_columns
        @secure_columns
end
set_columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 9
def self.set_columns
        @columns = {}
        @non_audit_columns = {}
        @primary_key_columns = {}
        @alternate_key_columns = {}
        @foreign_key_columns = {}
        @foreign_key_columns_by_table_name = {}
        @references = Set.new
        @secure_columns = {}
        @unique_indexes = []
        @indexes = []
        @table_name = self.name.split('::').last.underscore.to_sym
        @tagged_columns = {}
        @sequence = 0
end
table_name() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 82
                def self.table_name
return @override_table_name if @override_table_name
                        @table_name
                end
tagged_columns() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 57
def self.tagged_columns
        #call like: TableClass.tagged_columns[:my_tag] to return set of columns having given tag.
        @tagged_columns
end
template_model_name() click to toggle source
# File lib/jungle_path/gen/api.rb, line 18
def self.template_model_name
  "Model::#{self.name.split('::').last}"
end
template_new() click to toggle source

Adds useful methods to Table class for use when generating API and Model code:

# File lib/jungle_path/gen/api.rb, line 9
def self.template_new
  "#{self.name}.new"
end
template_params_pk_hash() click to toggle source
# File lib/jungle_path/gen/api.rb, line 22
def self.template_params_pk_hash
  #{id: p[:id]}
  array = []
  self.primary_key_columns.keys.each do |key|
    array << "#{key}: p[:#{key}]"
  end
  "{#{array.join(',')}}"
end
template_pk_url() click to toggle source
# File lib/jungle_path/gen/api.rb, line 13
def self.template_pk_url
  pk = self.primary_key_columns.keys.map {|key| "/:#{key}"}
  pk.join
end
view() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 121
def self.view
  @view
end
view=(value) click to toggle source
# File lib/jungle_path/db_model/table.rb, line 125
def self.view=(value)
  @view = value
end
view_references() click to toggle source
# File lib/jungle_path/db_model/table.rb, line 129
def self.view_references
  if @view
    @view.references
  else
    references
  end
end
view_references=(array_of_table_names) click to toggle source
# File lib/jungle_path/db_model/temp.rb, line 121
def self.view_references=(array_of_table_names)
  @view_references = Set.new(array_of_table_names)
end
view_sql() click to toggle source
# File lib/jungle_path/db_model/temp.rb, line 105
def self.view_sql
  @view_sql
end
view_sql=(value) click to toggle source
# File lib/jungle_path/db_model/temp.rb, line 109
def self.view_sql=(value)
  @view_sql = value
end