openehr-rails 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf0122af26f620b3082c006c5d469fdf3710c5dd1647b856c9024c8e4e3f7c66
-  data.tar.gz: b54d925956180cd9baffab027d42564ecd55864f839698952ed2bfbfdfb9356d
+  metadata.gz: a30bd4a561f8193c0603c1e43e1873e1c8835d2e7c418b95c429ac6e2b397e83
+  data.tar.gz: 180145cf2e294cc68ae84ddc35b147e07e6fb52f99062d14f8df3cb0e306108e
 SHA512:
-  metadata.gz: 90fadabcf5f3215e6c24f4c75f5bef98e38b831286e0f0da33d6d67ae6743937d7958d286384c85042830452e47fe08e22eca6dce72541ab7bfb5395cc029ef2
-  data.tar.gz: 700d4afc6e60805cc76c478035131d0aa62b5f0decc09d44c67f0ac1bb4e8181500de65ba56b40f2974a0e24259945fb26285a6b3eac0ebe3ca394656cdc1c56
+  metadata.gz: 46b84468c263139208e522562831d103cd43d8d3c865aa274fe7cf6db7ebe486fa67329b4e175564a9fc0f94d0a0a4454d679f3d42735ac4c7214b739fa7ba3a
+  data.tar.gz: dc189063ef16d43253287e9fed472bdc7d69b0b0c72fb5f393f772cf9adbe596ebd24b6dbea57514435c3a6afe8cdba048fd4b1c3c2e73e39b4a17315ad03b6d

data/.github/workflows/release.yml

@@ -26,6 +26,8 @@ jobs:
         run: bundle exec rake release:check
       - name: Build gem
         run: bundle exec rake build
+      - name: Record sha256
+        run: sha256sum pkg/*.gem | tee pkg/SHA256SUMS
       - name: Upload gem artifact
         uses: actions/upload-artifact@v7
         with:

data/.ruby-version

@@ -1 +1 @@
-4.0.6
+4.0.7

data/CHANGELOG.md

@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-10-12
+
+> **Upgrade note.** A stored Composition holding a `SECTION` or an `INSTRUCTION`
+> (with its `ACTIVITY`s) now reads back through `to_rm` and AQL; the ones 0.7.1
+> skipped with `openehr-rails AQL: skipping composition uid=...` are exactly the
+> ones that become visible, so query row counts can grow. Two injected defaults
+> are approximations until a later release persists them as columns: an
+> INSTRUCTION without a stored narrative reads back with its node name as
+> `narrative`, and every ACTIVITY with `action_archetype_id` `'/.*/'`.
+
+### Added
+- `RmObjectBuilder` rebuilds `SECTION`, `INSTRUCTION` and `ACTIVITY` nodes (and
+  every CARE_ENTRY's `protocol`), so compositions holding them -- a referral's
+  `service_request` with its requester/receiver under `protocol[...]`, entries
+  nested in a `SECTION` -- become readable through `to_rm` and queryable by AQL
+  instead of being skipped with the 0.7.1 warning (#45). Two values are
+  **approximations** because the graph does not carry them yet: an INSTRUCTION
+  without a stored narrative gets its node name as `narrative`, and every
+  ACTIVITY gets `action_archetype_id` `'/.*/'` (any ACTION archetype). Both will
+  be persisted as columns in a later release. `ACTION`, `ITEM_SINGLE` and
+  `ITEM_TABLE` are still unsupported (skipped with the warning).
+- `FieldExtractor` fields carry `rm_type_alternatives`: every value type the OPT
+  allows for the ELEMENT, in OPT order (e.g. `["DV_TEXT", "DV_CODED_TEXT"]` for
+  `problem_diagnosis` at0002). Additive; the chosen `rm_type` is unchanged. Lets a
+  host app tell an OR-constrained coded text (free text allowed) from a coded-only
+  one instead of rendering an empty select (#52, anlage #33).
+
+### Fixed
+- An entry with no extracted leaves (today every `INSTRUCTION`, see #47) no
+  longer gets a profile consisting of the archetype `code` rules and an empty
+  `component` slicing header; it is skipped and reported through `#skipped`
+  with a message saying the entry has no leaves, whatever its resource (#49).
+
 ## [0.7.1] - 2026-09-25
 
 > **Upgrade note.** AQL now skips a stored composition that holds an RM type

data/CLAUDE.md

@@ -61,6 +61,13 @@ documentation files and `lib/` was byte-identical - but nothing in the release
 path caught it. Measurements in `docs/reports/fsh-generator-log.md` R8; the
 matching `release:check` guard is `skoba/openehr-rails#34`.)
 
+**Local dev Ruby tracks the patch release CI builds with.** `.ruby-version`
+moved 4.0.6 -> 4.0.7 (2026-10-12) so a local rebuild at the tag stamps the same
+`rubygems_version` (4.0.20) as `ruby/setup-ruby`'s ruby 4.0 image did for 0.7.1,
+whose `metadata.gz` differed from the local rebuild by that one line
+(`docs/reports/referral-upstream-log.md` R2). The cross-check still judges by
+`data.tar.gz`, not the whole-gem sha256: the two toolchains can drift apart again.
+
 **Confirm publication by checksum, not by version number.** RubyGems publishes
 the sha256 it recorded at push time (`/api/v1/gems/openehr-rails.json` `sha`, and
 the `checksum:` field in `https://index.rubygems.org/info/openehr-rails`). The
@@ -225,7 +232,7 @@ This is `openehr-rails`, a Rails engine gem that turns an openEHR Operational Te
 
 ## Development Notes
 
-- Ruby 3.3+ required (raised from 3.0 in 2026-08 to track the `openehr` gem dependency dropping Ruby 3.2 support at EOL); CI matrix covers 3.3/3.4/4.0, local dev pinned via `.ruby-version` (currently 4.0.6)
+- Ruby 3.3+ required (raised from 3.0 in 2026-08 to track the `openehr` gem dependency dropping Ruby 3.2 support at EOL); CI matrix covers 3.3/3.4/4.0, local dev pinned via `.ruby-version` (currently 4.0.7)
 - Rails 7.0+ and Rails 8.x supported (CI matrix: `gemfiles/rails_{7_2,8_0,8_1}.gemfile`; demo app runs on Rails 8.1)
 - URI compatibility workaround implemented for Ruby 3.4
 - `ostruct` is an explicit development dependency — it left Ruby's default gems as of 4.0, and a couple of specs use `OpenStruct` as a lightweight test double

data/docs/backlog.md

@@ -81,7 +81,18 @@ that verification is deferred to the next real release (>= 0.5.0), not simulated
   against the value recorded for that run" cannot be followed literally; the
   tag-rebuild cross-check is what pins the bytes today. Add a "Record sha256" step
   after `rake build` (`sha256sum pkg/*.gem`), as openehr-ruby's `release.yml` has.
-  CI-only change; needs a PR, no Issue.
+  CI-only change; needs a PR, no Issue. **In PR #51 as `1410274` (2026-10-12,
+  `docs/reports/referral-upstream-log.md` R5)**; first run that prints it will be
+  the `v0.8.0` tag's.
+- **The tag-rebuild cross-check compares `data.tar.gz`, not the whole `.gem`**
+  (0.7.1, 2026-09-25, `docs/reports/referral-upstream-log.md` R2). A `.gem` embeds
+  `rubygems_version` in `metadata.gz`, so a rebuild on a different ruby/rubygems
+  (local 4.0.6/4.0.16 vs CI 4.0.7/4.0.20) yields a different whole-gem sha256 with
+  byte-identical shipped files. Procedure: `tar xf` both gems, compare
+  `sha256sum data.tar.gz` (must match) and `diff` the gunzipped `metadata.gz`
+  (only `rubygems_version` may differ). 0.7.0's whole-gem match was a coincidence
+  of equal toolchains. Fold this into `CLAUDE.md`'s Release convention together
+  with the "Record sha256" step above.
 
 **Done (2026-08-23, PR #28)** — kept below for the original rationale; see the CI
 status entry above for verification details.

data/docs/reports/referral-upstream-log.md

@@ -62,3 +62,242 @@ release carrying it is 0.8.0.
 
 Gate when the human has merged what should ride; version number decided from the
 merged content (0.7.1 if patch-only, 0.8.0 if #45 rides).
+
+## R2 -- 0.7.1 gate approved and tagged; artifact sha256 differs from the tag rebuild by the rubygems stamp only (2026-09-25)
+
+### Gate (approved by the 統括, 2026-09-25)
+
+`master` `df93c71` (= #43 + #50 merged): `lib/` touched by `5fcc0ec` (#38) and
+`dd157b6` (#44), both bug fixes -> **patch**; gemspec / version / dependencies
+unchanged; everything else docs. **0.7.1**, #45 deliberately excluded (minor ->
+0.8.0 later, its own inventory). CHANGELOG plan adopted with one addition asked
+for by the ruling: a one-line Upgrade note that AQL now warns and skips instead
+of failing every query, quoting the log line
+`openehr-rails AQL: skipping composition uid=...` so an operator can find it.
+
+### Release
+
+- `ceb4c5b` Release: bump version to 0.7.1 (`version.rb`, `[0.7.1] - 2026-09-25`
+  with the Upgrade note, fresh empty `[Unreleased]`). Before it: full suite
+  **311 examples, 0 failures**, rubocop **no offenses**, `release:check OK`;
+  `master` CI run 36128248178 success.
+- Tag `v0.7.1` -> `ceb4c5b`, **annotated** this time (`git tag -a`, the R14
+  correction applied).
+- `release.yml` run **36128715938**: 12 jobs success, `release:check OK` at the
+  tag. Artifact `pkg/openehr-rails-0.7.1.gem`, 251904 bytes,
+  sha256 **`29e89993894fe974a1f7eb1cbd51b1809c67aadd1cd5917f4b01af8142159784`**.
+  upload-artifact archive digest (not the gem): `216aff34…7c9a`.
+
+### The rebuild cross-check did not match, and why that is fine
+
+A `gem build` in a scratch worktree at `v0.7.1` (local ruby 4.0.6, rubygems
+4.0.16) gave sha256 `fd06e784…4f8a`, **not** the artifact's. Taken apart
+(`tar xf`; the .gem is a tar of `metadata.gz`, `data.tar.gz`, `checksums.yaml.gz`):
+
+| part | CI artifact | local rebuild |
+|---|---|---|
+| `data.tar.gz` (the shipped files) | `b54d9259…` | `b54d9259…` **identical** |
+| `metadata.gz` | differs on one line: `rubygems_version: 4.0.20` (CI ruby 4.0.7) | `rubygems_version: 4.0.16` |
+| `checksums.yaml.gz` | differs (it hashes metadata) | -- |
+
+So the bytes host apps load are identical; only rubygems' own version stamp
+moved, because `ruby/setup-ruby`'s ruby 4.0 image advanced from 4.0.6 to 4.0.7
+since 0.7.0 (when both sides happened to run rubygems 4.0.16 and the whole-gem
+sha256 matched). **Lesson, recorded in `docs/backlog.md`**: the rebuild
+cross-check must compare `data.tar.gz` (and `metadata.gz` minus
+`rubygems_version`), not the whole `.gem`; a whole-gem match is a coincidence of
+equal toolchains. The "Record sha256" CI step in the backlog stays the real pin
+for the published bytes.
+
+### Handed to the human
+
+`gem push pkg/openehr-rails-0.7.1.gem` (the downloaded CI artifact), then confirm
+`https://rubygems.org/api/v1/gems/openehr-rails.json` `sha` == `29e89993…9784`
+(compact index `checksum:` likewise), then delete the file from `pkg/`. Result
+-> R3. `master` is past the tag by these docs commits (`release:check` on
+`master` fails by design).
+
+### Pending
+
+#45: the ruling's "conditions a-c" (pre-freeze implementation approved, 0.8.0)
+have not reached this session as text; implementation starts once they do.
+
+## R3 -- 0.7.1 published; confirmed by checksum (2026-09-25)
+
+Human `gem push` of the CI artifact (R2). Confirmation against the artifact's
+sha256 `29e89993894fe974a1f7eb1cbd51b1809c67aadd1cd5917f4b01af8142159784`:
+
+| source | value |
+|---|---|
+| `/api/v1/gems/openehr-rails.json` | version 0.7.1, `sha` `29e89993…9784` |
+| compact index `info/openehr-rails` | `0.7.1 … checksum:29e89993…9784, created_at:2026-09-25T11:43:12Z` |
+| `/api/v1/versions/openehr-rails/latest.json` | `{"version":"0.7.1"}` |
+| `/api/v1/versions/openehr-rails.json` | **still 0.7.0 first** at check time -- the propagation lag CLAUDE.md warns about, observed for real this time |
+
+Published gem == CI artifact. `pkg/` emptied. The judgement rule from R2 (tag
+rebuild: `data.tar.gz` identical, metadata differs by `rubygems_version` only)
+stands as the cross-check for future releases.
+
+Next: #45 phase A implementation per the ruling (conditions a-c), PR `Fixes #45`,
+then the 0.8.0 inventory.
+
+## R4 -- #45 phase A implemented (PR #51), ride-alongs #52 (PR #53) and #49 (PR #54) (2026-09-25)
+
+Ruling: #45 phase A approved for pre-freeze implementation with conditions (a)
+injected defaults stated as approximations, (b) regression pin on the existing
+fixtures and the anlage demo queries, (c) #44's SECTION fixture -> ITEM_TABLE;
+ride-alongs to weigh: anlage upstream 19 (`rm_type_alternatives`) and #49.
+
+### PR #51 -- `feat/45-rm-object-builder-section-instruction` (Fixes #45)
+
+- (b) enhancement. **Red**: 8 new examples on a synthetic canonical hash
+  (`spec/support/synthetic_referral_canonical_hash.rb`: SECTION > EVALUATION;
+  INSTRUCTION with narrative, protocol ITEM_TREE, one ACTIVITY with description
+  and DV_PARSABLE timing) -> `UnsupportedRmTypeError` / empty AQL rows.
+  **Green**: 36/0 in the four touched spec files, full suite **324 examples,
+  0 failures**, rubocop clean (after one lint follow-up commit for the spec
+  file name).
+- `TYPE_CLASSES` += SECTION, INSTRUCTION, ACTIVITY; `build_node` split into
+  one helper per stored type (`entry_attributes`, `section_attributes`,
+  `instruction_attributes`, `activity_attributes`, `history_attributes`,
+  `event_attributes`, `element_attributes`); every CARE_ENTRY gets `protocol`
+  when stored. Constructor probes against openehr 2.4.3 before coding:
+  `Section.new(items: nil)` ok, `Activity.new(description:, action_archetype_id:)`
+  ok with `timing` nil, `DvParsable.new(value:, formalism:)` ok.
+- AQL measured through the new objects: `i/activities[at0001]/description[at0009]/items[at0121]/value/value`,
+  `i/protocol[at0008]/items[at0010]/value/value`, and an EVALUATION nested in a
+  SECTION via `CONTAINS EVALUATION ev[...]` -- all return the stored values.
+  (`CONTAINS SECTION s[...]` as a hop was not needed and not pinned.)
+- (a): `narrative` <- node name when no row; `action_archetype_id` <- `'/.*/'`
+  -- stated in the class comment, at the injection sites, in the specs and in
+  CHANGELOG `[Unreleased]` Added, as approximations pending phase B.
+- (b): `spec/openehr_rails/aql/executor_execute_demo_queries_spec.rb` pins the
+  four anlage demo queries (bmi_calculation graph + a synthetic
+  problem_diagnosis composition with the real at-codes). Measured on the way:
+  a naive `DV_DATE_TIME` value committed as `2026-02-01T00:00:00` comes back
+  as `2026-01-31T15:00:00Z` under JST -- the pin compares instants, not
+  strings (pre-existing behaviour, not touched). `protocol` nil pinned on an
+  OBSERVATION without one.
+- (c): the #44 fixtures in `dataset_adapter_spec` / `executor_spec` /
+  `rm_object_builder_spec` now use an ITEM_TABLE as an EVALUATION's data.
+- CI runs 36131797849 (`ca1af81`) and 36132042465 (`368da91`, lint follow-up):
+  success. Semver minor -> 0.8.0.
+
+### PR #53 -- `feat/52-rm-type-alternatives` (Fixes #52, filed for upstream 19)
+
+Small, so it rides. (b) enhancement: **red** 9/3 (key absent) -> **green** 9/0,
+full suite 314/0. `FieldExtractor` fields gain `rm_type_alternatives` (the
+value's child constraint types in OPT order), `rm_type` selection untouched.
+**Measured before the spec**: at0002 `[DV_TEXT, DV_CODED_TEXT]`, at0073
+`[DV_CODED_TEXT, DV_TEXT]` -- anlage's issue33-plan says at0073 is coded-only;
+the fixture disagrees, and the spec pins the fixture. CI 36132700126 success.
+
+### PR #54 -- `fix/49-zero-leaf-skip` (Fixes #49)
+
+Small, same decision point as #38, so it rides. (a) bug: **red** 44/4 (a
+0-leaf OBSERVATION and a 0-leaf INSTRUCTION each got a profile with an empty
+`component` slicing header) -> **green** 44/0, full suite 315/0.
+`TypeMap.assert_supported!` raises first for `fields.empty?`;
+`UnsupportedProfileError` says "the entry has no leaves" (pointing at #47).
+Built in a git worktree beside the main checkout (removed afterwards) so #52
+and #49 could proceed in parallel. CI 36132843280 success.
+
+### Merge notes for the human
+
+All three PRs are CI-green and `MERGEABLE CLEAN` against `560647a`, but each
+adds to the same `[Unreleased]` section of `CHANGELOG.md`, so after the first
+merge the other two will show as conflicting; this session resolves each by
+taking `master`'s CHANGELOG and re-adding the PR's bullet (as done for #43/#50),
+then re-runs CI. Any order works. Then the 0.8.0 inventory (R5).
+
+## R5 -- #53 and #54 merged into #51's branch; `release.yml` "Record sha256" rides along; CI green (2026-10-12)
+
+Instruction: fold the two ride-alongs into #51 the way #41 was folded into #39
+/ #42 (branch-into-branch merge, identical commit objects), so the human merges
+one PR; then the 0.8.0 inventory.
+
+### Branch `feat/45-rm-object-builder-section-instruction` (PR #51), now
+
+| commit | what |
+|---|---|
+| `ae71034` | Merge branch `feat/52-rm-type-alternatives` (#53, `d574358`) |
+| `e180eef` | Merge branch `fix/49-zero-leaf-skip` (#54, `7d4d203`) |
+| `1410274` | CI: `release.yml` gains `Record sha256` (`sha256sum pkg/*.gem \| tee pkg/SHA256SUMS`) after `rake build`, ported back from openehr-ruby's copy; `docs/backlog.md` "Release automation" item. CI-only, no Issue (the backlog's own call); rides here so one merge lands it ahead of the `v0.8.0` tag run, which is the first run that will print it. |
+
+- Code files were disjoint; the only conflict in both merges was
+  `CHANGELOG.md` `[Unreleased]` (as R4 predicted). Resolution: #45's and #52's
+  bullets kept in that order under one `### Added`; #49's bullet under a
+  `### Fixed` below. `git diff origin/master...HEAD`: 14 files, the union of
+  the three PRs' diffs plus `release.yml`.
+- Local, after the merges (bundle had to be installed first -- this checkout
+  had no gems): **331 examples, 0 failures**; rubocop **no offenses**
+  (111 files).
+- CI: run **38216664617** (`e180eef`, the two merges) success; run
+  **38216762262** (`1410274`, final head) **success, 11/11 jobs**. PR #51
+  `MERGEABLE CLEAN` against `master` `0434e06`.
+- PR #51's body now names the ride-alongs with `Fixes #52` / `Fixes #49`, so
+  the one merge closes #45, #52 and #49.
+
+### Handed to the human
+
+Merge #51 with a **merge commit** (not squash): then `d574358` and `7d4d203`
+become reachable from `master` as the same objects #53 / #54 point at, exactly
+the #41 situation. After the merge this session comments on #53 and #54
+("taken in via #51") and closes them if GitHub has not already, then runs the
+0.8.0 inventory (`v0.7.1..master`) as a gate report (R6).
+
+Inventory preview, measured on the branch (the gate itself waits for the
+merge): `lib/` touched by `rm_object_builder.rb` (#45, enhancement),
+`opt/field_extractor.rb` (#52, additive output), `fhir/type_map.rb` +
+`fhir/unsupported_profile_error.rb` (#49, bug); gemspec / version /
+dependencies untouched; `release.yml` and the docs commits neutral. Expected
+call: **minor -> 0.8.0**, as #45's plan said.
+
+## R6 -- #51 merged (with #53/#54 inside); 0.8.0 inventory and gate (2026-10-12)
+
+### Step 0: measured on `master` `1185c07` (the #51 merge commit)
+
+- `lib/openehr_rails/rm/rm_object_builder.rb:48-53` `TYPE_CLASSES` has
+  `SECTION`, `INSTRUCTION`, `ACTIVITY` (#45);
+  `lib/openehr_rails/opt/field_extractor.rb:167` emits `rm_type_alternatives`
+  (#52); `lib/openehr_rails/fhir/type_map.rb:29` raises first on
+  `fields.empty?` (#49); `.github/workflows/release.yml:29-30` has the
+  `Record sha256` step.
+- `CHANGELOG.md` `[Unreleased]`: `### Added` with the #45 and #52 bullets,
+  `### Fixed` with the #49 bullet -- the R5 resolution survived the merge.
+- #51 merged 13:37 UTC as a merge commit; GitHub marked #53 (`ae71034`) and
+  #54 (`e180eef`) merged by reachability, #45/#52/#49 closed. Both PRs got a
+  "taken in via #51" comment.
+- `master` CI run **38256998466** (`1185c07`) success. Local under ruby
+  4.0.7: **331 examples, 0 failures**, rubocop no offenses (111 files).
+  `release:check` on `master` fails by design (HEAD is past the `v0.7.1` tag).
+- #55 (FHIR profile id collision, anlage ledger 23): open issue, no PR,
+  nothing in `v0.7.1..master` references it -- stays out, December.
+
+### Step 1: inventory `v0.7.1..master`
+
+| commit | touches | class |
+|---|---|---|
+| `b403226` `560647a` `0434e06` `84244cd` | docs/reports, docs/backlog | neutral |
+| `32a79e7` `29a1444` | `.ruby-version`, CLAUDE.md | neutral (dev env / docs) |
+| `1185c07` = #51: `ca1af81` | `rm/rm_object_builder.rb` + specs (#45, enhancement) | **minor** |
+| -- `368da91` | spec file rename | neutral |
+| -- `ae71034` <- `d574358` | `opt/field_extractor.rb` (#52, additive output) | minor |
+| -- `e180eef` <- `7d4d203` | `fhir/type_map.rb`, `fhir/unsupported_profile_error.rb` (#49, bug) | patch |
+| -- `1410274` | `release.yml` Record sha256 | neutral (CI) |
+
+Gemspec, `version.rb`, `Gemfile`, `gemfiles/*` untouched. Highest class is
+minor -> **0.8.0**, matching the instructed number.
+
+### Prepared, uncommitted, for the release commit
+
+`CHANGELOG.md`: `[Unreleased]` -> `[0.8.0] - 2026-10-12` with an Upgrade note
+(two points: SECTION/INSTRUCTION compositions now read back through `to_rm`
+and AQL -- the ones 0.7.1 skipped with the warning are the ones that become
+visible; `narrative` / `action_archetype_id` injected defaults are
+approximations until phase B persists them), the three bullets unchanged, a
+fresh empty `[Unreleased]` above. `version.rb` 0.7.1 -> 0.8.0 goes in the
+same commit (`ceb4c5b`'s shape). Tag `v0.8.0` annotated; the Release run
+prints the gem's sha256 in `Record sha256`, which is the value the human's
+publish and the post-publish checksum are compared against; the tag-rebuild
+cross-check judges by `data.tar.gz` (R2 rule).

data/lib/openehr_rails/fhir/type_map.rb

@@ -99,6 +99,8 @@ module OpenehrRails
       # path the resource lacks.
       def assert_supported!(entry)
         resource_type = resource_for_entry(entry[:rm_type])
+        # No leaves at all: nothing to profile, whatever the resource (#49).
+        raise UnsupportedProfileError.new(entry[:archetype_id], resource_type, 0) if entry[:fields].empty?
         return if resource_type == 'Observation' || element_map_for(entry[:archetype_id])
 
         raise UnsupportedProfileError.new(entry[:archetype_id], resource_type, entry[:fields].size)

data/lib/openehr_rails/fhir/unsupported_profile_error.rb

@@ -17,12 +17,23 @@ module OpenehrRails
         @archetype_id = archetype_id
         @resource_type = resource_type
         @leaf_count = leaf_count
-        super(
-          "#{archetype_id}: #{leaf_count} #{leaf_count == 1 ? 'leaf maps' : 'leaves map'} to " \
+        super(leaf_count.zero? ? no_leaves_message : unmapped_message)
+      end
+
+      private
+
+      # 0 leaves: FieldExtractor found no ELEMENT under the entry (today that
+      # includes every INSTRUCTION, #47), so there is nothing to profile.
+      def no_leaves_message
+        "#{archetype_id} (#{resource_type}): the entry has no leaves, nothing to profile -- skipped " \
+          '(skoba/openehr-rails#49; INSTRUCTION leaves: #47)'
+      end
+
+      def unmapped_message
+        "#{archetype_id}: #{leaf_count} #{leaf_count == 1 ? 'leaf maps' : 'leaves map'} to " \
           "#{resource_type}, which has neither value[x] nor component, and " \
           'TypeMap::ENTRY_ELEMENT_MAPS has no row for this archetype -- skipped ' \
           '(skoba/openehr-rails#33, #38; mapping rows: #35, #37)'
-        )
       end
     end
   end

data/lib/openehr_rails/opt/field_extractor.rb

@@ -10,6 +10,8 @@ module OpenehrRails
     #   label:           display text from the template terminology (any language)
     #   path:            RM path from the COMPOSITION content
     #   rm_type:         openEHR data value type (e.g. 'DV_QUANTITY')
+    #   rm_type_alternatives: every alternative value type the OPT allows, in OPT order
+    #                    (e.g. ['DV_TEXT', 'DV_CODED_TEXT'] for an OR constraint; rm_type is the chosen one)
     #   node_id:         at-code of the ELEMENT
     #   archetype_id:    id of the nearest enclosing archetype root (entry or embedded C_ARCHETYPE_ROOT)
     #   column_type:     ActiveRecord column type symbol
@@ -162,6 +164,7 @@ module OpenehrRails
           label: label || element.node_id,
           path: "#{path}/value",
           rm_type: rm_type,
+          rm_type_alternatives: value_children(element).map(&:rm_type_name),
           node_id: element.node_id,
           archetype_id: archetype_id,
           entry_rm_type: entry[:rm_type],
@@ -176,10 +179,15 @@ module OpenehrRails
         field
       end
 
-      def value_constraint(element)
+      # All alternative constraints on the ELEMENT's value, in OPT order.
+      def value_children(element)
         attrs = element.attributes || []
         value = attrs.find { |a| a.rm_attribute_name == 'value' }
-        children = value&.children || []
+        value&.children || []
+      end
+
+      def value_constraint(element)
+        children = value_children(element)
         return children.first if children.size <= 1
 
         code_reference_class = OpenEHR::AM::OpenEHRProfile::DataTypes::Text::CCodeReference

data/lib/openehr_rails/rm/rm_object_builder.rb

@@ -29,11 +29,28 @@ module OpenehrRails
     # carried in OPT/stored data. The gem's own constructor validations
     # (ArgumentError on missing mandatory attrs) become the RM-conformance
     # check.
+    #
+    # Injected values, all documented approximations (#45 ruling condition
+    # (a); the graph does not carry them yet, phase B adds columns):
+    #   - ENTRY language / encoding / subject: OpenehrRails config defaults
+    #   - HISTORY.origin, EVENT.time: composition context time or now
+    #   - INSTRUCTION.narrative: the node's name when no narrative row exists
+    #   - ACTIVITY.action_archetype_id: '/.*/' (any ACTION archetype)
+    # rubocop:disable-next Metrics/ClassLength
     class RmObjectBuilder
-      # Map rm_type to the corresponding OpenEHR::RM class.
+      # The RM's "any ACTION archetype" pattern, injected because the graph
+      # cannot carry ACTIVITY.action_archetype_id yet (see class comment).
+      DEFAULT_ACTION_ARCHETYPE_ID = '/.*/'
+
+      # Map rm_type to the corresponding OpenEHR::RM class. ACTION,
+      # ITEM_SINGLE and ITEM_TABLE are persisted by GraphBuilder but not
+      # rebuilt here yet (UnsupportedRmTypeError; #44 skips them in AQL).
       TYPE_CLASSES = {
+        'SECTION' => OpenEHR::RM::Composition::Content::Navigation::Section,
         'OBSERVATION' => OpenEHR::RM::Composition::Content::Entry::Observation,
         'EVALUATION' => OpenEHR::RM::Composition::Content::Entry::Evaluation,
+        'INSTRUCTION' => OpenEHR::RM::Composition::Content::Entry::Instruction,
+        'ACTIVITY' => OpenEHR::RM::Composition::Content::Entry::Activity,
         'ADMIN_ENTRY' => OpenEHR::RM::Composition::Content::Entry::AdminEntry,
         'HISTORY' => OpenEHR::RM::DataStructures::History::History,
         'POINT_EVENT' => OpenEHR::RM::DataStructures::History::PointEvent,
@@ -90,68 +107,125 @@ module OpenehrRails
         TYPE_CLASSES.fetch(node.rm_type) { raise UnsupportedRmTypeError.new(@composition, node) }
       end
 
+      # One helper per stored node type; each adds the attributes the
+      # corresponding RM constructor needs, injecting the documented defaults
+      # where the graph carries nothing.
       def build_node(node)
         klass = node_class(node)
         attrs = {
           archetype_node_id: node.archetype_node_id,
           name: dv_text(node.name_value || node.archetype_node_id)
         }
+        attrs.merge!(entry_attributes(node)) if node.is_a?(OpenehrRails::Rm::EntryNode)
+        attrs.merge!(section_attributes(node)) if node.is_a?(OpenehrRails::Rm::Section)
+        attrs.merge!(instruction_attributes(node)) if node.is_a?(OpenehrRails::Rm::Instruction)
+        attrs.merge!(activity_attributes(node)) if node.is_a?(OpenehrRails::Rm::Activity)
+        attrs.merge!(history_attributes(node)) if node.is_a?(OpenehrRails::Rm::History)
+        attrs.merge!(event_attributes(node)) if event?(node)
+        attrs[:items] = child_nodes(node) if item_container?(node)
+        attrs.merge!(element_attributes(node)) if node.is_a?(OpenehrRails::Rm::Element)
+        klass.new(attrs)
+      end
 
-        # Entry-specific mandatory attributes
-        if [OpenehrRails::Rm::Observation, OpenehrRails::Rm::Evaluation,
-            OpenehrRails::Rm::AdminEntry].any? { |c| node.is_a?(c) }
-          attrs.merge!(
-            language: code_phrase(OpenehrRails.default_language, 'ISO_639-1'),
-            encoding: code_phrase(OpenehrRails.default_encoding, 'IANA_character-sets'),
-            subject: party_self
-          )
-        end
+      # ENTRY: language / encoding / subject are mandatory on every RM ENTRY
+      # and not stored, so the config defaults are injected; `data` for the
+      # entries that have one; `protocol` for every CARE_ENTRY that stored one
+      # (#45 -- INSTRUCTION keeps its requester/receiver there).
+      def entry_attributes(node)
+        attrs = {
+          language: code_phrase(OpenehrRails.default_language, 'ISO_639-1'),
+          encoding: code_phrase(OpenehrRails.default_encoding, 'IANA_character-sets'),
+          subject: party_self
+        }
+        data = child_node(node, 'data')
+        attrs[:data] = build_node(data) if data
+        protocol = child_node(node, 'protocol')
+        attrs[:protocol] = build_node(protocol) if protocol
+        attrs
+      end
 
-        # Entry-specific: add data from first child
-        if node.is_a?(OpenehrRails::Rm::EntryNode)
-          data_child = node.children.find { |c| c.rm_attribute_name == 'data' }
-          attrs[:data] = build_node(data_child) if data_child
-        end
+      # SECTION.items must be nil or non-empty for the RM constructor.
+      def section_attributes(node)
+        items = child_nodes(node)
+        items.empty? ? {} : { items: items }
+      end
 
-        # History-specific: origin is mandatory
-        if node.is_a?(OpenehrRails::Rm::History)
-          attrs[:origin] = dv_date_time(
-            node.history_origin || node.composition.context_start_time || Time.current
-          )
-          attrs[:events] = node.children.sort_by(&:position).map { |c| build_node(c) }
-        end
+      # INSTRUCTION.narrative is mandatory; the graph stores it as a
+      # `narrative` data-value row. When that row is absent the node's name
+      # stands in -- an approximation (#45 ruling condition (a)); phase B
+      # persists narrative as a column.
+      def instruction_attributes(node)
+        narrative = data_value_row(node, 'narrative')
+        attrs = { narrative: narrative ? dv_text(narrative.text_value) : dv_text(node.name_value || node.archetype_node_id) }
+        activities = child_nodes(node, 'activities')
+        attrs[:activities] = activities unless activities.empty?
+        expiry = data_value_row(node, 'expiry_time')
+        attrs[:expiry_time] = dv_date_time(expiry.datetime_value) if expiry&.datetime_value
+        attrs
+      end
 
-        # Event-specific: time is mandatory
-        if [OpenehrRails::Rm::PointEvent, OpenehrRails::Rm::IntervalEvent]
-           .any? { |c| node.is_a?(c) }
-          attrs[:time] = dv_date_time(node.event_time || Time.current)
-          attrs[:data] = build_node(
-            node.children.find { |c| c.rm_attribute_name == 'data' }
-          )
-          if node.is_a?(OpenehrRails::Rm::IntervalEvent)
-            attrs[:width] = parse_duration(node.width || 'PT0S')
-            attrs[:math_function] = code_phrase(node.math_function_code || '144', 'openehr')
-          end
-        end
+      # ACTIVITY.description is mandatory and never defaulted: a graph without
+      # one fails RM conformance (the gem raises, #44 reports and skips).
+      # action_archetype_id is mandatory too but the graph cannot carry it
+      # (GraphBuilder drops String-valued attributes), so the RM's "any ACTION
+      # archetype" pattern is injected -- an approximation (#45 ruling
+      # condition (a)); phase B persists the real value.
+      def activity_attributes(node)
+        attrs = { action_archetype_id: DEFAULT_ACTION_ARCHETYPE_ID }
+        description = child_node(node, 'description')
+        attrs[:description] = build_node(description) if description
+        timing = data_value_row(node, 'timing')
+        attrs[:timing] = dv_parsable(timing.text_value, timing.formalism) if timing
+        attrs
+      end
 
-        # ItemStructure: items child list
-        if [OpenehrRails::Rm::ItemTree, OpenehrRails::Rm::ItemList]
-           .any? { |c| node.is_a?(c) }
-          attrs[:items] = node.children.sort_by(&:position).map { |c| build_node(c) }
-        end
+      # HISTORY.origin is mandatory.
+      def history_attributes(node)
+        {
+          origin: dv_date_time(node.history_origin || node.composition.context_start_time || Time.current),
+          events: child_nodes(node)
+        }
+      end
 
-        # Cluster: items child list
-        if node.is_a?(OpenehrRails::Rm::Cluster)
-          attrs[:items] = node.children.sort_by(&:position).map { |c| build_node(c) }
-        end
+      def event?(node)
+        node.is_a?(OpenehrRails::Rm::PointEvent) || node.is_a?(OpenehrRails::Rm::IntervalEvent)
+      end
 
-        # Element: value leaf
-        if node.is_a?(OpenehrRails::Rm::Element)
-          dv = node.data_values.first
-          attrs[:value] = build_data_value(dv) if dv
+      # EVENT.time and .data are mandatory; INTERVAL_EVENT adds width and
+      # math_function.
+      def event_attributes(node)
+        attrs = { time: dv_date_time(node.event_time || Time.current), data: build_node(child_node(node, 'data')) }
+        if node.is_a?(OpenehrRails::Rm::IntervalEvent)
+          attrs[:width] = parse_duration(node.width || 'PT0S')
+          attrs[:math_function] = code_phrase(node.math_function_code || '144', 'openehr')
         end
+        attrs
+      end
 
-        klass.new(attrs)
+      def item_container?(node)
+        node.is_a?(OpenehrRails::Rm::ItemTree) || node.is_a?(OpenehrRails::Rm::ItemList) ||
+          node.is_a?(OpenehrRails::Rm::Cluster)
+      end
+
+      def element_attributes(node)
+        dv = node.data_values.first
+        dv ? { value: build_data_value(dv) } : {}
+      end
+
+      def child_node(node, attribute)
+        node.children.find { |c| c.rm_attribute_name == attribute }
+      end
+
+      # Children in position order, optionally restricted to one RM attribute
+      # (INSTRUCTION has `activities` and `protocol` children side by side).
+      def child_nodes(node, attribute = nil)
+        children = node.children.sort_by(&:position)
+        children = children.select { |c| c.rm_attribute_name == attribute } if attribute
+        children.map { |c| build_node(c) }
+      end
+
+      def data_value_row(node, attribute)
+        node.data_values.find { |dv| dv.rm_attribute_name == attribute }
       end
 
       def build_data_value(dv)
@@ -202,6 +276,10 @@ module OpenehrRails
         OpenEHR::RM::DataTypes::Text::DvText.new(value: value.to_s)
       end
 
+      def dv_parsable(value, formalism)
+        OpenEHR::RM::DataTypes::Encapsulated::DvParsable.new(value: value.to_s, formalism: formalism)
+      end
+
       def dv_coded_text(value, code, terminology)
         OpenEHR::RM::DataTypes::Text::DvCodedText.new(
           value: value,

data/lib/openehr_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenehrRails
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
 end

data/spec/openehr_rails/aql/dataset_adapter_spec.rb

@@ -57,28 +57,28 @@ describe OpenehrRails::Aql::DatasetAdapter do
 
   # skoba/openehr-rails#44, resolution shape (a) bug: one composition whose
   # graph cannot be rebuilt as RM objects used to fail every query in the
-  # store. Synthetic canonical hash (invented ids): a SECTION is accepted by
-  # GraphBuilder (Rm::TypeMap::NODE_TYPES) but not by RmObjectBuilder::
-  # TYPE_CLASSES, so it is the smallest graph whose to_rm fails today; #45
-  # makes SECTION buildable later, at which point this spec needs a different
-  # unsupported type (ITEM_TABLE is the next candidate).
+  # store. Synthetic canonical hash (invented ids): an ITEM_TABLE as an
+  # EVALUATION's data is accepted by GraphBuilder (Rm::TypeMap::NODE_TYPES)
+  # but not by RmObjectBuilder::TYPE_CLASSES. (It was a SECTION until #45
+  # made SECTION buildable -- ruling condition (c).)
   describe 'a composition whose to_rm fails' do
-    let(:section_hash) do
+    let(:table_hash) do
       {
         '_type' => 'COMPOSITION',
-        'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1',
+        'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_table_test.v1',
         'archetype_details' => {
           '_type' => 'ARCHETYPED',
-          'archetype_id' => { 'value' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1' },
-          'template_id' => { 'value' => 'synthetic_section_test' },
+          'archetype_id' => { 'value' => 'openEHR-EHR-COMPOSITION.synthetic_table_test.v1' },
+          'template_id' => { 'value' => 'synthetic_table_test' },
           'rm_version' => '1.0.4'
         },
         'content' => [
           {
-            '_type' => 'SECTION',
-            'archetype_node_id' => 'openEHR-EHR-SECTION.synthetic_test.v1',
-            'name' => { '_type' => 'DV_TEXT', 'value' => 'Synthetic section' },
-            'items' => []
+            '_type' => 'EVALUATION',
+            'archetype_node_id' => 'openEHR-EHR-EVALUATION.synthetic_table_test.v1',
+            'archetype_details' => { 'archetype_id' => { 'value' => 'openEHR-EHR-EVALUATION.synthetic_table_test.v1' } },
+            'name' => { '_type' => 'DV_TEXT', 'value' => 'Synthetic table' },
+            'data' => { '_type' => 'ITEM_TABLE', 'archetype_node_id' => 'at0001', 'rows' => [] }
           }
         ]
       }
@@ -87,18 +87,18 @@ describe OpenehrRails::Aql::DatasetAdapter do
     before do
       BmiCalculation.create!(height: 170.0, ehr_id: 'ehr-mixed')
       ehr = OpenehrRails::Rm::Ehr.find_by!(ehr_id: 'ehr-mixed')
-      OpenehrRails::Rm::CompositionCommitter.commit(section_hash, uid: 'uid-section', ehr: ehr)
+      OpenehrRails::Rm::CompositionCommitter.commit(table_hash, uid: 'uid-table', ehr: ehr)
     end
 
     it 'warns, skips that composition, and keeps the rest of the EHR queryable' do
       records = nil
 
       expect { records = described_class.build.each_ehr.to_a }
-        .to output(/uid-section.*UnsupportedRmTypeError.*SECTION/).to_stderr
+        .to output(/uid-table.*UnsupportedRmTypeError.*ITEM_TABLE/).to_stderr
 
       matching = records.find { |r| r.ehr_id == 'ehr-mixed' }
       expect(matching.compositions.size).to eq(1)
-      expect(matching.compositions.map { |c| c.uid.value }).not_to include('uid-section')
+      expect(matching.compositions.map { |c| c.uid.value }).not_to include('uid-table')
     end
   end
 end

data/spec/openehr_rails/aql/executor_execute_demo_queries_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'openehr'
+require 'openehr/aql'
+require 'openehr_rails'
+require_relative '../storable_spec_model'
+
+# Regression pin (skoba/openehr-rails#45, ruling condition (b)): the four AQL
+# queries the anlage demo runs (anlage docs/demo/aql-queries.md 1-4) must keep
+# returning the same rows after RmObjectBuilder started rebuilding `protocol`,
+# SECTION, INSTRUCTION and ACTIVITY. Resolution shape (c): these results were
+# already true before #45 and red is not achievable -- this file pins them.
+#
+# Data: query 1 and 3 run on the BmiCalculation model (real bmi_calculation.opt
+# graph). Queries 2 and 4 need a problem_diagnosis EVALUATION, for which this
+# repo has no model, so a **synthetic** canonical hash is committed directly:
+# hand-authored, but its archetype id and at-codes are the real ones from
+# spec/templates/problem_list.opt (at0002 diagnosis, at0073 certainty with the
+# local code at0076, at0003 date/time recognised) so the demo queries run
+# verbatim. Design authority: docs/design/rm-object-builder-section-instruction-plan.md
+# section 3.
+describe OpenehrRails::Aql::Executor, '.execute' do
+  # anlage demo AQL queries (regression pin) -- see the file comment above.
+  let(:problem_diagnosis_hash) do
+    {
+      '_type' => 'COMPOSITION',
+      'archetype_node_id' => 'openEHR-EHR-COMPOSITION.problem_list.v1',
+      'archetype_details' => {
+        '_type' => 'ARCHETYPED',
+        'archetype_id' => { 'value' => 'openEHR-EHR-COMPOSITION.problem_list.v1' },
+        'template_id' => { 'value' => 'problem_list' }, 'rm_version' => '1.0.4'
+      },
+      'name' => { '_type' => 'DV_TEXT', 'value' => 'Problem list' },
+      'content' => [
+        {
+          '_type' => 'EVALUATION', 'archetype_node_id' => 'openEHR-EHR-EVALUATION.problem_diagnosis.v1',
+          'archetype_details' => { 'archetype_id' => { 'value' => 'openEHR-EHR-EVALUATION.problem_diagnosis.v1' } },
+          'name' => { '_type' => 'DV_TEXT', 'value' => 'Problem/Diagnosis' },
+          'data' => {
+            '_type' => 'ITEM_TREE', 'archetype_node_id' => 'at0001',
+            'items' => [
+              { '_type' => 'ELEMENT', 'archetype_node_id' => 'at0002',
+                'value' => { '_type' => 'DV_TEXT', 'value' => 'Hypertension' } },
+              { '_type' => 'ELEMENT', 'archetype_node_id' => 'at0073',
+                'value' => { '_type' => 'DV_CODED_TEXT', 'value' => 'Confirmed',
+                             'defining_code' => { 'terminology_id' => { 'value' => 'local' }, 'code_string' => 'at0076' } } },
+              { '_type' => 'ELEMENT', 'archetype_node_id' => 'at0003',
+                'value' => { '_type' => 'DV_DATE_TIME', 'value' => '2026-02-01T00:00:00' } }
+            ]
+          }
+        }
+      ]
+    }
+  end
+
+  before do
+    BmiCalculation.create!(height: 170.0)
+    BmiCalculation.create!(height: 180.0)
+    OpenehrRails::Rm::CompositionCommitter.commit(problem_diagnosis_hash, uid: 'uid-demo-problem')
+  end
+
+  it '1. height inequality (alias in SELECT, path in WHERE)' do
+    query = 'SELECT o/data[at0001]/events[at0002]/data[at0003]/items[at0004]/value/magnitude AS height ' \
+            'FROM EHR e CONTAINS COMPOSITION c CONTAINS OBSERVATION o[openEHR-EHR-OBSERVATION.height.v2] ' \
+            'WHERE o/data[at0001]/events[at0002]/data[at0003]/items[at0004]/value/magnitude > 170'
+
+    expect(OpenehrRails::Aql.execute(query).rows).to eq([[180.0]])
+  end
+
+  it '2. MATCHES against a literal value list on the certainty label' do
+    query = 'SELECT c/name/value AS composition_name, o/data[at0001]/items[at0073]/value/value AS certainty ' \
+            'FROM EHR e CONTAINS COMPOSITION c CONTAINS EVALUATION o[openEHR-EHR-EVALUATION.problem_diagnosis.v1] ' \
+            "WHERE o/data[at0001]/items[at0073]/value/value MATCHES {'Confirmed', 'Suspected'}"
+
+    expect(OpenehrRails::Aql.execute(query).rows).to eq([['Problem list', 'Confirmed']])
+  end
+
+  it '3. CONTAINS nodePredicate with WHERE EXISTS' do
+    query = 'SELECT c/name/value AS composition_name ' \
+            'FROM EHR e CONTAINS COMPOSITION c CONTAINS OBSERVATION o[openEHR-EHR-OBSERVATION.height.v2] ' \
+            'CONTAINS ELEMENT el[at0004] WHERE EXISTS el/value/magnitude'
+
+    expect(OpenehrRails::Aql.execute(query).rows)
+      .to eq([['openEHR-EHR-COMPOSITION.report-result.v1'], ['openEHR-EHR-COMPOSITION.report-result.v1']])
+  end
+
+  it '4. date range WHERE on an ELEMENT-held date/time' do
+    query = 'SELECT o/data[at0001]/items[at0003]/value/value AS recognized_at ' \
+            'FROM EHR e CONTAINS COMPOSITION c CONTAINS EVALUATION o[openEHR-EHR-EVALUATION.problem_diagnosis.v1] ' \
+            'WHERE o/data[at0001]/items[at0003]/value/value >= "2026-01-01T00:00:00"'
+
+    rows = OpenehrRails::Aql.execute(query).rows
+
+    # Measured: the naive input is parsed in the process's local zone and
+    # comes back as UTC (`2026-01-31T15:00:00Z` under JST) -- pinned as the
+    # same instant, not as the literal string.
+    expect(rows.size).to eq(1)
+    expect(Time.iso8601(rows.first.first)).to eq(Time.parse('2026-02-01T00:00:00').utc)
+  end
+end

data/spec/openehr_rails/aql/executor_spec.rb

@@ -104,24 +104,64 @@ describe OpenehrRails::Aql::Executor do
   describe 'with a composition whose to_rm fails in the store' do
     before do
       BmiCalculation.create!(height: 170.0)
+      # ITEM_TABLE stays outside RmObjectBuilder::TYPE_CLASSES after #45
+      # made SECTION buildable (ruling condition (c)).
       OpenehrRails::Rm::CompositionCommitter.commit(
         {
           '_type' => 'COMPOSITION',
-          'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1',
+          'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_table_test.v1',
           'content' => [
-            { '_type' => 'SECTION', 'archetype_node_id' => 'openEHR-EHR-SECTION.synthetic_test.v1', 'items' => [] }
+            {
+              '_type' => 'EVALUATION', 'archetype_node_id' => 'openEHR-EHR-EVALUATION.synthetic_table_test.v1',
+              'archetype_details' => { 'archetype_id' => { 'value' => 'openEHR-EHR-EVALUATION.synthetic_table_test.v1' } },
+              'data' => { '_type' => 'ITEM_TABLE', 'archetype_node_id' => 'at0001', 'rows' => [] }
+            }
           ]
         },
-        uid: 'uid-section-exec'
+        uid: 'uid-table-exec'
       )
     end
 
     it 'still answers a query on another template, skipping the broken composition' do
       rows = nil
 
-      expect { rows = described_class.execute(height_query).rows }.to output(/uid-section-exec/).to_stderr
+      expect { rows = described_class.execute(height_query).rows }.to output(/uid-table-exec/).to_stderr
 
       expect(rows).to eq([[170.0]])
     end
   end
+
+  # skoba/openehr-rails#45 (b) enhancement, end to end: values under
+  # INSTRUCTION.protocol / activities and inside a SECTION are reachable by
+  # AQL once the builder rebuilds those nodes. Same synthetic fixture as
+  # rm_object_builder_spec.rb.
+  describe 'INSTRUCTION and SECTION paths (#45)' do
+    before do
+      OpenehrRails::Rm::CompositionCommitter.commit(SyntheticReferralCanonicalHash.composition, uid: 'uid-referral-aql')
+    end
+
+    it 'reaches an ACTIVITY description leaf through i/activities[...]/description[...]' do
+      query = 'SELECT i/activities[at0001]/description[at0009]/items[at0121]/value/value ' \
+              'FROM EHR e CONTAINS COMPOSITION c ' \
+              "CONTAINS INSTRUCTION i[#{SyntheticReferralCanonicalHash::INSTRUCTION_ID}]"
+
+      expect(described_class.execute(query).rows).to eq([['Chest pain work-up']])
+    end
+
+    it 'reaches a protocol leaf through i/protocol[...]' do
+      query = 'SELECT i/protocol[at0008]/items[at0010]/value/value ' \
+              'FROM EHR e CONTAINS COMPOSITION c ' \
+              "CONTAINS INSTRUCTION i[#{SyntheticReferralCanonicalHash::INSTRUCTION_ID}]"
+
+      expect(described_class.execute(query).rows).to eq([['Synthetic Hospital']])
+    end
+
+    it 'reaches an EVALUATION nested in a SECTION' do
+      query = 'SELECT ev/data[at0001]/items[at0002]/value/value ' \
+              'FROM EHR e CONTAINS COMPOSITION c ' \
+              "CONTAINS EVALUATION ev[#{SyntheticReferralCanonicalHash::EVALUATION_ID}]"
+
+      expect(described_class.execute(query).rows).to eq([['stable']])
+    end
+  end
 end

data/spec/openehr_rails/fhir/fsh_generator_spec.rb

@@ -268,6 +268,45 @@ describe OpenehrRails::Fhir::FshGenerator do
     end
   end
 
+  # skoba/openehr-rails#49, resolution shape (a) bug: an entry with no leaves
+  # at all produced an archetype `code` rule plus an empty `component` slicing
+  # header (and, for a non-Observation resource, invalid FHIR). Any 0-leaf
+  # entry is now skipped and reported, whatever its resource. Synthetic
+  # entries (stubbed FieldExtractor, invented ids), as for #33/#38.
+  describe '0-leaf entries' do
+    let(:real_entries) { OpenehrRails::Opt::FieldExtractor.new(template).entries }
+    let(:empty_observation) do
+      real_entries.first.merge(archetype_id: 'openEHR-EHR-OBSERVATION.synthetic_empty_test.v1',
+                               concept: 'synthetic_empty_test', fields: [])
+    end
+    let(:empty_instruction) do
+      real_entries.first.merge(archetype_id: 'openEHR-EHR-INSTRUCTION.synthetic_empty_test.v1',
+                               rm_type: 'INSTRUCTION', concept: 'synthetic_empty_test', fields: [])
+    end
+
+    before do
+      extractor = instance_double(OpenehrRails::Opt::FieldExtractor,
+                                  entries: [empty_observation, empty_instruction, *real_entries])
+      allow(OpenehrRails::Opt::FieldExtractor).to receive(:new).with(template).and_return(extractor)
+    end
+
+    it 'emits nothing for them and keeps the real entries' do
+      expect(generator.to_fsh_files.keys).to eq(
+        %w[openehr-observation-height-v2 openehr-observation-body-weight-v2 openehr-observation-body-mass-index-v2]
+      )
+    end
+
+    it 'reports each as an UnsupportedProfileError that says the entry has no leaves' do
+      generator.to_fsh_files
+
+      expect(generator.skipped.map(&:archetype_id)).to eq(
+        %w[openEHR-EHR-OBSERVATION.synthetic_empty_test.v1 openEHR-EHR-INSTRUCTION.synthetic_empty_test.v1]
+      )
+      expect(generator.skipped.map(&:leaf_count)).to eq([0, 0])
+      expect(generator.skipped.map(&:message)).to all(include('no leaves'))
+    end
+  end
+
   describe '#skipped' do
     it 'is empty for an all-Observation template' do
       generator.to_fsh_files

data/spec/openehr_rails/fhir/profile_generator_spec.rb

@@ -282,6 +282,45 @@ describe OpenehrRails::Fhir::ProfileGenerator do
     end
   end
 
+  # skoba/openehr-rails#49, resolution shape (a) bug: an entry with no leaves
+  # at all produced an archetype `code` rule plus an empty `component` slicing
+  # header (and, for a non-Observation resource, invalid FHIR). Any 0-leaf
+  # entry is now skipped and reported, whatever its resource. Synthetic
+  # entries (stubbed FieldExtractor, invented ids), as for #33/#38. JSON facade half.
+  describe '0-leaf entries' do
+    let(:real_entries) { OpenehrRails::Opt::FieldExtractor.new(template).entries }
+    let(:empty_observation) do
+      real_entries.first.merge(archetype_id: 'openEHR-EHR-OBSERVATION.synthetic_empty_test.v1',
+                               concept: 'synthetic_empty_test', fields: [])
+    end
+    let(:empty_instruction) do
+      real_entries.first.merge(archetype_id: 'openEHR-EHR-INSTRUCTION.synthetic_empty_test.v1',
+                               rm_type: 'INSTRUCTION', concept: 'synthetic_empty_test', fields: [])
+    end
+
+    before do
+      extractor = instance_double(OpenehrRails::Opt::FieldExtractor,
+                                  entries: [empty_observation, empty_instruction, *real_entries])
+      allow(OpenehrRails::Opt::FieldExtractor).to receive(:new).with(template).and_return(extractor)
+    end
+
+    it 'emits nothing for them and keeps the real entries' do
+      expect(generator.profiles.map { |p| p[:id] }).to eq(
+        %w[openehr-observation-height-v2 openehr-observation-body-weight-v2 openehr-observation-body-mass-index-v2]
+      )
+    end
+
+    it 'reports each as an UnsupportedProfileError that says the entry has no leaves' do
+      generator.profiles
+
+      expect(generator.skipped.map(&:archetype_id)).to eq(
+        %w[openEHR-EHR-OBSERVATION.synthetic_empty_test.v1 openEHR-EHR-INSTRUCTION.synthetic_empty_test.v1]
+      )
+      expect(generator.skipped.map(&:leaf_count)).to eq([0, 0])
+      expect(generator.skipped.map(&:message)).to all(include('no leaves'))
+    end
+  end
+
   describe '#skipped' do
     it 'is empty for an all-Observation template' do
       generator.profiles

data/spec/openehr_rails/opt/field_extractor_binding_spec.rb

@@ -65,6 +65,26 @@ describe OpenehrRails::Opt::FieldExtractor do
       expect(diagnostic_status[:value_set_uri]).to be_nil
       expect(diagnostic_status[:code_list]).not_to be_empty
     end
+
+    # skoba/openehr-rails#52, resolution shape (b) enhancement: the value
+    # constraint's alternative RM types travel with the field, in OPT order,
+    # so a host app can tell an OR-constrained coded text (DV_TEXT allowed)
+    # from a coded-only one. rm_type selection is unchanged. Values measured
+    # on the fixture before the spec was written.
+    describe 'rm_type_alternatives' do
+      it 'lists every alternative of an OR-constrained value in OPT order' do
+        expect(field_for(fields, archetype_id, 'at0002')[:rm_type_alternatives]).to eq(%w[DV_TEXT DV_CODED_TEXT])
+        expect(field_for(fields, archetype_id, 'at0073')[:rm_type_alternatives]).to eq(%w[DV_CODED_TEXT DV_TEXT])
+      end
+
+      it 'lists the single type of a plain value' do
+        expect(field_for(fields, archetype_id, 'at0077')[:rm_type_alternatives]).to eq(%w[DV_DATE_TIME])
+      end
+
+      it 'leaves the chosen rm_type as before' do
+        expect(field_for(fields, archetype_id, 'at0002')[:rm_type]).to eq('DV_CODED_TEXT')
+      end
+    end
   end
 
   describe 'a hand-built template without terminology objects' do
@@ -93,7 +113,7 @@ describe OpenehrRails::Opt::FieldExtractor do
 
       # enhancement: additive binding keys remain safe for lightweight template doubles.
       expect(described_class.new(template).fields.first)
-        .to include(value_set_uri: nil, code_bindings: [])
+        .to include(value_set_uri: nil, code_bindings: [], rm_type_alternatives: %w[DV_TEXT])
     end
   end
 end

data/spec/openehr_rails/rm/rm_object_builder_spec.rb

@@ -77,21 +77,100 @@ describe OpenehrRails::Rm::RmObjectBuilder do
   # skoba/openehr-rails#44 (a) bug: a node type the graph stores but
   # TYPE_CLASSES lacks used to surface as `NoMethodError: undefined method
   # 'new' for nil`. The typed error names what the caller needs to act on.
+  # Since #45 SECTION is buildable, so the unsupported type here is an
+  # ITEM_TABLE as an EVALUATION's data (ruling condition (c)).
   it 'raises UnsupportedRmTypeError, naming composition and node, for an rm_type outside TYPE_CLASSES' do
     composition = OpenehrRails::Rm::CompositionCommitter.commit(
       {
         '_type' => 'COMPOSITION',
-        'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_section_test.v1',
+        'archetype_node_id' => 'openEHR-EHR-COMPOSITION.synthetic_table_test.v1',
         'content' => [
-          { '_type' => 'SECTION', 'archetype_node_id' => 'openEHR-EHR-SECTION.synthetic_test.v1', 'items' => [] }
+          {
+            '_type' => 'EVALUATION', 'archetype_node_id' => 'openEHR-EHR-EVALUATION.synthetic_table_test.v1',
+            'archetype_details' => { 'archetype_id' => { 'value' => 'openEHR-EHR-EVALUATION.synthetic_table_test.v1' } },
+            'data' => { '_type' => 'ITEM_TABLE', 'archetype_node_id' => 'at0001', 'rows' => [] }
+          }
         ]
       },
-      uid: 'uid-section-builder'
+      uid: 'uid-table-builder'
     )
 
     expect { composition.to_rm }.to raise_error(OpenehrRails::Rm::UnsupportedRmTypeError) { |error|
-      expect(error.message).to include('uid-section-builder', 'SECTION', 'openEHR-EHR-SECTION.synthetic_test.v1')
-      expect(error.rm_type).to eq('SECTION')
+      expect(error.message).to include('uid-table-builder', 'ITEM_TABLE', 'data[at0001]')
+      expect(error.rm_type).to eq('ITEM_TABLE')
     }
   end
+
+  # skoba/openehr-rails#45, resolution shape (b) enhancement: SECTION,
+  # INSTRUCTION and ACTIVITY nodes -- persisted by GraphBuilder all along --
+  # are rebuilt as RM objects. Fixture: spec/support/synthetic_referral_canonical_hash.rb
+  # (synthetic; design authority docs/design/rm-object-builder-section-instruction-plan.md
+  # section 3). Red before #45: UnsupportedRmTypeError on the SECTION.
+  describe 'SECTION, INSTRUCTION and ACTIVITY (#45)' do
+    let(:fixture) { SyntheticReferralCanonicalHash }
+    let(:rm) do
+      OpenehrRails::Rm::CompositionCommitter.commit(fixture.composition, uid: 'uid-referral').to_rm
+    end
+
+    it 'rebuilds a SECTION with its items' do
+      section = rm.content.first
+
+      expect(section).to be_a(OpenEHR::RM::Composition::Content::Navigation::Section)
+      expect(section.archetype_node_id).to eq(fixture::SECTION_ID)
+      expect(section.items.size).to eq(1)
+      expect(section.items.first).to be_a(OpenEHR::RM::Composition::Content::Entry::Evaluation)
+      expect(section.items.first.data.items.first.value.value).to eq('stable')
+    end
+
+    it 'rebuilds an INSTRUCTION with entry defaults, narrative, protocol and activities' do
+      instruction = rm.content.last
+
+      expect(instruction).to be_a(OpenEHR::RM::Composition::Content::Entry::Instruction)
+      expect(instruction.language.code_string).to eq(OpenehrRails.default_language)
+      expect(instruction.narrative.value).to eq('Refer to cardiology')
+      expect(instruction.protocol.items.first.value.value).to eq('Synthetic Hospital')
+      expect(instruction.activities.size).to eq(1)
+    end
+
+    it 'rebuilds an ACTIVITY with description, timing and the injected action_archetype_id' do
+      activity = rm.content.last.activities.first
+
+      expect(activity).to be_a(OpenEHR::RM::Composition::Content::Entry::Activity)
+      expect(activity.archetype_node_id).to eq('at0001')
+      expect(activity.description.items.first.value.value).to eq('Chest pain work-up')
+      expect(activity.timing).to be_a(OpenEHR::RM::DataTypes::Encapsulated::DvParsable)
+      expect(activity.timing.value).to eq('R1')
+      expect(activity.timing.formalism).to eq('timing')
+      # Approximation (ruling condition (a)): the graph does not carry
+      # action_archetype_id yet, so the RM's "any ACTION archetype" pattern is
+      # injected; phase B persists the real value.
+      expect(activity.action_archetype_id).to eq('/.*/')
+    end
+
+    # Approximation (ruling condition (a)): narrative is mandatory on the RM
+    # INSTRUCTION; when the graph has no narrative row, the node's name stands
+    # in. Phase B persists it as a column.
+    it 'injects the node name as narrative when the graph has none' do
+      composition = OpenehrRails::Rm::CompositionCommitter.commit(
+        fixture.composition(content: [fixture.instruction(narrative: false)]), uid: 'uid-referral-no-narrative'
+      )
+
+      expect(composition.to_rm.content.first.narrative.value).to eq('Request')
+    end
+
+    it 'builds a SECTION without items as items nil (the RM rejects an empty list)' do
+      composition = OpenehrRails::Rm::CompositionCommitter.commit(
+        fixture.composition(content: [fixture.section([])]), uid: 'uid-referral-empty-section'
+      )
+
+      expect(composition.to_rm.content.first.items).to be_nil
+    end
+
+    # Ruling condition (b): restoring `protocol` for every CARE_ENTRY must not
+    # change what an entry without a protocol node rebuilds to.
+    # Regression pin -- this was already true before #45.
+    it 'leaves protocol nil on an OBSERVATION that has no protocol node' do
+      expect(BmiCalculation.create!(height: 170.0).rm_graph.to_rm.content.first.protocol).to be_nil
+    end
+  end
 end

data/spec/support/synthetic_referral_canonical_hash.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# Fixture kind: **synthetic** (hand-authored, not derived from any real
+# artifact). Design authority: docs/design/rm-object-builder-section-instruction-plan.md
+# section 3 (skoba/openehr-rails#45). Every archetype id is self-evidently
+# invented (`synthetic_*_test`); the at-codes mirror the *shape* of
+# jp_referral's service_request (activities[at0001]/description[at0009],
+# protocol[at0008]) so the AQL paths in the specs read like the real ones,
+# but no real canonical JSON with SECTION/INSTRUCTION exists in this repo --
+# anlage's hand-mapped composition lives outside it.
+#
+# Shape: COMPOSITION whose content is a SECTION holding one EVALUATION, and
+# an INSTRUCTION with a narrative, a protocol ITEM_TREE and one ACTIVITY
+# (description ITEM_TREE + DV_PARSABLE timing). Everything GraphBuilder
+# accepts today; before #45 RmObjectBuilder could rebuild none of it.
+module SyntheticReferralCanonicalHash
+  COMPOSITION_ID = 'openEHR-EHR-COMPOSITION.synthetic_referral_test.v1'
+  SECTION_ID = 'openEHR-EHR-SECTION.synthetic_details_test.v1'
+  EVALUATION_ID = 'openEHR-EHR-EVALUATION.synthetic_summary_test.v1'
+  INSTRUCTION_ID = 'openEHR-EHR-INSTRUCTION.synthetic_request_test.v1'
+
+  module_function
+
+  def dv_text(value)
+    { '_type' => 'DV_TEXT', 'value' => value }
+  end
+
+  def element(node_id, value)
+    { '_type' => 'ELEMENT', 'archetype_node_id' => node_id, 'name' => dv_text(node_id), 'value' => value }
+  end
+
+  def item_tree(node_id, items)
+    { '_type' => 'ITEM_TREE', 'archetype_node_id' => node_id, 'name' => dv_text(node_id), 'items' => items }
+  end
+
+  def archetyped(id)
+    { '_type' => 'ARCHETYPED', 'archetype_id' => { 'value' => id }, 'rm_version' => '1.0.4' }
+  end
+
+  def evaluation
+    {
+      '_type' => 'EVALUATION', 'archetype_node_id' => EVALUATION_ID,
+      'archetype_details' => archetyped(EVALUATION_ID), 'name' => dv_text('Summary'),
+      'data' => item_tree('at0001', [element('at0002', dv_text('stable'))])
+    }
+  end
+
+  def activity
+    {
+      '_type' => 'ACTIVITY', 'archetype_node_id' => 'at0001', 'name' => dv_text('Request'),
+      'description' => item_tree('at0009', [element('at0121', dv_text('Chest pain work-up'))]),
+      'timing' => { '_type' => 'DV_PARSABLE', 'value' => 'R1', 'formalism' => 'timing' }
+    }
+  end
+
+  # narrative: pass false to omit the narrative (the injected-default case).
+  def instruction(narrative: 'Refer to cardiology')
+    hash = {
+      '_type' => 'INSTRUCTION', 'archetype_node_id' => INSTRUCTION_ID,
+      'archetype_details' => archetyped(INSTRUCTION_ID), 'name' => dv_text('Request'),
+      'protocol' => item_tree('at0008', [element('at0010', dv_text('Synthetic Hospital'))]),
+      'activities' => [activity]
+    }
+    hash['narrative'] = dv_text(narrative) if narrative
+    hash
+  end
+
+  def section(items = [evaluation])
+    { '_type' => 'SECTION', 'archetype_node_id' => SECTION_ID, 'name' => dv_text('Details'), 'items' => items }
+  end
+
+  def composition(content: [section, instruction])
+    {
+      '_type' => 'COMPOSITION', 'archetype_node_id' => COMPOSITION_ID,
+      'archetype_details' => archetyped(COMPOSITION_ID).merge('template_id' => { 'value' => 'synthetic_referral_test' }),
+      'name' => dv_text('Synthetic referral'),
+      'content' => content
+    }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: openehr-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Shinji KOBAYASHI
@@ -346,6 +346,7 @@ files:
 - spec/generators/templates/openEHR-EHR-OBSERVATION.blood_pressure.v1.adl
 - spec/models/openehr_template_spec.rb
 - spec/openehr_rails/aql/dataset_adapter_spec.rb
+- spec/openehr_rails/aql/executor_execute_demo_queries_spec.rb
 - spec/openehr_rails/aql/executor_spec.rb
 - spec/openehr_rails/aql/model_api_spec.rb
 - spec/openehr_rails/aql/query_validator_spec.rb
@@ -383,6 +384,7 @@ files:
 - spec/openehr_rails/template_uploader_spec.rb
 - spec/spec_helper.rb
 - spec/support/active_record.rb
+- spec/support/synthetic_referral_canonical_hash.rb
 - spec/templates/bmi_calculation_without_uid.opt
 - spec/templates/lab_result_report_reduced.opt
 - spec/templates/problem_list.opt