Module: ShouldaMatchmakers::Model::ActiveRecord::ActiveRecordModelSmModelHelper

Included in:
ActiveRecordModelSmModel, FactorySmModel
Defined in:
lib/model/active_record/active_record_model_sm_model_helper.rb

Instance Method Summary collapse

Instance Method Details

#adjust_conditional_test_indentation(conditional_test) ⇒ Object 



173
174
175
176
177
178
179
180
181
182
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 173

def adjust_conditional_test_indentation(conditional_test)
  if conditional_test.include?("\n")
    conditional_test.sub("  it do\n","\n    it do\n").
                     sub("it do\n    ","it do\n      ").
                     gsub(").\n    ",").\n      ").
                     sub("\n  end","\n    end")
  else
    conditional_test.sub("  it {", "\n    it {")
  end
end

#all_option_values_are_symbols(option_values) ⇒ Object 



54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 54

def all_option_values_are_symbols(option_values)
  option_values_are_symbols = true
  if option_values.present?
    option_values.each do |option_value|
      if !option_value.is_a?(Symbol)
        option_values_are_symbols = false
      end
    end
  end
  option_values_are_symbols
end

#append_element(element, element_set) ⇒ Object 



166
167
168
169
170
171
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 166

def append_element(element, element_set)
  if element.present?
    element_set << element
  end
  element_set
end

#apply_option_value_qualifiers(option_value, association_option_string) ⇒ Object 



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 97

def apply_option_value_qualifiers(option_value, association_option_string)
  option_value_refined = option_value
  option_value_qualifiers = association_option_string.scan(/(?: option_value|\.[a-zA-Z0-9_]+)(\.[a-zA-Z0-9_]+)/)
  option_value_qualifiers.each do |option_value_qualifier|
    case option_value_qualifier
      when ".first"
        option_value_refined = option_value_refined.first
      when ".last"
        option_value_refined = option_value_refined.last
      when ".to_s"
        option_value_refined = option_value_refined.to_s
    end
  end
  option_value_refined.to_s
end

#compose_conditional_before_strings(validator_options, conditional_options_permutation) ⇒ Object 



157
158
159
160
161
162
163
164
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 157

def compose_conditional_before_strings(validator_options, conditional_options_permutation)
  conditional_before_strings = ""
  conditional_option_values = validator_options[:if_option_values] + validator_options[:unless_option_values]
  conditional_option_values.each_with_index do |conditional_option_value, cov_index|
    conditional_before_strings.concat("    before { allow(subject).to receive(:#{ conditional_option_value }).and_return(#{ conditional_options_permutation[cov_index] }) }\n")
  end
  conditional_before_strings
end

#compose_conditional_non_validating_context_string(validator_options, non_validating_permutation) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 126

def compose_conditional_non_validating_context_string(validator_options, non_validating_permutation)
  non_validating_context_string = "  context \""
  conditional_option_values = validator_options[:if_option_values] + validator_options[:unless_option_values]
  conditional_option_values.each_with_index do |conditional_option_value, cov_index|
    if cov_index < validator_options[:if_option_values].size
      non_validating_context_string.concat(get_if_context_condition(conditional_option_value, non_validating_permutation[cov_index]))
    else
      non_validating_context_string.concat(get_unless_context_condition(conditional_option_value, non_validating_permutation[cov_index]))
    end
  end
  non_validating_context_string.chomp!(" and ").concat("\" do\n")
end

#compose_conditional_validating_context_string(validator_options) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 113

def compose_conditional_validating_context_string(validator_options)
  validating_context_string = "  context \""
  conditional_option_values = validator_options[:if_option_values] + validator_options[:unless_option_values]
  conditional_option_values.each_with_index do |option_value, cov_index|
    if cov_index < validator_options[:if_option_values].size
      validating_context_string.concat("if #{ option_value.to_s.chomp('?')} and ")
    else
      validating_context_string.concat("unless #{ option_value.to_s.chomp('?')} and ")
    end
  end
  validating_context_string.chomp!(" and ").concat("\" do\n")
end

#compose_extended_model_file_path(app_class_name) ⇒ Object 



9
10
11
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 9

def compose_extended_model_file_path(app_class_name)
  Rails.root.join("app", "models").to_s + "/" + app_class_name.underscore.concat(".rb")
end

#conditional_options_exist(validator_options) ⇒ Object 



20
21
22
23
24
25
26
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 20

def conditional_options_exist(validator_options)
  if validator_options.key?(:if) || validator_options.key?(:unless)
    true
  else
    false
  end
end

#extract_validators(app_class_name, validator_type) ⇒ Object 



13
14
15
16
17
18
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 13

def extract_validators(app_class_name, validator_type)
  extracted_validators = app_class_name.constantize.validators.select do |validator|
                           validator.class.to_s == validator_type.to_s
                         end
  extracted_validators.flatten
end

#format_tests(tests) ⇒ Object 



184
185
186
187
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 184

def format_tests(tests)
  formatted_tests = properly_line_space_tests(tests)
  formatted_tests.flatten.compact.uniq.join("\n")
end

#get_if_context_condition(option_value, permutation_boolean_value_for_option) ⇒ Object 



139
140
141
142
143
144
145
146
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 139

def get_if_context_condition(option_value, permutation_boolean_value_for_option)
  if permutation_boolean_value_for_option
    if_context_condition = "if #{ option_value.to_s.chomp('?')} and "
  else
    if_context_condition = "if not #{ option_value.to_s.chomp('?')} and "
  end
  if_context_condition
end

#get_options_string(options) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 83

def get_options_string(options)
  options_hash = ::ShouldaMatchmakers::Model::ActiveRecord::OptionsDefinition.new.options_hash
  options_string = ""
  options.map do |option_key, option_value|
   if options_hash.key?(option_key)
      option_string = options_hash[option_key].to_s
      option_value_refined = apply_option_value_qualifiers(option_value, option_string)
      option_string = option_string.gsub(/\s*\{\s*/,"").gsub(/\s*\}\s*/,"").gsub(/option_value(?:\.[a-zA-Z0-9_]+)*/, option_value_refined)
      options_string.concat("." + option_string)
    end
  end
  options_string
end

#get_possible_true_false_permutations(validator_options) ⇒ Object 



66
67
68
69
70
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 66

def get_possible_true_false_permutations(validator_options)
  number_of_conditional_option_values = validator_options[:if_option_values].size +
                                          validator_options[:unless_option_values].size
  [true, false].repeated_permutation(number_of_conditional_option_values).to_a
end

#get_unless_context_condition(option_value, permutation_boolean_value_for_option) ⇒ Object 



148
149
150
151
152
153
154
155
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 148

def get_unless_context_condition(option_value, permutation_boolean_value_for_option)
  if permutation_boolean_value_for_option
    unless_context_condition = "if (unless not) #{ option_value.to_s.chomp('?')} and "
  else
    unless_context_condition = "if not (unless) #{ option_value.to_s.chomp('?')} and "
  end
  unless_context_condition
end

#get_validating_true_false_permutation(validator_options) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 72

def get_validating_true_false_permutation(validator_options)
  validating_permutation = []
  validator_options[:if_option_values].size.times do |n|
    validating_permutation << true
  end
  validator_options[:unless_option_values].size.times do |n|
    validating_permutation << false
  end
  validating_permutation
end

#order_options(options) ⇒ Object 



45
46
47
48
49
50
51
52
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 45

def order_options(options)
  options_unordered = options.dup
  options_ordered = {}
  options_ordered = options_ordered.merge({ :in=>options_unordered.delete(:in) }) if options_unordered.include?(:in)
  options_ordered = options_ordered.merge({ :minimum=>options_unordered.delete(:minimum) }) if options_unordered.include?(:minimum)
  options_ordered = options_ordered.merge({ :maximum=>options_unordered.delete(:maximum) }) if options_unordered.include?(:maximum)
  options_ordered.merge(options_unordered)
end

#parse_validator_options(validator_options) ⇒ Object 



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 28

def parse_validator_options(validator_options)
  non_conditional_options = validator_options
  if validator_options.key?(:if)
    if_option_values = non_conditional_options.delete(:if)
    if_option_values = [if_option_values] if !if_option_values.is_a?(Array)
  else
    if_option_values = []
  end
  if validator_options.key?(:unless)
    unless_option_values = non_conditional_options.delete(:unless)
    unless_option_values = [unless_option_values] if !unless_option_values.is_a?(Array)
  else
    unless_option_values = []
  end
  { non_conditional_options: non_conditional_options, if_option_values: if_option_values, unless_option_values: unless_option_values }
end

#properly_line_space_tests(tests) ⇒ Object 



189
190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'lib/model/active_record/active_record_model_sm_model_helper.rb', line 189

def properly_line_space_tests(tests)
  tests_properly_line_spaced = []
  previous_test = ""
  tests.each do |test|
    if (test.include?("\n") && previous_test.present?) ||
         (!test.include?("\n") && previous_test.include?("\n"))
      test = "\n" + test
    end
    tests_properly_line_spaced << test
    previous_test = test
  end
  tests_properly_line_spaced
end