activerecord 6.0.1

Sign up to get free protection for your applications and to get access to all the features.

Potentially problematic release.


This version of activerecord might be problematic. Click here for more details.

Files changed (340) hide show
  1. checksums.yaml +7 -0
  2. data/CHANGELOG.md +1086 -0
  3. data/MIT-LICENSE +22 -0
  4. data/README.rdoc +219 -0
  5. data/examples/performance.rb +185 -0
  6. data/examples/simple.rb +15 -0
  7. data/lib/active_record.rb +195 -0
  8. data/lib/active_record/aggregations.rb +285 -0
  9. data/lib/active_record/association_relation.rb +49 -0
  10. data/lib/active_record/associations.rb +1865 -0
  11. data/lib/active_record/associations/alias_tracker.rb +81 -0
  12. data/lib/active_record/associations/association.rb +340 -0
  13. data/lib/active_record/associations/association_scope.rb +166 -0
  14. data/lib/active_record/associations/belongs_to_association.rb +124 -0
  15. data/lib/active_record/associations/belongs_to_polymorphic_association.rb +36 -0
  16. data/lib/active_record/associations/builder/association.rb +136 -0
  17. data/lib/active_record/associations/builder/belongs_to.rb +130 -0
  18. data/lib/active_record/associations/builder/collection_association.rb +72 -0
  19. data/lib/active_record/associations/builder/has_and_belongs_to_many.rb +114 -0
  20. data/lib/active_record/associations/builder/has_many.rb +19 -0
  21. data/lib/active_record/associations/builder/has_one.rb +64 -0
  22. data/lib/active_record/associations/builder/singular_association.rb +44 -0
  23. data/lib/active_record/associations/collection_association.rb +498 -0
  24. data/lib/active_record/associations/collection_proxy.rb +1128 -0
  25. data/lib/active_record/associations/foreign_association.rb +20 -0
  26. data/lib/active_record/associations/has_many_association.rb +136 -0
  27. data/lib/active_record/associations/has_many_through_association.rb +220 -0
  28. data/lib/active_record/associations/has_one_association.rb +118 -0
  29. data/lib/active_record/associations/has_one_through_association.rb +45 -0
  30. data/lib/active_record/associations/join_dependency.rb +262 -0
  31. data/lib/active_record/associations/join_dependency/join_association.rb +80 -0
  32. data/lib/active_record/associations/join_dependency/join_base.rb +23 -0
  33. data/lib/active_record/associations/join_dependency/join_part.rb +71 -0
  34. data/lib/active_record/associations/preloader.rb +201 -0
  35. data/lib/active_record/associations/preloader/association.rb +133 -0
  36. data/lib/active_record/associations/preloader/through_association.rb +116 -0
  37. data/lib/active_record/associations/singular_association.rb +59 -0
  38. data/lib/active_record/associations/through_association.rb +121 -0
  39. data/lib/active_record/attribute_assignment.rb +85 -0
  40. data/lib/active_record/attribute_decorators.rb +90 -0
  41. data/lib/active_record/attribute_methods.rb +420 -0
  42. data/lib/active_record/attribute_methods/before_type_cast.rb +81 -0
  43. data/lib/active_record/attribute_methods/dirty.rb +221 -0
  44. data/lib/active_record/attribute_methods/primary_key.rb +136 -0
  45. data/lib/active_record/attribute_methods/query.rb +41 -0
  46. data/lib/active_record/attribute_methods/read.rb +47 -0
  47. data/lib/active_record/attribute_methods/serialization.rb +90 -0
  48. data/lib/active_record/attribute_methods/time_zone_conversion.rb +91 -0
  49. data/lib/active_record/attribute_methods/write.rb +61 -0
  50. data/lib/active_record/attributes.rb +279 -0
  51. data/lib/active_record/autosave_association.rb +512 -0
  52. data/lib/active_record/base.rb +328 -0
  53. data/lib/active_record/callbacks.rb +339 -0
  54. data/lib/active_record/coders/json.rb +15 -0
  55. data/lib/active_record/coders/yaml_column.rb +50 -0
  56. data/lib/active_record/connection_adapters/abstract/connection_pool.rb +1175 -0
  57. data/lib/active_record/connection_adapters/abstract/database_limits.rb +85 -0
  58. data/lib/active_record/connection_adapters/abstract/database_statements.rb +516 -0
  59. data/lib/active_record/connection_adapters/abstract/query_cache.rb +155 -0
  60. data/lib/active_record/connection_adapters/abstract/quoting.rb +251 -0
  61. data/lib/active_record/connection_adapters/abstract/savepoints.rb +23 -0
  62. data/lib/active_record/connection_adapters/abstract/schema_creation.rb +153 -0
  63. data/lib/active_record/connection_adapters/abstract/schema_definitions.rb +713 -0
  64. data/lib/active_record/connection_adapters/abstract/schema_dumper.rb +93 -0
  65. data/lib/active_record/connection_adapters/abstract/schema_statements.rb +1475 -0
  66. data/lib/active_record/connection_adapters/abstract/transaction.rb +323 -0
  67. data/lib/active_record/connection_adapters/abstract_adapter.rb +772 -0
  68. data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb +830 -0
  69. data/lib/active_record/connection_adapters/column.rb +95 -0
  70. data/lib/active_record/connection_adapters/connection_specification.rb +297 -0
  71. data/lib/active_record/connection_adapters/determine_if_preparable_visitor.rb +29 -0
  72. data/lib/active_record/connection_adapters/mysql/column.rb +27 -0
  73. data/lib/active_record/connection_adapters/mysql/database_statements.rb +202 -0
  74. data/lib/active_record/connection_adapters/mysql/explain_pretty_printer.rb +72 -0
  75. data/lib/active_record/connection_adapters/mysql/quoting.rb +81 -0
  76. data/lib/active_record/connection_adapters/mysql/schema_creation.rb +72 -0
  77. data/lib/active_record/connection_adapters/mysql/schema_definitions.rb +95 -0
  78. data/lib/active_record/connection_adapters/mysql/schema_dumper.rb +88 -0
  79. data/lib/active_record/connection_adapters/mysql/schema_statements.rb +264 -0
  80. data/lib/active_record/connection_adapters/mysql/type_metadata.rb +31 -0
  81. data/lib/active_record/connection_adapters/mysql2_adapter.rb +146 -0
  82. data/lib/active_record/connection_adapters/postgresql/column.rb +30 -0
  83. data/lib/active_record/connection_adapters/postgresql/database_statements.rb +184 -0
  84. data/lib/active_record/connection_adapters/postgresql/explain_pretty_printer.rb +44 -0
  85. data/lib/active_record/connection_adapters/postgresql/oid.rb +34 -0
  86. data/lib/active_record/connection_adapters/postgresql/oid/array.rb +92 -0
  87. data/lib/active_record/connection_adapters/postgresql/oid/bit.rb +53 -0
  88. data/lib/active_record/connection_adapters/postgresql/oid/bit_varying.rb +15 -0
  89. data/lib/active_record/connection_adapters/postgresql/oid/bytea.rb +17 -0
  90. data/lib/active_record/connection_adapters/postgresql/oid/cidr.rb +50 -0
  91. data/lib/active_record/connection_adapters/postgresql/oid/date.rb +23 -0
  92. data/lib/active_record/connection_adapters/postgresql/oid/date_time.rb +23 -0
  93. data/lib/active_record/connection_adapters/postgresql/oid/decimal.rb +15 -0
  94. data/lib/active_record/connection_adapters/postgresql/oid/enum.rb +21 -0
  95. data/lib/active_record/connection_adapters/postgresql/oid/hstore.rb +71 -0
  96. data/lib/active_record/connection_adapters/postgresql/oid/inet.rb +15 -0
  97. data/lib/active_record/connection_adapters/postgresql/oid/jsonb.rb +15 -0
  98. data/lib/active_record/connection_adapters/postgresql/oid/legacy_point.rb +45 -0
  99. data/lib/active_record/connection_adapters/postgresql/oid/money.rb +41 -0
  100. data/lib/active_record/connection_adapters/postgresql/oid/oid.rb +15 -0
  101. data/lib/active_record/connection_adapters/postgresql/oid/point.rb +65 -0
  102. data/lib/active_record/connection_adapters/postgresql/oid/range.rb +97 -0
  103. data/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb +18 -0
  104. data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb +113 -0
  105. data/lib/active_record/connection_adapters/postgresql/oid/uuid.rb +26 -0
  106. data/lib/active_record/connection_adapters/postgresql/oid/vector.rb +28 -0
  107. data/lib/active_record/connection_adapters/postgresql/oid/xml.rb +30 -0
  108. data/lib/active_record/connection_adapters/postgresql/quoting.rb +205 -0
  109. data/lib/active_record/connection_adapters/postgresql/referential_integrity.rb +43 -0
  110. data/lib/active_record/connection_adapters/postgresql/schema_creation.rb +76 -0
  111. data/lib/active_record/connection_adapters/postgresql/schema_definitions.rb +222 -0
  112. data/lib/active_record/connection_adapters/postgresql/schema_dumper.rb +50 -0
  113. data/lib/active_record/connection_adapters/postgresql/schema_statements.rb +776 -0
  114. data/lib/active_record/connection_adapters/postgresql/type_metadata.rb +36 -0
  115. data/lib/active_record/connection_adapters/postgresql/utils.rb +81 -0
  116. data/lib/active_record/connection_adapters/postgresql_adapter.rb +953 -0
  117. data/lib/active_record/connection_adapters/schema_cache.rb +141 -0
  118. data/lib/active_record/connection_adapters/sql_type_metadata.rb +37 -0
  119. data/lib/active_record/connection_adapters/sqlite3/database_statements.rb +120 -0
  120. data/lib/active_record/connection_adapters/sqlite3/explain_pretty_printer.rb +21 -0
  121. data/lib/active_record/connection_adapters/sqlite3/quoting.rb +103 -0
  122. data/lib/active_record/connection_adapters/sqlite3/schema_creation.rb +17 -0
  123. data/lib/active_record/connection_adapters/sqlite3/schema_definitions.rb +19 -0
  124. data/lib/active_record/connection_adapters/sqlite3/schema_dumper.rb +18 -0
  125. data/lib/active_record/connection_adapters/sqlite3/schema_statements.rb +137 -0
  126. data/lib/active_record/connection_adapters/sqlite3_adapter.rb +561 -0
  127. data/lib/active_record/connection_adapters/statement_pool.rb +61 -0
  128. data/lib/active_record/connection_handling.rb +274 -0
  129. data/lib/active_record/core.rb +603 -0
  130. data/lib/active_record/counter_cache.rb +193 -0
  131. data/lib/active_record/database_configurations.rb +233 -0
  132. data/lib/active_record/database_configurations/database_config.rb +37 -0
  133. data/lib/active_record/database_configurations/hash_config.rb +50 -0
  134. data/lib/active_record/database_configurations/url_config.rb +79 -0
  135. data/lib/active_record/define_callbacks.rb +22 -0
  136. data/lib/active_record/dynamic_matchers.rb +122 -0
  137. data/lib/active_record/enum.rb +274 -0
  138. data/lib/active_record/errors.rb +388 -0
  139. data/lib/active_record/explain.rb +50 -0
  140. data/lib/active_record/explain_registry.rb +32 -0
  141. data/lib/active_record/explain_subscriber.rb +34 -0
  142. data/lib/active_record/fixture_set/file.rb +82 -0
  143. data/lib/active_record/fixture_set/model_metadata.rb +33 -0
  144. data/lib/active_record/fixture_set/render_context.rb +17 -0
  145. data/lib/active_record/fixture_set/table_row.rb +153 -0
  146. data/lib/active_record/fixture_set/table_rows.rb +47 -0
  147. data/lib/active_record/fixtures.rb +738 -0
  148. data/lib/active_record/gem_version.rb +17 -0
  149. data/lib/active_record/inheritance.rb +293 -0
  150. data/lib/active_record/insert_all.rb +179 -0
  151. data/lib/active_record/integration.rb +207 -0
  152. data/lib/active_record/internal_metadata.rb +53 -0
  153. data/lib/active_record/legacy_yaml_adapter.rb +48 -0
  154. data/lib/active_record/locale/en.yml +48 -0
  155. data/lib/active_record/locking/optimistic.rb +197 -0
  156. data/lib/active_record/locking/pessimistic.rb +89 -0
  157. data/lib/active_record/log_subscriber.rb +118 -0
  158. data/lib/active_record/middleware/database_selector.rb +75 -0
  159. data/lib/active_record/middleware/database_selector/resolver.rb +88 -0
  160. data/lib/active_record/middleware/database_selector/resolver/session.rb +45 -0
  161. data/lib/active_record/migration.rb +1397 -0
  162. data/lib/active_record/migration/command_recorder.rb +284 -0
  163. data/lib/active_record/migration/compatibility.rb +244 -0
  164. data/lib/active_record/migration/join_table.rb +17 -0
  165. data/lib/active_record/model_schema.rb +545 -0
  166. data/lib/active_record/nested_attributes.rb +600 -0
  167. data/lib/active_record/no_touching.rb +65 -0
  168. data/lib/active_record/null_relation.rb +68 -0
  169. data/lib/active_record/persistence.rb +967 -0
  170. data/lib/active_record/query_cache.rb +52 -0
  171. data/lib/active_record/querying.rb +82 -0
  172. data/lib/active_record/railtie.rb +263 -0
  173. data/lib/active_record/railties/collection_cache_association_loading.rb +34 -0
  174. data/lib/active_record/railties/console_sandbox.rb +7 -0
  175. data/lib/active_record/railties/controller_runtime.rb +51 -0
  176. data/lib/active_record/railties/databases.rake +527 -0
  177. data/lib/active_record/readonly_attributes.rb +24 -0
  178. data/lib/active_record/reflection.rb +1042 -0
  179. data/lib/active_record/relation.rb +860 -0
  180. data/lib/active_record/relation/batches.rb +290 -0
  181. data/lib/active_record/relation/batches/batch_enumerator.rb +69 -0
  182. data/lib/active_record/relation/calculations.rb +424 -0
  183. data/lib/active_record/relation/delegation.rb +130 -0
  184. data/lib/active_record/relation/finder_methods.rb +561 -0
  185. data/lib/active_record/relation/from_clause.rb +26 -0
  186. data/lib/active_record/relation/merger.rb +184 -0
  187. data/lib/active_record/relation/predicate_builder.rb +150 -0
  188. data/lib/active_record/relation/predicate_builder/array_handler.rb +49 -0
  189. data/lib/active_record/relation/predicate_builder/association_query_value.rb +43 -0
  190. data/lib/active_record/relation/predicate_builder/base_handler.rb +18 -0
  191. data/lib/active_record/relation/predicate_builder/basic_object_handler.rb +19 -0
  192. data/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb +53 -0
  193. data/lib/active_record/relation/predicate_builder/range_handler.rb +22 -0
  194. data/lib/active_record/relation/predicate_builder/relation_handler.rb +19 -0
  195. data/lib/active_record/relation/query_attribute.rb +50 -0
  196. data/lib/active_record/relation/query_methods.rb +1371 -0
  197. data/lib/active_record/relation/record_fetch_warning.rb +51 -0
  198. data/lib/active_record/relation/spawn_methods.rb +77 -0
  199. data/lib/active_record/relation/where_clause.rb +190 -0
  200. data/lib/active_record/relation/where_clause_factory.rb +33 -0
  201. data/lib/active_record/result.rb +168 -0
  202. data/lib/active_record/runtime_registry.rb +24 -0
  203. data/lib/active_record/sanitization.rb +214 -0
  204. data/lib/active_record/schema.rb +61 -0
  205. data/lib/active_record/schema_dumper.rb +270 -0
  206. data/lib/active_record/schema_migration.rb +60 -0
  207. data/lib/active_record/scoping.rb +106 -0
  208. data/lib/active_record/scoping/default.rb +151 -0
  209. data/lib/active_record/scoping/named.rb +217 -0
  210. data/lib/active_record/secure_token.rb +40 -0
  211. data/lib/active_record/serialization.rb +22 -0
  212. data/lib/active_record/statement_cache.rb +148 -0
  213. data/lib/active_record/store.rb +290 -0
  214. data/lib/active_record/suppressor.rb +61 -0
  215. data/lib/active_record/table_metadata.rb +75 -0
  216. data/lib/active_record/tasks/database_tasks.rb +506 -0
  217. data/lib/active_record/tasks/mysql_database_tasks.rb +115 -0
  218. data/lib/active_record/tasks/postgresql_database_tasks.rb +141 -0
  219. data/lib/active_record/tasks/sqlite_database_tasks.rb +77 -0
  220. data/lib/active_record/test_databases.rb +23 -0
  221. data/lib/active_record/test_fixtures.rb +224 -0
  222. data/lib/active_record/timestamp.rb +167 -0
  223. data/lib/active_record/touch_later.rb +66 -0
  224. data/lib/active_record/transactions.rb +493 -0
  225. data/lib/active_record/translation.rb +24 -0
  226. data/lib/active_record/type.rb +78 -0
  227. data/lib/active_record/type/adapter_specific_registry.rb +129 -0
  228. data/lib/active_record/type/date.rb +9 -0
  229. data/lib/active_record/type/date_time.rb +9 -0
  230. data/lib/active_record/type/decimal_without_scale.rb +15 -0
  231. data/lib/active_record/type/hash_lookup_type_map.rb +25 -0
  232. data/lib/active_record/type/internal/timezone.rb +17 -0
  233. data/lib/active_record/type/json.rb +30 -0
  234. data/lib/active_record/type/serialized.rb +71 -0
  235. data/lib/active_record/type/text.rb +11 -0
  236. data/lib/active_record/type/time.rb +21 -0
  237. data/lib/active_record/type/type_map.rb +62 -0
  238. data/lib/active_record/type/unsigned_integer.rb +17 -0
  239. data/lib/active_record/type_caster.rb +9 -0
  240. data/lib/active_record/type_caster/connection.rb +34 -0
  241. data/lib/active_record/type_caster/map.rb +20 -0
  242. data/lib/active_record/validations.rb +94 -0
  243. data/lib/active_record/validations/absence.rb +25 -0
  244. data/lib/active_record/validations/associated.rb +60 -0
  245. data/lib/active_record/validations/length.rb +26 -0
  246. data/lib/active_record/validations/presence.rb +68 -0
  247. data/lib/active_record/validations/uniqueness.rb +226 -0
  248. data/lib/active_record/version.rb +10 -0
  249. data/lib/arel.rb +58 -0
  250. data/lib/arel/alias_predication.rb +9 -0
  251. data/lib/arel/attributes.rb +22 -0
  252. data/lib/arel/attributes/attribute.rb +37 -0
  253. data/lib/arel/collectors/bind.rb +24 -0
  254. data/lib/arel/collectors/composite.rb +31 -0
  255. data/lib/arel/collectors/plain_string.rb +20 -0
  256. data/lib/arel/collectors/sql_string.rb +20 -0
  257. data/lib/arel/collectors/substitute_binds.rb +28 -0
  258. data/lib/arel/crud.rb +42 -0
  259. data/lib/arel/delete_manager.rb +18 -0
  260. data/lib/arel/errors.rb +9 -0
  261. data/lib/arel/expressions.rb +29 -0
  262. data/lib/arel/factory_methods.rb +49 -0
  263. data/lib/arel/insert_manager.rb +49 -0
  264. data/lib/arel/math.rb +45 -0
  265. data/lib/arel/nodes.rb +68 -0
  266. data/lib/arel/nodes/and.rb +32 -0
  267. data/lib/arel/nodes/ascending.rb +23 -0
  268. data/lib/arel/nodes/binary.rb +52 -0
  269. data/lib/arel/nodes/bind_param.rb +36 -0
  270. data/lib/arel/nodes/case.rb +55 -0
  271. data/lib/arel/nodes/casted.rb +50 -0
  272. data/lib/arel/nodes/comment.rb +29 -0
  273. data/lib/arel/nodes/count.rb +12 -0
  274. data/lib/arel/nodes/delete_statement.rb +45 -0
  275. data/lib/arel/nodes/descending.rb +23 -0
  276. data/lib/arel/nodes/equality.rb +18 -0
  277. data/lib/arel/nodes/extract.rb +24 -0
  278. data/lib/arel/nodes/false.rb +16 -0
  279. data/lib/arel/nodes/full_outer_join.rb +8 -0
  280. data/lib/arel/nodes/function.rb +44 -0
  281. data/lib/arel/nodes/grouping.rb +8 -0
  282. data/lib/arel/nodes/in.rb +8 -0
  283. data/lib/arel/nodes/infix_operation.rb +80 -0
  284. data/lib/arel/nodes/inner_join.rb +8 -0
  285. data/lib/arel/nodes/insert_statement.rb +37 -0
  286. data/lib/arel/nodes/join_source.rb +20 -0
  287. data/lib/arel/nodes/matches.rb +18 -0
  288. data/lib/arel/nodes/named_function.rb +23 -0
  289. data/lib/arel/nodes/node.rb +50 -0
  290. data/lib/arel/nodes/node_expression.rb +13 -0
  291. data/lib/arel/nodes/outer_join.rb +8 -0
  292. data/lib/arel/nodes/over.rb +15 -0
  293. data/lib/arel/nodes/regexp.rb +16 -0
  294. data/lib/arel/nodes/right_outer_join.rb +8 -0
  295. data/lib/arel/nodes/select_core.rb +67 -0
  296. data/lib/arel/nodes/select_statement.rb +41 -0
  297. data/lib/arel/nodes/sql_literal.rb +16 -0
  298. data/lib/arel/nodes/string_join.rb +11 -0
  299. data/lib/arel/nodes/table_alias.rb +27 -0
  300. data/lib/arel/nodes/terminal.rb +16 -0
  301. data/lib/arel/nodes/true.rb +16 -0
  302. data/lib/arel/nodes/unary.rb +45 -0
  303. data/lib/arel/nodes/unary_operation.rb +20 -0
  304. data/lib/arel/nodes/unqualified_column.rb +22 -0
  305. data/lib/arel/nodes/update_statement.rb +41 -0
  306. data/lib/arel/nodes/values_list.rb +9 -0
  307. data/lib/arel/nodes/window.rb +126 -0
  308. data/lib/arel/nodes/with.rb +11 -0
  309. data/lib/arel/order_predications.rb +13 -0
  310. data/lib/arel/predications.rb +257 -0
  311. data/lib/arel/select_manager.rb +271 -0
  312. data/lib/arel/table.rb +110 -0
  313. data/lib/arel/tree_manager.rb +72 -0
  314. data/lib/arel/update_manager.rb +34 -0
  315. data/lib/arel/visitors.rb +20 -0
  316. data/lib/arel/visitors/depth_first.rb +204 -0
  317. data/lib/arel/visitors/dot.rb +297 -0
  318. data/lib/arel/visitors/ibm_db.rb +34 -0
  319. data/lib/arel/visitors/informix.rb +62 -0
  320. data/lib/arel/visitors/mssql.rb +157 -0
  321. data/lib/arel/visitors/mysql.rb +83 -0
  322. data/lib/arel/visitors/oracle.rb +159 -0
  323. data/lib/arel/visitors/oracle12.rb +66 -0
  324. data/lib/arel/visitors/postgresql.rb +110 -0
  325. data/lib/arel/visitors/sqlite.rb +39 -0
  326. data/lib/arel/visitors/to_sql.rb +889 -0
  327. data/lib/arel/visitors/visitor.rb +46 -0
  328. data/lib/arel/visitors/where_sql.rb +23 -0
  329. data/lib/arel/window_predications.rb +9 -0
  330. data/lib/rails/generators/active_record.rb +19 -0
  331. data/lib/rails/generators/active_record/application_record/application_record_generator.rb +27 -0
  332. data/lib/rails/generators/active_record/application_record/templates/application_record.rb.tt +5 -0
  333. data/lib/rails/generators/active_record/migration.rb +48 -0
  334. data/lib/rails/generators/active_record/migration/migration_generator.rb +75 -0
  335. data/lib/rails/generators/active_record/migration/templates/create_table_migration.rb.tt +24 -0
  336. data/lib/rails/generators/active_record/migration/templates/migration.rb.tt +48 -0
  337. data/lib/rails/generators/active_record/model/model_generator.rb +49 -0
  338. data/lib/rails/generators/active_record/model/templates/model.rb.tt +22 -0
  339. data/lib/rails/generators/active_record/model/templates/module.rb.tt +7 -0
  340. metadata +418 -0
@@ -0,0 +1,285 @@
1
+ # frozen_string_literal: true
2
+
3
+ module ActiveRecord
4
+ # See ActiveRecord::Aggregations::ClassMethods for documentation
5
+ module Aggregations
6
+ def initialize_dup(*) # :nodoc:
7
+ @aggregation_cache = {}
8
+ super
9
+ end
10
+
11
+ def reload(*) # :nodoc:
12
+ clear_aggregation_cache
13
+ super
14
+ end
15
+
16
+ private
17
+
18
+ def clear_aggregation_cache
19
+ @aggregation_cache.clear if persisted?
20
+ end
21
+
22
+ def init_internals
23
+ @aggregation_cache = {}
24
+ super
25
+ end
26
+
27
+ # Active Record implements aggregation through a macro-like class method called #composed_of
28
+ # for representing attributes as value objects. It expresses relationships like "Account [is]
29
+ # composed of Money [among other things]" or "Person [is] composed of [an] address". Each call
30
+ # to the macro adds a description of how the value objects are created from the attributes of
31
+ # the entity object (when the entity is initialized either as a new object or from finding an
32
+ # existing object) and how it can be turned back into attributes (when the entity is saved to
33
+ # the database).
34
+ #
35
+ # class Customer < ActiveRecord::Base
36
+ # composed_of :balance, class_name: "Money", mapping: %w(balance amount)
37
+ # composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
38
+ # end
39
+ #
40
+ # The customer class now has the following methods to manipulate the value objects:
41
+ # * <tt>Customer#balance, Customer#balance=(money)</tt>
42
+ # * <tt>Customer#address, Customer#address=(address)</tt>
43
+ #
44
+ # These methods will operate with value objects like the ones described below:
45
+ #
46
+ # class Money
47
+ # include Comparable
48
+ # attr_reader :amount, :currency
49
+ # EXCHANGE_RATES = { "USD_TO_DKK" => 6 }
50
+ #
51
+ # def initialize(amount, currency = "USD")
52
+ # @amount, @currency = amount, currency
53
+ # end
54
+ #
55
+ # def exchange_to(other_currency)
56
+ # exchanged_amount = (amount * EXCHANGE_RATES["#{currency}_TO_#{other_currency}"]).floor
57
+ # Money.new(exchanged_amount, other_currency)
58
+ # end
59
+ #
60
+ # def ==(other_money)
61
+ # amount == other_money.amount && currency == other_money.currency
62
+ # end
63
+ #
64
+ # def <=>(other_money)
65
+ # if currency == other_money.currency
66
+ # amount <=> other_money.amount
67
+ # else
68
+ # amount <=> other_money.exchange_to(currency).amount
69
+ # end
70
+ # end
71
+ # end
72
+ #
73
+ # class Address
74
+ # attr_reader :street, :city
75
+ # def initialize(street, city)
76
+ # @street, @city = street, city
77
+ # end
78
+ #
79
+ # def close_to?(other_address)
80
+ # city == other_address.city
81
+ # end
82
+ #
83
+ # def ==(other_address)
84
+ # city == other_address.city && street == other_address.street
85
+ # end
86
+ # end
87
+ #
88
+ # Now it's possible to access attributes from the database through the value objects instead. If
89
+ # you choose to name the composition the same as the attribute's name, it will be the only way to
90
+ # access that attribute. That's the case with our +balance+ attribute. You interact with the value
91
+ # objects just like you would with any other attribute:
92
+ #
93
+ # customer.balance = Money.new(20) # sets the Money value object and the attribute
94
+ # customer.balance # => Money value object
95
+ # customer.balance.exchange_to("DKK") # => Money.new(120, "DKK")
96
+ # customer.balance > Money.new(10) # => true
97
+ # customer.balance == Money.new(20) # => true
98
+ # customer.balance < Money.new(5) # => false
99
+ #
100
+ # Value objects can also be composed of multiple attributes, such as the case of Address. The order
101
+ # of the mappings will determine the order of the parameters.
102
+ #
103
+ # customer.address_street = "Hyancintvej"
104
+ # customer.address_city = "Copenhagen"
105
+ # customer.address # => Address.new("Hyancintvej", "Copenhagen")
106
+ #
107
+ # customer.address = Address.new("May Street", "Chicago")
108
+ # customer.address_street # => "May Street"
109
+ # customer.address_city # => "Chicago"
110
+ #
111
+ # == Writing value objects
112
+ #
113
+ # Value objects are immutable and interchangeable objects that represent a given value, such as
114
+ # a Money object representing $5. Two Money objects both representing $5 should be equal (through
115
+ # methods such as <tt>==</tt> and <tt><=></tt> from Comparable if ranking makes sense). This is
116
+ # unlike entity objects where equality is determined by identity. An entity class such as Customer can
117
+ # easily have two different objects that both have an address on Hyancintvej. Entity identity is
118
+ # determined by object or relational unique identifiers (such as primary keys). Normal
119
+ # ActiveRecord::Base classes are entity objects.
120
+ #
121
+ # It's also important to treat the value objects as immutable. Don't allow the Money object to have
122
+ # its amount changed after creation. Create a new Money object with the new value instead. The
123
+ # <tt>Money#exchange_to</tt> method is an example of this. It returns a new value object instead of changing
124
+ # its own values. Active Record won't persist value objects that have been changed through means
125
+ # other than the writer method.
126
+ #
127
+ # The immutable requirement is enforced by Active Record by freezing any object assigned as a value
128
+ # object. Attempting to change it afterwards will result in a +RuntimeError+.
129
+ #
130
+ # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not
131
+ # keeping value objects immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
132
+ #
133
+ # == Custom constructors and converters
134
+ #
135
+ # By default value objects are initialized by calling the <tt>new</tt> constructor of the value
136
+ # class passing each of the mapped attributes, in the order specified by the <tt>:mapping</tt>
137
+ # option, as arguments. If the value class doesn't support this convention then #composed_of allows
138
+ # a custom constructor to be specified.
139
+ #
140
+ # When a new value is assigned to the value object, the default assumption is that the new value
141
+ # is an instance of the value class. Specifying a custom converter allows the new value to be automatically
142
+ # converted to an instance of value class if necessary.
143
+ #
144
+ # For example, the +NetworkResource+ model has +network_address+ and +cidr_range+ attributes that should be
145
+ # aggregated using the +NetAddr::CIDR+ value class (http://www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR).
146
+ # The constructor for the value class is called +create+ and it expects a CIDR address string as a parameter.
147
+ # New values can be assigned to the value object using either another +NetAddr::CIDR+ object, a string
148
+ # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
149
+ # these requirements:
150
+ #
151
+ # class NetworkResource < ActiveRecord::Base
152
+ # composed_of :cidr,
153
+ # class_name: 'NetAddr::CIDR',
154
+ # mapping: [ %w(network_address network), %w(cidr_range bits) ],
155
+ # allow_nil: true,
156
+ # constructor: Proc.new { |network_address, cidr_range| NetAddr::CIDR.create("#{network_address}/#{cidr_range}") },
157
+ # converter: Proc.new { |value| NetAddr::CIDR.create(value.is_a?(Array) ? value.join('/') : value) }
158
+ # end
159
+ #
160
+ # # This calls the :constructor
161
+ # network_resource = NetworkResource.new(network_address: '192.168.0.1', cidr_range: 24)
162
+ #
163
+ # # These assignments will both use the :converter
164
+ # network_resource.cidr = [ '192.168.2.1', 8 ]
165
+ # network_resource.cidr = '192.168.0.1/24'
166
+ #
167
+ # # This assignment won't use the :converter as the value is already an instance of the value class
168
+ # network_resource.cidr = NetAddr::CIDR.create('192.168.2.1/8')
169
+ #
170
+ # # Saving and then reloading will use the :constructor on reload
171
+ # network_resource.save
172
+ # network_resource.reload
173
+ #
174
+ # == Finding records by a value object
175
+ #
176
+ # Once a #composed_of relationship is specified for a model, records can be loaded from the database
177
+ # by specifying an instance of the value object in the conditions hash. The following example
178
+ # finds all customers with +address_street+ equal to "May Street" and +address_city+ equal to "Chicago":
179
+ #
180
+ # Customer.where(address: Address.new("May Street", "Chicago"))
181
+ #
182
+ module ClassMethods
183
+ # Adds reader and writer methods for manipulating a value object:
184
+ # <tt>composed_of :address</tt> adds <tt>address</tt> and <tt>address=(new_address)</tt> methods.
185
+ #
186
+ # Options are:
187
+ # * <tt>:class_name</tt> - Specifies the class name of the association. Use it only if that name
188
+ # can't be inferred from the part id. So <tt>composed_of :address</tt> will by default be linked
189
+ # to the Address class, but if the real class name is +CompanyAddress+, you'll have to specify it
190
+ # with this option.
191
+ # * <tt>:mapping</tt> - Specifies the mapping of entity attributes to attributes of the value
192
+ # object. Each mapping is represented as an array where the first item is the name of the
193
+ # entity attribute and the second item is the name of the attribute in the value object. The
194
+ # order in which mappings are defined determines the order in which attributes are sent to the
195
+ # value class constructor.
196
+ # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
197
+ # attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
198
+ # mapped attributes.
199
+ # This defaults to +false+.
200
+ # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that
201
+ # is called to initialize the value object. The constructor is passed all of the mapped attributes,
202
+ # in the order that they are defined in the <tt>:mapping option</tt>, as arguments and uses them
203
+ # to instantiate a <tt>:class_name</tt> object.
204
+ # The default is <tt>:new</tt>.
205
+ # * <tt>:converter</tt> - A symbol specifying the name of a class method of <tt>:class_name</tt>
206
+ # or a Proc that is called when a new value is assigned to the value object. The converter is
207
+ # passed the single value that is used in the assignment and is only called if the new value is
208
+ # not an instance of <tt>:class_name</tt>. If <tt>:allow_nil</tt> is set to true, the converter
209
+ # can return +nil+ to skip the assignment.
210
+ #
211
+ # Option examples:
212
+ # composed_of :temperature, mapping: %w(reading celsius)
213
+ # composed_of :balance, class_name: "Money", mapping: %w(balance amount)
214
+ # composed_of :address, mapping: [ %w(address_street street), %w(address_city city) ]
215
+ # composed_of :gps_location
216
+ # composed_of :gps_location, allow_nil: true
217
+ # composed_of :ip_address,
218
+ # class_name: 'IPAddr',
219
+ # mapping: %w(ip to_i),
220
+ # constructor: Proc.new { |ip| IPAddr.new(ip, Socket::AF_INET) },
221
+ # converter: Proc.new { |ip| ip.is_a?(Integer) ? IPAddr.new(ip, Socket::AF_INET) : IPAddr.new(ip.to_s) }
222
+ #
223
+ def composed_of(part_id, options = {})
224
+ options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
225
+
226
+ unless self < Aggregations
227
+ include Aggregations
228
+ end
229
+
230
+ name = part_id.id2name
231
+ class_name = options[:class_name] || name.camelize
232
+ mapping = options[:mapping] || [ name, name ]
233
+ mapping = [ mapping ] unless mapping.first.is_a?(Array)
234
+ allow_nil = options[:allow_nil] || false
235
+ constructor = options[:constructor] || :new
236
+ converter = options[:converter]
237
+
238
+ reader_method(name, class_name, mapping, allow_nil, constructor)
239
+ writer_method(name, class_name, mapping, allow_nil, converter)
240
+
241
+ reflection = ActiveRecord::Reflection.create(:composed_of, part_id, nil, options, self)
242
+ Reflection.add_aggregate_reflection self, part_id, reflection
243
+ end
244
+
245
+ private
246
+ def reader_method(name, class_name, mapping, allow_nil, constructor)
247
+ define_method(name) do
248
+ if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !_read_attribute(key).nil? })
249
+ attrs = mapping.collect { |key, _| _read_attribute(key) }
250
+ object = constructor.respond_to?(:call) ?
251
+ constructor.call(*attrs) :
252
+ class_name.constantize.send(constructor, *attrs)
253
+ @aggregation_cache[name] = object
254
+ end
255
+ @aggregation_cache[name]
256
+ end
257
+ end
258
+
259
+ def writer_method(name, class_name, mapping, allow_nil, converter)
260
+ define_method("#{name}=") do |part|
261
+ klass = class_name.constantize
262
+
263
+ unless part.is_a?(klass) || converter.nil? || part.nil?
264
+ part = converter.respond_to?(:call) ? converter.call(part) : klass.send(converter, part)
265
+ end
266
+
267
+ hash_from_multiparameter_assignment = part.is_a?(Hash) &&
268
+ part.each_key.all? { |k| k.is_a?(Integer) }
269
+ if hash_from_multiparameter_assignment
270
+ raise ArgumentError unless part.size == part.each_key.max
271
+ part = klass.new(*part.sort.map(&:last))
272
+ end
273
+
274
+ if part.nil? && allow_nil
275
+ mapping.each { |key, _| self[key] = nil }
276
+ @aggregation_cache[name] = nil
277
+ else
278
+ mapping.each { |key, value| self[key] = part.send(value) }
279
+ @aggregation_cache[name] = part.freeze
280
+ end
281
+ end
282
+ end
283
+ end
284
+ end
285
+ end
@@ -0,0 +1,49 @@
1
+ # frozen_string_literal: true
2
+
3
+ module ActiveRecord
4
+ class AssociationRelation < Relation
5
+ def initialize(klass, association)
6
+ super(klass)
7
+ @association = association
8
+ end
9
+
10
+ def proxy_association
11
+ @association
12
+ end
13
+
14
+ def ==(other)
15
+ other == records
16
+ end
17
+
18
+ def build(attributes = nil, &block)
19
+ block = _deprecated_scope_block("new", &block)
20
+ @association.scoping(self) do
21
+ @association.build(attributes, &block)
22
+ end
23
+ end
24
+ alias new build
25
+
26
+ def create(attributes = nil, &block)
27
+ block = _deprecated_scope_block("create", &block)
28
+ @association.scoping(self) do
29
+ @association.create(attributes, &block)
30
+ end
31
+ end
32
+
33
+ def create!(attributes = nil, &block)
34
+ block = _deprecated_scope_block("create!", &block)
35
+ @association.scoping(self) do
36
+ @association.create!(attributes, &block)
37
+ end
38
+ end
39
+
40
+ private
41
+
42
+ def exec_queries
43
+ super do |record|
44
+ @association.set_inverse_instance_from_queries(record)
45
+ yield record if block_given?
46
+ end
47
+ end
48
+ end
49
+ end
@@ -0,0 +1,1865 @@
1
+ # frozen_string_literal: true
2
+
3
+ require "active_support/core_ext/enumerable"
4
+ require "active_support/core_ext/string/conversions"
5
+ require "active_support/core_ext/module/remove_method"
6
+ require "active_record/errors"
7
+
8
+ module ActiveRecord
9
+ class AssociationNotFoundError < ConfigurationError #:nodoc:
10
+ def initialize(record = nil, association_name = nil)
11
+ if record && association_name
12
+ super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
13
+ else
14
+ super("Association was not found.")
15
+ end
16
+ end
17
+ end
18
+
19
+ class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
20
+ def initialize(reflection = nil, associated_class = nil)
21
+ if reflection
22
+ super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
23
+ else
24
+ super("Could not find the inverse association.")
25
+ end
26
+ end
27
+ end
28
+
29
+ class HasManyThroughAssociationNotFoundError < ActiveRecordError #:nodoc:
30
+ def initialize(owner_class_name = nil, reflection = nil)
31
+ if owner_class_name && reflection
32
+ super("Could not find the association #{reflection.options[:through].inspect} in model #{owner_class_name}")
33
+ else
34
+ super("Could not find the association.")
35
+ end
36
+ end
37
+ end
38
+
39
+ class HasManyThroughAssociationPolymorphicSourceError < ActiveRecordError #:nodoc:
40
+ def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
41
+ if owner_class_name && reflection && source_reflection
42
+ super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' on the polymorphic object '#{source_reflection.class_name}##{source_reflection.name}' without 'source_type'. Try adding 'source_type: \"#{reflection.name.to_s.classify}\"' to 'has_many :through' definition.")
43
+ else
44
+ super("Cannot have a has_many :through association.")
45
+ end
46
+ end
47
+ end
48
+
49
+ class HasManyThroughAssociationPolymorphicThroughError < ActiveRecordError #:nodoc:
50
+ def initialize(owner_class_name = nil, reflection = nil)
51
+ if owner_class_name && reflection
52
+ super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
53
+ else
54
+ super("Cannot have a has_many :through association.")
55
+ end
56
+ end
57
+ end
58
+
59
+ class HasManyThroughAssociationPointlessSourceTypeError < ActiveRecordError #:nodoc:
60
+ def initialize(owner_class_name = nil, reflection = nil, source_reflection = nil)
61
+ if owner_class_name && reflection && source_reflection
62
+ super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' with a :source_type option if the '#{reflection.through_reflection.class_name}##{source_reflection.name}' is not polymorphic. Try removing :source_type on your association.")
63
+ else
64
+ super("Cannot have a has_many :through association.")
65
+ end
66
+ end
67
+ end
68
+
69
+ class HasOneThroughCantAssociateThroughCollection < ActiveRecordError #:nodoc:
70
+ def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
71
+ if owner_class_name && reflection && through_reflection
72
+ super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' where the :through association '#{owner_class_name}##{through_reflection.name}' is a collection. Specify a has_one or belongs_to association in the :through option instead.")
73
+ else
74
+ super("Cannot have a has_one :through association.")
75
+ end
76
+ end
77
+ end
78
+
79
+ class HasOneAssociationPolymorphicThroughError < ActiveRecordError #:nodoc:
80
+ def initialize(owner_class_name = nil, reflection = nil)
81
+ if owner_class_name && reflection
82
+ super("Cannot have a has_one :through association '#{owner_class_name}##{reflection.name}' which goes through the polymorphic association '#{owner_class_name}##{reflection.through_reflection.name}'.")
83
+ else
84
+ super("Cannot have a has_one :through association.")
85
+ end
86
+ end
87
+ end
88
+
89
+ class HasManyThroughSourceAssociationNotFoundError < ActiveRecordError #:nodoc:
90
+ def initialize(reflection = nil)
91
+ if reflection
92
+ through_reflection = reflection.through_reflection
93
+ source_reflection_names = reflection.source_reflection_names
94
+ source_associations = reflection.through_reflection.klass._reflections.keys
95
+ super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')} in model #{through_reflection.klass}. Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'. Is it one of #{source_associations.to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')}?")
96
+ else
97
+ super("Could not find the source association(s).")
98
+ end
99
+ end
100
+ end
101
+
102
+ class HasManyThroughOrderError < ActiveRecordError #:nodoc:
103
+ def initialize(owner_class_name = nil, reflection = nil, through_reflection = nil)
104
+ if owner_class_name && reflection && through_reflection
105
+ super("Cannot have a has_many :through association '#{owner_class_name}##{reflection.name}' which goes through '#{owner_class_name}##{through_reflection.name}' before the through association is defined.")
106
+ else
107
+ super("Cannot have a has_many :through association before the through association is defined.")
108
+ end
109
+ end
110
+ end
111
+
112
+ class ThroughCantAssociateThroughHasOneOrManyReflection < ActiveRecordError #:nodoc:
113
+ def initialize(owner = nil, reflection = nil)
114
+ if owner && reflection
115
+ super("Cannot modify association '#{owner.class.name}##{reflection.name}' because the source reflection class '#{reflection.source_reflection.class_name}' is associated to '#{reflection.through_reflection.class_name}' via :#{reflection.source_reflection.macro}.")
116
+ else
117
+ super("Cannot modify association.")
118
+ end
119
+ end
120
+ end
121
+
122
+ class AmbiguousSourceReflectionForThroughAssociation < ActiveRecordError # :nodoc:
123
+ def initialize(klass, macro, association_name, options, possible_sources)
124
+ example_options = options.dup
125
+ example_options[:source] = possible_sources.first
126
+
127
+ super("Ambiguous source reflection for through association. Please " \
128
+ "specify a :source directive on your declaration like:\n" \
129
+ "\n" \
130
+ " class #{klass} < ActiveRecord::Base\n" \
131
+ " #{macro} :#{association_name}, #{example_options}\n" \
132
+ " end"
133
+ )
134
+ end
135
+ end
136
+
137
+ class HasManyThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection #:nodoc:
138
+ end
139
+
140
+ class HasOneThroughCantAssociateThroughHasOneOrManyReflection < ThroughCantAssociateThroughHasOneOrManyReflection #:nodoc:
141
+ end
142
+
143
+ class ThroughNestedAssociationsAreReadonly < ActiveRecordError #:nodoc:
144
+ def initialize(owner = nil, reflection = nil)
145
+ if owner && reflection
146
+ super("Cannot modify association '#{owner.class.name}##{reflection.name}' because it goes through more than one other association.")
147
+ else
148
+ super("Through nested associations are read-only.")
149
+ end
150
+ end
151
+ end
152
+
153
+ class HasManyThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly #:nodoc:
154
+ end
155
+
156
+ class HasOneThroughNestedAssociationsAreReadonly < ThroughNestedAssociationsAreReadonly #:nodoc:
157
+ end
158
+
159
+ # This error is raised when trying to eager load a polymorphic association using a JOIN.
160
+ # Eager loading polymorphic associations is only possible with
161
+ # {ActiveRecord::Relation#preload}[rdoc-ref:QueryMethods#preload].
162
+ class EagerLoadPolymorphicError < ActiveRecordError
163
+ def initialize(reflection = nil)
164
+ if reflection
165
+ super("Cannot eagerly load the polymorphic association #{reflection.name.inspect}")
166
+ else
167
+ super("Eager load polymorphic error.")
168
+ end
169
+ end
170
+ end
171
+
172
+ # This error is raised when trying to destroy a parent instance in N:1 or 1:1 associations
173
+ # (has_many, has_one) when there is at least 1 child associated instance.
174
+ # ex: if @project.tasks.size > 0, DeleteRestrictionError will be raised when trying to destroy @project
175
+ class DeleteRestrictionError < ActiveRecordError #:nodoc:
176
+ def initialize(name = nil)
177
+ if name
178
+ super("Cannot delete record because of dependent #{name}")
179
+ else
180
+ super("Delete restriction error.")
181
+ end
182
+ end
183
+ end
184
+
185
+ # See ActiveRecord::Associations::ClassMethods for documentation.
186
+ module Associations # :nodoc:
187
+ extend ActiveSupport::Autoload
188
+ extend ActiveSupport::Concern
189
+
190
+ # These classes will be loaded when associations are created.
191
+ # So there is no need to eager load them.
192
+ autoload :Association
193
+ autoload :SingularAssociation
194
+ autoload :CollectionAssociation
195
+ autoload :ForeignAssociation
196
+ autoload :CollectionProxy
197
+ autoload :ThroughAssociation
198
+
199
+ module Builder #:nodoc:
200
+ autoload :Association, "active_record/associations/builder/association"
201
+ autoload :SingularAssociation, "active_record/associations/builder/singular_association"
202
+ autoload :CollectionAssociation, "active_record/associations/builder/collection_association"
203
+
204
+ autoload :BelongsTo, "active_record/associations/builder/belongs_to"
205
+ autoload :HasOne, "active_record/associations/builder/has_one"
206
+ autoload :HasMany, "active_record/associations/builder/has_many"
207
+ autoload :HasAndBelongsToMany, "active_record/associations/builder/has_and_belongs_to_many"
208
+ end
209
+
210
+ eager_autoload do
211
+ autoload :BelongsToAssociation
212
+ autoload :BelongsToPolymorphicAssociation
213
+ autoload :HasManyAssociation
214
+ autoload :HasManyThroughAssociation
215
+ autoload :HasOneAssociation
216
+ autoload :HasOneThroughAssociation
217
+
218
+ autoload :Preloader
219
+ autoload :JoinDependency
220
+ autoload :AssociationScope
221
+ autoload :AliasTracker
222
+ end
223
+
224
+ def self.eager_load!
225
+ super
226
+ Preloader.eager_load!
227
+ end
228
+
229
+ # Returns the association instance for the given name, instantiating it if it doesn't already exist
230
+ def association(name) #:nodoc:
231
+ association = association_instance_get(name)
232
+
233
+ if association.nil?
234
+ unless reflection = self.class._reflect_on_association(name)
235
+ raise AssociationNotFoundError.new(self, name)
236
+ end
237
+ association = reflection.association_class.new(self, reflection)
238
+ association_instance_set(name, association)
239
+ end
240
+
241
+ association
242
+ end
243
+
244
+ def association_cached?(name) # :nodoc:
245
+ @association_cache.key?(name)
246
+ end
247
+
248
+ def initialize_dup(*) # :nodoc:
249
+ @association_cache = {}
250
+ super
251
+ end
252
+
253
+ def reload(*) # :nodoc:
254
+ clear_association_cache
255
+ super
256
+ end
257
+
258
+ private
259
+ # Clears out the association cache.
260
+ def clear_association_cache
261
+ @association_cache.clear if persisted?
262
+ end
263
+
264
+ def init_internals
265
+ @association_cache = {}
266
+ super
267
+ end
268
+
269
+ # Returns the specified association instance if it exists, +nil+ otherwise.
270
+ def association_instance_get(name)
271
+ @association_cache[name]
272
+ end
273
+
274
+ # Set the specified association instance.
275
+ def association_instance_set(name, association)
276
+ @association_cache[name] = association
277
+ end
278
+
279
+ # \Associations are a set of macro-like class methods for tying objects together through
280
+ # foreign keys. They express relationships like "Project has one Project Manager"
281
+ # or "Project belongs to a Portfolio". Each macro adds a number of methods to the
282
+ # class which are specialized according to the collection or association symbol and the
283
+ # options hash. It works much the same way as Ruby's own <tt>attr*</tt>
284
+ # methods.
285
+ #
286
+ # class Project < ActiveRecord::Base
287
+ # belongs_to :portfolio
288
+ # has_one :project_manager
289
+ # has_many :milestones
290
+ # has_and_belongs_to_many :categories
291
+ # end
292
+ #
293
+ # The project class now has the following methods (and more) to ease the traversal and
294
+ # manipulation of its relationships:
295
+ # * <tt>Project#portfolio</tt>, <tt>Project#portfolio=(portfolio)</tt>, <tt>Project#reload_portfolio</tt>
296
+ # * <tt>Project#project_manager</tt>, <tt>Project#project_manager=(project_manager)</tt>, <tt>Project#reload_project_manager</tt>
297
+ # * <tt>Project#milestones.empty?</tt>, <tt>Project#milestones.size</tt>, <tt>Project#milestones</tt>, <tt>Project#milestones<<(milestone)</tt>,
298
+ # <tt>Project#milestones.delete(milestone)</tt>, <tt>Project#milestones.destroy(milestone)</tt>, <tt>Project#milestones.find(milestone_id)</tt>,
299
+ # <tt>Project#milestones.build</tt>, <tt>Project#milestones.create</tt>
300
+ # * <tt>Project#categories.empty?</tt>, <tt>Project#categories.size</tt>, <tt>Project#categories</tt>, <tt>Project#categories<<(category1)</tt>,
301
+ # <tt>Project#categories.delete(category1)</tt>, <tt>Project#categories.destroy(category1)</tt>
302
+ #
303
+ # === A word of warning
304
+ #
305
+ # Don't create associations that have the same name as {instance methods}[rdoc-ref:ActiveRecord::Core] of
306
+ # <tt>ActiveRecord::Base</tt>. Since the association adds a method with that name to
307
+ # its model, using an association with the same name as one provided by <tt>ActiveRecord::Base</tt> will override the method inherited through <tt>ActiveRecord::Base</tt> and will break things.
308
+ # For instance, +attributes+ and +connection+ would be bad choices for association names, because those names already exist in the list of <tt>ActiveRecord::Base</tt> instance methods.
309
+ #
310
+ # == Auto-generated methods
311
+ # See also Instance Public methods below for more details.
312
+ #
313
+ # === Singular associations (one-to-one)
314
+ # | | belongs_to |
315
+ # generated methods | belongs_to | :polymorphic | has_one
316
+ # ----------------------------------+------------+--------------+---------
317
+ # other | X | X | X
318
+ # other=(other) | X | X | X
319
+ # build_other(attributes={}) | X | | X
320
+ # create_other(attributes={}) | X | | X
321
+ # create_other!(attributes={}) | X | | X
322
+ # reload_other | X | X | X
323
+ #
324
+ # === Collection associations (one-to-many / many-to-many)
325
+ # | | | has_many
326
+ # generated methods | habtm | has_many | :through
327
+ # ----------------------------------+-------+----------+----------
328
+ # others | X | X | X
329
+ # others=(other,other,...) | X | X | X
330
+ # other_ids | X | X | X
331
+ # other_ids=(id,id,...) | X | X | X
332
+ # others<< | X | X | X
333
+ # others.push | X | X | X
334
+ # others.concat | X | X | X
335
+ # others.build(attributes={}) | X | X | X
336
+ # others.create(attributes={}) | X | X | X
337
+ # others.create!(attributes={}) | X | X | X
338
+ # others.size | X | X | X
339
+ # others.length | X | X | X
340
+ # others.count | X | X | X
341
+ # others.sum(*args) | X | X | X
342
+ # others.empty? | X | X | X
343
+ # others.clear | X | X | X
344
+ # others.delete(other,other,...) | X | X | X
345
+ # others.delete_all | X | X | X
346
+ # others.destroy(other,other,...) | X | X | X
347
+ # others.destroy_all | X | X | X
348
+ # others.find(*args) | X | X | X
349
+ # others.exists? | X | X | X
350
+ # others.distinct | X | X | X
351
+ # others.reset | X | X | X
352
+ # others.reload | X | X | X
353
+ #
354
+ # === Overriding generated methods
355
+ #
356
+ # Association methods are generated in a module included into the model
357
+ # class, making overrides easy. The original generated method can thus be
358
+ # called with +super+:
359
+ #
360
+ # class Car < ActiveRecord::Base
361
+ # belongs_to :owner
362
+ # belongs_to :old_owner
363
+ #
364
+ # def owner=(new_owner)
365
+ # self.old_owner = self.owner
366
+ # super
367
+ # end
368
+ # end
369
+ #
370
+ # The association methods module is included immediately after the
371
+ # generated attributes methods module, meaning an association will
372
+ # override the methods for an attribute with the same name.
373
+ #
374
+ # == Cardinality and associations
375
+ #
376
+ # Active Record associations can be used to describe one-to-one, one-to-many and many-to-many
377
+ # relationships between models. Each model uses an association to describe its role in
378
+ # the relation. The #belongs_to association is always used in the model that has
379
+ # the foreign key.
380
+ #
381
+ # === One-to-one
382
+ #
383
+ # Use #has_one in the base, and #belongs_to in the associated model.
384
+ #
385
+ # class Employee < ActiveRecord::Base
386
+ # has_one :office
387
+ # end
388
+ # class Office < ActiveRecord::Base
389
+ # belongs_to :employee # foreign key - employee_id
390
+ # end
391
+ #
392
+ # === One-to-many
393
+ #
394
+ # Use #has_many in the base, and #belongs_to in the associated model.
395
+ #
396
+ # class Manager < ActiveRecord::Base
397
+ # has_many :employees
398
+ # end
399
+ # class Employee < ActiveRecord::Base
400
+ # belongs_to :manager # foreign key - manager_id
401
+ # end
402
+ #
403
+ # === Many-to-many
404
+ #
405
+ # There are two ways to build a many-to-many relationship.
406
+ #
407
+ # The first way uses a #has_many association with the <tt>:through</tt> option and a join model, so
408
+ # there are two stages of associations.
409
+ #
410
+ # class Assignment < ActiveRecord::Base
411
+ # belongs_to :programmer # foreign key - programmer_id
412
+ # belongs_to :project # foreign key - project_id
413
+ # end
414
+ # class Programmer < ActiveRecord::Base
415
+ # has_many :assignments
416
+ # has_many :projects, through: :assignments
417
+ # end
418
+ # class Project < ActiveRecord::Base
419
+ # has_many :assignments
420
+ # has_many :programmers, through: :assignments
421
+ # end
422
+ #
423
+ # For the second way, use #has_and_belongs_to_many in both models. This requires a join table
424
+ # that has no corresponding model or primary key.
425
+ #
426
+ # class Programmer < ActiveRecord::Base
427
+ # has_and_belongs_to_many :projects # foreign keys in the join table
428
+ # end
429
+ # class Project < ActiveRecord::Base
430
+ # has_and_belongs_to_many :programmers # foreign keys in the join table
431
+ # end
432
+ #
433
+ # Choosing which way to build a many-to-many relationship is not always simple.
434
+ # If you need to work with the relationship model as its own entity,
435
+ # use #has_many <tt>:through</tt>. Use #has_and_belongs_to_many when working with legacy schemas or when
436
+ # you never work directly with the relationship itself.
437
+ #
438
+ # == Is it a #belongs_to or #has_one association?
439
+ #
440
+ # Both express a 1-1 relationship. The difference is mostly where to place the foreign
441
+ # key, which goes on the table for the class declaring the #belongs_to relationship.
442
+ #
443
+ # class User < ActiveRecord::Base
444
+ # # I reference an account.
445
+ # belongs_to :account
446
+ # end
447
+ #
448
+ # class Account < ActiveRecord::Base
449
+ # # One user references me.
450
+ # has_one :user
451
+ # end
452
+ #
453
+ # The tables for these classes could look something like:
454
+ #
455
+ # CREATE TABLE users (
456
+ # id bigint NOT NULL auto_increment,
457
+ # account_id bigint default NULL,
458
+ # name varchar default NULL,
459
+ # PRIMARY KEY (id)
460
+ # )
461
+ #
462
+ # CREATE TABLE accounts (
463
+ # id bigint NOT NULL auto_increment,
464
+ # name varchar default NULL,
465
+ # PRIMARY KEY (id)
466
+ # )
467
+ #
468
+ # == Unsaved objects and associations
469
+ #
470
+ # You can manipulate objects and associations before they are saved to the database, but
471
+ # there is some special behavior you should be aware of, mostly involving the saving of
472
+ # associated objects.
473
+ #
474
+ # You can set the <tt>:autosave</tt> option on a #has_one, #belongs_to,
475
+ # #has_many, or #has_and_belongs_to_many association. Setting it
476
+ # to +true+ will _always_ save the members, whereas setting it to +false+ will
477
+ # _never_ save the members. More details about <tt>:autosave</tt> option is available at
478
+ # AutosaveAssociation.
479
+ #
480
+ # === One-to-one associations
481
+ #
482
+ # * Assigning an object to a #has_one association automatically saves that object and
483
+ # the object being replaced (if there is one), in order to update their foreign
484
+ # keys - except if the parent object is unsaved (<tt>new_record? == true</tt>).
485
+ # * If either of these saves fail (due to one of the objects being invalid), an
486
+ # ActiveRecord::RecordNotSaved exception is raised and the assignment is
487
+ # cancelled.
488
+ # * If you wish to assign an object to a #has_one association without saving it,
489
+ # use the <tt>#build_association</tt> method (documented below). The object being
490
+ # replaced will still be saved to update its foreign key.
491
+ # * Assigning an object to a #belongs_to association does not save the object, since
492
+ # the foreign key field belongs on the parent. It does not save the parent either.
493
+ #
494
+ # === Collections
495
+ #
496
+ # * Adding an object to a collection (#has_many or #has_and_belongs_to_many) automatically
497
+ # saves that object, except if the parent object (the owner of the collection) is not yet
498
+ # stored in the database.
499
+ # * If saving any of the objects being added to a collection (via <tt>push</tt> or similar)
500
+ # fails, then <tt>push</tt> returns +false+.
501
+ # * If saving fails while replacing the collection (via <tt>association=</tt>), an
502
+ # ActiveRecord::RecordNotSaved exception is raised and the assignment is
503
+ # cancelled.
504
+ # * You can add an object to a collection without automatically saving it by using the
505
+ # <tt>collection.build</tt> method (documented below).
506
+ # * All unsaved (<tt>new_record? == true</tt>) members of the collection are automatically
507
+ # saved when the parent is saved.
508
+ #
509
+ # == Customizing the query
510
+ #
511
+ # \Associations are built from <tt>Relation</tt> objects, and you can use the Relation syntax
512
+ # to customize them. For example, to add a condition:
513
+ #
514
+ # class Blog < ActiveRecord::Base
515
+ # has_many :published_posts, -> { where(published: true) }, class_name: 'Post'
516
+ # end
517
+ #
518
+ # Inside the <tt>-> { ... }</tt> block you can use all of the usual Relation methods.
519
+ #
520
+ # === Accessing the owner object
521
+ #
522
+ # Sometimes it is useful to have access to the owner object when building the query. The owner
523
+ # is passed as a parameter to the block. For example, the following association would find all
524
+ # events that occur on the user's birthday:
525
+ #
526
+ # class User < ActiveRecord::Base
527
+ # has_many :birthday_events, ->(user) { where(starts_on: user.birthday) }, class_name: 'Event'
528
+ # end
529
+ #
530
+ # Note: Joining, eager loading and preloading of these associations is not possible.
531
+ # These operations happen before instance creation and the scope will be called with a +nil+ argument.
532
+ #
533
+ # == Association callbacks
534
+ #
535
+ # Similar to the normal callbacks that hook into the life cycle of an Active Record object,
536
+ # you can also define callbacks that get triggered when you add an object to or remove an
537
+ # object from an association collection.
538
+ #
539
+ # class Project
540
+ # has_and_belongs_to_many :developers, after_add: :evaluate_velocity
541
+ #
542
+ # def evaluate_velocity(developer)
543
+ # ...
544
+ # end
545
+ # end
546
+ #
547
+ # It's possible to stack callbacks by passing them as an array. Example:
548
+ #
549
+ # class Project
550
+ # has_and_belongs_to_many :developers,
551
+ # after_add: [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}]
552
+ # end
553
+ #
554
+ # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+.
555
+ #
556
+ # If any of the +before_add+ callbacks throw an exception, the object will not be
557
+ # added to the collection.
558
+ #
559
+ # Similarly, if any of the +before_remove+ callbacks throw an exception, the object
560
+ # will not be removed from the collection.
561
+ #
562
+ # == Association extensions
563
+ #
564
+ # The proxy objects that control the access to associations can be extended through anonymous
565
+ # modules. This is especially beneficial for adding new finders, creators, and other
566
+ # factory-type methods that are only used as part of this association.
567
+ #
568
+ # class Account < ActiveRecord::Base
569
+ # has_many :people do
570
+ # def find_or_create_by_name(name)
571
+ # first_name, last_name = name.split(" ", 2)
572
+ # find_or_create_by(first_name: first_name, last_name: last_name)
573
+ # end
574
+ # end
575
+ # end
576
+ #
577
+ # person = Account.first.people.find_or_create_by_name("David Heinemeier Hansson")
578
+ # person.first_name # => "David"
579
+ # person.last_name # => "Heinemeier Hansson"
580
+ #
581
+ # If you need to share the same extensions between many associations, you can use a named
582
+ # extension module.
583
+ #
584
+ # module FindOrCreateByNameExtension
585
+ # def find_or_create_by_name(name)
586
+ # first_name, last_name = name.split(" ", 2)
587
+ # find_or_create_by(first_name: first_name, last_name: last_name)
588
+ # end
589
+ # end
590
+ #
591
+ # class Account < ActiveRecord::Base
592
+ # has_many :people, -> { extending FindOrCreateByNameExtension }
593
+ # end
594
+ #
595
+ # class Company < ActiveRecord::Base
596
+ # has_many :people, -> { extending FindOrCreateByNameExtension }
597
+ # end
598
+ #
599
+ # Some extensions can only be made to work with knowledge of the association's internals.
600
+ # Extensions can access relevant state using the following methods (where +items+ is the
601
+ # name of the association):
602
+ #
603
+ # * <tt>record.association(:items).owner</tt> - Returns the object the association is part of.
604
+ # * <tt>record.association(:items).reflection</tt> - Returns the reflection object that describes the association.
605
+ # * <tt>record.association(:items).target</tt> - Returns the associated object for #belongs_to and #has_one, or
606
+ # the collection of associated objects for #has_many and #has_and_belongs_to_many.
607
+ #
608
+ # However, inside the actual extension code, you will not have access to the <tt>record</tt> as
609
+ # above. In this case, you can access <tt>proxy_association</tt>. For example,
610
+ # <tt>record.association(:items)</tt> and <tt>record.items.proxy_association</tt> will return
611
+ # the same object, allowing you to make calls like <tt>proxy_association.owner</tt> inside
612
+ # association extensions.
613
+ #
614
+ # == Association Join Models
615
+ #
616
+ # Has Many associations can be configured with the <tt>:through</tt> option to use an
617
+ # explicit join model to retrieve the data. This operates similarly to a
618
+ # #has_and_belongs_to_many association. The advantage is that you're able to add validations,
619
+ # callbacks, and extra attributes on the join model. Consider the following schema:
620
+ #
621
+ # class Author < ActiveRecord::Base
622
+ # has_many :authorships
623
+ # has_many :books, through: :authorships
624
+ # end
625
+ #
626
+ # class Authorship < ActiveRecord::Base
627
+ # belongs_to :author
628
+ # belongs_to :book
629
+ # end
630
+ #
631
+ # @author = Author.first
632
+ # @author.authorships.collect { |a| a.book } # selects all books that the author's authorships belong to
633
+ # @author.books # selects all books by using the Authorship join model
634
+ #
635
+ # You can also go through a #has_many association on the join model:
636
+ #
637
+ # class Firm < ActiveRecord::Base
638
+ # has_many :clients
639
+ # has_many :invoices, through: :clients
640
+ # end
641
+ #
642
+ # class Client < ActiveRecord::Base
643
+ # belongs_to :firm
644
+ # has_many :invoices
645
+ # end
646
+ #
647
+ # class Invoice < ActiveRecord::Base
648
+ # belongs_to :client
649
+ # end
650
+ #
651
+ # @firm = Firm.first
652
+ # @firm.clients.flat_map { |c| c.invoices } # select all invoices for all clients of the firm
653
+ # @firm.invoices # selects all invoices by going through the Client join model
654
+ #
655
+ # Similarly you can go through a #has_one association on the join model:
656
+ #
657
+ # class Group < ActiveRecord::Base
658
+ # has_many :users
659
+ # has_many :avatars, through: :users
660
+ # end
661
+ #
662
+ # class User < ActiveRecord::Base
663
+ # belongs_to :group
664
+ # has_one :avatar
665
+ # end
666
+ #
667
+ # class Avatar < ActiveRecord::Base
668
+ # belongs_to :user
669
+ # end
670
+ #
671
+ # @group = Group.first
672
+ # @group.users.collect { |u| u.avatar }.compact # select all avatars for all users in the group
673
+ # @group.avatars # selects all avatars by going through the User join model.
674
+ #
675
+ # An important caveat with going through #has_one or #has_many associations on the
676
+ # join model is that these associations are *read-only*. For example, the following
677
+ # would not work following the previous example:
678
+ #
679
+ # @group.avatars << Avatar.new # this would work if User belonged_to Avatar rather than the other way around
680
+ # @group.avatars.delete(@group.avatars.last) # so would this
681
+ #
682
+ # == Setting Inverses
683
+ #
684
+ # If you are using a #belongs_to on the join model, it is a good idea to set the
685
+ # <tt>:inverse_of</tt> option on the #belongs_to, which will mean that the following example
686
+ # works correctly (where <tt>tags</tt> is a #has_many <tt>:through</tt> association):
687
+ #
688
+ # @post = Post.first
689
+ # @tag = @post.tags.build name: "ruby"
690
+ # @tag.save
691
+ #
692
+ # The last line ought to save the through record (a <tt>Tagging</tt>). This will only work if the
693
+ # <tt>:inverse_of</tt> is set:
694
+ #
695
+ # class Tagging < ActiveRecord::Base
696
+ # belongs_to :post
697
+ # belongs_to :tag, inverse_of: :taggings
698
+ # end
699
+ #
700
+ # If you do not set the <tt>:inverse_of</tt> record, the association will
701
+ # do its best to match itself up with the correct inverse. Automatic
702
+ # inverse detection only works on #has_many, #has_one, and
703
+ # #belongs_to associations.
704
+ #
705
+ # Extra options on the associations, as defined in the
706
+ # <tt>AssociationReflection::INVALID_AUTOMATIC_INVERSE_OPTIONS</tt>
707
+ # constant, or a custom scope, will also prevent the association's inverse
708
+ # from being found automatically.
709
+ #
710
+ # The automatic guessing of the inverse association uses a heuristic based
711
+ # on the name of the class, so it may not work for all associations,
712
+ # especially the ones with non-standard names.
713
+ #
714
+ # You can turn off the automatic detection of inverse associations by setting
715
+ # the <tt>:inverse_of</tt> option to <tt>false</tt> like so:
716
+ #
717
+ # class Tagging < ActiveRecord::Base
718
+ # belongs_to :tag, inverse_of: false
719
+ # end
720
+ #
721
+ # == Nested \Associations
722
+ #
723
+ # You can actually specify *any* association with the <tt>:through</tt> option, including an
724
+ # association which has a <tt>:through</tt> option itself. For example:
725
+ #
726
+ # class Author < ActiveRecord::Base
727
+ # has_many :posts
728
+ # has_many :comments, through: :posts
729
+ # has_many :commenters, through: :comments
730
+ # end
731
+ #
732
+ # class Post < ActiveRecord::Base
733
+ # has_many :comments
734
+ # end
735
+ #
736
+ # class Comment < ActiveRecord::Base
737
+ # belongs_to :commenter
738
+ # end
739
+ #
740
+ # @author = Author.first
741
+ # @author.commenters # => People who commented on posts written by the author
742
+ #
743
+ # An equivalent way of setting up this association this would be:
744
+ #
745
+ # class Author < ActiveRecord::Base
746
+ # has_many :posts
747
+ # has_many :commenters, through: :posts
748
+ # end
749
+ #
750
+ # class Post < ActiveRecord::Base
751
+ # has_many :comments
752
+ # has_many :commenters, through: :comments
753
+ # end
754
+ #
755
+ # class Comment < ActiveRecord::Base
756
+ # belongs_to :commenter
757
+ # end
758
+ #
759
+ # When using a nested association, you will not be able to modify the association because there
760
+ # is not enough information to know what modification to make. For example, if you tried to
761
+ # add a <tt>Commenter</tt> in the example above, there would be no way to tell how to set up the
762
+ # intermediate <tt>Post</tt> and <tt>Comment</tt> objects.
763
+ #
764
+ # == Polymorphic \Associations
765
+ #
766
+ # Polymorphic associations on models are not restricted on what types of models they
767
+ # can be associated with. Rather, they specify an interface that a #has_many association
768
+ # must adhere to.
769
+ #
770
+ # class Asset < ActiveRecord::Base
771
+ # belongs_to :attachable, polymorphic: true
772
+ # end
773
+ #
774
+ # class Post < ActiveRecord::Base
775
+ # has_many :assets, as: :attachable # The :as option specifies the polymorphic interface to use.
776
+ # end
777
+ #
778
+ # @asset.attachable = @post
779
+ #
780
+ # This works by using a type column in addition to a foreign key to specify the associated
781
+ # record. In the Asset example, you'd need an +attachable_id+ integer column and an
782
+ # +attachable_type+ string column.
783
+ #
784
+ # Using polymorphic associations in combination with single table inheritance (STI) is
785
+ # a little tricky. In order for the associations to work as expected, ensure that you
786
+ # store the base model for the STI models in the type column of the polymorphic
787
+ # association. To continue with the asset example above, suppose there are guest posts
788
+ # and member posts that use the posts table for STI. In this case, there must be a +type+
789
+ # column in the posts table.
790
+ #
791
+ # Note: The <tt>attachable_type=</tt> method is being called when assigning an +attachable+.
792
+ # The +class_name+ of the +attachable+ is passed as a String.
793
+ #
794
+ # class Asset < ActiveRecord::Base
795
+ # belongs_to :attachable, polymorphic: true
796
+ #
797
+ # def attachable_type=(class_name)
798
+ # super(class_name.constantize.base_class.to_s)
799
+ # end
800
+ # end
801
+ #
802
+ # class Post < ActiveRecord::Base
803
+ # # because we store "Post" in attachable_type now dependent: :destroy will work
804
+ # has_many :assets, as: :attachable, dependent: :destroy
805
+ # end
806
+ #
807
+ # class GuestPost < Post
808
+ # end
809
+ #
810
+ # class MemberPost < Post
811
+ # end
812
+ #
813
+ # == Caching
814
+ #
815
+ # All of the methods are built on a simple caching principle that will keep the result
816
+ # of the last query around unless specifically instructed not to. The cache is even
817
+ # shared across methods to make it even cheaper to use the macro-added methods without
818
+ # worrying too much about performance at the first go.
819
+ #
820
+ # project.milestones # fetches milestones from the database
821
+ # project.milestones.size # uses the milestone cache
822
+ # project.milestones.empty? # uses the milestone cache
823
+ # project.milestones.reload.size # fetches milestones from the database
824
+ # project.milestones # uses the milestone cache
825
+ #
826
+ # == Eager loading of associations
827
+ #
828
+ # Eager loading is a way to find objects of a certain class and a number of named associations.
829
+ # It is one of the easiest ways to prevent the dreaded N+1 problem in which fetching 100
830
+ # posts that each need to display their author triggers 101 database queries. Through the
831
+ # use of eager loading, the number of queries will be reduced from 101 to 2.
832
+ #
833
+ # class Post < ActiveRecord::Base
834
+ # belongs_to :author
835
+ # has_many :comments
836
+ # end
837
+ #
838
+ # Consider the following loop using the class above:
839
+ #
840
+ # Post.all.each do |post|
841
+ # puts "Post: " + post.title
842
+ # puts "Written by: " + post.author.name
843
+ # puts "Last comment on: " + post.comments.first.created_on
844
+ # end
845
+ #
846
+ # To iterate over these one hundred posts, we'll generate 201 database queries. Let's
847
+ # first just optimize it for retrieving the author:
848
+ #
849
+ # Post.includes(:author).each do |post|
850
+ #
851
+ # This references the name of the #belongs_to association that also used the <tt>:author</tt>
852
+ # symbol. After loading the posts, +find+ will collect the +author_id+ from each one and load
853
+ # all of the referenced authors with one query. Doing so will cut down the number of queries
854
+ # from 201 to 102.
855
+ #
856
+ # We can improve upon the situation further by referencing both associations in the finder with:
857
+ #
858
+ # Post.includes(:author, :comments).each do |post|
859
+ #
860
+ # This will load all comments with a single query. This reduces the total number of queries
861
+ # to 3. In general, the number of queries will be 1 plus the number of associations
862
+ # named (except if some of the associations are polymorphic #belongs_to - see below).
863
+ #
864
+ # To include a deep hierarchy of associations, use a hash:
865
+ #
866
+ # Post.includes(:author, { comments: { author: :gravatar } }).each do |post|
867
+ #
868
+ # The above code will load all the comments and all of their associated
869
+ # authors and gravatars. You can mix and match any combination of symbols,
870
+ # arrays, and hashes to retrieve the associations you want to load.
871
+ #
872
+ # All of this power shouldn't fool you into thinking that you can pull out huge amounts
873
+ # of data with no performance penalty just because you've reduced the number of queries.
874
+ # The database still needs to send all the data to Active Record and it still needs to
875
+ # be processed. So it's no catch-all for performance problems, but it's a great way to
876
+ # cut down on the number of queries in a situation as the one described above.
877
+ #
878
+ # Since only one table is loaded at a time, conditions or orders cannot reference tables
879
+ # other than the main one. If this is the case, Active Record falls back to the previously
880
+ # used <tt>LEFT OUTER JOIN</tt> based strategy. For example:
881
+ #
882
+ # Post.includes([:author, :comments]).where(['comments.approved = ?', true])
883
+ #
884
+ # This will result in a single SQL query with joins along the lines of:
885
+ # <tt>LEFT OUTER JOIN comments ON comments.post_id = posts.id</tt> and
886
+ # <tt>LEFT OUTER JOIN authors ON authors.id = posts.author_id</tt>. Note that using conditions
887
+ # like this can have unintended consequences.
888
+ # In the above example, posts with no approved comments are not returned at all because
889
+ # the conditions apply to the SQL statement as a whole and not just to the association.
890
+ #
891
+ # You must disambiguate column references for this fallback to happen, for example
892
+ # <tt>order: "author.name DESC"</tt> will work but <tt>order: "name DESC"</tt> will not.
893
+ #
894
+ # If you want to load all posts (including posts with no approved comments), then write
895
+ # your own <tt>LEFT OUTER JOIN</tt> query using <tt>ON</tt>:
896
+ #
897
+ # Post.joins("LEFT OUTER JOIN comments ON comments.post_id = posts.id AND comments.approved = '1'")
898
+ #
899
+ # In this case, it is usually more natural to include an association which has conditions defined on it:
900
+ #
901
+ # class Post < ActiveRecord::Base
902
+ # has_many :approved_comments, -> { where(approved: true) }, class_name: 'Comment'
903
+ # end
904
+ #
905
+ # Post.includes(:approved_comments)
906
+ #
907
+ # This will load posts and eager load the +approved_comments+ association, which contains
908
+ # only those comments that have been approved.
909
+ #
910
+ # If you eager load an association with a specified <tt>:limit</tt> option, it will be ignored,
911
+ # returning all the associated objects:
912
+ #
913
+ # class Picture < ActiveRecord::Base
914
+ # has_many :most_recent_comments, -> { order('id DESC').limit(10) }, class_name: 'Comment'
915
+ # end
916
+ #
917
+ # Picture.includes(:most_recent_comments).first.most_recent_comments # => returns all associated comments.
918
+ #
919
+ # Eager loading is supported with polymorphic associations.
920
+ #
921
+ # class Address < ActiveRecord::Base
922
+ # belongs_to :addressable, polymorphic: true
923
+ # end
924
+ #
925
+ # A call that tries to eager load the addressable model
926
+ #
927
+ # Address.includes(:addressable)
928
+ #
929
+ # This will execute one query to load the addresses and load the addressables with one
930
+ # query per addressable type.
931
+ # For example, if all the addressables are either of class Person or Company, then a total
932
+ # of 3 queries will be executed. The list of addressable types to load is determined on
933
+ # the back of the addresses loaded. This is not supported if Active Record has to fallback
934
+ # to the previous implementation of eager loading and will raise ActiveRecord::EagerLoadPolymorphicError.
935
+ # The reason is that the parent model's type is a column value so its corresponding table
936
+ # name cannot be put in the +FROM+/+JOIN+ clauses of that query.
937
+ #
938
+ # == Table Aliasing
939
+ #
940
+ # Active Record uses table aliasing in the case that a table is referenced multiple times
941
+ # in a join. If a table is referenced only once, the standard table name is used. The
942
+ # second time, the table is aliased as <tt>#{reflection_name}_#{parent_table_name}</tt>.
943
+ # Indexes are appended for any more successive uses of the table name.
944
+ #
945
+ # Post.joins(:comments)
946
+ # # => SELECT ... FROM posts INNER JOIN comments ON ...
947
+ # Post.joins(:special_comments) # STI
948
+ # # => SELECT ... FROM posts INNER JOIN comments ON ... AND comments.type = 'SpecialComment'
949
+ # Post.joins(:comments, :special_comments) # special_comments is the reflection name, posts is the parent table name
950
+ # # => SELECT ... FROM posts INNER JOIN comments ON ... INNER JOIN comments special_comments_posts
951
+ #
952
+ # Acts as tree example:
953
+ #
954
+ # TreeMixin.joins(:children)
955
+ # # => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
956
+ # TreeMixin.joins(children: :parent)
957
+ # # => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
958
+ # INNER JOIN parents_mixins ...
959
+ # TreeMixin.joins(children: {parent: :children})
960
+ # # => SELECT ... FROM mixins INNER JOIN mixins childrens_mixins ...
961
+ # INNER JOIN parents_mixins ...
962
+ # INNER JOIN mixins childrens_mixins_2
963
+ #
964
+ # Has and Belongs to Many join tables use the same idea, but add a <tt>_join</tt> suffix:
965
+ #
966
+ # Post.joins(:categories)
967
+ # # => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
968
+ # Post.joins(categories: :posts)
969
+ # # => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
970
+ # INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
971
+ # Post.joins(categories: {posts: :categories})
972
+ # # => SELECT ... FROM posts INNER JOIN categories_posts ... INNER JOIN categories ...
973
+ # INNER JOIN categories_posts posts_categories_join INNER JOIN posts posts_categories
974
+ # INNER JOIN categories_posts categories_posts_join INNER JOIN categories categories_posts_2
975
+ #
976
+ # If you wish to specify your own custom joins using ActiveRecord::QueryMethods#joins method, those table
977
+ # names will take precedence over the eager associations:
978
+ #
979
+ # Post.joins(:comments).joins("inner join comments ...")
980
+ # # => SELECT ... FROM posts INNER JOIN comments_posts ON ... INNER JOIN comments ...
981
+ # Post.joins(:comments, :special_comments).joins("inner join comments ...")
982
+ # # => SELECT ... FROM posts INNER JOIN comments comments_posts ON ...
983
+ # INNER JOIN comments special_comments_posts ...
984
+ # INNER JOIN comments ...
985
+ #
986
+ # Table aliases are automatically truncated according to the maximum length of table identifiers
987
+ # according to the specific database.
988
+ #
989
+ # == Modules
990
+ #
991
+ # By default, associations will look for objects within the current module scope. Consider:
992
+ #
993
+ # module MyApplication
994
+ # module Business
995
+ # class Firm < ActiveRecord::Base
996
+ # has_many :clients
997
+ # end
998
+ #
999
+ # class Client < ActiveRecord::Base; end
1000
+ # end
1001
+ # end
1002
+ #
1003
+ # When <tt>Firm#clients</tt> is called, it will in turn call
1004
+ # <tt>MyApplication::Business::Client.find_all_by_firm_id(firm.id)</tt>.
1005
+ # If you want to associate with a class in another module scope, this can be done by
1006
+ # specifying the complete class name.
1007
+ #
1008
+ # module MyApplication
1009
+ # module Business
1010
+ # class Firm < ActiveRecord::Base; end
1011
+ # end
1012
+ #
1013
+ # module Billing
1014
+ # class Account < ActiveRecord::Base
1015
+ # belongs_to :firm, class_name: "MyApplication::Business::Firm"
1016
+ # end
1017
+ # end
1018
+ # end
1019
+ #
1020
+ # == Bi-directional associations
1021
+ #
1022
+ # When you specify an association, there is usually an association on the associated model
1023
+ # that specifies the same relationship in reverse. For example, with the following models:
1024
+ #
1025
+ # class Dungeon < ActiveRecord::Base
1026
+ # has_many :traps
1027
+ # has_one :evil_wizard
1028
+ # end
1029
+ #
1030
+ # class Trap < ActiveRecord::Base
1031
+ # belongs_to :dungeon
1032
+ # end
1033
+ #
1034
+ # class EvilWizard < ActiveRecord::Base
1035
+ # belongs_to :dungeon
1036
+ # end
1037
+ #
1038
+ # The +traps+ association on +Dungeon+ and the +dungeon+ association on +Trap+ are
1039
+ # the inverse of each other, and the inverse of the +dungeon+ association on +EvilWizard+
1040
+ # is the +evil_wizard+ association on +Dungeon+ (and vice-versa). By default,
1041
+ # Active Record can guess the inverse of the association based on the name
1042
+ # of the class. The result is the following:
1043
+ #
1044
+ # d = Dungeon.first
1045
+ # t = d.traps.first
1046
+ # d.object_id == t.dungeon.object_id # => true
1047
+ #
1048
+ # The +Dungeon+ instances +d+ and <tt>t.dungeon</tt> in the above example refer to
1049
+ # the same in-memory instance since the association matches the name of the class.
1050
+ # The result would be the same if we added +:inverse_of+ to our model definitions:
1051
+ #
1052
+ # class Dungeon < ActiveRecord::Base
1053
+ # has_many :traps, inverse_of: :dungeon
1054
+ # has_one :evil_wizard, inverse_of: :dungeon
1055
+ # end
1056
+ #
1057
+ # class Trap < ActiveRecord::Base
1058
+ # belongs_to :dungeon, inverse_of: :traps
1059
+ # end
1060
+ #
1061
+ # class EvilWizard < ActiveRecord::Base
1062
+ # belongs_to :dungeon, inverse_of: :evil_wizard
1063
+ # end
1064
+ #
1065
+ # For more information, see the documentation for the +:inverse_of+ option.
1066
+ #
1067
+ # == Deleting from associations
1068
+ #
1069
+ # === Dependent associations
1070
+ #
1071
+ # #has_many, #has_one, and #belongs_to associations support the <tt>:dependent</tt> option.
1072
+ # This allows you to specify that associated records should be deleted when the owner is
1073
+ # deleted.
1074
+ #
1075
+ # For example:
1076
+ #
1077
+ # class Author
1078
+ # has_many :posts, dependent: :destroy
1079
+ # end
1080
+ # Author.find(1).destroy # => Will destroy all of the author's posts, too
1081
+ #
1082
+ # The <tt>:dependent</tt> option can have different values which specify how the deletion
1083
+ # is done. For more information, see the documentation for this option on the different
1084
+ # specific association types. When no option is given, the behavior is to do nothing
1085
+ # with the associated records when destroying a record.
1086
+ #
1087
+ # Note that <tt>:dependent</tt> is implemented using Rails' callback
1088
+ # system, which works by processing callbacks in order. Therefore, other
1089
+ # callbacks declared either before or after the <tt>:dependent</tt> option
1090
+ # can affect what it does.
1091
+ #
1092
+ # Note that <tt>:dependent</tt> option is ignored for #has_one <tt>:through</tt> associations.
1093
+ #
1094
+ # === Delete or destroy?
1095
+ #
1096
+ # #has_many and #has_and_belongs_to_many associations have the methods <tt>destroy</tt>,
1097
+ # <tt>delete</tt>, <tt>destroy_all</tt> and <tt>delete_all</tt>.
1098
+ #
1099
+ # For #has_and_belongs_to_many, <tt>delete</tt> and <tt>destroy</tt> are the same: they
1100
+ # cause the records in the join table to be removed.
1101
+ #
1102
+ # For #has_many, <tt>destroy</tt> and <tt>destroy_all</tt> will always call the <tt>destroy</tt> method of the
1103
+ # record(s) being removed so that callbacks are run. However <tt>delete</tt> and <tt>delete_all</tt> will either
1104
+ # do the deletion according to the strategy specified by the <tt>:dependent</tt> option, or
1105
+ # if no <tt>:dependent</tt> option is given, then it will follow the default strategy.
1106
+ # The default strategy is to do nothing (leave the foreign keys with the parent ids set), except for
1107
+ # #has_many <tt>:through</tt>, where the default strategy is <tt>delete_all</tt> (delete
1108
+ # the join records, without running their callbacks).
1109
+ #
1110
+ # There is also a <tt>clear</tt> method which is the same as <tt>delete_all</tt>, except that
1111
+ # it returns the association rather than the records which have been deleted.
1112
+ #
1113
+ # === What gets deleted?
1114
+ #
1115
+ # There is a potential pitfall here: #has_and_belongs_to_many and #has_many <tt>:through</tt>
1116
+ # associations have records in join tables, as well as the associated records. So when we
1117
+ # call one of these deletion methods, what exactly should be deleted?
1118
+ #
1119
+ # The answer is that it is assumed that deletion on an association is about removing the
1120
+ # <i>link</i> between the owner and the associated object(s), rather than necessarily the
1121
+ # associated objects themselves. So with #has_and_belongs_to_many and #has_many
1122
+ # <tt>:through</tt>, the join records will be deleted, but the associated records won't.
1123
+ #
1124
+ # This makes sense if you think about it: if you were to call <tt>post.tags.delete(Tag.find_by(name: 'food'))</tt>
1125
+ # you would want the 'food' tag to be unlinked from the post, rather than for the tag itself
1126
+ # to be removed from the database.
1127
+ #
1128
+ # However, there are examples where this strategy doesn't make sense. For example, suppose
1129
+ # a person has many projects, and each project has many tasks. If we deleted one of a person's
1130
+ # tasks, we would probably not want the project to be deleted. In this scenario, the delete method
1131
+ # won't actually work: it can only be used if the association on the join model is a
1132
+ # #belongs_to. In other situations you are expected to perform operations directly on
1133
+ # either the associated records or the <tt>:through</tt> association.
1134
+ #
1135
+ # With a regular #has_many there is no distinction between the "associated records"
1136
+ # and the "link", so there is only one choice for what gets deleted.
1137
+ #
1138
+ # With #has_and_belongs_to_many and #has_many <tt>:through</tt>, if you want to delete the
1139
+ # associated records themselves, you can always do something along the lines of
1140
+ # <tt>person.tasks.each(&:destroy)</tt>.
1141
+ #
1142
+ # == Type safety with ActiveRecord::AssociationTypeMismatch
1143
+ #
1144
+ # If you attempt to assign an object to an association that doesn't match the inferred
1145
+ # or specified <tt>:class_name</tt>, you'll get an ActiveRecord::AssociationTypeMismatch.
1146
+ #
1147
+ # == Options
1148
+ #
1149
+ # All of the association macros can be specialized through options. This makes cases
1150
+ # more complex than the simple and guessable ones possible.
1151
+ module ClassMethods
1152
+ # Specifies a one-to-many association. The following methods for retrieval and query of
1153
+ # collections of associated objects will be added:
1154
+ #
1155
+ # +collection+ is a placeholder for the symbol passed as the +name+ argument, so
1156
+ # <tt>has_many :clients</tt> would add among others <tt>clients.empty?</tt>.
1157
+ #
1158
+ # [collection]
1159
+ # Returns a Relation of all the associated objects.
1160
+ # An empty Relation is returned if none are found.
1161
+ # [collection<<(object, ...)]
1162
+ # Adds one or more objects to the collection by setting their foreign keys to the collection's primary key.
1163
+ # Note that this operation instantly fires update SQL without waiting for the save or update call on the
1164
+ # parent object, unless the parent object is a new record.
1165
+ # This will also run validations and callbacks of associated object(s).
1166
+ # [collection.delete(object, ...)]
1167
+ # Removes one or more objects from the collection by setting their foreign keys to +NULL+.
1168
+ # Objects will be in addition destroyed if they're associated with <tt>dependent: :destroy</tt>,
1169
+ # and deleted if they're associated with <tt>dependent: :delete_all</tt>.
1170
+ #
1171
+ # If the <tt>:through</tt> option is used, then the join records are deleted (rather than
1172
+ # nullified) by default, but you can specify <tt>dependent: :destroy</tt> or
1173
+ # <tt>dependent: :nullify</tt> to override this.
1174
+ # [collection.destroy(object, ...)]
1175
+ # Removes one or more objects from the collection by running <tt>destroy</tt> on
1176
+ # each record, regardless of any dependent option, ensuring callbacks are run.
1177
+ #
1178
+ # If the <tt>:through</tt> option is used, then the join records are destroyed
1179
+ # instead, not the objects themselves.
1180
+ # [collection=objects]
1181
+ # Replaces the collections content by deleting and adding objects as appropriate. If the <tt>:through</tt>
1182
+ # option is true callbacks in the join models are triggered except destroy callbacks, since deletion is
1183
+ # direct by default. You can specify <tt>dependent: :destroy</tt> or
1184
+ # <tt>dependent: :nullify</tt> to override this.
1185
+ # [collection_singular_ids]
1186
+ # Returns an array of the associated objects' ids
1187
+ # [collection_singular_ids=ids]
1188
+ # Replace the collection with the objects identified by the primary keys in +ids+. This
1189
+ # method loads the models and calls <tt>collection=</tt>. See above.
1190
+ # [collection.clear]
1191
+ # Removes every object from the collection. This destroys the associated objects if they
1192
+ # are associated with <tt>dependent: :destroy</tt>, deletes them directly from the
1193
+ # database if <tt>dependent: :delete_all</tt>, otherwise sets their foreign keys to +NULL+.
1194
+ # If the <tt>:through</tt> option is true no destroy callbacks are invoked on the join models.
1195
+ # Join models are directly deleted.
1196
+ # [collection.empty?]
1197
+ # Returns +true+ if there are no associated objects.
1198
+ # [collection.size]
1199
+ # Returns the number of associated objects.
1200
+ # [collection.find(...)]
1201
+ # Finds an associated object according to the same rules as ActiveRecord::FinderMethods#find.
1202
+ # [collection.exists?(...)]
1203
+ # Checks whether an associated object with the given conditions exists.
1204
+ # Uses the same rules as ActiveRecord::FinderMethods#exists?.
1205
+ # [collection.build(attributes = {}, ...)]
1206
+ # Returns one or more new objects of the collection type that have been instantiated
1207
+ # with +attributes+ and linked to this object through a foreign key, but have not yet
1208
+ # been saved.
1209
+ # [collection.create(attributes = {})]
1210
+ # Returns a new object of the collection type that has been instantiated
1211
+ # with +attributes+, linked to this object through a foreign key, and that has already
1212
+ # been saved (if it passed the validation). *Note*: This only works if the base model
1213
+ # already exists in the DB, not if it is a new (unsaved) record!
1214
+ # [collection.create!(attributes = {})]
1215
+ # Does the same as <tt>collection.create</tt>, but raises ActiveRecord::RecordInvalid
1216
+ # if the record is invalid.
1217
+ # [collection.reload]
1218
+ # Returns a Relation of all of the associated objects, forcing a database read.
1219
+ # An empty Relation is returned if none are found.
1220
+ #
1221
+ # === Example
1222
+ #
1223
+ # A <tt>Firm</tt> class declares <tt>has_many :clients</tt>, which will add:
1224
+ # * <tt>Firm#clients</tt> (similar to <tt>Client.where(firm_id: id)</tt>)
1225
+ # * <tt>Firm#clients<<</tt>
1226
+ # * <tt>Firm#clients.delete</tt>
1227
+ # * <tt>Firm#clients.destroy</tt>
1228
+ # * <tt>Firm#clients=</tt>
1229
+ # * <tt>Firm#client_ids</tt>
1230
+ # * <tt>Firm#client_ids=</tt>
1231
+ # * <tt>Firm#clients.clear</tt>
1232
+ # * <tt>Firm#clients.empty?</tt> (similar to <tt>firm.clients.size == 0</tt>)
1233
+ # * <tt>Firm#clients.size</tt> (similar to <tt>Client.count "firm_id = #{id}"</tt>)
1234
+ # * <tt>Firm#clients.find</tt> (similar to <tt>Client.where(firm_id: id).find(id)</tt>)
1235
+ # * <tt>Firm#clients.exists?(name: 'ACME')</tt> (similar to <tt>Client.exists?(name: 'ACME', firm_id: firm.id)</tt>)
1236
+ # * <tt>Firm#clients.build</tt> (similar to <tt>Client.new(firm_id: id)</tt>)
1237
+ # * <tt>Firm#clients.create</tt> (similar to <tt>c = Client.new(firm_id: id); c.save; c</tt>)
1238
+ # * <tt>Firm#clients.create!</tt> (similar to <tt>c = Client.new(firm_id: id); c.save!</tt>)
1239
+ # * <tt>Firm#clients.reload</tt>
1240
+ # The declaration can also include an +options+ hash to specialize the behavior of the association.
1241
+ #
1242
+ # === Scopes
1243
+ #
1244
+ # You can pass a second argument +scope+ as a callable (i.e. proc or
1245
+ # lambda) to retrieve a specific set of records or customize the generated
1246
+ # query when you access the associated collection.
1247
+ #
1248
+ # Scope examples:
1249
+ # has_many :comments, -> { where(author_id: 1) }
1250
+ # has_many :employees, -> { joins(:address) }
1251
+ # has_many :posts, ->(blog) { where("max_post_length > ?", blog.max_post_length) }
1252
+ #
1253
+ # === Extensions
1254
+ #
1255
+ # The +extension+ argument allows you to pass a block into a has_many
1256
+ # association. This is useful for adding new finders, creators and other
1257
+ # factory-type methods to be used as part of the association.
1258
+ #
1259
+ # Extension examples:
1260
+ # has_many :employees do
1261
+ # def find_or_create_by_name(name)
1262
+ # first_name, last_name = name.split(" ", 2)
1263
+ # find_or_create_by(first_name: first_name, last_name: last_name)
1264
+ # end
1265
+ # end
1266
+ #
1267
+ # === Options
1268
+ # [:class_name]
1269
+ # Specify the class name of the association. Use it only if that name can't be inferred
1270
+ # from the association name. So <tt>has_many :products</tt> will by default be linked
1271
+ # to the +Product+ class, but if the real class name is +SpecialProduct+, you'll have to
1272
+ # specify it with this option.
1273
+ # [:foreign_key]
1274
+ # Specify the foreign key used for the association. By default this is guessed to be the name
1275
+ # of this class in lower-case and "_id" suffixed. So a Person class that makes a #has_many
1276
+ # association will use "person_id" as the default <tt>:foreign_key</tt>.
1277
+ #
1278
+ # If you are going to modify the association (rather than just read from it), then it is
1279
+ # a good idea to set the <tt>:inverse_of</tt> option.
1280
+ # [:foreign_type]
1281
+ # Specify the column used to store the associated object's type, if this is a polymorphic
1282
+ # association. By default this is guessed to be the name of the polymorphic association
1283
+ # specified on "as" option with a "_type" suffix. So a class that defines a
1284
+ # <tt>has_many :tags, as: :taggable</tt> association will use "taggable_type" as the
1285
+ # default <tt>:foreign_type</tt>.
1286
+ # [:primary_key]
1287
+ # Specify the name of the column to use as the primary key for the association. By default this is +id+.
1288
+ # [:dependent]
1289
+ # Controls what happens to the associated objects when
1290
+ # their owner is destroyed. Note that these are implemented as
1291
+ # callbacks, and Rails executes callbacks in order. Therefore, other
1292
+ # similar callbacks may affect the <tt>:dependent</tt> behavior, and the
1293
+ # <tt>:dependent</tt> behavior may affect other callbacks.
1294
+ #
1295
+ # * <tt>:destroy</tt> causes all the associated objects to also be destroyed.
1296
+ # * <tt>:delete_all</tt> causes all the associated objects to be deleted directly from the database (so callbacks will not be executed).
1297
+ # * <tt>:nullify</tt> causes the foreign keys to be set to +NULL+. Polymorphic type will also be nullified
1298
+ # on polymorphic associations. Callbacks are not executed.
1299
+ # * <tt>:restrict_with_exception</tt> causes an <tt>ActiveRecord::DeleteRestrictionError</tt> exception to be raised if there are any associated records.
1300
+ # * <tt>:restrict_with_error</tt> causes an error to be added to the owner if there are any associated objects.
1301
+ #
1302
+ # If using with the <tt>:through</tt> option, the association on the join model must be
1303
+ # a #belongs_to, and the records which get deleted are the join records, rather than
1304
+ # the associated records.
1305
+ #
1306
+ # If using <tt>dependent: :destroy</tt> on a scoped association, only the scoped objects are destroyed.
1307
+ # For example, if a Post model defines
1308
+ # <tt>has_many :comments, -> { where published: true }, dependent: :destroy</tt> and <tt>destroy</tt> is
1309
+ # called on a post, only published comments are destroyed. This means that any unpublished comments in the
1310
+ # database would still contain a foreign key pointing to the now deleted post.
1311
+ # [:counter_cache]
1312
+ # This option can be used to configure a custom named <tt>:counter_cache.</tt> You only need this option,
1313
+ # when you customized the name of your <tt>:counter_cache</tt> on the #belongs_to association.
1314
+ # [:as]
1315
+ # Specifies a polymorphic interface (See #belongs_to).
1316
+ # [:through]
1317
+ # Specifies an association through which to perform the query. This can be any other type
1318
+ # of association, including other <tt>:through</tt> associations. Options for <tt>:class_name</tt>,
1319
+ # <tt>:primary_key</tt> and <tt>:foreign_key</tt> are ignored, as the association uses the
1320
+ # source reflection.
1321
+ #
1322
+ # If the association on the join model is a #belongs_to, the collection can be modified
1323
+ # and the records on the <tt>:through</tt> model will be automatically created and removed
1324
+ # as appropriate. Otherwise, the collection is read-only, so you should manipulate the
1325
+ # <tt>:through</tt> association directly.
1326
+ #
1327
+ # If you are going to modify the association (rather than just read from it), then it is
1328
+ # a good idea to set the <tt>:inverse_of</tt> option on the source association on the
1329
+ # join model. This allows associated records to be built which will automatically create
1330
+ # the appropriate join model records when they are saved. (See the 'Association Join Models'
1331
+ # section above.)
1332
+ # [:source]
1333
+ # Specifies the source association name used by #has_many <tt>:through</tt> queries.
1334
+ # Only use it if the name cannot be inferred from the association.
1335
+ # <tt>has_many :subscribers, through: :subscriptions</tt> will look for either <tt>:subscribers</tt> or
1336
+ # <tt>:subscriber</tt> on Subscription, unless a <tt>:source</tt> is given.
1337
+ # [:source_type]
1338
+ # Specifies type of the source association used by #has_many <tt>:through</tt> queries where the source
1339
+ # association is a polymorphic #belongs_to.
1340
+ # [:validate]
1341
+ # When set to +true+, validates new objects added to association when saving the parent object. +true+ by default.
1342
+ # If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
1343
+ # [:autosave]
1344
+ # If true, always save the associated objects or destroy them if marked for destruction,
1345
+ # when saving the parent object. If false, never save or destroy the associated objects.
1346
+ # By default, only save associated objects that are new records. This option is implemented as a
1347
+ # +before_save+ callback. Because callbacks are run in the order they are defined, associated objects
1348
+ # may need to be explicitly saved in any user-defined +before_save+ callbacks.
1349
+ #
1350
+ # Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for sets
1351
+ # <tt>:autosave</tt> to <tt>true</tt>.
1352
+ # [:inverse_of]
1353
+ # Specifies the name of the #belongs_to association on the associated object
1354
+ # that is the inverse of this #has_many association.
1355
+ # See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
1356
+ # [:extend]
1357
+ # Specifies a module or array of modules that will be extended into the association object returned.
1358
+ # Useful for defining methods on associations, especially when they should be shared between multiple
1359
+ # association objects.
1360
+ #
1361
+ # Option examples:
1362
+ # has_many :comments, -> { order("posted_on") }
1363
+ # has_many :comments, -> { includes(:author) }
1364
+ # has_many :people, -> { where(deleted: false).order("name") }, class_name: "Person"
1365
+ # has_many :tracks, -> { order("position") }, dependent: :destroy
1366
+ # has_many :comments, dependent: :nullify
1367
+ # has_many :tags, as: :taggable
1368
+ # has_many :reports, -> { readonly }
1369
+ # has_many :subscribers, through: :subscriptions, source: :user
1370
+ def has_many(name, scope = nil, **options, &extension)
1371
+ reflection = Builder::HasMany.build(self, name, scope, options, &extension)
1372
+ Reflection.add_reflection self, name, reflection
1373
+ end
1374
+
1375
+ # Specifies a one-to-one association with another class. This method should only be used
1376
+ # if the other class contains the foreign key. If the current class contains the foreign key,
1377
+ # then you should use #belongs_to instead. See also ActiveRecord::Associations::ClassMethods's overview
1378
+ # on when to use #has_one and when to use #belongs_to.
1379
+ #
1380
+ # The following methods for retrieval and query of a single associated object will be added:
1381
+ #
1382
+ # +association+ is a placeholder for the symbol passed as the +name+ argument, so
1383
+ # <tt>has_one :manager</tt> would add among others <tt>manager.nil?</tt>.
1384
+ #
1385
+ # [association]
1386
+ # Returns the associated object. +nil+ is returned if none is found.
1387
+ # [association=(associate)]
1388
+ # Assigns the associate object, extracts the primary key, sets it as the foreign key,
1389
+ # and saves the associate object. To avoid database inconsistencies, permanently deletes an existing
1390
+ # associated object when assigning a new one, even if the new one isn't saved to database.
1391
+ # [build_association(attributes = {})]
1392
+ # Returns a new object of the associated type that has been instantiated
1393
+ # with +attributes+ and linked to this object through a foreign key, but has not
1394
+ # yet been saved.
1395
+ # [create_association(attributes = {})]
1396
+ # Returns a new object of the associated type that has been instantiated
1397
+ # with +attributes+, linked to this object through a foreign key, and that
1398
+ # has already been saved (if it passed the validation).
1399
+ # [create_association!(attributes = {})]
1400
+ # Does the same as <tt>create_association</tt>, but raises ActiveRecord::RecordInvalid
1401
+ # if the record is invalid.
1402
+ # [reload_association]
1403
+ # Returns the associated object, forcing a database read.
1404
+ #
1405
+ # === Example
1406
+ #
1407
+ # An Account class declares <tt>has_one :beneficiary</tt>, which will add:
1408
+ # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.where(account_id: id).first</tt>)
1409
+ # * <tt>Account#beneficiary=(beneficiary)</tt> (similar to <tt>beneficiary.account_id = account.id; beneficiary.save</tt>)
1410
+ # * <tt>Account#build_beneficiary</tt> (similar to <tt>Beneficiary.new(account_id: id)</tt>)
1411
+ # * <tt>Account#create_beneficiary</tt> (similar to <tt>b = Beneficiary.new(account_id: id); b.save; b</tt>)
1412
+ # * <tt>Account#create_beneficiary!</tt> (similar to <tt>b = Beneficiary.new(account_id: id); b.save!; b</tt>)
1413
+ # * <tt>Account#reload_beneficiary</tt>
1414
+ #
1415
+ # === Scopes
1416
+ #
1417
+ # You can pass a second argument +scope+ as a callable (i.e. proc or
1418
+ # lambda) to retrieve a specific record or customize the generated query
1419
+ # when you access the associated object.
1420
+ #
1421
+ # Scope examples:
1422
+ # has_one :author, -> { where(comment_id: 1) }
1423
+ # has_one :employer, -> { joins(:company) }
1424
+ # has_one :latest_post, ->(blog) { where("created_at > ?", blog.enabled_at) }
1425
+ #
1426
+ # === Options
1427
+ #
1428
+ # The declaration can also include an +options+ hash to specialize the behavior of the association.
1429
+ #
1430
+ # Options are:
1431
+ # [:class_name]
1432
+ # Specify the class name of the association. Use it only if that name can't be inferred
1433
+ # from the association name. So <tt>has_one :manager</tt> will by default be linked to the Manager class, but
1434
+ # if the real class name is Person, you'll have to specify it with this option.
1435
+ # [:dependent]
1436
+ # Controls what happens to the associated object when
1437
+ # its owner is destroyed:
1438
+ #
1439
+ # * <tt>:destroy</tt> causes the associated object to also be destroyed
1440
+ # * <tt>:delete</tt> causes the associated object to be deleted directly from the database (so callbacks will not execute)
1441
+ # * <tt>:nullify</tt> causes the foreign key to be set to +NULL+. Polymorphic type column is also nullified
1442
+ # on polymorphic associations. Callbacks are not executed.
1443
+ # * <tt>:restrict_with_exception</tt> causes an <tt>ActiveRecord::DeleteRestrictionError</tt> exception to be raised if there is an associated record
1444
+ # * <tt>:restrict_with_error</tt> causes an error to be added to the owner if there is an associated object
1445
+ #
1446
+ # Note that <tt>:dependent</tt> option is ignored when using <tt>:through</tt> option.
1447
+ # [:foreign_key]
1448
+ # Specify the foreign key used for the association. By default this is guessed to be the name
1449
+ # of this class in lower-case and "_id" suffixed. So a Person class that makes a #has_one association
1450
+ # will use "person_id" as the default <tt>:foreign_key</tt>.
1451
+ #
1452
+ # If you are going to modify the association (rather than just read from it), then it is
1453
+ # a good idea to set the <tt>:inverse_of</tt> option.
1454
+ # [:foreign_type]
1455
+ # Specify the column used to store the associated object's type, if this is a polymorphic
1456
+ # association. By default this is guessed to be the name of the polymorphic association
1457
+ # specified on "as" option with a "_type" suffix. So a class that defines a
1458
+ # <tt>has_one :tag, as: :taggable</tt> association will use "taggable_type" as the
1459
+ # default <tt>:foreign_type</tt>.
1460
+ # [:primary_key]
1461
+ # Specify the method that returns the primary key used for the association. By default this is +id+.
1462
+ # [:as]
1463
+ # Specifies a polymorphic interface (See #belongs_to).
1464
+ # [:through]
1465
+ # Specifies a Join Model through which to perform the query. Options for <tt>:class_name</tt>,
1466
+ # <tt>:primary_key</tt>, and <tt>:foreign_key</tt> are ignored, as the association uses the
1467
+ # source reflection. You can only use a <tt>:through</tt> query through a #has_one
1468
+ # or #belongs_to association on the join model.
1469
+ #
1470
+ # If you are going to modify the association (rather than just read from it), then it is
1471
+ # a good idea to set the <tt>:inverse_of</tt> option.
1472
+ # [:source]
1473
+ # Specifies the source association name used by #has_one <tt>:through</tt> queries.
1474
+ # Only use it if the name cannot be inferred from the association.
1475
+ # <tt>has_one :favorite, through: :favorites</tt> will look for a
1476
+ # <tt>:favorite</tt> on Favorite, unless a <tt>:source</tt> is given.
1477
+ # [:source_type]
1478
+ # Specifies type of the source association used by #has_one <tt>:through</tt> queries where the source
1479
+ # association is a polymorphic #belongs_to.
1480
+ # [:validate]
1481
+ # When set to +true+, validates new objects added to association when saving the parent object. +false+ by default.
1482
+ # If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
1483
+ # [:autosave]
1484
+ # If true, always save the associated object or destroy it if marked for destruction,
1485
+ # when saving the parent object. If false, never save or destroy the associated object.
1486
+ # By default, only save the associated object if it's a new record.
1487
+ #
1488
+ # Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for sets
1489
+ # <tt>:autosave</tt> to <tt>true</tt>.
1490
+ # [:inverse_of]
1491
+ # Specifies the name of the #belongs_to association on the associated object
1492
+ # that is the inverse of this #has_one association.
1493
+ # See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
1494
+ # [:required]
1495
+ # When set to +true+, the association will also have its presence validated.
1496
+ # This will validate the association itself, not the id. You can use
1497
+ # +:inverse_of+ to avoid an extra query during validation.
1498
+ #
1499
+ # Option examples:
1500
+ # has_one :credit_card, dependent: :destroy # destroys the associated credit card
1501
+ # has_one :credit_card, dependent: :nullify # updates the associated records foreign
1502
+ # # key value to NULL rather than destroying it
1503
+ # has_one :last_comment, -> { order('posted_on') }, class_name: "Comment"
1504
+ # has_one :project_manager, -> { where(role: 'project_manager') }, class_name: "Person"
1505
+ # has_one :attachment, as: :attachable
1506
+ # has_one :boss, -> { readonly }
1507
+ # has_one :club, through: :membership
1508
+ # has_one :primary_address, -> { where(primary: true) }, through: :addressables, source: :addressable
1509
+ # has_one :credit_card, required: true
1510
+ def has_one(name, scope = nil, **options)
1511
+ reflection = Builder::HasOne.build(self, name, scope, options)
1512
+ Reflection.add_reflection self, name, reflection
1513
+ end
1514
+
1515
+ # Specifies a one-to-one association with another class. This method should only be used
1516
+ # if this class contains the foreign key. If the other class contains the foreign key,
1517
+ # then you should use #has_one instead. See also ActiveRecord::Associations::ClassMethods's overview
1518
+ # on when to use #has_one and when to use #belongs_to.
1519
+ #
1520
+ # Methods will be added for retrieval and query for a single associated object, for which
1521
+ # this object holds an id:
1522
+ #
1523
+ # +association+ is a placeholder for the symbol passed as the +name+ argument, so
1524
+ # <tt>belongs_to :author</tt> would add among others <tt>author.nil?</tt>.
1525
+ #
1526
+ # [association]
1527
+ # Returns the associated object. +nil+ is returned if none is found.
1528
+ # [association=(associate)]
1529
+ # Assigns the associate object, extracts the primary key, and sets it as the foreign key.
1530
+ # No modification or deletion of existing records takes place.
1531
+ # [build_association(attributes = {})]
1532
+ # Returns a new object of the associated type that has been instantiated
1533
+ # with +attributes+ and linked to this object through a foreign key, but has not yet been saved.
1534
+ # [create_association(attributes = {})]
1535
+ # Returns a new object of the associated type that has been instantiated
1536
+ # with +attributes+, linked to this object through a foreign key, and that
1537
+ # has already been saved (if it passed the validation).
1538
+ # [create_association!(attributes = {})]
1539
+ # Does the same as <tt>create_association</tt>, but raises ActiveRecord::RecordInvalid
1540
+ # if the record is invalid.
1541
+ # [reload_association]
1542
+ # Returns the associated object, forcing a database read.
1543
+ #
1544
+ # === Example
1545
+ #
1546
+ # A Post class declares <tt>belongs_to :author</tt>, which will add:
1547
+ # * <tt>Post#author</tt> (similar to <tt>Author.find(author_id)</tt>)
1548
+ # * <tt>Post#author=(author)</tt> (similar to <tt>post.author_id = author.id</tt>)
1549
+ # * <tt>Post#build_author</tt> (similar to <tt>post.author = Author.new</tt>)
1550
+ # * <tt>Post#create_author</tt> (similar to <tt>post.author = Author.new; post.author.save; post.author</tt>)
1551
+ # * <tt>Post#create_author!</tt> (similar to <tt>post.author = Author.new; post.author.save!; post.author</tt>)
1552
+ # * <tt>Post#reload_author</tt>
1553
+ # The declaration can also include an +options+ hash to specialize the behavior of the association.
1554
+ #
1555
+ # === Scopes
1556
+ #
1557
+ # You can pass a second argument +scope+ as a callable (i.e. proc or
1558
+ # lambda) to retrieve a specific record or customize the generated query
1559
+ # when you access the associated object.
1560
+ #
1561
+ # Scope examples:
1562
+ # belongs_to :firm, -> { where(id: 2) }
1563
+ # belongs_to :user, -> { joins(:friends) }
1564
+ # belongs_to :level, ->(game) { where("game_level > ?", game.current_level) }
1565
+ #
1566
+ # === Options
1567
+ #
1568
+ # [:class_name]
1569
+ # Specify the class name of the association. Use it only if that name can't be inferred
1570
+ # from the association name. So <tt>belongs_to :author</tt> will by default be linked to the Author class, but
1571
+ # if the real class name is Person, you'll have to specify it with this option.
1572
+ # [:foreign_key]
1573
+ # Specify the foreign key used for the association. By default this is guessed to be the name
1574
+ # of the association with an "_id" suffix. So a class that defines a <tt>belongs_to :person</tt>
1575
+ # association will use "person_id" as the default <tt>:foreign_key</tt>. Similarly,
1576
+ # <tt>belongs_to :favorite_person, class_name: "Person"</tt> will use a foreign key
1577
+ # of "favorite_person_id".
1578
+ #
1579
+ # If you are going to modify the association (rather than just read from it), then it is
1580
+ # a good idea to set the <tt>:inverse_of</tt> option.
1581
+ # [:foreign_type]
1582
+ # Specify the column used to store the associated object's type, if this is a polymorphic
1583
+ # association. By default this is guessed to be the name of the association with a "_type"
1584
+ # suffix. So a class that defines a <tt>belongs_to :taggable, polymorphic: true</tt>
1585
+ # association will use "taggable_type" as the default <tt>:foreign_type</tt>.
1586
+ # [:primary_key]
1587
+ # Specify the method that returns the primary key of associated object used for the association.
1588
+ # By default this is +id+.
1589
+ # [:dependent]
1590
+ # If set to <tt>:destroy</tt>, the associated object is destroyed when this object is. If set to
1591
+ # <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method.
1592
+ # This option should not be specified when #belongs_to is used in conjunction with
1593
+ # a #has_many relationship on another class because of the potential to leave
1594
+ # orphaned records behind.
1595
+ # [:counter_cache]
1596
+ # Caches the number of belonging objects on the associate class through the use of CounterCache::ClassMethods#increment_counter
1597
+ # and CounterCache::ClassMethods#decrement_counter. The counter cache is incremented when an object of this
1598
+ # class is created and decremented when it's destroyed. This requires that a column
1599
+ # named <tt>#{table_name}_count</tt> (such as +comments_count+ for a belonging Comment class)
1600
+ # is used on the associate class (such as a Post class) - that is the migration for
1601
+ # <tt>#{table_name}_count</tt> is created on the associate class (such that <tt>Post.comments_count</tt> will
1602
+ # return the count cached, see note below). You can also specify a custom counter
1603
+ # cache column by providing a column name instead of a +true+/+false+ value to this
1604
+ # option (e.g., <tt>counter_cache: :my_custom_counter</tt>.)
1605
+ # Note: Specifying a counter cache will add it to that model's list of readonly attributes
1606
+ # using +attr_readonly+.
1607
+ # [:polymorphic]
1608
+ # Specify this association is a polymorphic association by passing +true+.
1609
+ # Note: If you've enabled the counter cache, then you may want to add the counter cache attribute
1610
+ # to the +attr_readonly+ list in the associated classes (e.g. <tt>class Post; attr_readonly :comments_count; end</tt>).
1611
+ # [:validate]
1612
+ # When set to +true+, validates new objects added to association when saving the parent object. +false+ by default.
1613
+ # If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
1614
+ # [:autosave]
1615
+ # If true, always save the associated object or destroy it if marked for destruction, when
1616
+ # saving the parent object.
1617
+ # If false, never save or destroy the associated object.
1618
+ # By default, only save the associated object if it's a new record.
1619
+ #
1620
+ # Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for
1621
+ # sets <tt>:autosave</tt> to <tt>true</tt>.
1622
+ # [:touch]
1623
+ # If true, the associated object will be touched (the updated_at/on attributes set to current time)
1624
+ # when this record is either saved or destroyed. If you specify a symbol, that attribute
1625
+ # will be updated with the current time in addition to the updated_at/on attribute.
1626
+ # Please note that with touching no validation is performed and only the +after_touch+,
1627
+ # +after_commit+ and +after_rollback+ callbacks are executed.
1628
+ # [:inverse_of]
1629
+ # Specifies the name of the #has_one or #has_many association on the associated
1630
+ # object that is the inverse of this #belongs_to association.
1631
+ # See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
1632
+ # [:optional]
1633
+ # When set to +true+, the association will not have its presence validated.
1634
+ # [:required]
1635
+ # When set to +true+, the association will also have its presence validated.
1636
+ # This will validate the association itself, not the id. You can use
1637
+ # +:inverse_of+ to avoid an extra query during validation.
1638
+ # NOTE: <tt>required</tt> is set to <tt>true</tt> by default and is deprecated. If
1639
+ # you don't want to have association presence validated, use <tt>optional: true</tt>.
1640
+ # [:default]
1641
+ # Provide a callable (i.e. proc or lambda) to specify that the association should
1642
+ # be initialized with a particular record before validation.
1643
+ #
1644
+ # Option examples:
1645
+ # belongs_to :firm, foreign_key: "client_of"
1646
+ # belongs_to :person, primary_key: "name", foreign_key: "person_name"
1647
+ # belongs_to :author, class_name: "Person", foreign_key: "author_id"
1648
+ # belongs_to :valid_coupon, ->(o) { where "discounts > ?", o.payments_count },
1649
+ # class_name: "Coupon", foreign_key: "coupon_id"
1650
+ # belongs_to :attachable, polymorphic: true
1651
+ # belongs_to :project, -> { readonly }
1652
+ # belongs_to :post, counter_cache: true
1653
+ # belongs_to :comment, touch: true
1654
+ # belongs_to :company, touch: :employees_last_updated_at
1655
+ # belongs_to :user, optional: true
1656
+ # belongs_to :account, default: -> { company.account }
1657
+ def belongs_to(name, scope = nil, **options)
1658
+ reflection = Builder::BelongsTo.build(self, name, scope, options)
1659
+ Reflection.add_reflection self, name, reflection
1660
+ end
1661
+
1662
+ # Specifies a many-to-many relationship with another class. This associates two classes via an
1663
+ # intermediate join table. Unless the join table is explicitly specified as an option, it is
1664
+ # guessed using the lexical order of the class names. So a join between Developer and Project
1665
+ # will give the default join table name of "developers_projects" because "D" precedes "P" alphabetically.
1666
+ # Note that this precedence is calculated using the <tt><</tt> operator for String. This
1667
+ # means that if the strings are of different lengths, and the strings are equal when compared
1668
+ # up to the shortest length, then the longer string is considered of higher
1669
+ # lexical precedence than the shorter one. For example, one would expect the tables "paper_boxes" and "papers"
1670
+ # to generate a join table name of "papers_paper_boxes" because of the length of the name "paper_boxes",
1671
+ # but it in fact generates a join table name of "paper_boxes_papers". Be aware of this caveat, and use the
1672
+ # custom <tt>:join_table</tt> option if you need to.
1673
+ # If your tables share a common prefix, it will only appear once at the beginning. For example,
1674
+ # the tables "catalog_categories" and "catalog_products" generate a join table name of "catalog_categories_products".
1675
+ #
1676
+ # The join table should not have a primary key or a model associated with it. You must manually generate the
1677
+ # join table with a migration such as this:
1678
+ #
1679
+ # class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[5.0]
1680
+ # def change
1681
+ # create_join_table :developers, :projects
1682
+ # end
1683
+ # end
1684
+ #
1685
+ # It's also a good idea to add indexes to each of those columns to speed up the joins process.
1686
+ # However, in MySQL it is advised to add a compound index for both of the columns as MySQL only
1687
+ # uses one index per table during the lookup.
1688
+ #
1689
+ # Adds the following methods for retrieval and query:
1690
+ #
1691
+ # +collection+ is a placeholder for the symbol passed as the +name+ argument, so
1692
+ # <tt>has_and_belongs_to_many :categories</tt> would add among others <tt>categories.empty?</tt>.
1693
+ #
1694
+ # [collection]
1695
+ # Returns a Relation of all the associated objects.
1696
+ # An empty Relation is returned if none are found.
1697
+ # [collection<<(object, ...)]
1698
+ # Adds one or more objects to the collection by creating associations in the join table
1699
+ # (<tt>collection.push</tt> and <tt>collection.concat</tt> are aliases to this method).
1700
+ # Note that this operation instantly fires update SQL without waiting for the save or update call on the
1701
+ # parent object, unless the parent object is a new record.
1702
+ # [collection.delete(object, ...)]
1703
+ # Removes one or more objects from the collection by removing their associations from the join table.
1704
+ # This does not destroy the objects.
1705
+ # [collection.destroy(object, ...)]
1706
+ # Removes one or more objects from the collection by running destroy on each association in the join table, overriding any dependent option.
1707
+ # This does not destroy the objects.
1708
+ # [collection=objects]
1709
+ # Replaces the collection's content by deleting and adding objects as appropriate.
1710
+ # [collection_singular_ids]
1711
+ # Returns an array of the associated objects' ids.
1712
+ # [collection_singular_ids=ids]
1713
+ # Replace the collection by the objects identified by the primary keys in +ids+.
1714
+ # [collection.clear]
1715
+ # Removes every object from the collection. This does not destroy the objects.
1716
+ # [collection.empty?]
1717
+ # Returns +true+ if there are no associated objects.
1718
+ # [collection.size]
1719
+ # Returns the number of associated objects.
1720
+ # [collection.find(id)]
1721
+ # Finds an associated object responding to the +id+ and that
1722
+ # meets the condition that it has to be associated with this object.
1723
+ # Uses the same rules as ActiveRecord::FinderMethods#find.
1724
+ # [collection.exists?(...)]
1725
+ # Checks whether an associated object with the given conditions exists.
1726
+ # Uses the same rules as ActiveRecord::FinderMethods#exists?.
1727
+ # [collection.build(attributes = {})]
1728
+ # Returns a new object of the collection type that has been instantiated
1729
+ # with +attributes+ and linked to this object through the join table, but has not yet been saved.
1730
+ # [collection.create(attributes = {})]
1731
+ # Returns a new object of the collection type that has been instantiated
1732
+ # with +attributes+, linked to this object through the join table, and that has already been
1733
+ # saved (if it passed the validation).
1734
+ # [collection.reload]
1735
+ # Returns a Relation of all of the associated objects, forcing a database read.
1736
+ # An empty Relation is returned if none are found.
1737
+ #
1738
+ # === Example
1739
+ #
1740
+ # A Developer class declares <tt>has_and_belongs_to_many :projects</tt>, which will add:
1741
+ # * <tt>Developer#projects</tt>
1742
+ # * <tt>Developer#projects<<</tt>
1743
+ # * <tt>Developer#projects.delete</tt>
1744
+ # * <tt>Developer#projects.destroy</tt>
1745
+ # * <tt>Developer#projects=</tt>
1746
+ # * <tt>Developer#project_ids</tt>
1747
+ # * <tt>Developer#project_ids=</tt>
1748
+ # * <tt>Developer#projects.clear</tt>
1749
+ # * <tt>Developer#projects.empty?</tt>
1750
+ # * <tt>Developer#projects.size</tt>
1751
+ # * <tt>Developer#projects.find(id)</tt>
1752
+ # * <tt>Developer#projects.exists?(...)</tt>
1753
+ # * <tt>Developer#projects.build</tt> (similar to <tt>Project.new(developer_id: id)</tt>)
1754
+ # * <tt>Developer#projects.create</tt> (similar to <tt>c = Project.new(developer_id: id); c.save; c</tt>)
1755
+ # * <tt>Developer#projects.reload</tt>
1756
+ # The declaration may include an +options+ hash to specialize the behavior of the association.
1757
+ #
1758
+ # === Scopes
1759
+ #
1760
+ # You can pass a second argument +scope+ as a callable (i.e. proc or
1761
+ # lambda) to retrieve a specific set of records or customize the generated
1762
+ # query when you access the associated collection.
1763
+ #
1764
+ # Scope examples:
1765
+ # has_and_belongs_to_many :projects, -> { includes(:milestones, :manager) }
1766
+ # has_and_belongs_to_many :categories, ->(post) {
1767
+ # where("default_category = ?", post.default_category)
1768
+ # }
1769
+ #
1770
+ # === Extensions
1771
+ #
1772
+ # The +extension+ argument allows you to pass a block into a
1773
+ # has_and_belongs_to_many association. This is useful for adding new
1774
+ # finders, creators and other factory-type methods to be used as part of
1775
+ # the association.
1776
+ #
1777
+ # Extension examples:
1778
+ # has_and_belongs_to_many :contractors do
1779
+ # def find_or_create_by_name(name)
1780
+ # first_name, last_name = name.split(" ", 2)
1781
+ # find_or_create_by(first_name: first_name, last_name: last_name)
1782
+ # end
1783
+ # end
1784
+ #
1785
+ # === Options
1786
+ #
1787
+ # [:class_name]
1788
+ # Specify the class name of the association. Use it only if that name can't be inferred
1789
+ # from the association name. So <tt>has_and_belongs_to_many :projects</tt> will by default be linked to the
1790
+ # Project class, but if the real class name is SuperProject, you'll have to specify it with this option.
1791
+ # [:join_table]
1792
+ # Specify the name of the join table if the default based on lexical order isn't what you want.
1793
+ # <b>WARNING:</b> If you're overwriting the table name of either class, the +table_name+ method
1794
+ # MUST be declared underneath any #has_and_belongs_to_many declaration in order to work.
1795
+ # [:foreign_key]
1796
+ # Specify the foreign key used for the association. By default this is guessed to be the name
1797
+ # of this class in lower-case and "_id" suffixed. So a Person class that makes
1798
+ # a #has_and_belongs_to_many association to Project will use "person_id" as the
1799
+ # default <tt>:foreign_key</tt>.
1800
+ #
1801
+ # If you are going to modify the association (rather than just read from it), then it is
1802
+ # a good idea to set the <tt>:inverse_of</tt> option.
1803
+ # [:association_foreign_key]
1804
+ # Specify the foreign key used for the association on the receiving side of the association.
1805
+ # By default this is guessed to be the name of the associated class in lower-case and "_id" suffixed.
1806
+ # So if a Person class makes a #has_and_belongs_to_many association to Project,
1807
+ # the association will use "project_id" as the default <tt>:association_foreign_key</tt>.
1808
+ # [:validate]
1809
+ # When set to +true+, validates new objects added to association when saving the parent object. +true+ by default.
1810
+ # If you want to ensure associated objects are revalidated on every update, use +validates_associated+.
1811
+ # [:autosave]
1812
+ # If true, always save the associated objects or destroy them if marked for destruction, when
1813
+ # saving the parent object.
1814
+ # If false, never save or destroy the associated objects.
1815
+ # By default, only save associated objects that are new records.
1816
+ #
1817
+ # Note that NestedAttributes::ClassMethods#accepts_nested_attributes_for sets
1818
+ # <tt>:autosave</tt> to <tt>true</tt>.
1819
+ #
1820
+ # Option examples:
1821
+ # has_and_belongs_to_many :projects
1822
+ # has_and_belongs_to_many :projects, -> { includes(:milestones, :manager) }
1823
+ # has_and_belongs_to_many :nations, class_name: "Country"
1824
+ # has_and_belongs_to_many :categories, join_table: "prods_cats"
1825
+ # has_and_belongs_to_many :categories, -> { readonly }
1826
+ def has_and_belongs_to_many(name, scope = nil, **options, &extension)
1827
+ habtm_reflection = ActiveRecord::Reflection::HasAndBelongsToManyReflection.new(name, scope, options, self)
1828
+
1829
+ builder = Builder::HasAndBelongsToMany.new name, self, options
1830
+
1831
+ join_model = builder.through_model
1832
+
1833
+ const_set join_model.name, join_model
1834
+ private_constant join_model.name
1835
+
1836
+ middle_reflection = builder.middle_reflection join_model
1837
+
1838
+ Builder::HasMany.define_callbacks self, middle_reflection
1839
+ Reflection.add_reflection self, middle_reflection.name, middle_reflection
1840
+ middle_reflection.parent_reflection = habtm_reflection
1841
+
1842
+ include Module.new {
1843
+ class_eval <<-RUBY, __FILE__, __LINE__ + 1
1844
+ def destroy_associations
1845
+ association(:#{middle_reflection.name}).delete_all(:delete_all)
1846
+ association(:#{name}).reset
1847
+ super
1848
+ end
1849
+ RUBY
1850
+ }
1851
+
1852
+ hm_options = {}
1853
+ hm_options[:through] = middle_reflection.name
1854
+ hm_options[:source] = join_model.right_reflection.name
1855
+
1856
+ [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend].each do |k|
1857
+ hm_options[k] = options[k] if options.key? k
1858
+ end
1859
+
1860
+ has_many name, scope, hm_options, &extension
1861
+ _reflections[name.to_s].parent_reflection = habtm_reflection
1862
+ end
1863
+ end
1864
+ end
1865
+ end