Module: DatabaseConsistency::Helper

Defined in:
lib/database_consistency/helper.rb

Overview

The module contains helper methods

Class Method Summary collapse

Class Method Details

.adapter ⇒ Object 



8
9
10
11
12
13
14
 
# File 'lib/database_consistency/helper.rb', line 8

def adapter
  if ActiveRecord::Base.respond_to?(:connection_db_config)
    ActiveRecord::Base.connection_db_config.configuration_hash[:adapter]
  else
    ActiveRecord::Base.connection_config[:adapter]
  end
end

.check_inclusion?(array, element) ⇒ Boolean

Returns:

  • (Boolean) 


71
72
73
 
# File 'lib/database_consistency/helper.rb', line 71

def check_inclusion?(array, element)
  array.include?(element.to_s) || array.include?(element.to_sym)
end

.connected?(klass) ⇒ Boolean

Returns:

  • (Boolean) 


47
48
49
50
51
52
 
# File 'lib/database_consistency/helper.rb', line 47

def connected?(klass)
  klass.connection
rescue ActiveRecord::ConnectionNotEstablished
  puts "#{klass} doesn't have active connection: ignoring"
  false
end

.connection_config(klass) ⇒ Object 



24
25
26
27
28
29
30
 
# File 'lib/database_consistency/helper.rb', line 24

def connection_config(klass)
  if klass.respond_to?(:connection_db_config)
    klass.connection_db_config.configuration_hash
  else
    klass.connection_config
  end
end

.database_name(model) ⇒ Object 



16
17
18
 
# File 'lib/database_consistency/helper.rb', line 16

def database_name(model)
  model.connection_db_config.name.to_s if model.respond_to?(:connection_db_config)
end

.extract_index_columns(index_columns) ⇒ Array<String>

Returns:

  • (Array<String>) 


87
88
89
90
91
92
93
94
95
 
# File 'lib/database_consistency/helper.rb', line 87

def extract_index_columns(index_columns)
  return index_columns unless index_columns.is_a?(String)

  index_columns.split(',')
               .map(&:strip)
               .map { |str| str.gsub(/lower\(/i, 'lower(') }
               .map { |str| str.gsub(/\(([^)]+)\)::\w+/, '\1') }
               .map { |str| str.gsub(/'([^)]+)'::\w+/, '\1') }
end

.first_level_associations(model) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
 
# File 'lib/database_consistency/helper.rb', line 75

def first_level_associations(model)
  associations = model.reflect_on_all_associations

  while model != ActiveRecord::Base && model.respond_to?(:reflect_on_all_associations)
    model = model.superclass
    associations -= model.reflect_on_all_associations
  end

  associations
end

.foreign_key_or_attribute(model, attribute) ⇒ Object 



111
112
113
 
# File 'lib/database_consistency/helper.rb', line 111

def foreign_key_or_attribute(model, attribute)
  model._reflect_on_association(attribute)&.foreign_key || attribute
end

.models ⇒ Object

Returns list of models to check



39
40
41
42
43
44
45
 
# File 'lib/database_consistency/helper.rb', line 39

def models
  project_models.select do |klass|
    !klass.abstract_class? &&
      klass.connection.table_exists?(klass.table_name) &&
      !klass.name.include?('HABTM_')
  end
end

.parent_models ⇒ Object

Return list of not inherited models



55
56
57
58
59
 
# File 'lib/database_consistency/helper.rb', line 55

def parent_models
  models.group_by(&:table_name).each_value.flat_map do |models|
    models.reject { |model| models.include?(model.superclass) }
  end
end

.postgresql? ⇒ Boolean

Returns:

  • (Boolean) 


20
21
22
 
# File 'lib/database_consistency/helper.rb', line 20

def postgresql?
  adapter == 'postgresql'
end

.project_klass?(klass) ⇒ Boolean

Parameters:

  • klass (ActiveRecord::Base)

Returns:

  • (Boolean) 


64
65
66
67
68
 
# File 'lib/database_consistency/helper.rb', line 64

def project_klass?(klass)
  return true unless Module.respond_to?(:const_source_location) && defined?(Bundler)

  !Module.const_source_location(klass.to_s).first.to_s.include?(Bundler.bundle_path.to_s)
end

.project_models ⇒ Object 



32
33
34
35
36
 
# File 'lib/database_consistency/helper.rb', line 32

def project_models
  ActiveRecord::Base.descendants.select do |klass|
    project_klass?(klass) && connected?(klass)
  end
end

.scope_columns(validator, model) ⇒ Object 



105
106
107
108
109
 
# File 'lib/database_consistency/helper.rb', line 105

def scope_columns(validator, model)
  Array.wrap(validator.options[:scope]).map do |scope_item|
    foreign_key_or_attribute(model, scope_item)
  end
end

.sorted_uniqueness_validator_columns(attribute, validator, model) ⇒ Object 



97
98
99
 
# File 'lib/database_consistency/helper.rb', line 97

def sorted_uniqueness_validator_columns(attribute, validator, model)
  uniqueness_validator_columns(attribute, validator, model).sort
end

.uniqueness_validator_columns(attribute, validator, model) ⇒ Object 



101
102
103
 
# File 'lib/database_consistency/helper.rb', line 101

def uniqueness_validator_columns(attribute, validator, model)
  ([wrapped_attribute_name(attribute, validator, model)] + scope_columns(validator, model)).map(&:to_s)
end

.wrapped_attribute_name(attribute, validator, model) ⇒ String

Returns:

  • (String) 


116
117
118
119
120
121
122
123
124
 
# File 'lib/database_consistency/helper.rb', line 116

def wrapped_attribute_name(attribute, validator, model)
  attribute = foreign_key_or_attribute(model, attribute)

  if validator.options[:case_sensitive].nil? || validator.options[:case_sensitive]
    attribute
  else
    "lower(#{attribute})"
  end
end