[{"authors":"Stefan Kroes, Keenan Brock","built_at":"1980-01-02T00:00:00.000Z","created_at":"2026-03-08T22:01:59.049Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":1168749,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/","rubygems_mfa_required":"true"},"number":"5.1.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"8a073cf6f7e306eeed36af72595abd19602ef4a197bf4beda2f31cf8f55de27b","spec_sha":"fe5bfe03d6db16a338d21fa04dfabf358685e27153f348fba01ece09681c2f5c"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"1980-01-02T00:00:00.000Z","created_at":"2026-02-09T05:00:16.886Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":268892,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/","rubygems_mfa_required":"true"},"number":"5.0.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"f88dd5457e6c9756dc81752f98064cd93447f0230d0b8fe5f911e327c22cecab","spec_sha":"e29db7725cf2a03e3dbb479adc56f118ea0202bc0ea913242792bc6ead9d2e11"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2023-04-10T00:00:00.000Z","created_at":"2023-04-10T23:05:06.284Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":9240333,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"4.3.3","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"af3f6bcf405c219af02eec5b9c8206e68cba8d7976fe5269559ef0986f5e7ca0","spec_sha":"e595d01894a87a4bc3d5fb59f55a2b50f3aea15d6157e88142ac21832607300a"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2023-03-26T00:00:00.000Z","created_at":"2023-03-26T22:31:32.046Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":88562,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"4.3.2","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"08876d26ad89dd045153db6e6b0c36aa223014f58d43130fa3e57b257e17becc","spec_sha":"a731794ff67858ec21c03d8dabc74bb6cf23ffc439df3af63b89315fd87c355b"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2023-03-20T00:00:00.000Z","created_at":"2023-03-20T02:11:55.038Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":50716,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"4.3.1","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"4269933895bbde539c4ddf45d482ae6e83ed0f85804a76bdf4f15d6885bdf08d","spec_sha":"90754ffd03b1b43077459c3507adcf944eeb04f9060cc9c39ee2c1b6fba14d63"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2023-03-09T00:00:00.000Z","created_at":"2023-03-09T21:19:48.648Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":91406,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"4.3.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"82f7b4320c1ce4660b56b76793b0777d39895c894901e734892a36bcadf84901","spec_sha":"a2918e9187aacc133b1fb66611d810868dfa98421b36079676575fc2f2bfa122"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2022-06-10T00:00:00.000Z","created_at":"2022-06-10T03:36:35.682Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":2079693,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"4.2.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"0638ce264f770871adbea2adb1c092bfb55731ae81655ddd8b2b8d92170e0b42","spec_sha":"a42e73ed33fe849d32c2abb2a5f1bd1dc96e988b6e70d018aced2b76e13123f0"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2021-06-28T00:00:00.000Z","created_at":"2021-06-28T17:56:35.780Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":3183818,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"4.1.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.5","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"a9ea983a87d115a75e30876c5f5cbc1e21d5729bd1344d929058f931d82e1fa0","spec_sha":"8e61c26c423461391d5831eab0efc7e7f4a378f2804a90dcc402e6f13cfe2f19"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2021-04-13T00:00:00.000Z","created_at":"2021-04-13T03:01:37.846Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":770687,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"4.0.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.0.0","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"315371a19c0038c990bdc14a2adad46863889a2531ae1383da408e0b7c5af229","spec_sha":"e3de726e70d43a2b05e8219cc27ff46d4a0fecb7ff2f062007b4d95cef84e0b0"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2020-09-23T00:00:00.000Z","created_at":"2020-09-23T23:56:55.923Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":2634898,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.2.1","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.0.0","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"a1905781105a7a49e79960b4983bec6c0425df79849f7457eadc90749832c9cd","spec_sha":"069d632bfef80f008f06760915a1a2a0945c3481c39bc4fcb9465cdeb82c7060"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2020-09-23T00:00:00.000Z","created_at":"2020-09-23T14:39:20.933Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using the materialized path pattern. It exposes the standard\n  relations (ancestors, parent, root, children, siblings, descendants)\n  and allows them to be fetched in a single query. Additional features include\n  named scopes, integrity checking, integrity restoration, arrangement\n  of (sub)tree into hashes and different strategies for dealing with orphaned\n  records.\n","downloads_count":2896,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.2.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.0.0","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"c13e52eac87378f335e38382362009581588dd35e5a60fcebed76295c41388fc","spec_sha":"58c66d5c9adf8f8e549fd4f687ce13a925a6a51e79b4ba52911ed85715ddecfc"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2020-08-03T00:00:00.000Z","created_at":"2020-08-03T23:04:56.453Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":595457,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.1.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 2.0.0","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"a610f52d37a8e59020656cb4df945878578f68b32cc183ba475de2da8476af6a","spec_sha":"ac4d59f75057c51a0913b668e0b017fffa256e4083b5627da416676746354ba0"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2019-06-06T00:00:00.000Z","created_at":"2019-06-06T18:17:24.327Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":7398343,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.0.7","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"38033d6933166d98b38da09ee331575d25bf0cb02751a24ce1ef9722e1a340ed","spec_sha":"209c6e316c25407774f4b2cf4c4652f863bc7d0f885c778c94f3d1216414fc42"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2019-04-24T00:00:00.000Z","created_at":"2019-04-24T14:54:57.266Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":242819,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.0.6","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"68b62624ca32e62cec0f3578bca5d5cbb9e937e4eed74c2897d2133c1b88f716","spec_sha":"f177e2e4e803007a6972e7384069a9006e69cddaf7f850761f23e22b5fc75c2e"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2018-11-06T00:00:00.000Z","created_at":"2018-11-06T18:11:37.101Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":1320880,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.0.5","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"f2d14a679e3556a2970a34e0d5d79ba0a17c8bb7c4622216a44cceae90d723fa","spec_sha":"3635971b8b465b2f3a538e1c4a2555ab1ef097b40ff8f9548a02881132fa7e60"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2018-11-03T00:00:00.000Z","created_at":"2018-11-03T00:19:25.991Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":53203,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.0.4","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"d787124fa235dd44a90683bcee6eaf747d065ffba40da95fecd249dcfdee99df","spec_sha":"2f4b8fbdc57a66cf5a13d2489670d149eb2c2d3551ef3fc1906a8a2af91362cf"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2018-10-23T00:00:00.000Z","created_at":"2018-10-23T16:06:04.311Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":419819,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.0.3","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"8c62c68c83a89f46b5fc276f319bddf595e330fbcab28081e273b3bb04b73d0f","spec_sha":"701bc8ffed2de3ebfdfe7ea478c3a58e169b2ea489faacf46cbe739330101f4d"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2018-04-23T00:00:00.000Z","created_at":"2018-04-23T14:38:42.850Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":1871243,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.0.2","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"f6922b9c2d2bbf7b139a0cc6c8a0023b25f19dc40af3f4b0f01d86fbad5c36b5","spec_sha":"86a9ce75b981a1c590ca4fd0f17a5d92797c8b8799959510da5ee9f640507e59"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2017-07-05T00:00:00.000Z","created_at":"2017-07-05T18:29:26.577Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":2232336,"metadata":{"homepage_uri":"https://github.com/stefankroes/ancestry","changelog_uri":"https://github.com/stefankroes/ancestry/blob/master/CHANGELOG.md","bug_tracker_uri":"https://github.com/stefankroes/ancestry/issues","source_code_uri":"https://github.com/stefankroes/ancestry/"},"number":"3.0.1","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"76245658df6cd2076bc315d30c56579d023040969b601ca1432431227597c2da","spec_sha":"35892fe4b3c237c714c76302388d584b8eaac91d06bc3706fdf4cd6bbaf15ed5"},{"authors":"Stefan Kroes, Keenan Brock","built_at":"2017-05-20T00:00:00.000Z","created_at":"2017-05-20T10:48:51.587Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":153679,"metadata":{},"number":"3.0.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"1cb29f4f836ba9b41d20208728451ee7f56dd6837993a65452ceb965da05d01e","spec_sha":"6300e02ce06a3774eae5741aeb52553a2937c06158c9911c7a5cea3945a8b0cb"},{"authors":"Stefan Kroes","built_at":"2016-11-01T00:00:00.000Z","created_at":"2016-11-01T21:04:51.133Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":1013419,"metadata":{},"number":"2.2.2","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"fb0b66ec33237da004af6d0157c20b5c0d99b2ea5b55f962efe7fb1cfdc26766","spec_sha":"0d449285db50a8d37f7b979b9aa5a12c4d64af14453a22095ac62a7f98b01480"},{"authors":"Stefan Kroes","built_at":"2016-10-25T00:00:00.000Z","created_at":"2016-10-25T21:04:05.436Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":13464,"metadata":{},"number":"2.2.1","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"11d1e7da3f54114f9f6d977a0ed446e0f8196b0db40ac3f2f83df468a8189188","spec_sha":"f1326940c6b6b90e44b0ba85bc7acee9fb7710e58ec700b5e08c1293919aee6c"},{"authors":"Stefan Kroes","built_at":"2016-10-25T00:00:00.000Z","created_at":"2016-10-25T19:39:56.835Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":3396,"metadata":{},"number":"2.2.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 1.8.7","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"9b17b3c58a284df2900ea979be0704787f899684b654e58c98fc7a305ded6265","spec_sha":"5665c037c44d58108d53d03c72679e6f4c7dc7b8b376af7df48a32f0207a13a0"},{"authors":"Stefan Kroes","built_at":"2014-04-16T00:00:00.000Z","created_at":"2014-04-16T10:25:40.238Z","description":"  Ancestry allows the records of a ActiveRecord model to be organized in a tree\n  structure, using a single, intuitively formatted database column. It exposes\n  all the standard tree structure relations (ancestors, parent, root, children,\n  siblings, descendants) and all of them can be fetched in a single sql query.\n  Additional features are named_scopes, integrity checking, integrity restoration,\n  arrangement of (sub)tree into hashes and different strategies for dealing with\n  orphaned records.\n","downloads_count":2220695,"metadata":{},"number":"2.1.0","summary":"Organize ActiveRecord model into a tree structure","platform":"ruby","rubygems_version":">= 0","ruby_version":">= 0","prerelease":false,"licenses":["MIT"],"requirements":[],"sha":"1a83d0ef11e260b6eef34e67595843959bdae13b6d3fab905de6a42975949405","spec_sha":"297b1b3301842e2f21dfab36b390d4da8fb7b92ace15a9bb72cf65bca494884a"},{"authors":"Stefan Kroes","built_at":"2013-05-17T00:00:00.000Z","created_at":"2013-05-17T15:07:25.591Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":567338,"metadata":{},"number":"2.0.0","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":[],"requirements":null,"sha":"0d74af95229faed077af5c0dedf405e3b4519362353fdf9c7df740c9568778c0","spec_sha":"442c9e77cb73fe204cf6f8659a2a23300cfd9516404a449a746abb496dd96503"},{"authors":"Stefan Kroes","built_at":"2013-05-07T00:00:00.000Z","created_at":"2013-05-07T14:11:26.151Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":3276,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"2.0.0.rc1","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":"> 1.3.1","ruby_version":null,"prerelease":true,"licenses":[],"requirements":null,"sha":"4199a47ef09dec334d4214ee192788096af7a863839faba5f59d61fd0f3576f8","spec_sha":"e083a0ac4d4cf25dca5383447d6d3cc8d1040dda9519fc7c574712138c6e56e6"},{"authors":"Stefan Kroes","built_at":"2012-05-03T22:00:00.000Z","created_at":"2012-05-04T12:01:19.665Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":520785,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.3.0","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"15d3b8a7d2792a8529c6ffc3410e484086daa1f1cac15111efca05fd9c0fee8c","spec_sha":"d588475799b7bcc23bf8c55bf6c06a1b182701ddae8f463d66de30ef1a79ad60"},{"authors":"Stefan Kroes","built_at":"2012-03-14T23:00:00.000Z","created_at":"2012-03-15T12:15:02.912Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":133988,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.2.5","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"8f89af8dfe153cce7a79cbfdad1156bc59a744b2e03a897aae5e987a31520f8d","spec_sha":"8aa5ba73fc35fef37c63620369672edb9ffbfff3bf96f808ec47f77191703446"},{"authors":"Stefan Kroes","built_at":"2011-04-21T22:00:00.000Z","created_at":"2011-04-22T07:53:20.209Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":107897,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.2.4","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"ffc43a77415f9d4799a055ba27e4aa98f0070ca6b2c2448caaa80eee08a11e22","spec_sha":"24d1afb85cbb9da94781c12dd7c49c8ab4abafe1f635e354057733b7a7075dad"},{"authors":"Stefan Kroes","built_at":"2010-10-27T22:00:00.000Z","created_at":"2010-10-28T07:16:11.920Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":20678,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.2.3","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"3175249429d02fd289f9d435d1f2acbbc459a187ec8a6027232a2ed3f007a322","spec_sha":"d0aa999172d2d84218e2e48b773255cc413a03d2e668a8de4825dce3c9c4cd45"},{"authors":"Stefan Kroes","built_at":"2010-10-23T22:00:00.000Z","created_at":"2010-10-24T09:35:23.336Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":6400,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.2.2","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"51af95dfcc425cf8feee51361e790657dd29f6c3761d652f1006ac15158cf50d","spec_sha":"6d4eacef8c25c40f9b74cb467fabcebae5fa6862b99d140f9a69e5a1a474ad8d"},{"authors":"Stefan Kroes","built_at":"2010-01-26T23:00:00.000Z","created_at":"2010-02-27T16:55:52.900Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":14696,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.2.0","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"36e6f7202e40daa46e6ae8bf7c0168f1f590166d8b6593980318ef8f8bcd1d25","spec_sha":"ee788b8104e264813743abf597bb7ddcdfd85bed499fcc7c4d84a00038266842"},{"authors":"Stefan Kroes","built_at":"2009-11-07T02:00:00.000Z","created_at":"2009-11-07T12:20:37.924Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":9288,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.1.4","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"74c2a4e61b30cd39bb0392a25abfaf55076355e42d9431cc0854ac447584deae","spec_sha":"6ec1d8117adb2afd54567cda4e136186f44062f99d8c4b6cacb5c3d41339a0f6"},{"authors":"Stefan Kroes","built_at":"2009-11-01T01:00:00.000Z","created_at":"2009-11-01T16:36:45.748Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":6310,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.1.3","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"7d54c5cf82d6e0be0bde749e2526f9122fe4ee6c8ec5a486b303e338a39ade16","spec_sha":"a6d53682bdc52f96f185bf51e815dfd9f8ecc3935873006c2bd5fc8e836651c7"},{"authors":"Stefan Kroes","built_at":"2009-10-29T02:00:00.000Z","created_at":"2009-10-29T14:32:41.090Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":6214,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.1.2","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"4e39b15b0a2ae97d7a8fe25855c988be1df522344d2d9ebaa24137b78a38811d","spec_sha":"57eccfcac7e021314179e07c329c93753451cd75ad1113c4895412c0d00c9a12"},{"authors":"Stefan Kroes","built_at":"2009-10-29T02:00:00.000Z","created_at":"2009-10-28T10:56:01.125Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":6279,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.1.1","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"6f5a3531b70fad4f4939ecf3f3ed260bcd0aafd770d463c3c68a8031aad28412","spec_sha":"2322ab8334382bc20b4f4bd6e8c284e6eed32557057fae17b2fdb11ab61e1f11"},{"authors":"Stefan Kroes","built_at":"2009-10-22T01:00:00.000Z","created_at":"2009-10-22T17:36:22.417Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":5984,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.1.0","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"968de67d14c1fcf89d17749df3b435b88bd1f9e427d5a7512fc0d54b2a494bc0","spec_sha":"a31e1422d741b297acaf2b508ec062044153b70a2f1581a2b8806ba8924f306a"},{"authors":"Stefan Kroes","built_at":"2009-10-16T01:00:00.000Z","created_at":"2009-10-16T16:18:52.272Z","description":"Organise ActiveRecord model into a tree structure","downloads_count":6123,"metadata":{"wiki_uri":"https://github.com/stefankroes/ancestry/wiki","homepage_uri":"https://github.com/stefankroes/ancestry","bug_tracker_uri":"http://github.com/stefankroes/ancestry/issues","source_code_uri":"http://github.com/stefankroes/ancestry","mailing_list_uri":"","documentation_uri":"http://github.com/stefankroes/ancestry"},"number":"1.0.0","summary":"Ancestry allows the records of a ActiveRecord model to be organised in a tree structure, using a single, intuitively formatted database column. It exposes all the standard tree structure relations (ancestors, parent, root, children, siblings, descendants) and all of them can be fetched in a single sql query. Additional features are named_scopes, integrity checking, integrity restoration, arrangement of (sub)tree into hashes and different strategies for dealing with orphaned records.","platform":"ruby","rubygems_version":">= 0","ruby_version":null,"prerelease":false,"licenses":null,"requirements":null,"sha":"3b80d02772d7dd80edd9caadf3031f80a0d7b99641b50eb18173fae8d2d90ea0","spec_sha":"b6907fb286bdf310f61e4f09305a09fa877a298b30bcffbfb8295c1d7a1ecd6c"}]