Module: DatabaseDocumenter::ColumnDescription

Defined in:
lib/database_documenter/column_description.rb

Class Method Summary collapse

Class Method Details

.generate(column_name, column_type, klass) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/database_documenter/column_description.rb', line 4

def self.generate(column_name, column_type, klass)
  klass_name = klass.name.demodulize.titleize

  # Handle enums
  return generate_enum_column_description(column_name, column_type, klass_name, klass) if klass.defined_enums.key?(column_name)

  # Handle assm
  return generate_assm_column_description(column_name, column_type, klass_name, klass) if klass.respond_to?(:aasm) && klass.aasm.attribute_name.to_s == column_name

  unless klass.subclasses.select { |x| x.respond_to?(:aasm) }[0].nil?
    subklass = klass.subclasses.select { |x| x.respond_to?(:aasm) }[0]
    return generate_assm_column_description(column_name, column_type, klass_name, subklass) if subklass.aasm.attribute_name.to_s == column_name
  end

  # Default
  generate_default_column_descrription(column_name, column_type, klass_name, klass)
end

.generate_assm_column_description(column_name, _column_type, klass_name, klass) ⇒ Object 



89
90
91
92
 
# File 'lib/database_documenter/column_description.rb', line 89

def self.generate_assm_column_description(column_name, _column_type, klass_name, klass)
  values_hash = Hash[klass.aasm.states.collect { |k| [k.name.to_s.humanize, k.name.to_s] }]
  represent_multi_value_column(column_name, klass_name, values_hash)
end

.generate_boolean_column_description(column_name, _column_type, klass_name) ⇒ Object 



51
52
53
54
55
56
57
58
59
60
 
# File 'lib/database_documenter/column_description.rb', line 51

def self.generate_boolean_column_description(column_name, _column_type, klass_name)
  case column_name
  when /.*active/, /has_.*/, "canceled"
    "Is #{klass_name.titlecase.downcase} #{column_name.titlecase.downcase}"
  when /is_.*/
    column_name.titlecase.downcase
  else
    "Is #{klass_name.titlecase.downcase} has #{column_name.titlecase.downcase}"
  end
end

.generate_datetime_column_description(column_name, _column_type, _klass_name) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/database_documenter/column_description.rb', line 34

def self.generate_datetime_column_description(column_name, _column_type, _klass_name)
  case column_name
  when 'reset_password_sent_at'
    "Date when reset password sent"
  when 'current_sign_in_at'
    "Date when the user current signed in"
  when "last_sign_in_at"
    "Date when the user last signed in"
  when 'remember_created_at'
    "Date when remember token created"
  when /.*_at/
    "Date when the row was #{column_name.titlecase.downcase[0..-4]}"
  else
    "Date when the row was #{column_name.titlecase.downcase}"
  end
end

.generate_default_column_descrription(column_name, column_type, klass_name, klass) ⇒ Object 



22
23
24
25
26
27
28
 
# File 'lib/database_documenter/column_description.rb', line 22

def self.generate_default_column_descrription(column_name, column_type, klass_name, klass)
  if respond_to?("generate_#{column_type}_column_description")
    send("generate_#{column_type}_column_description", column_name, column_type, klass_name)
  else
    generate_with_default_rules(column_name, column_type, klass_name, klass)
  end
end

.generate_enum_column_description(column_name, _column_type, klass_name, klass) ⇒ Object 



84
85
86
87
 
# File 'lib/database_documenter/column_description.rb', line 84

def self.generate_enum_column_description(column_name, _column_type, klass_name, klass)
  values_hash = klass.defined_enums[column_name]
  represent_multi_value_column(column_name, klass_name, values_hash)
end

.generate_with_default_rules(column_name, _column_type, klass_name, klass) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/database_documenter/column_description.rb', line 62

def self.generate_with_default_rules(column_name, _column_type, klass_name, klass)
  case column_name
  when 'type'
    values_hash = Hash[klass.subclasses.collect { |k| [k.name.underscore.humanize, k.name] }]
    represent_multi_value_column(column_name, klass_name, values_hash)
  when /.*_code/
    refered_table_name = column_name.scan(/(.*)_code/)[0][0]
    "Code of #{refered_table_name.titleize}".capitalize
  when /.*_id/
    refered_table_name = column_name.scan(/(.*)_id/)[0][0]
    "Id of #{refered_table_name.titleize}".capitalize
  when /.*_type/
    refered_table_name = column_name.scan(/(.*)_type/)[0][0]
    "Type of #{refered_table_name.titleize}".capitalize
  when /.*_count/
    refered_table_name = column_name.scan(/(.*)_count/)[0][0]
    "Count of #{refered_table_name.titleize}".capitalize
  else
    "#{column_name.titlecase.downcase} of #{klass_name.titleize}".capitalize
  end
end

.handle_enums(column_name, column_type, klass_name, klass) ⇒ Object 



30
31
32
 
# File 'lib/database_documenter/column_description.rb', line 30

def self.handle_enums(column_name, column_type, klass_name, klass)
  generate_enum_column_description(column_name, column_type, klass_name, klass)
end

.represent_multi_value_column(column_name, klass_name, values_hash) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/database_documenter/column_description.rb', line 94

def self.represent_multi_value_column(column_name, klass_name, values_hash)
  description = ["#{column_name.titlecase.downcase} of #{klass_name.titleize}, possible values:"]
  values_hash.each do |k, v|
    description <<  if k == values_hash.keys.last
                      "[#{v}] => #{k}."
                    else
                      "[#{v}] => #{k},"
                    end
  end
  description
end