Module: Shoulda::Matchers::RailsShim

Defined in:
lib/shoulda/matchers/rails_shim.rb

Defined Under Namespace

Classes: FakeAttributeType

Class Method Summary collapse

Class Method Details

.action_pack_version ⇒ Object 



6
7
8
9
10
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 6

def action_pack_version
  Gem::Version.new(::ActionPack::VERSION::STRING)
rescue NameError
  Gem::Version.new('0')
end

.active_record_gte_6? ⇒ Boolean

Returns:

  • (Boolean) 


12
13
14
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 12

def active_record_gte_6?
  Gem::Requirement.new('>= 6').satisfied_by?(active_record_version)
end

.active_record_version ⇒ Object 



16
17
18
19
20
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 16

def active_record_version
  Gem::Version.new(::ActiveRecord::VERSION::STRING)
rescue NameError
  Gem::Version.new('0')
end

.attribute_serialization_coder_for(model, attribute_name) ⇒ Object 



61
62
63
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 61

def attribute_serialization_coder_for(model, attribute_name)
  serialized_attributes_for(model)[attribute_name.to_s]
end

.attribute_type_for(model, attribute_name) ⇒ Object 



120
121
122
123
124
125
126
127
128
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 120

def attribute_type_for(model, attribute_name)
  attribute_types_for(model)[attribute_name.to_s]
rescue NotImplementedError
  if model.respond_to?(:type_for_attribute)
    model.type_for_attribute(attribute_name)
  else
    FakeAttributeType.new(model, attribute_name)
  end
end

.attribute_types_for(model) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 106

def attribute_types_for(model)
  if model.respond_to?(:attribute_types)
    model.attribute_types
  elsif model.respond_to?(:type_for_attribute)
    model.columns.inject({}) do |hash, column|
      key = column.name.to_s
      value = model.type_for_attribute(column.name)
      hash.merge(key => value)
    end
  else
    raise NotImplementedError
  end
end

.digestible_attributes_in(record) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 86

def digestible_attributes_in(record)
  record.methods.inject([]) do |array, method_name|
    match = method_name.to_s.match(
      /\A(\w+)_(?:confirmation|digest)=\Z/,
    )

    if match
      array.concat([match[1].to_sym])
    else
      array
    end
  end
end

.generate_validation_message(record, attribute, type, model_name, options) ⇒ Object 



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 22

def generate_validation_message(
  record,
  attribute,
  type,
  model_name,
  options
)
  if record && record.errors.respond_to?(:generate_message)
    record.errors.generate_message(attribute.to_sym, type, options)
  else
    simply_generate_validation_message(
      attribute,
      type,
      model_name,
      options,
    )
  end
rescue RangeError
  simply_generate_validation_message(
    attribute,
    type,
    model_name,
    options,
  )
end

.has_secure_password?(record, attribute_name) ⇒ Boolean

Returns:

  • (Boolean) 


77
78
79
80
81
82
83
84
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 77

def has_secure_password?(record, attribute_name)
  if secure_password_module
    attribute_name == :password &&
      record.class.ancestors.include?(secure_password_module)
  else
    record.respond_to?("authenticate_#{attribute_name}")
  end
end

.parent_of(mod) ⇒ Object 



69
70
71
72
73
74
75
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 69

def parent_of(mod)
  if mod.respond_to?(:module_parent)
    mod.module_parent
  else
    mod.parent
  end
end

.secure_password_module ⇒ Object 



100
101
102
103
104
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 100

def secure_password_module
  ::ActiveModel::SecurePassword::InstanceMethodsOnActivation
rescue NameError
  nil
end

.serialized_attributes_for(model) ⇒ Object 



48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 48

def serialized_attributes_for(model)
  attribute_types_for(model).
    inject({}) do |hash, (attribute_name, attribute_type)|
      if attribute_type.is_a?(::ActiveRecord::Type::Serialized)
        hash.merge(attribute_name => attribute_type.coder)
      else
        hash
      end
    end
rescue NotImplementedError
  {}
end

.supports_full_attributes_api?(model) ⇒ Boolean

Returns:

  • (Boolean) 


130
131
132
133
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 130

def supports_full_attributes_api?(model)
  defined?(::ActiveModel::Attributes) &&
    model.respond_to?(:attribute_types)
end

.verb_for_update ⇒ Object 



65
66
67
 
# File 'lib/shoulda/matchers/rails_shim.rb', line 65

def verb_for_update
  :patch
end